简单的离谱
#A 浮点数
本题总分:5 分
问题描述
IEEE 754 规定一个双精度浮点数由
1
1
1 位符号位、
11
11
11 位阶和
52
52
52 位尾数组成(以上位数都表示二进制位数)。
请问,按此规定一个双精度浮点数占用几个字节?
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
8
calcCode:
public class Test {
public static void main(String[] args) {
System.out.println(1 + 11 + 52 >> 3);
}
}
警惕新型攻击言论
#B 求余
本题总分:5 分
问题描述
在 C/C++/Java/Python 等语言中,使用 % 表示求余,请问 2021%20 的值是多少?
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
1
calcCode:
public class Test {
public static void main(String[] args) {
System.out.println(2021 % 20);
}
}
怎么都是些能一眼看出答案的题啊
#C 双阶乘
本题总分:10 分
问题描述
一个正整数的双阶乘,表示不超过这个正整数且与它有相同奇偶性的所有正整数乘积。
n
n
n 的双阶乘用
n
!
!
n!!
n!! 表示。
例如:
3
!
!
=
3
×
1
=
3
3!! = 3 × 1 = 3
3!!=3×1=3。
8
!
!
=
8
×
6
×
4
×
2
=
384
8!! = 8 × 6 × 4 × 2 = 384
8!!=8×6×4×2=384。
11
!
!
=
11
×
9
×
7
×
5
×
3
×
1
=
10395
11!! = 11 × 9 × 7 × 5 × 3 × 1 = 10395
11!!=11×9×7×5×3×1=10395。
请问,
2021
!
!
2021!!
2021!! 的最后
5
5
5 位(这里指十进制位)是多少?
注意:
2021
!
!
=
2021
×
2019
×
⋅
⋅
⋅
×
5
×
3
×
1
2021!! = 2021 × 2019 × · · · × 5 × 3 × 1
2021!!=2021×2019×⋅⋅⋅×5×3×1。
提示:建议使用计算机编程解决问题。
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
59375
calcCode:
public class Test {
public static void main(String[] args) {
long ans = 1;
for (long n = 2021; n > 1; n -= 2)
ans = (ans * n) % (int)1e5;
System.out.println(ans);
}
}
Java 的话还可以用 BigInteger
import java.math.BigInteger;
public class Test {
public static void main(String[] args) {
BigInteger ans = BigInteger.ONE;
for (int i = 2021; i > 1; i -= 2)
ans = ans.multiply(BigInteger.valueOf(i));
System.out.println(ans);
}
}
手动复制就可以了
挂这里是介绍 BigInteger.valueOf
这个方法,效率会比 new
高一点,原理可以自行从源码中找到
#D 格点
本题总分:10 分
问题描述
如果一个点
(
x
,
y
)
(x, y)
(x,y) 的两维坐标都是整数,即
x
∈
Z
x ∈ Z
x∈Z 且
y
∈
Z
y ∈ Z
y∈Z,则称这个点为一个格点。
如果一个点
(
x
,
y
)
(x, y)
(x,y) 的两维坐标都是正数,即
x
>
0
x > 0
x>0 且
y
>
0
y > 0
y>0,则称这个点在第一象限。
请问在第一象限的格点中,有多少个点
(
x
,
y
)
(x, y)
(x,y) 的两维坐标乘积不超过
2021
2021
2021,即
x
⋅
y
≤
2021
x · y ≤ 2021
x⋅y≤2021。
提示:建议使用计算机编程解决问题。
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
15698
calcCode:
public class Test {
public static void main(String[] args) {
int ans = 0;
for (int i = 1; i <= 2021; i++)
for (int j = 1; j <= 2021; j++)
if (i * j <= 2021) ans++;
System.out.println(ans);
}
}
我们显然可以得知
x
≤
2021
y
≤
2021
x ≤ \frac{2021}{y} ≤ 2021
x≤y2021≤2021
然后符号交换范围出来暴力就行了
#E 整数分解
本题总分:15 分
问题描述
将
3
3
3 分解成两个正整数的和,有两种分解方法,分别是
3
=
1
+
2
3 = 1 + 2
3=1+2 和
3
=
2
+
1
3 = 2 + 1
3=2+1。注意顺序不同算不同的方法。
将
5
5
5 分解成三个正整数的和,有
6
6
6 种分解方法,它们是
1
+
1
+
3
=
1
+
2
+
2
=
1
+
3
+
1
=
2
+
1
+
2
=
2
+
2
+
1
=
3
+
1
+
1
1+1+3 = 1+2+2 = 1 + 3 + 1 = 2 + 1 + 2 = 2 + 2 + 1 = 3 + 1 + 1
1+1+3=1+2+2=1+3+1=2+1+2=2+2+1=3+1+1。
请问,将
2021
2021
2021 分解成五个正整数的和,有多少种分解方法?
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
691677274345
calcCode:
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]);
}
}
套 for 复杂度太高了,不想去等结果,就打了个草稿找规律。
也不知道是对是错
#F 3 的倍数
时间限制: 1.0s 内存限制: 512.0MB 本题总分: 15 分
问题描述
小蓝对
3
3
3 的倍数很感兴趣。现在他手头有三个不同的数
a
,
b
,
c
a, b, c
a,b,c,他想知道,这三个数中是不是有两个数的和是
3
3
3 的倍数。
例如,当
a
=
3
,
b
=
4
,
c
=
6
a = 3, b = 4, c = 6
a=3,b=4,c=6 时,可以找到
a
a
a 和
c
c
c 的和是
3
3
3 的倍数。
例如,当
a
=
3
,
b
=
4
,
c
=
7
a = 3, b = 4, c = 7
a=3,b=4,c=7 时,没办法找到两个数的和是
3
3
3 的倍数。
输入格式
输入三行,每行一个整数,分别表示 a , b , c a, b, c a,b,c。
输出格式
如果可以找到两个数的和是 3 3 3 的倍数,输出 y e s yes yes,否则输出 n o no no。
测试样例1
Input:
3
4
6
Output:
yes
测试样例2
Input:
3
4
7
Output:
no
评测用例规模与约定
对于所有评测用例, 1 ≤ a ≤ b ≤ c ≤ 100 1 ≤ a ≤ b ≤ c ≤ 100 1≤a≤b≤c≤100。
code:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
boolean flag = false, torch[] = new boolean[4];
for (int i = 0, n; i < 3; i++) {
n = in.nextInt();
if (torch[n % 3]) flag = true;
else torch[mod(-n, 3)] = true;
}
System.out.println(flag ? "yes" : "no");
}
static int mod(int a, int b) { return a - Math.floorDiv(a, b) * b; }
}
想写的优雅一点,但Java并没有取模运算,艹
#G 特殊年份
时间限制: 1.0s 内存限制: 512.0MB 本题总分:20 分
问题描述
今年是
2021
2021
2021 年,
2021
2021
2021 这个数字非常特殊,它的千位和十位相等,个位比百位大
1
1
1,我们称满足这样条件的年份为特殊年份。
输入
5
5
5 个年份,请计算这里面有多少个特殊年份。
输入格式
输入 5 5 5 行,每行一个 4 4 4 位十进制数(数值范围为 1000 1000 1000 至 9999 9999 9999),表示一个年份。
输出格式
输出一个整数,表示输入的 5 5 5 个年份中有多少个特殊年份。
测试样例1
Input:
2019
2021
1920
2120
9899
Output:
2
Explanation:
2021 和 9899 是特殊年份,其它不是特殊年份。
code:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int i = 5, ans = 0;
char[] buff;
while (i-- > 0) {
buff = in.next().toCharArray();
if (buff[0] == buff[2] && buff[1] + 1 == buff[3]) ans++;
}
System.out.println(ans);
}
}
题出的都是些什么玩意
#H 小平方
时间限制: 1.0s 内存限制: 512.0MB 本题总分:20 分
问题描述
小蓝发现,对于一个正整数
n
n
n 和一个小于
n
n
n 的正整数
v
v
v,将
v
v
v 平方后对
n
n
n 取余可能小于
n
n
n 的一半,也可能大于等于
n
n
n 的一半。
请问,在
1
1
1 到
n
−
1
n − 1
n−1 中,有多少个数平方后除以
n
n
n 的余数小于
n
n
n 的一半。
例如,当
n
=
4
n = 4
n=4 时,
1
,
2
,
3
1, 2, 3
1,2,3 的平方除以
4
4
4 的余数都小于
4
4
4 的一半。
又如,当
n
=
5
n = 5
n=5 时,
1
,
4
1, 4
1,4 的平方除以
5
5
5 的余数都是
1
1
1,小于
5
5
5 的一半。而
2
,
3
2, 3
2,3 的平方除以
5
5
5 的余数都是
4
4
4,大于等于
5
5
5 的一半。
输入格式
输入一行包含一个整数 n n n。
输出格式
输出一个整数,表示满足条件的数的数量。
测试样例1
Input:
5
Output:
2
评测用例规模与约定
对于所有评测用例, 1 ≤ n ≤ 10000 1 ≤ n ≤ 10000 1≤n≤10000。
code:
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);
}
}
弱智题写的就会让人很暴躁知道吧
#I 完全平方数
时间限制: 2.0s 内存限制: 512.0MB 本题总分:25 分
问题描述
一个整数
a
a
a 是一个完全平方数,是指它是某一个整数的平方,即存在一个整数
b
b
b,使得
a
=
b
2
a = b^{2}
a=b2。
给定一个正整数
n
n
n,请找到最小的正整数
x
x
x,使得它们的乘积是一个完全平方数。
输入格式
输入一行包含一个正整数 n n n。
输出格式
输出找到的最小的正整数 x x x。
测试样例1
Input:
12
Output:
3
测试样例2
Input:
15
Output:
15
评测用例规模与约定
对于
30
30
30% 的评测用例,
1
≤
n
≤
1000
1 ≤ n ≤ 1000
1≤n≤1000,答案不超过
1000
1000
1000。
对于
60
60
60% 的评测用例,
1
≤
n
≤
1
0
8
1 ≤ n ≤ 10^{8}
1≤n≤108,答案不超过
1
0
8
10^{8}
108。
对于所有评测用例,
1
≤
n
≤
1
0
12
1 ≤ n ≤ 10^{12}
1≤n≤1012,答案不超过
1
0
12
10^{12}
1012。
code:
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);
}
}
还是基本算式定理
答案逻辑一联立就可得知不包含0,不用特判
#J 负载均衡
时间限制: 2.0s 内存限制: 512.0MB 本题总分: 25 分
问题描述
有
n
n
n 台计算机,第
i
i
i 台计算机的运算能力为
v
i
v_{i}
vi。
有一系列的任务被指派到各个计算机上,第
i
i
i 个任务在
a
i
a_{i}
ai 时刻分配,指定计算机编号为
b
i
b_{i}
bi ,耗时为
c
i
c_{i}
ci 且算力消耗为
d
i
d_{i}
di 。如果此任务成功分配,将立刻开始运行,期间持续占用
b
i
b_{i}
bi 号计算机
d
i
d_{i}
di 的算力,持续
c
i
c_{i}
ci 秒。
对于每次任务分配,如果计算机剩余的运算能力不足则输出
−
1
−1
−1,并取消这次分配,否则输出分配完这个任务后这台计算机的剩余运算能力。
输入格式
输入的第一行包含两个整数
n
,
m
n, m
n,m,分别表示计算机数目和要分配的任务数。
第二行包含
n
n
n 个整数
v
1
,
v
2
,
⋅
⋅
⋅
v
n
v_{1}, v_{2}, · · · v_{n}
v1,v2,⋅⋅⋅vn,分别表示每个计算机的运算能力。
接下来
m
m
m 行每行
4
4
4 个整数
a
i
,
b
i
,
c
i
,
d
i
a_{i}, b_{i}, c_{i}, d_{i}
ai,bi,ci,di,意义如上所述。数据保证
a
i
a_{i}
ai 严格递增,即
a
i
<
a
i
+
1
a_{i} < a_{i+1}
ai<ai+1。
输出格式
输出 m m m 行,每行包含一个数,对应每次任务分配的结果。
测试样例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 个任务,剩余算力足够,且恰好用完。
评测用例规模与约定
对于
20
20
20% 的评测用例,
n
,
m
≤
200
n, m ≤ 200
n,m≤200。
对于
40
40
40% 的评测用例,
n
,
m
≤
2000
n, m ≤ 2000
n,m≤2000。
对于所有评测用例,
1
≤
n
,
m
≤
200000
1 ≤ n, m ≤ 200000
1≤n,m≤200000,
1
≤
a
i
,
c
i
,
d
i
,
v
i
≤
1
0
9
1 ≤ a_{i}, c_{i}, d_{i}, v_{i} ≤ 10^{9}
1≤ai,ci,di,vi≤109,
1
≤
b
i
≤
n
1 ≤ b_{i} ≤ n
1≤bi≤n。
code:
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()); }
}
}
一个大模拟
就感觉没啥含量,有手就能A