RT

我闲来无事，突发奇想 (吃饱了撑的)，使用了大量现代 (真的有人用这些打OI吗) 的特性写出一份神奇 (逆天) 代码。 随后发现本应该能够递归的 finalize() 函数不能递归，左查右找时发现数据范围 $n \leq 20000$ ，随发现解决办法其实就是手动堆叠 finalize() 函数 。

最后发现只需要叠三层就能过…… 毕竟数据很水

// 非常好(确信)
std::cout << (new BasicNum(x))->finalize()->finalize()->finalize()->stringize() << std::endl;

AC截图

Code

#include <iostream>
#include <cstdint>
#include <string>
#include <list>

class NumberLike;
class BasicNum;
class TwoBased;
class Listed;
int main();

class NumberLike {
private:
    static constexpr const char* UNDEFINED = "UNDEFIEND";
protected:
    enum class _TYPE { UNDEFINED, BASICNUM, TWOBASED, LISTED };
    class _SPEC {
    protected:
        int16_t spec;
    public:
        static constexpr int16_t NONE = 0, BN_R1 = 1, LT_L0 = 2, LT_L1 = 4;
        operator int16_t&() { return spec; }
        _SPEC(int16_t _spec): spec(_spec) { }
    };
public:
    static constexpr _TYPE TYPE = _TYPE::UNDEFINED;

    virtual NumberLike* finalize(void) const = 0;
    virtual std::string const stringize(void) const { return UNDEFINED; }
    virtual _SPEC const get_spec(void) const { return _SPEC::NONE; }
};

class Listed: public NumberLike {
private:
    static constexpr const char* STR_LEMPTY = "LE";

    std::list<NumberLike*> list;
public:
    static constexpr _TYPE TYPE = _TYPE::LISTED;

    Listed() { }
    
    void join(NumberLike* const pn) {
        list.push_back(pn);
    }

    NumberLike* L1_target() const {
        return this->list.empty()? (NumberLike*)this: list.front();
    }

    virtual NumberLike* finalize(void) const {
        if(this->list.size() == 1)
            return this->list.front()->finalize();
        Listed * const ll = new Listed();
        for(NumberLike const* const &pn: this->list)
            ll->join(pn->finalize());
        return ll;
    }

    virtual std::string const stringize(void) const {
        if(list.empty()) return STR_LEMPTY;
        std::list<NumberLike*>::const_iterator it = list.begin();
        std::string s = (*it++)->stringize();
        for(; it != list.end(); ++it)
            s += "+",
            s += (*it)->stringize();
        return s;
    }

    virtual _SPEC const get_spec(void) const {
        _SPEC spec = _SPEC::NONE;
        if(this->list.empty())
            spec |= _SPEC::LT_L0;
        else if(this->list.size() == 1)
            spec |= _SPEC::LT_L1;
        return spec;
    }
};

class TwoBased: public NumberLike {
private:
    static constexpr const char* STR_PWRBN1 = "2";
    static constexpr const char* STR_PWRBN0 = "2(0)";
    static constexpr const char* STR_PERTB1 = "2(2(0))";

    NumberLike* const power;
public:
    static constexpr _TYPE TYPE = _TYPE::TWOBASED;

    TwoBased(NumberLike *pw): power(pw) {}

    virtual TwoBased* finalize(void) const {
        return new TwoBased(power->finalize());
    }

    virtual std::string const stringize(void) const {
        _SPEC pwr_spec = this->power->get_spec();
        if(pwr_spec & _SPEC::BN_R1)
            return STR_PWRBN1;
        if(pwr_spec & _SPEC::LT_L0)
            return STR_PWRBN0;
        if(pwr_spec & _SPEC::LT_L1)
            return ((Listed*)power)->L1_target()->stringize();
        std::string rw = "2(";
        rw += this->power->stringize();
        rw += ")";
        return rw != STR_PERTB1? rw: STR_PWRBN1;
    }
};

class BasicNum: public NumberLike {
private:
    uint16_t const raw;
public:
    static constexpr _TYPE TYPE = _TYPE::BASICNUM;

    BasicNum(uint16_t _raw): raw(_raw) { };

    virtual NumberLike * finalize(void) const {
        if(raw == 1 || raw == 2)
            return new TwoBased(raw == 1? new BasicNum(0): new BasicNum(1));

        Listed * ll = new Listed();
        for(uint16_t mask = 1 << 15, k = 15; mask; mask >>= 1, --k)
            if(raw & mask)
                ll->join(new TwoBased(new BasicNum(k)));
        return ll;
    }

    virtual std::string const stringize(void) const { return std::to_string(raw); }
    virtual _SPEC const get_spec(void) const {
        _SPEC spec = _SPEC::NONE;
        if(this->raw == 1)
            spec |= _SPEC::BN_R1;
        return spec;
    }
};

int main() {
    uint16_t x;
    std::cin >> x;
    std::cout << (new BasicNum(x))->finalize()->finalize()->finalize()->stringize() << std::endl;
}