2020全国高校计算机能力挑战赛（程序设计Java）模拟题

其他 2021-01-31 23:38
0 阅读

  1. 统计1到N（含）之间所有平方数的个数，并输出这个数目。
    提示：平方数的个数，如4是2的平方数，16是4的平方数，5不是平方数。
    输入说明：一个整数N(N<100000)；
    输出说明：平方数的个数
    输入样例：50
    输出样例：7

    import java.util.Scanner;

public class sim01 {
      
      
    public static void main(String[] args) {
      
      
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int count = 0;
        for (int i = 1; i <= N; i++) {
      
      
            if (Math.sqrt(i) % 1 == 0) {
      
      
                count++;
            }
        }
        System.out.println(count);
        in.close();
    }
}

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

    import java.util.Scanner;

public class sim02 {
      
      
    public static void main(String[] args) {
      
      
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int[] a = new int[N];
        int count = 0;
        boolean[] b = new boolean[N];
        for (int i = 0; i < N; i++) {
      
      
            a[i] = in.nextInt();
        }
        for (int i = 0; i < N; i++) {
      
      
            for (int j = 2; j <= Math.sqrt(a[i]); j++) {
      
      
                if (a[i] % j == 0) {
      
      
                    b[i] = true;
                    break;
                }
            }
        }
        for (int i = 0; i < b.length - 2; i++) {
      
      
            if (b[i] & b[i + 1] & b[i + 2]) {
      
      
                count++;
            }
        }
        System.out.println(count);
        in.close();
    }
}

  3. 字母连连看，给定一个由小写英文字母组成的字符串(长度<1000)，如果字符串中有两个连续的字母相同，则这两个字母可同时消除，并不断重复该操作，直到不能消除为止。请编程判断该字符串是否可以完全消除。
    输入说明：一个字符串。
    输出说明：如果可以完全消除，输出“YES”，如果不可以，输出消除后的结果。
    输入样例1：abacddcaba
    输出样例1：YES
    输入样例2：asdfghhgf
    输出样例2：asd

    import java.util.Scanner;

public class sim03 {
      
      
    public static void main(String[] args) {
      
      
        Scanner in = new Scanner(System.in);
        String str = in.next();
        String jiequ = jiequ(str);
        if (jiequ.length() < 1) {
      
      
            System.out.println("YES");
        } else {
      
      
            System.out.println(jiequ);
        }
        in.close();
    }

    public static String jiequ(String str) {
      
      
        String s = str;
        for (int i = 0; i < s.length() - 1; i++) {
      
      
            if (s.charAt(i) == s.charAt(i + 1)) {
      
      
                s = s.substring(0, i) + s.substring(i + 2, s.length());
            }
        }
        if (s.equals(str)) {
      
      
            return s;
        } else {
      
      
            return jiequ(s);
        }
    }
}

  4. 由N（N<=10000）个整数组成的数组，其中连续K（K<=200）个元素构成一个区间，称为K区间。一个K区间中所有素数的和记为Sk，请计算整个数组中，所有K区间中的最大Sk值，并输出。
    输入说明：第一行是两个整数N和K，第二行输入N个数，表示数组中的元素。
    输出说明：最大Sk值
    输入样例：8 2
    12 23 27 34 19 17 45 8
    输出样例：36

    import java.util.Scanner;

public class sim04 {
      
      
    public static void main(String[] args) {
      
      
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int K = in.nextInt();
        int[] n = new int[N];
        int count = 0;
        for (int i = 0; i < N; i++) {
      
      
            n[i] = in.nextInt();
        }
        for (int i = 0; i < N - K + 1; i++) {
      
      
            int temp = 0;
            for (int j = 0; j < K; j++) {
      
      
                if (!issushu(n[i + j])) {
      
      
                    temp += n[i + j];
                }
            }
            if (count < temp) {
      
      
                count = temp;
            }
        }
        System.out.println(count);
    }

    public static boolean issushu(int a) {
      
      
        for (int i = 2; i < Math.sqrt(a); i++) {
      
      
            if (a % i == 0) {
      
      
                return true;
            }
        }
        return false;
    }
}

  5. 仓库新进了几批物资，只知道每批物资的数量和单价，请编写程序，按照每种物资的总价值，由高到低次序输出。
    输入说明：第1行 一个整数N，表明物资的批次数量
    第2-N+1行，每批物资的类别、数量及单价，中间用空格隔开，其中类别用A-Z加以区分。
    输出说明：按物资价值降序输出排序结果，每行输出一种物资。
    输入样例：5
    A 5 10.00
    B 3 2.00
    A 5 8.00
    B 3 2.50
    C 10 3.50
    输出样例：A 90.00
    C 35.00
    B 13.50

    import java.text.DecimalFormat;
import java.util.*;

public class sim05 {
      
      
    public static void main(String[] args) {
      
      
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        List<String> listname = new ArrayList<String>();
        List<Double> listd = new ArrayList<Double>();
        for (int i = 0; i < N; i++) {
      
      
            String s = in.next();
            Double d = in.nextInt() * in.nextDouble();
            boolean flag = false;
            for (int i1 = 0; i1 < listname.size(); i1++) {
      
      
                if (listname.get(i1).equals(s)) {
      
      
                    listd.set(i1, listd.get(i1) + d);
                    flag = true;
                }
            }
            if (!flag) {
      
      
                listname.add(s);
                listd.add(d);
            }
        }
        for (int j = 0; j < listd.size(); j++) {
      
      
            for (int k = 0; k < listd.size() - 1; k++) {
      
      
                if (listd.get(k) < listd.get(k + 1)) {
      
      
                    double temp = listd.get(k);
                    listd.set(k, listd.get(k + 1));
                    listd.set(k + 1, temp);
                    String str = listname.get(k);
                    listname.set(k, listname.get(k + 1));
                    listname.set(k + 1, str);
                }
            }
        }
        DecimalFormat df = new DecimalFormat("0.00 ");
        for (int i1 = 0; i1 < listd.size(); i1++) {
      
      
            System.out.println(listname.get(i1) + " " + df.format(listd.get(i1)));
        }
    }
}

  6. 统计1到N（含）之间所有立方数的个数，并输出这个数目。
    提示：立方数的个数，如8是2的立方数，27是3的立方数，9不是立方数。
    输入说明：一个整数N(N<100000)；
    输出说明：立方数的个数
    输入样例：200
    输出样例：5

    import java.util.Scanner;

public class sim06 {
      
      
    public static void main(String[] args) {
      
      
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        double pow = Math.pow(N, 1.0 / 3);
        int count = (int) (pow / 1);
        System.out.println(count);
        in.close();
    }
}

  7. 统计整数区间[N, M] (N,M<100000)中所有非偶数的合数个数，并输出这个数。
    输入说明：两个整数N、M；
    输出说明：非偶数的合数个数
    输入样例：2 16
    输出样例：2

    import java.util.Scanner;

public class sim07 {
      
      
    public static void main(String[] args) {
      
      
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int M = in.nextInt();
        int count = 0;
        for (int i = N; i < M; i++) {
      
      
            for (int j = 3; j <= Math.sqrt(i); j = j + 2) {
      
      
                if (i % j == 0 & i % 2 != 0) {
      
      
                    count++;
                    break;
                }
            }
        }
        System.out.println(count);
        in.close();
    }
}

  8. 对于给定的字符数组（字符数少于10000），统计其中字母类型、数字类型和符号类型的字符出现次数，其中字母类型是英文字母a-z之间的字符（不区分大小写）；数字类型是0-9之间的字符；符号类型是除英文字母、数字及空格外的其它字符。
    输入说明：一个字符序列；
    输出说明：分三行输出：第一行字母类型，以a-z标识；第二行数字类型，以0-9标识；第三行符号类型，以others标识。每行格式如下：
    类别标识 出现次数（中间用一个空格分隔）
    输入样例：Hello World!
    输出样例：a-z 10
    0-9 0
    others 1

    import java.util.Scanner;

public class sim08 {
      
      
    public static void main(String[] args) {
      
      
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        int num = 0;
        int abz = 0;
        int others = 0;
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
      
      
            if ((int) chars[i] == 32) {
      
      
                continue;
            } else if ((int) chars[i] >= 48 && (int) chars[i] <= 57) {
      
      
                num++;
                continue;
            } else if ((int) chars[i] >= 65 && (int) chars[i] <= 122) {
      
      
                abz++;
                continue;
            } else {
      
      
                others++;
            }
        }
        System.out.println("a-z " + abz);
        System.out.println("0-9 " + num);
        System.out.println("others " + others);
        in.close();
    }
}

  9. 由N（N<=10000）个整数组成的数组，其中连续K（K<=200）个元素构成一个区间，称为K区间。一个K区间中任意两个数求其差值的绝对值，其中最大的绝对值记为Dk。请计算整个数组中，所有K区间中的最大Dk值，并输出。
    输入说明：第一行是两个整数N和K，第二行输入N个数，表示数组中的元素。
    输出说明：最大Dk值。
    输入样例：8 2
    12 23 27 34 35 36 8 45
    输出样例：37

    import java.util.Scanner;

public class sim09 {
      
      
    public static void main(String[] args) {
      
      
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int K = in.nextInt();
        int[] n = new int[N];
        int[][] a = new int[N - K + 1][K];
        int count = 0;
        for (int i = 0; i < N; i++) {
      
      
            n[i] = in.nextInt();
        }
        for (int i = 0; i < a.length; i++) {
      
      
            for (int j = 0; j < a[i].length; j++) {
      
      
                a[i][j] = n[i + j];
            }
        }
        int x = 0;
        for (int i = 0; i < a.length; i++) {
      
      
            for (int j = 0; j < a[i].length - 1; j++) {
      
      
                if (a[i][j] - a[i][j + 1] > 0) {
      
      
                    x = a[i][j] - a[i][j + 1];
                } else {
      
      
                    x = a[i][j + 1] - a[i][j];
                }
                count = x > count ? x : count;
            }
        }
        System.out.println(count);
        in.close();
    }
}

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

    import java.util.Scanner;

public class sim10 {
      
      
    public static void main(String[] args) {
      
      
        Scanner in = new Scanner(System.in);
        String str = in.next();
        String[] split1 = str.split("\\*");
        int result = 1;
        for (int i = 0; i < split1.length; i++) {
      
      
            String[] split2 = split1[i].split("\\+");
            int count = 0;
            for (int j = 0; j < split2.length; j++) {
      
      
                count += Integer.parseInt(split2[j]);
            }
            result *= count;
        }
        System.out.println(result);
        in.close();
    }
}

猜你喜欢

目录

热门文章