#include<bits/stdc++.h> using namespace std; int main(){ cout<<"Hello World "; return 0;

1 条评论

  • @ 2026-5-15 21:25:26 
    #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>
int a;
int b;
int c;
int d;
int e;
int f;
int g;
int h;
int i;
int j;
int k;
int l;
int m;
int n;
int o;
int p;
int q;
int r;
int s;
int t;
int u;
int v;
int w;
int x;
int y;
int z;
/*
#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 "身份不明的答辩";
        }
    }
};
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!";
}
*/
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 "身份不明的答辩";
        }
    }
};
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!";
}
/*
#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>
int a;
int b;
int c;
int d;
int e;
int f;
int g;
int h;
int i;
int j;
int k;
int l;
int m;
int n;
int o;
int p;
int q;
int r;
int s;
int t;
int u;
int v;
int w;
int x;
int y;
int z;
/*
#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 "身份不明的答辩";
        }
    }
};
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!";
}
/*
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 "身份不明的答辩";
        }
    }
};
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!";
}
*/
    • 1
    106
    已通过
    0
    题解被赞

    【例2.1】Hello World

    信息

    ID
    805
    时间
    ms
    内存
    MiB
    难度
    1
    标签
    递交数
    272
    已通过
    125
    上传者
    1. Language
    2. 兼容模式
    3. 主题
    3. Worker 0, 10ms
    4. Powered by Hydro v5.0.1 Community