第十二届蓝桥杯省赛JavaC组【第二场】真题——详细答案对照(完整版)

红目香薰

已于 2023-02-07 20:52:57 修改

阅读量2.7k

点赞数 4

分类专栏： # 2022年蓝桥杯文章标签：蓝桥杯 java 算法

于 2022-03-10 22:44:41 首次发布

本文链接：https://blog.csdn.net/feng8403000/article/details/123413271

版权

2022年蓝桥杯专栏收录该内容

124 篇文章 88 订阅

订阅专栏

第十二届蓝桥杯省赛JavaC组【第二场】真题——详细答案对照(完整版)

A 浮点数

本题总分：5 分

问题描述

IEEE 754 规定一个双精度浮点数由 1位符号位、11 位阶和 52 位尾数组成（以上位数都表示二进制位数）。
请问，按此规定一个双精度浮点数占用几个字节？

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写

这个整数，填写多余的内容将无法得分。
8

代码实现
无
思路：

（1+11+52）/8

B 求余

本题总分：5 分

问题描述

在 C/C++/Java/Python 等语言中，使用 % 表示求余，请问 2021%20 的值是多少？

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

C 双阶乘

本题总分：10 分

问题描述

一个正整数的双阶乘，表示不超过这个正整数且与它有相同奇偶性的所有正整数乘积。n 的双阶乘用 n!!表示。
例如：
3 ! ! = 3 × 1 = 3。
8 ! ! = 8 × 6 × 4 × 2 = 384。
11 ! ! = 11 × 9 × 7 × 5 × 3 × 1 = 10395。
请问，2021!! 的最后 5 位（这里指十进制位）是多少？
注意：2021!!=2021×2019×⋅⋅⋅×5×3×1。
提示：建议使用计算机编程解决问题。
答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

59375

代码实现

public static void main(String[] args) {
    int x=2021,sum=1;
    for (int i = 3; i <= 2021; i+=2) {
            sum=(sum*i)%100000;
    }
    System.out.println(sum);

}

D 格点

本题总分：10 分

问题描述

如果一个点 ( x , y ) 的两维坐标都是整数，即 x ∈ Z 且 y ∈ Z ，则称这个点为一个格点。
如果一个点 ( x , y ) 的两维坐标都是正数，即 x > 0 且 y > 0 ，则称这个点在第一象限。
请问在第一象限的格点中，有多少个点 ( x , y ) 的两维坐标乘积不超过 2021 ，即 x ⋅ y ≤ 2021。
提示：建议使用计算机编程解决问题。

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

15696

代码实现

public static void main(String[] args) {
    int sum=0;
    for (int i = 1; i < 2021; i++) {
        for (int j = 1; j < 2021; j++) {
            if(i*j<=2021) {
                sum++;
            }
        }
    }
    System.out.println(sum);

}

E 整数分解

本题总分：15 分

问题描述

将 3 分解成两个正整数的和，有两种分解方法，分别是 3 = 1 + 2 和 3 = 2 + 1 。注意顺序不同算不同的方法。
将 5 分解成三个正整数的和，有 6 种分解方法，它们是 1 + 1 + 3 = 1 + 2 + 2 = 1 + 3 + 1 = 2 + 1 + 2 = 2 + 2 + 1 = 3 + 1 + 1。
请问，将 2021 分解成五个正整数的和，有多少种分解方法？

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

public static void main(String[] args) {
        long[][] dp = new long[6][2022];
        java.util.Arrays.fill(dp[1], 1);
        for (int k = 2; k <= 5; k++)
            for (int i = k; i <= 2021; i++)
                dp[k][i] = dp[k][i - 1] + dp[k - 1][i - 1];
        System.out.println(dp[5][2021]);
    }

F 3 的倍数

时间限制: 1.0s 内存限制: 512.0MB 本题总分: 15 分

问题描述

小蓝对 3 33 的倍数很感兴趣。现在他手头有三个不同的数 a , b , c ，他想知道，这三个数中是不是有两个数的和是 3 的倍数。
例如，当 a = 3 , b = 4 , c = 6 时，可以找到 a aa 和 c cc 的和是 3 的倍数。
例如，当 a = 3 , b = 4 , c = 7 时，没办法找到两个数的和是 3 的倍数。

输入格式

输入三行，每行一个整数，分别表示 a , b , c a, b, ca,b,c。

输出格式

如果可以找到两个数的和是 3 33 的倍数，输出 y e s yesyes，否则输出 n o nono。

测试样例1
Input：
3
4
6

Output：
yes

测试样例2
Input：
3
4
7

Output：
no
评测用例规模与约定

对于所有评测用例，1 ≤ a ≤ b ≤ c ≤ 100 。

代码实现

public static void main(String[] args) {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    System.out.println(f(a,b,c,0));

}
public static String f(int x,int y,int z,int count) {
    if(count>=6) {
        return "no";
    }
    if((x+y)%3==0) {
        return "yes";
    }else {
        return f(y,z,x,count+1);
    }
}

G 特殊年份

时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分

问题描述

今年是 2021 年，2021 这个数字非常特殊，它的千位和十位相等，个位比百位大 1 ，我们称满足这样条件的年份为特殊年份。
输入 5 个年份，请计算这里面有多少个特殊年份。

输入格式

输入 5 行，每行一个 4 位十进制数（数值范围为 1000 至 9999 ），表示一个年份。

输出格式

输出一个整数，表示输入的 5 个年份中有多少个特殊年份。

测试样例1
Input：
2019
2021
1920
2120
9899

Output：
2

Explanation：
2021 和 9899 是特殊年份，其它不是特殊年份。

代码实现

static int sum=0;
public static void main(String[] args) {
    Scanner sc=new Scanner(System.in);
    for (int i = 0; i < 5; i++) {
        f(sc.nextInt());
    }
    System.out.println(sum);

}
public static void f(int x) {
    if(x%10==x/100%10+1&&x/1000==x/10%10) {
        sum++;
    }
}

H 小平方

时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分

问题描述

小蓝发现，对于一个正整数 n 和一个小于 n 的正整数 v，将 v 平方后对 n 取余可能小于 n 的一半，也可能大于等于 n 的一半。
请问，在 1 到 n − 1 中，有多少个数平方后除以 n 的余数小于 n 的一半。
例如，当 n = 4 时，1 , 2 , 3 的平方除以 4 的余数都小于 4 的一半。
又如，当 n = 5 时，1 , 4 的平方除以 5 的余数都是 1 ，小于 5 的一半。而 2 , 3 的平方除以 5 的余数都是 4 ，大于等于 5 的一半。

输入格式

输入一行包含一个整数 n 。

输出格式

输出一个整数，表示满足条件的数的数量。

测试样例1
Input：
5

Output：
2
评测用例规模与约定

对于所有评测用例，1 ≤ n ≤ 10000 。

代码实现

public static void main(String[] args) {
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=x/2;
    int sum=0;
    for (int i = 1; i <= x-1; i++) {
        double a=Math.pow(i, 2)%x;
        if(a<y) {
            sum++;
        }
    }
    System.out.println(sum);
}

I 完全平方数

时间限制: 2.0s 内存限制: 512.0MB 本题总分：25 分

问题描述

一个整数 a 是一个完全平方数，是指它是某一个整数的平方，即存在一个整数 b ，使得 a = b^2 。
给定一个正整数 n ，请找到最小的正整数 x ，使得它们的乘积是一个完全平方数。

输入格式

输入一行包含一个正整数 n 。

输出格式

输出找到的最小的正整数 x 。

测试样例1
Input：
12

Output：
3
测试样例2
Input：
15

Output：
15
评测用例规模与约定

对于 30% 的评测用例，1 ≤ n ≤ 1000 ，答案不超过 1000 10001000。
对于 60% 的评测用例，1 ≤ n ≤ 10^8 ，答案不超过 10^8。
对于所有评测用例，1 ≤ n ≤ 1 0^12 ，答案不超过 10^12。

代码实现

public static void main(String[] args) {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=1;
    while(true) {
        String str=String.valueOf(Math.sqrt(n*a));
        int x=str.indexOf(".");
        int b=Integer.parseInt(String.valueOf(str.charAt(x+1)));
        if(b==0&&str.length()-x-1==1) {
            System.out.println(a);
            return;
        }
        a++;
    }
}

J 负载均衡

时间限制: 2.0s 内存限制: 512.0MB 本题总分: 25 分

问题描述

有 n 台计算机，第i台计算机的运算能力为 $v_{i}$ 。
有一系列的任务被指派到各个计算机上，第 i 个任务在 $a_{i}$ 时刻分配，指定计算机编号为 $b_{i}$ ，耗时为 $c_{i}$ 且算力消耗为 $d_{i}$ 。如果此任务成功分配，将立刻开始运行，期间持续占用 $b_{i}$ 号计算机 $d_{i}$ 的算力，持续 $c_{i}$ 秒。对于每次任务分配，如果计算机剩余的运算能力不足则输出 −1，并取消这次分配，否则输出分配完这个任务后这台计算机的剩余运算能力。

输入格式

输入的第一行包含两个整数 n,m，分别表示计算机数目和要分配的任务数。
第二行包含 n 个整数 $v_{1}$ , $v_{2}$ ,··· $v_{n}$ ，分别表示每个计算机的运算能力。
接下来 m 行每行 4 个整数 $a_{i}, b_{i}, c_{i}, d_{i}$ 意义如上所述。数据保证 $a_{i}$ 严格递增，即 $a_{i} < a_{i+1}$ 。

输出格式

输出 m 行，每行包含一个数，对应每次任务分配的结果。

测试数据

没有完全解出来，但是已经能过几个数据了，多少有一些提示作用。

代码实现 (有个bug没修，但是给的测试用例没问题)
//存储任务的总信息
	static Map<Integer, List<Integer>> map=new HashMap<>();
	//存储每个任务的时间
	static List<Integer> times=new ArrayList<>();
	//存储每个任务所消耗的空间
	static List<Integer> kj=new ArrayList<>();
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();//电脑的数量
		int m=sc.nextInt();//任务数
		for (int i =1 ; i < n+1; i++) {
			map.putIfAbsent(i, new ArrayList<>());
			map.get(i).add(sc.nextInt());
		}
		for (int i = 1; i < m+1; i++) {
			int a=sc.nextInt();//读取任务编号
			int b=sc.nextInt();//读取电脑编号
			int c=sc.nextInt();//读取时间消耗
			int d=sc.nextInt();//读取空间消耗
			//时间消耗随着任务的增长而减小
			for (Integer item:map.keySet()) {
				if(map.get(item).size()==5) {
					for (int j = 0; j < times.size(); j++) {
						int y=times.get(j)-1;
						if(y==0) {
							int x=map.get(item).get(0);
							map.get(item).set(0,x+kj.remove(j));
							times.remove(j);
						}else {
							times.set(j, y);
						}		
					}
				}
			}
			//初始化电脑的任务
			if(map.get(b).get(0)>d&&map.get(b).size()<5) {
				map.get(b).add(a);
				map.get(b).add(b);
				map.get(b).add(c);
				map.get(b).add(d);
//				times.add(c);
//				kj.add(d);
			}
			//判断任务的消耗是否超出电脑本身的消耗
			if(map.get(b).get(0)-d<0) {
				System.out.println(-1);
				continue;
			}else {
				//未超出电脑消耗的话则为任务分配空间
				int x=map.get(b).get(0)-d;
					times.add(c);
					kj.add(d);
					System.out.println(x);
				map.get(b).set(0,x);
			}
			
		}
	}

照搬网上的，话说按照网上的这个方法，我是很懵逼的。

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.PriorityQueue;
import java.util.Queue;

public class Main {

    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
        Queue<Item> queue = new PriorityQueue();
        int n = in.nextInt(), m = in.nextInt();
        int[] comp = new int[n + 1];
        int a, b, c, d, time = 1;
        for (int i = 1; i <= n; i++)
              comp[i] = in.nextInt();
        for (int i = 0; i < m; i++) {
            a = in.nextInt();
            b = in.nextInt();
            c = in.nextInt();
            d = in.nextInt();
            if (a > time) time = a;
            while (queue.size() > 0) {
                Item item = queue.peek();
                if (item.time > time) break;
                comp[item.idx] += item.val;
                queue.remove();
            }
            if (comp[b] >= d) {
                queue.add(new Item(b, d, time + c));
                out.println(comp[b] -= d);
            } else out.println("-1");
        }
        out.flush();
    }

    static class Item implements Comparable<Item> {

        int time, idx, val;

        Item(int idx, int val, int time) {
            this.time = time;
            this.idx = idx;
            this.val = val;
        }

        @Override
        public int compareTo(Item o) {
            return this.time - o.time;
        }
    }

    static class InputReader {

        BufferedReader read;
        StringTokenizer token;
        String delimiters;

        InputReader (InputStream in) { this(in, " \t\n\r\f"); }

        InputReader (InputStream in, String delimiters) {
            this.read = new BufferedReader(new InputStreamReader(in));
            this.token = new StringTokenizer("", this.delimiters = delimiters);
        }

        String next() {
            while (!token.hasMoreTokens())
                try {
                    token = new StringTokenizer(read.readLine(), delimiters);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return token.nextToken();
        }

        int nextInt() { return Integer.parseInt(next()); }
    }
}