// 产生随机数
    public static String createnum() {
        ThreadLocalRandom rand = ThreadLocalRandom.current();
        int a = rand.nextInt(range);
        int b = rand.nextInt(range);
        if (a == 0) {
            a += (int) (Math.random()*range + 1);
        }
        if (b == 0) {
            b += (int) (Math.random()*range + 1);
        }
        if (b == range) {
            b = b-1;
        }
        num n = new num(a,b);
        easy(n);
        if (n.a == n.b) {
            return Integer.toString(1);
        }
        if (n.b == 1) {
            return Integer.toString(n.a);
        }
//        System.out.println(n.tostring());
        return n.tostring();
    }

 // 生成表达式，并存入题目列表

    static void subject() {

        // 运算符个数 1-3 个

        List<String> exp = new ArrayList<String>();

        int opr_n = (int) (Math.random()*3 + 1);

        switch(opr_n) {

            case 1:

                exp.add(createnum());

                exp.add(createopr1());

                exp.add(createnum());

                break;

            case 2:

                // 括号起始位置

                int bkt_s = (int) (Math.random()*3);

                // 括号结束位置

                int bkt_e = 0;

                // 无括号

                if (bkt_s == 0) {

                    bkt_e = 0;

                } else {

                    bkt_e = bkt_s + 1;

                }

                for (int i = 1; i <= 3; i++) {

                    if (bkt_s == i) {

                        exp.add("(");

                    }

                    exp.add(createnum());

                    if (bkt_e == i) {

                        exp.add(")");

                    }

                    exp.add(createopr1());

                }

                // 处理括号无意义情况

                 checkbkt(bkt_s, bkt_e,exp);

                exp.remove(exp.size()-1);    // 删除最后多加入的一个运算符

                break;

            case 3:

                // 括号起始位置

                bkt_s = (int) (Math.random()*4);

                // 无括号

                if (bkt_s == 0) {

                    bkt_e = 0;

                } else if (bkt_s == 3){

                    bkt_e = 4;

                } else {

                    bkt_e = bkt_s + (int) (Math.random()*2 + 1);    // [1,3)

                }

                for (int i = 1; i <= 4; i++) {

                    if (bkt_s == i) {

                        exp.add("(");

                    }

                    exp.add(createnum());

                    if (bkt_e == i) {

                        exp.add(")");

                    }

                    exp.add(createopr1());

                }

                // 处理括号无意义情况

                checkbkt(bkt_s, bkt_e,exp);

                exp.remove(exp.size()-1);    // 删除最后多加入的一个运算符

                break;

        }

        e.add(exp);

        System.out.println(toString(exp));

      //  exp.clear();

    }

 // 构建树计算表达式，并存入题目列表

    public static String count(List<String> list) {

        Stack<Node> a1 = new Stack<>();    // 数值栈

        Stack<String> b = new Stack<>();    // 未处理的运算符栈

//        Stack<Node> c = new Stack<>();    // 处理后的运算符栈

        for (int i=0; i<list.size(); i++) {

            String string = list.get(i);

            if (!isop(string)) {
　　　　　　　　　　// 当前指针为数值

                a1.push(new Node(string, null, null, null));

            } else {

                //比较栈顶符号与当前符号的优先级

                while (!b.isEmpty() && !(string.equals("(") || (prefer(string)==2 && prefer(b.peek())==1) ||

                        (!string.equals(")") && b.peek().equals("(")))) {

                    String symbol = b.pop();

                    if (symbol.equals("(") && string.equals(")")) {

                        break;

                    }

                    push(symbol, a1);

                }

                //如果符号不是")"就进栈

                if (!string.equals(")")) {

                    b.push(string);

                }

            }

        }

        while (!b.isEmpty()) {

            push(b.pop(), a1);

        }

        negative(a1);

        return a1.peek().result;

    }

    // 处理负数

    public static void negative(Stack<Node> c) {

        if (!c.isEmpty()) {

            for (int i=0; i<c.size(); i++) {

                Node n = c.get(i);

                if (n.op.equals("-")) {

                    num l = new num(n.left.result);

                    num r = new num(n.right.result);

                    if (l.a*r.b < r.a*l.b) {

                        Node m = n.left;

                        n.left = n.right;

                        n.right = m;

                        n.setResult();

                    }

                }

            }

        }

    }

    public static void push(String op, Stack<Node> a) {

        if (!op.equals("(")) {

            Node r = a.pop();

            Node l = a.pop();

            Node o = new Node(null, r, l, op);

            o.result = count(r.result, l.result, op);

            a.push(o);

        }

    }

    public static String count(String r, String l, String op) {

        num left = new num(l);

        num right = new num(r);

        switch (op) {

            case "+":

                return left.add(right).tostring();

            case "-":

                return left.sub(right).tostring();

            case "x":

                return left.mul(right).tostring();

            case "÷":

                return left.div(right).tostring();

        }

        return null;

    }

    static class Node {

        String result;

        Node right;

        Node left;

        String op;

        public Node(String result, Node right, Node left, String op) {

            this.result = result;

            this.right = right;

            this.left = left;

            this.op = op;

        }

        public void setResult() {

            if (op!=null) {

                result = count(right.result, left.result, op);

            }

        }

        public void changelr() {

            Node m = left;

            right = left;

            left = m;

        }

    }

    public static int prefer(String op) {  // 判断运算符优先级

        if (op.equals("-") || op.equals("+")) {

            return 1;

        } else if (op.equals("x") || op.equals("÷")) {

            return 2;

        } else {

            return 3;

        }

    }

    public static boolean isop(String op) { // 判断是否为运算符

        if (op.equals("+") || op.equals("-")

                || op.equals("x") || op.equals("÷")

                || op.equals("(") || op.equals(")")) {

            return true;

        } else  {

            return false;

        }

    }

