清蒸萌新literal @[email protected]

#include <cstdlib>
#include <ctype.h>
#include <stdio.h>
#include <sstream>
#include <vector>

// 项
struct term
{
    int mul;
    int exp;
};

// 多项式
typedef std::vector<term> poly;

enum poly_parse_state
{
    ppoly_init, // 初始状态
    ppoly_mul,  // 系数
    ppoly_var,  // 变量
    ppoly_exp,  // 指数
    ppoly_tem,  // 产生一个项
    ppoly_suc,  // 产生一个多项式
    ppoly_err   // 错误
};

// 状态转移
#define transfer_state(s) {state = s; continue;}

// 解析多项式
poly parse_poly(std::string polystr)
{
    std::istringstream is(polystr);
    std::string buff;
    term t{.mul = 0, .exp = 0};
    poly p;

    int state = ppoly_init;
    while(1)
    switch(state)
    {
        case ppoly_init:
        {
            int ch = is.get();

            if(isdigit(ch))
            {
                buff.push_back(ch);
                transfer_state(ppoly_mul);
            }

            if(isalpha(ch))
            {
                t.mul = 1;
                transfer_state(ppoly_var);
            }

            if(ch == EOF)
            {
                transfer_state(ppoly_suc);
            }
            
            transfer_state(ppoly_err);
        }
        case ppoly_mul:
        {
            int ch = is.get();

            if(isdigit(ch))
            {
                buff.push_back(ch);
                transfer_state(ppoly_mul);
            }

            if(isalpha(ch))
            {
                t.mul = (int)strtol(buff.c_str(), NULL, 10);
                buff.clear();

                transfer_state(ppoly_var);
            }

            if(ch == '+')
            {
                t.mul = (int)strtol(buff.c_str(), NULL, 10);
                buff.clear();
                t.exp = 0;
                transfer_state(ppoly_tem);
            }

            if(ch == EOF)
            {
                t.mul = (int)strtol(buff.c_str(), NULL, 10);
                t.exp = 0;
                buff.clear();
                transfer_state(ppoly_tem);
            }
        }
        case ppoly_var:
        {
            int ch = is.get();

            if(ch == '^')
            {
                transfer_state(ppoly_exp);
            }

            if(ch == '+')
            {
                t.exp = 1;
                transfer_state(ppoly_tem);
            }

            if(ch == EOF)
            {
                t.exp = 1;
                transfer_state(ppoly_tem);
            }
        }
        case ppoly_exp:
        {
            int ch = is.get();

            if(isdigit(ch))
            {
                buff.push_back(ch);
                transfer_state(ppoly_exp);
            }

            if(ch == '+')
            {
                t.exp = (int)strtol(buff.c_str(), NULL, 10);
                buff.clear();
                transfer_state(ppoly_tem);
            }

            if(ch == EOF)
            {
                t.exp = (int)strtol(buff.c_str(), NULL, 10);
                buff.clear();
                transfer_state(ppoly_tem);
            }
        }
        case ppoly_tem:
        {
            p.push_back(t);
            transfer_state(ppoly_init);
        }
        case ppoly_suc:
        {
            return p;
        }
        case ppoly_err:
        {
            fprintf(stderr, "poly parse error\n");
            p.clear();
            return p;
        }
    }
}

// 输出多项式
void print_poly(poly p)
{
    for(term t : p)
    {
        printf("%d * x ^ %d\n", t.mul, t.exp);
    }
}

// 多项式测试
void poly_test(std::string name, std::string s)
{
    printf("test [%s] | input: %s\n-----\n", name.c_str(), s.c_str());
    print_poly(parse_poly(s));
    puts("");
}

int main()
{
    poly_test("pure mul", "2");
    poly_test("pure exp", "x^2");
    poly_test("pure var", "x");

    poly_test("mul & var", "2x");
    poly_test("mul & exp", "2x^2");

    poly_test("poly", "x^2+2x+2");

    return 0;
}