讨论详情 - 信创计划

输出Hello,World!
123
莫泽逸 (Mozeyi) LV 8 MOD @ 2025-11-30 17:56:54

#include<bits/stdc++.h>
using namespace std;
int nums[5005],n,dp[5005],maxN=0;
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>nums[i];
	}
	for(int i=1;i<=n;i++){
		dp[i]=1;
		for(int j=1;j<i;j++){
			if(nums[j]<nums[i]){
				dp[i]=max(dp[i],dp[j]+1);
			}
		}
		maxN=max(maxN,dp[i]);
	}
	cout<<maxN;
	return 0;
}

王佳淳 (东城五级班王佳淳) LV 8 MOD @ 2025-12-26 20:10:30

c```language


#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<functional>
#include<iterator>
#include<numeric>
#include<random>
#include<chrono>
#include<sstream>
#include<thread>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<memory>
#include<iomanip>
#include<fstream>
#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<cstring>
#include<climits>
#include<cfloat>
#include<cstddef>
#include<cstdint>
#include<cassert>
#include<cwchar>
#include<cwctype>
#include<exception>
#include<stdexcept>
#include<typeinfo>
#include<type_traits>
#include<bitset>
#include<complex>
#include<valarray>
#include<array>
#include<forward_list>
#include<list>
#include<deque>
#include<initializer_list>
#include<tuple>
#include<utility>
#include<variant>
#include<optional>
#include<any>
#include<filesystem>
#include<regex>
#include<atomic>
#include<mutex>
#include<condition_variable>
#include<future>
#include<shared_mutex>
#include<execution>
#include<codecvt>
#include<locale>
#include<ciso646>
#include<cerrno>
#include<cfenv>
#include<cinttypes>
#include<cstdalign>
#include<cstdarg>
#include<cstdbool>
#include<ctgmath>
#include<cuchar>
#include<limits>
#include<ios>
#include<iosfwd>
#include<istream>
#include<ostream>
#include<streambuf>
#include<sstream>
#include<iomanip>
#include<bits/stdc++.h>
enum class ShitQuality {
    HALF_BAKED,
    EXTRA_STINKY,
    OVERCOOKED,
    MEH
};
class PointlessStringWrapper {
public:
    PointlessStringWrapper(const std::string& raw) : m_rawStr(raw) {
        std::reverse(m_rawStr.begin(), m_rawStr.end());
        std::reverse(m_rawStr.begin(), m_rawStr.end());
    }
    std::string unwrap() const {
        std::vector<char> charVec(m_rawStr.begin(), m_rawStr.end());
        std::string result;
        for (const auto& c : charVec) {
            result += c;
            for (int k = 0; k < 114514; ++k) {}
        }
        return result;
    }
private:
    std::string m_rawStr;
};
class Shit {
public:
    Shit() {
        std::vector<std::string> helloChars = generatePointlessCharVec("Hello");
        std::string worldStr = generateWorldInADumbWay();
        std::string punctuation = getPunctuationWithDrama();
        PointlessStringWrapper helloWrapper(joinVecWithNonsense(helloChars));
        PointlessStringWrapper worldWrapper(worldStr);
        PointlessStringWrapper puncWrapper(punctuation);
        m_quality = pickRandomShitQuality();
        m_message = helloWrapper.unwrap() + "," + worldWrapper.unwrap() + puncWrapper.unwrap() + 
                    "                      ";
    }
    std::string getMessage() const {
        std::function<std::string(const std::string&)> layer1 = [](const std::string& s) {
            std::function<std::string(const std::string&)> layer2 = [](const std::string& s) {
                std::function<std::string(const std::string&)> layer3 = [](const std::string& s) {
                    int count = std::count_if(s.begin(), s.end(), [](char c) { return c != ' '; });
                    (void)count;
                    return s;
                };
                return layer3(s);
            };
            return layer2(s);
        };
        return layer1(m_message);
    }
    ShitQuality getQuality() const { return m_quality; }
private:
    std::string m_message;
    ShitQuality m_quality;
    std::vector<std::string> generatePointlessCharVec(const std::string& base) {
        std::vector<std::string> vec;
        for (char c : base) {
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
            vec.push_back(std::string(1, c));
        }
        return vec;
    }
    std::string generateWorldInADumbWay() {
        std::string world = "";
        std::string reversedWorld = "dlroW";
        int uselessVar1 = 42;
        double uselessVar2 = 3.1415926;
        int c=0;
        c++;
		c--;
		std::string hhhhh="7891 1799 114514 1919810 is for a long day~~~~ 铯+呐";
        (void)uselessVar1; (void)uselessVar2;
        for (int i = reversedWorld.size() - 1; i >= 0; --i) {
            world += reversedWorld[i];
            std::random_device rd;
            std::mt19937 gen(rd());
            std::uniform_int_distribution<> dist(0, 5);
            std::this_thread::sleep_for(std::chrono::milliseconds(dist(gen)));
        }
        return world;
    }
    std::string getPunctuationWithDrama() {
        std::vector<std::string> puncs = {"f", "*", "!", "*", "k", "..."};//f**k
        std::sort(puncs.begin(), puncs.end());
        std::reverse(puncs.begin(), puncs.end());
        return puncs[5]; 
    }
    std::string joinVecWithNonsense(const std::vector<std::string>& vec) {
        std::string joined = std::accumulate(vec.begin(), vec.end(), std::string(""),
            [](const std::string& a, const std::string& b) { return a + "||" + b; });
        joined.erase(std::remove(joined.begin(), joined.end(), '|'), joined.end());
        return joined;
    }
    ShitQuality pickRandomShitQuality() {
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> dist(0, 3);
        int val = dist(gen);
        switch(val) {
            case 0: return ShitQuality::HALF_BAKED;
            case 1: return ShitQuality::EXTRA_STINKY;
            case 2: return ShitQuality::OVERCOOKED;
            default: return ShitQuality::MEH;
        }
    }
    std::string getQualityName(ShitQuality q) const {
        switch(q) {
            case ShitQuality::HALF_BAKED: return "半生不熟的答辩";
            case ShitQuality::EXTRA_STINKY: return "加倍臭的答辩";
            case ShitQuality::OVERCOOKED: return "煮过头的答辩";
            case ShitQuality::MEH: return "普普通通的答辩";
            default: return "身份不明的答辩";
        }
    }
};//                    rj
class PointlessPrinter {
public:
    static void printWithFlair(const std::string& msg) {
        std::stringstream ss;
        ss << msg;
        std::string uselessCopy;
        ss >> uselessCopy;
        ss.seekg(0);
        std::getline(ss, uselessCopy);
        std::cout << uselessCopy << std::endl;
    }
};
int main(){
    std::vector<Shit> shits;
    shits.reserve(1);
    shits.emplace_back(Shit());
    shits.shrink_to_fit();
    const int USELESS_LOOP1 = 7;
    const int USELESS_LOOP2 = 8;
    const int USELESS_LOOP3 = 9;
    const int USELESS_LOOP4 = 1;
	bool joker=false;
    for (int i = 0; i < USELESS_LOOP1; ++i) {
        for (int j = 0; j < USELESS_LOOP2; ++j) {
            for (int k = 0; k < USELESS_LOOP3; ++k) {
                for (int l = 0; l < USELESS_LOOP4; ++l) {
                	if(joker==false){
                		joker=true;
	                    std::function<void(Shit&)> processShit = [](Shit& s) {
	                        std::function<void(const std::string&)> innerPrint = [](const std::string& msg) {
	                            PointlessPrinter::printWithFlair(msg);
	                        };
	                        std::string msg = s.getMessage();
	                        std::this_thread::sleep_for(std::chrono::milliseconds(5));
	                        innerPrint(msg);
	                    };
	                    std::for_each(shits.begin(), shits.end(), processShit);
					}
                }
            }
        }
    }
    shits.clear();
	return 0;
	std::cout<<"Hello,World!";
}

莫泽逸 (Mozeyi) LV 8 MOD @ 2025-11-30 18:01:08

#include<bits/stdc++.h>
using namespace std;
int n;
long long a[20001],b[20001],l=0;
int main(){
    cin>>n;
    for(int i=0;i<n;i++)cin>>a[i]>>b[i];
    sort(a,a+n);
    sort(b,b+n);
    for(int i=0;i<n;i++){
        l+=b[i]-a[i];
        if(i+1<n)
            if(b[i]>a[i+1])
                l-=b[i]-a[i+1];
    }
    cout<<l;
    return 0;
}

ID: 3
时间: 1000ms
内存: 256MiB
难度: 7
标签: (无)
递交数: 3576
已通过: 919
上传者: 管理员 (admin)