public class num {

    public int a;  // 分子

    public int b;  // 分母

    public num() {

    }

    public num(String s) {  // 处理数值

        s = s.trim();

        int a,b;

        int x = s.indexOf("'");

        int y = s.indexOf("/");

        if (x != -1) {  // 代分数处理

            int c = Integer.parseInt(s.substring(0, x));    // 代分数的整数部分

            b = Integer.parseInt(s.substring(y+1));

            a = c * b + Integer.parseInt(s.substring(x+1,y));

        } else if (y != -1) {   // 分数处理

            a = Integer.parseInt(s.substring(0,y));

            b = Integer.parseInt(s.substring(y+1));

        } else {  // 整数处理

            a = Integer.parseInt(s);

            b = 1;

        }

        check(a,b);

    }

    public num(int a, int b) {

        check(a,b);

    }

    public void check(int a, int b) {

        if (a>=0 && b>0) {

            this.a = a;

            this.b = b;

        }

    }

    public num add(num n) { // 加法 a + b

        return new num((this.b*n.a + this.a*n.b), this.b*n.b);

    }

    public num sub(num n) { // 减法 a - b

        return new num((this.a*n.b - this.b*n.a), this.b*n.b);

    }

    public num mul(num n) { // 乘法 a * b

        return new num(this.a*n.a, this.b*n.b);

    }

    public num div(num n) { // 除法 a / b

        return new num(this.a*n.b, this.b*n.a);

    }

    public int gcd(int a, int b) { // 求分数最大公约数

        if (a<b) {

            int x = b % a;

            return x == 0 ? a : gcd(a,x);

        } else if (a>b) {

            int y = a % b;

            return y == 0 ? b : gcd(b,y);

        } else return 1;

    }

    public static num easy(num n) {    // 约分

        if (n.a == 0) {

            return new num(0, 1);

        } else {

            int m = n.gcd(n.a, n.b);

            if (m == 1) {

                return n;

            } else  {

                n.a = n.a/m;

                n.b = n.b/m;

                return n;

            }

        }

    }

    public String change(int n, int d) {

        // 将假分数转换为真分数，第一个参数为分子，第二个为分母

        //假分数转真分数方法 求 最大整除数+余数/分母

        num a = easy(new num(n,d));

        int left=a.a/a.b;

        int up=a.a-left*a.b;

        int down=a.b;

        if(left==0) {

            return up+"/"+down;

        }

        else if(down == 1) {

            return Integer.toString(n);

        }else {

            return left+"'"+up+"/"+down;

        }

    }

    public String tostring() {  // 转换为字符串

        if (this.a>this.b) {

            return this.change(a,b);

        } else if (this.b ==1){

            return Integer.toString(this.a);

        } else {

            return this.a + "/" + this.b;

        }

    }

}　

 // 检查题目列表中是否有相同的题目，并处理

    static void ifExist(ArrayList<String> s) {

        for (int i=0; i<s.size(); i++) {

            for (int j=i+1; j<s.size();) {

                Stack<Node> f = e1.get(i);

                Stack<Node> se = e1.get(j);

                if (f.size() == se.size() && equals(f.pop(), se.pop())) {

                    s.remove(j);

                } else {

                    j++;

                }

            }

        }

    }

    static boolean equals(Node f, Node s) {

            if (fullequals(f, s)) {

                return true;

            } else if (f.op.equals(s.op) && f.result.equals(s.result)){

                if (change(f, s)) {

                    return true;

                } else {

                    return equals(f.left, s.left) && equals(f.right, s.right);

                }

            }

        return false;

    }

    static boolean change(Node f, Node s) {

        if (f.op.equals("+") || f.op.equals("x")) {

            f.changelr();

            f.setResult();

            if (nodeequal(f.left, s.left) && nodeequal(f.right, s.right)) {

                return true;

            }

        }

        return false;

    }

    static boolean nodeequal(Node f, Node s) {

        return f.op.equals(s.left.op) && f.result.equals(s.left.result);

    }

    static boolean fullequals(Node f, Node s) {

        if (f.op.equals(s.op) && f.result.equals(s.result)) {

            return fullequals(f.left, s.left) && fullequals(f.right, s.right);

        }

        return false;

    }

  static void save(List<List<String>> s) {
        // 用于将题目存入当前目录下的Exercises.txt文件
        File question = new File("./Exercises.txt");
        if (!question.exists()) {
            System.out.println("文件不存在，创建文件: Exercises.txt" );
            try {
                question.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("文件已存在，文件为: Exercises.txt" );
        }
        FileWriter fw;
        try {
         fw=new FileWriter(question);
         BufferedWriter bw = new BufferedWriter(fw);
            for(int i=0;i<s.size();i++) {
                String temp="";
                for(int j=0;j<s.get(i).size();j++) { 
                 temp+=s.get(i).get(j)+"";
                }
                String t = (i + 1) + ". " + temp;
                bw.write(t);
                bw.newLine();
            }
                bw.close();
           
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
   static void answer(List<String> a) {
        // 用于将题目答案存入当前目录下的Answer.txt文件
        File answer = new File("./Answer.txt");
        if (!answer.exists()) {
            System.out.println("文件不存在，创建文件: Answer.txt" );
            try {
                answer.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("文件已存在，文件为: Answer.txt" );
        }
        FileWriter fw;
        try {
            fw = new FileWriter(answer);
            BufferedWriter bw =new BufferedWriter(fw);
            for(int i=0;i<a.size();i++){
                String t =i+1+". "+ a.get(i);
                bw.write( t);
                bw.newLine();
            }
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }