蓝桥杯 2021年省赛真题 (Java 大学C组) 第二场
题目：
问题描述
IEEE 754 规定一个双精度浮点数由 1位符号位、11 位阶和 52 位尾数组成（以上位数都表示二进制位数）。
请问，按此规定一个双精度浮点数占用几个字节？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。代码：
public class Test {
public static void main(String[] args) {
System.out.println(1 + 11 + 52 >> 3);
}
}
答案：8
这道题就不用说了吧
题目：
问题描述
在 C/C++/Java/Python 等语言中，使用 % 表示求余，请问 2021%20 的值是多少？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。代码：
import java.util.*;
public class Main
{
public static void main(String args[])
{
System.out.println(2021%20);
}
}答案：1
直接打印输出就行
题目：
问题描述
一个正整数的双阶乘，表示不超过这个正整数且与它有相同奇偶性的所有正整数乘积。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。
提示：建议使用计算机编程解决问题。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。代码：
import java.util.*;
public class Main
{
public static void main(String args[])
{
long num = 1;
for (int i = 1; i <= 2021; i += 2) {
num = num * i;
num = num % 100000;
}
System.out.println(num);
}
}答案：59375
for循环从1循环到2021，然后挨个相乘，最后取余10000即可
题目：
问题描述
如果一个点 ( x , y ) 的两维坐标都是整数，即 x ∈ Z 且 y ∈ Z ，则称这个点为一个格点。
如果一个点 ( x , y ) 的两维坐标都是正数，即 x > 0 且 y > 0 ，则称这个点在第一象限。
请问在第一象限的格点中，有多少个点 ( x , y ) 的两维坐标乘积不超过 2021 ，即 x ⋅ y ≤ 2021。
提示：建议使用计算机编程解决问题。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。代码：
import java.util.*;
public class Main
{
public static void main(String args[])
{
int a=0;
for (int i = 1; i <= 2021; i++) {
for (int j = 1; j <=2021; j++) {
if (i*j<=2021) {
a++;
}
}
}
System.out.println(a);
}
}答案：15698
两个坐标，两个for循环，判断当x*y<=2021的时候 计次 输出
题目：
问题描述
将 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 class Test {
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]);
}
}
答案：691677274345
这个有个for循环但是需要等结果，时间特长
题目：
问题描述
小蓝对 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 。代码：
import java.util.*;
public class Main
{
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
for (int i = 1; i <= 1000; i++) {
if ((a + b) % 3 == 0 || (a + c) % 3 == 0 || (b + c) % 3 == 0) {
System.out.println("yes");
break;
} else {
System.out.println("no");
break;
}
}
}
}直接循环判断相加取余3等于0输出yes否则no
题目：
问题描述
今年是 2021 年，2021 这个数字非常特殊，它的千位和十位相等，个位比百位大 1 ，我们称满足这样条件的年份为特殊年份。
输入 5 个年份，请计算这里面有多少个特殊年份。
输入格式
输入 5 行，每行一个 4 位十进制数（数值范围为 1000 至 9999 ），表示一个年份。
输出格式
输出一个整数，表示输入的 5 个年份中有多少个特殊年份。
测试样例1
Input：
2019
2021
1920
2120
9899
Output：
2
Explanation：
2021 和 9899 是特殊年份，其它不是特殊年份。代码：
import java.util.*;
public class Main
{
public static void main(String args[])
{
//Scanner sc = new Scanner(System.in);
// int count = 0;
// for (int i = 0; i < 5; i++) {
// char[] arr = sc.nextLine().toCharArray();
// if (arr[0] == arr[2] && arr[3] - arr[1] == 1) {
// count++;
// }
// }
// System.out.println(count);
Scanner sc = new Scanner(System.in);
String[] year = new String[5];
int count = 0;
for (int i = 0; i < 5; i++) {
year[i] = sc.nextLine();
}
for (int i = 0; i < year.length; i++) {
int a = year[i].charAt(0);// 千位
int b = year[i].charAt(1);// 百位
int c = year[i].charAt(2);// 十位
int d = year[i].charAt(3);// 个位
if (a == c && d - b == 1) {
count++;
}
}
System.out.println(count);
}
}两种方式 哪个都可以 都是用数组判断下标
题目：
问题描述
小蓝发现，对于一个正整数 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 。代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int n = new Scanner(System.in).nextInt();
int ans = 0, mid = n + 1 >> 1;
for (int i = 1; i < n; i++)
if (i * i % n < mid) ans++;
System.out.println(ans);
}
}
题目：
问题描述
一个整数 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。代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
long n = new Scanner(System.in).nextLong(), x = 1;
for (int k = 2, i, j; k <= n; k ++) {
i = 0;
while (n % k == 0) {
n /= k;
i++;
}
if (i > 0) {
j = -i & i;
if (i != 1 && i == j) continue;
x *= Math.pow(k, (j << 1) - i);
}
}
System.out.println(x);
}
}
题目：
测试样例1
Input：
2 6
5 5
1 1 5 3
2 2 2 6
3 1 2 3
4 1 6 1
5 1 3 3
6 1 3 4
Output：
2
-1
-1
1
-1
0
Explanation：
时刻 1，第 1 个任务被分配到第 1 台计算机，耗时为 5 ，这个任务时刻 6 会结束，占用计算机 1 的算力 3。
时刻 2，第 2 个任务需要的算力不足，所以分配失败了。
时刻 3，第 1 个计算机仍然正在计算第 1 个任务，剩余算力不足 3，所以失败。
时刻 4，第 1 个计算机仍然正在计算第 1 个任务，但剩余算力足够，分配后剩余算力 1。
时刻 5，第 1 个计算机仍然正在计算第 1, 4 个任务，剩余算力不足 4，失败。
时刻 6，第 1 个计算机仍然正在计算第 4 个任务，剩余算力足够，且恰好用完。
代码：
import java.util.Scanner;
public class Main {
public static int[][] T = new int[10005][10005]; //T[i][j]存储的是i号计算机在时刻j还剩余多少算力
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int n = in.nextInt(); //计算机台数
int m = in.nextInt(); //要分配的任务数
//输入每台计算机的算力
for(int i = 1; i <= n; i++)
{
int cacl = in.nextInt();
//初始化存放各计算机当前剩余算力的数组T
for(int j = 1; j <= 5000; j++)
{
T[i][j] = cacl;
}
}
//输入m次任务分配详情，并判断本次分配结果
while(m-- > 0)
{
int ai = in.nextInt(); //时刻ai
int bi = in.nextInt(); //分配给几号计算机
int ci = in.nextInt(); //任务占用耗时
int di = in.nextInt(); //任务消耗的算力
if(T[bi][ai] < di) //算力不够，无法分配，取消该次分配
{
System.out.println(-1);
continue;
}
for(int j = ai; j < ai + ci; j++) //占用时长为ci，消耗算力di
{
T[bi][j] -= di;
}
System.out.println(T[bi][ai]);
}
in.close();
}
}最后几道题有点难，总之加油吧！