2019年全国高校计算机能力挑战赛初赛java赛题

1. 某星球存在两种生物，A种生物有1个头6条腿，B种生物有3个头4条腿。来自地球的太空船刚刚在该星球降落，突然发现一大群这两种生物组成的队伍，由于时间紧，只数了头的数量和腿的数量，请帮助宇航员分析A、B两种生物各有多少个。
   输入说明：头的数量L腿的数量Z，（L，Z<=100000）；输出说明：A生物的数量B生物的数量（两个整数用一个空格隔开）；输入样例：10 32输出样例：4 2

 	public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int L = in.nextInt(); // 头
        int Z = in.nextInt(); // 腿

        int x; // A生物数量
        int y; // B生物数量

        x = (3*Z - 4*L) / 14;
        y = (6*L - Z) / 14;

        System.out.println(x + " " + y);

    }

2. 对于给出的长度为N（N<1000）的正整数数组，满足连续3个元素均为合数的区间称为3合数区间，计算该数组中3合数区间的个数。
   输入说明：第一行，数组中元素个数N，第二行，N个正整数，用空格隔开。
   输出说明：3合数区间的个数
   输入样例：
   7
   6 8 4 9 7 5 8
   输出样例：
   2

	public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int result = 0;
        int N = in.nextInt();
        int[] val = new int[N];
        for (int i = 0;i < N;i++) {
            val[i] = in.nextInt();
        }

        for (int i = 0;i < val.length - 2;i++) {
            boolean is = true; // 默认是三合数区间
            for (int j = i;j < i + 3;j++) {
                if (!isPrime(val[j])) { //如果val[j]不是合数
                    is = false;
                }
            }
            if (is) {
                result++;
            }
        }
        System.out.println(result);
    }

    public static boolean isPrime(int n) {  //判断是否为合数
        boolean flag = false;
        for (int i = 2; i < n; i++) {
            if (n % i == 0) {
                flag = true;
            }
        }
        return flag;
    }

3. 给定两个字符串，均只包含英文字母，需区分大小写，一个是源字符串SS（长度<1000），另一个是目标字符串TS（长度<1000），请问能否通过删除SS中的字符（不改变顺序）将它变换成TS，如果可以输出“YES"，不可以则输出“NO"。
   输入说明：第一行为源字符串SS，第二行为目标字符串TS。
   输出说明：可以输出“YES"，不可以输出“NO"。
   输入样例1：Thereisacomputer Treat输出样例1：YES输入样例2：Thereisacomputer Trait输出样例2：NO

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String SS = in.nextLine();
        String TS = in.nextLine();

        if (SS.length() < TS.length()) {
            System.out.println("NO");
            return;
        }

        ArrayList<Character> slist = new ArrayList();
        char[] schar = SS.toCharArray();
        char[] tchar = TS.toCharArray();


        for (int i = 0; i < schar.length; i++) {
            slist.add(schar[i]);
        }

        int index = 0; // 记录目标字符串中的指针
        for (int i = 0; i < slist.size(); i++) {
            if (index >= tchar.length) {
                break;
            }

            if (slist.get(i) != tchar[index]) {
                slist.remove(i);
                i--;
            } else {
                index++;
            }
        }
        if (slist.size() > tchar.length) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }

4. 数字连连看，给出一个整数数组和一个目标值，请在数组中找到三个元素，它们的和为该目标值。
   输入说明：第一行是整数N和T，N（N<10000）表示整数数组中元素个数，T是目标值。
   第二行是N个整数，表示数组中的元素，且每个数的绝对值小于等于100000。
   输出说明：找到的这三个匹配元素所在位置（数组元素起始位置为1），中间用一个空格隔开，若存在多个，请输出位置最小的一个（例如：数组为85453，目标值为16，位置125和145均满足条件，输出125）；不满足输出-1。
   输入样例：7 12
   2 8 7 6 3 4 3
   输出样例：1 3 5

	public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N = in.nextInt(); // 数组元素个数
        int T = in.nextInt(); // 目标值
        int[] val = new int[N];
        for (int i = 0;i < N;i++) {
            val[i] = in.nextInt();
        }

        for (int i = 0;i < N;i++) {
            for (int j = 1;j < N;j++) {
                for (int k = 2;k < N;k++) {
                    if (val[i] + val[j] + val[k] == T) {
                        System.out.println((i+1) + " " + (j+1) + " " + (k+1));
                        return;
                    }
                }
            }
        }
        System.out.println("-1");

    }

5. 给定一个只包含0-9、+’、’的合法数学表达式（长度<1000），规定加号‘+”的优先级高于乘号”，请输出计算结果。输入说明：合法的数学表达式
   输出说明：输出表达式的计算结果
   输入样例：123+122输出样例：360

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        //首先将表达式的数字、字符串、括号，提取成单独的元素存放，方便操作
        List<String> list = prefixToList(str);
        //将中缀表达式转换为空格隔开的后缀表达式
        String s = toSuffix(list);
        //计算后缀表达式
        int result = calculationSuffix(s);
        System.out.println(result);
    }

    //计算后缀表达式
    public static int calculationSuffix(String notation) {
        Stack<Integer> stack = new Stack<>();
        //以空格分割上述表达式，存到数组中
        String[] s = notation.split(" ");
        for (int i = 0;i < s.length;i++) {
            if (!isOper(s[i])) {
                //不是运算符，压栈
                stack.push(Integer.parseInt(s[i]));
            } else {
                //是运算符，取出栈中两个数字进行运算
                int res = calculation(stack.pop(),stack.pop(),s[i]);
                stack.push(res);
            }
        }
        return stack.pop();
    }

    //将中缀表达式转换为以空格隔开的后缀表达式
    public static String toSuffix(List<String> list) {
        Stack<String> resultStack = new Stack<>();     //结果栈
        Stack<String> operStack = new Stack<>();    //符号栈
        operStack.push("#");    //用于判断栈中是否还有符号
        //循环入栈
        for (String s : list) {
            if (isOper(s)) {    //判断是否为运算符
                /**
                 * 如果是运算符
                 * 则与栈顶元素比较
                 * 如果优先级高于栈顶运算符（包括左括号）优先级，则进栈
                 * 否则，将栈顶运算符输出
                 * 直至高于栈顶运算符（包括左括号）优先级时停止弹出运算符
                 * 最后将该运算符送入s1栈
                 */
                while (true) {
                    if (priority(s) > priority(operStack.peek())) {
                        operStack.push(s);
                        break;
                    } else {
                        resultStack.push(operStack.pop());
                    }
                }
            } else if (s.equals("(")) {
                //左括号，直接入符号栈
                operStack.push(s);
            } else if (s.equals(")")) {
                //右括号
                //则将距离栈顶最近的左括号之间的运算符输出，舍弃括号
                while (!operStack.peek().equals("(")) {
                    resultStack.push(operStack.pop());
                }
                //将左括号舍弃
                operStack.pop();
            } else {
                //数字，直接入结果栈
                resultStack.push(s);
            }
        }

        //为防止循环结束有运算符留在符号栈
        while (!operStack.peek().equals("#")) {
            resultStack.push(operStack.pop());
        }
        String str = "";
        //以空格隔开方便处理
        for (String s : resultStack) {
            str = str + s + " ";
        }
        return str;
    }


    //将表达式的数字、字符串、括号，提取成单独的元素存放，方便操作
    public static List<String> prefixToList(String notation) {
        String str1;
        String str2;
        List<String> array = new ArrayList<>();
        int i = 0;
        while (i < notation.length()) {
            str1 = Character.toString(notation.charAt(i));

            if (isOper(str1) || str1.equals("(") || str1.equals(")")) {
                //如果是运算符或括号，直接入集合
                array.add(str1);
                i++;
            } else {
                //不是符号
                str2 = "";
                //检查是否为多位数字
                while (!(isOper(str1) || str1.equals("(") || str1.equals(")")) && i < notation.length()) {
                    //如果为数字，拼接字符串
                    str2 = str2 + str1;
                    i++;
                    if (i < notation.length()) {
                        str1 = Character.toString(notation.charAt(i));
                    }
                }
                array.add(str2);
            }
        }
        return array;
    }

    //判断是否为运算符
    public static boolean isOper(String oper) {
        return oper.equals("+") || oper.equals("*");
    }

    //判断运算符的优先级
    public static int priority(String oper) {
        switch (oper) {
            case "+" :
                return 1;
            case "*" :
                return 0;
            default:
                return -1;
        }
    }

    //计算加、乘
    public static int calculation(int num1,int num2,String oper) {
        switch (oper) {
            case "+" :
                return num1 + num2;
            case "*" :
                return num1 * num2;
            default:
                return 0;
        }

    }