抱歉，您的浏览器无法访问本站
本页面需要浏览器支持（启用）JavaScript
了解详情 >

编程月练习（1-15题）

刷题

发布于：2025年4月29日

编程月练习题解1-15题

1.小聪买房（基础）

描述

小聪家很有钱，但有钱不代表他傻。现在他要开始买房了，他琢磨着不能买多了，于是将 $n$ 栋房纳入了考虑范围。

如果这栋房性价比高，他就会买；否则，他就不会买。

现在会给出每栋房的总价 $v$，与每栋房的大小 $s$，你可以算出每栋房单位面积内的房价，若该单位面积内的房价超出小聪的接受范围 $w$，则不买；否则，买。

输入

第 1 行两个整数 $n$，$w$。

接下来 $n$ 行，每行两个整数 $v$，$s$。

（$1\le n\le10^6,100\le v,w,s\le10^6+1$）

输出

如果他要买请输出 Yes，否则输出 NO，并换行。

样例

输入

1
2
3
4
3 101
100 200
10100 100
10101 100

输出

1
2
3
Yes
Yes
NO

提示

请从标准输入读入数据，将结果输出到标准输出。

（$1\le n\le10^6,100\le v,w,s\le10^6+1$）

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
using namespace std;

int main(){
    int n,w;
    scanf("%d%d",&n,&w);
    for(int i=0;i<n;i++){
        int v,s;
        scanf("%d%d",&v,&s);
        float result = float(v)/s;
        if(result>w){
            printf("No\n");
        }
        else{
            printf("Yes\n");
        }
    }
    return 0;
}

2.逃跑的吴谦（基础）

描述

吴谦违法被逮捕后的某一天，用超能力逃跑了，此时吴谦被传送到了离警局 $x$ 米处的地方。警察在 $t$ 秒后发现吴谦逃跑，以 $v$ 的速度立马去追。而吴谦因为过度劳累无法逃跑，只能再一次发挥超能力，但超能力有冷却，两次超能力间隔时间必须不小于 $t_2$ 秒。

请问在警察追到他之前，他能否再一次发动超能力。

输入

第 1 行两个整数 $n$，表示有 $n$ 组数据。

接下来 $n$ 行，每行四个整数 $x$，$t$，$v$，$t_2$。

（$1\le n\le10^4,1\le x\le10^6,1\le t<t_2\le10^3,1\le v\le10^3$）

输出

如果他能逃脱请输出 NO!!!，否则输 Nice!，每个字符串占一行。

样例

输入

1
2
3
4
3
12 3 6 5
14 4 10 5
199 100 101 102

输出

1
2
3
Nice!
NO!!!
Nice!

提示

请从标准输入读入数据，将结果输出到标准输出。
输入数据包含多组数据，可以读一组，计算一组，输出一组。

（$1\le n\le10^4,1\le x\le10^6,1\le t<t_2\le10^3,1\le v\le10^3$）

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
using namespace std;

int main(){
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        int x,t,v,t2;
        scanf("%d%d%d%d",&x,&t,&v,&t2);
        double t_catch = (double) x / v + t;
        if (t_catch > t2) {
            cout << "NO!!!" << endl;
        } else {
            cout << "Nice!" << endl;
        }
    }
    return 0;
}

3.接下吧，最后的无为转变（基础）

描述

真子可以通过无为转变将灵魂改变形状，从而将人类变成怪物。为了对抗真子，五条悟老师展开了无量空处 0.5s，一条条信息涌入真子脑海，真子已经奄奄一息之时，突然回光返照，想起了梦中的完美灵魂形状，为了构筑这个完美灵魂，真子先构筑了一个三边边长分别为 $a$，$b$，$c$ 的三角形，并在三角形内部做了一个面积最大的圆。

“桀桀桀”，他笑着伸出双手，“无为转变！五条悟接受我最后的防御形态吧！”

五条悟咧嘴一笑：“苍！”

轰！

“这么强……我的内切圆竟然如此不堪一击。”

那么内切圆半径为多少？

输入

第 1 行一个整数 $n$，表示有 $n$ 组数据。

接下来 $n$ 行，每行三个数 $a$，$b$，$c$。

（$1<n,a,b,c<10^3$）

输出

对每组数据输出内接圆半径（保留两位小数），并换行。

样例

输入

1
2
3
4
3
3 4 5
3.4 4.5 5.6
4.12 6.21 9.74

输出

1
2
3
1.00
1.13
0.82

提示

你或许会用到求面积的海伦公式：$S_{\Delta ABC}=\frac14\sqrt{4a^2b^2-(a^2+b^2-c^2)^2}$（$a$，$b$，$c$ 为三角形三边边长）

输入数据包含多组数据，可以读一组，计算一组，输出一组。

（$1<n,a,b,c<=10^3$）

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
#include <math.h>
using namespace std;

int main(){
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        double a,b,c;
        scanf("%lf%lf%lf",&a,&b,&c);
        double p = (a+b+c)/2;
        double s = sqrt(p*(p-a)*(p-b)*(p-c));
        double r = 2*s/(a+b+c);
        printf("%.2lf\n",r);
    }
}

4.南通学院大赛（基础）

描述

小李是南通学院的优秀学子，在学院庆典上，他决定表演电臀，但令他没想到的是，小雀同学也要表演电臀。一个庆典无法上场两个相同的节目，所以他们决定私下来比试一下电臀水平，谁赢了，谁就能上场表演。

在表演前，你想知道小李与小雀的比赛结果。可是他们却卖了个关子，他们告诉了你两人电臀数的最大公约数 $n$ 与最小公倍数 $m$。你需要输出所有可能的两人的电臀数。

输入

第 1 行一个整数 $t$，表示有 $t$ 组数据。（$1\le t\le1024$）

接下来 $t$ 行，每行两个整数 $n$，$m$。($1\le n\le m\le5\times10^4$)

输出

对于每个 $n$，$m$，输出所有可能的情况，每种情况的两数以空格隔开，并独占一行，每种情况输完后换行。

注：

每种情况需要将较小数优先输出。一组数据中，应将较小数较小的情况优先输出。

样例

输入

1
2
3
4
3
4 32
6 36
1 56

输出

1
2
3
4
5
4 32
6 36
12 18
1 56
7 8

提示

请从标准输入读入数据，将结果输出到标准输出。
输入数据包含多组数据，可以读一组，计算一组，输出一组。

（$1\le t\le1024$）

($1\le n\le m\le5\times10^4$)

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <iostream>
using namespace std;

int min_bei(int a,int b){
    int min = a<b?a:b;
    int more = a+b-min;
    for(int i=1;i<=more;i++){
        if(min*i%more==0){
            return min*i;
        }
    }
}

int max_yue(int a,int b){
    int c;
	while(b)
	{
		c=a%b;
		a=b;
		b=c;
	}
    return a;
}

int main(){
    int t;
    scanf("%d",&t);
    for(int i=0;i<t;i++){
        int n,m;
        scanf("%d%d",&n,&m);
        printf("%d %d\n",n,m);
        int j=2;
        int n2=n*j;
        int m2=m/j;
        while (n2<m2)
        {
            if(m%j==0){
                n2=n*j;
                m2=m/j;
                if(m2%n2!=0 && n2<m2){
                    if(min_bei(n2,m2)==m&&max_yue(n2,m2)==n)
                    printf("%d %d\n",n2,m2);
                }
            }
            j++;
        }
        
    }
    return 0;
}

5.小坤打王者（基础）

描述

小坤最近爱上了一个叫王者农药的游戏，但是他发现这个游戏有一种恶心的 ELO 机制——如果打得太好就会被安排上垃圾队友。为了减少来自垃圾队友的迫害迫害垃圾队友，小坤想到了一个绝妙的法子，就是控制自己的水平，在最后评分尽可能低的情况下赢得游戏的胜利。

小坤和他的 2 位队友都可以挑选刺客、法师、射手、战士 4 种职业，每个人对每种职业的实力值可以不同，但是保证都在区间 $[30,160]$ 中。而小坤对于每种职业的实力值均能在区间 $[30,160]$ 中任意取。当我方实力值总和大于等于敌方实力值总和时，我方就能赢下对局。每个人本局的评分与其本场比赛所选职业的实力值成正比，且比值为 0.1。

小坤给了你每一场比赛中 2 位队友对于每种职业的实力值和对手的实力值总和，请你合理为队友分配职业使小坤能在评分尽可能低的情况下赢下对局。

输入

第 1 行一个整数 $n$，表示有 $n$ 场比赛。（$1\le n\le 100$）

接下来 $n$ 组数据，每组数据占 3 行。

对于每组数据：

第 1 行四个整数 $a_1,a_2,a_3,a_4$，表示第一位队友选刺客、法师、射手、战士时的实力值。

第 2 行四个整数 $b_1,b_2,b_3,b_4$，表示第二位队友选刺客、法师、射手、战士时的实力值。

（对 $n=1,2,3,4$，$30\le a_n,b_n\le160$）；

第 3 行一个整数，为对手实力值总和 $s$。（$90\le s\le480$）

输出

对于每组输入，输出一行。

若无论如何也无法取胜，输出 Sad。

若能取胜，输出一个保留一位小数的浮点数，表示小坤尽可能低的评分。

样例

输入

1
2
3
4
5
6
7
8
9
10
3
50 60 70 70
60 50 30 100
320
90 70 30 80
30 40 30 45
300
160 30 30 30
30 30 30 30
340

输出

1
2
3
15.0
Sad
15.0

提示

你可以使用 printf("%.1f",x); 如此格式化输出语句来输出保留一位小数的单精度浮点数。

当你完成了此题后，不妨在本题基础上加上如下条件作为思考：

由于游戏机制，若队伍中有两人选择相同的职业会使得两人实力值都降低到原来的一半，当然评分也会相应降低。而若有三人选择相同的职业，队友会吵起来而发起投降，直接输掉比赛。

提示：相比本题需再知道每位队友对于每种职业实力的次大值，并判断自己需不需要选相同职业来让自己的评分低于 3.0，由此进行比较。

（$1\le n\le 100$）

（$90\le s\le480$）

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
using namespace std;

int max(int a,int b){
    return a>b?a:b;
}

int main(){
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        int p_max[2];
        for(int p=0;p<2;p++){
            int a,b,c,d;
            scanf("%d%d%d%d",&a,&b,&c,&d);
            p_max[p] = max(max(a,b),max(c,d));
        }
        int enemy;
        scanf("%d",&enemy);
        if(enemy-p_max[0]-p_max[1]>160){
            printf("Sad\n");
        }else{
            float result = float(enemy-p_max[0]-p_max[1])*0.1;
            if(result<3.0)result=3.0;
            printf("%.1f\n",result);
        }
    }
}

6.a,b,c?（基础）

描述

现在有 3 张写了字母 a，b，c 的卡片，现在你可以调换任意 2 张卡片的位置至多一次。

那么让卡片呈现 ”abc“ 顺序的排列可能吗？

若可能，输出 “NO”；若不可能，输出 “YES”。

输入

第一行一个整数 t（$1\le t\le6$）表示有 t 组数据。

接下来 t 行，每行 1 个包含 ”a“、”b“、”c“ 的字符串。

输出

对于每一种数据，输出“YES”和“NO”作为答案。

样例

输入

1
2
3
4
5
6
7
6
abc
acb
bac
bca
cab
cba

输出

1
2
3
4
5
6
YES
YES
YES
NO
NO
YES

提示

In the first test case, we don’t need to do any operations, since the row is already $abc$.

In the second test case, we can swap $c$ and bb: $acb→abc$.

In the third test case, we can swap $b$ and aa: $bac→abc$.

In the fourth test case, it is impossible to make $abc$ using at most one operation.

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
using namespace std;

int main(){
    int t;
    scanf("%d",&t);
    for(int i=0;i<t;i++){
        char str[4];
        scanf("%s",str);
        if(str[0]!='a'){
            if(str[1]!='b'){
                if(str[2]!='c'){
                    printf("NO\n");
                    continue;
                }
            }
        }
        printf("YES\n");
    }
}

7.rating（基础）

描述

在 OI 界，有 10 位世界级顶尖选手，他们在某网站的分数如下：

1
2
3
4
5
6
7
8
9
10
tourist 3858
ksun48 3679
Benq 3658
Um_nik 3648
apiad 3638
Stonefeang 3630
ecnerwala 3613
mnbvmar 3555
newbiedmy 3516
semiexp 3481

你将会被给予一个字符串 S 作为该选手的名字，请输出该选手的分数。

输入

一个字符串 S。

输出

输出该选手的分数。

样例1

输入

1
tourist

输出

1
3858

样例2

输入

1
semiexp

输出

1
3481

提示

请从标准输入读入数据，将结果输出到标准输出。

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <string>
#include <map>
using namespace std;

int main(){
    map<string,int> scores;
    scores["tourist"] = 3858;
    scores["ksun48"] = 3679;
    scores["Benq"] = 3658;
    scores["Um_nik"] = 3648;
    scores["apiad"] = 3638;
    scores["Stonefeang"] = 3630;
    scores["ecnerwala"] = 3613;
    scores["mnbvmar"] = 3555;
    scores["newbiedmy"] = 3516;
    scores["semiexp"] = 3481;
    char name[20];
    scanf("%s",name);
    printf("%d",scores[string(name)]);
}

8.加与减（基础）

描述

你有三个数，分别为 a，b，c。

如果这三个数满足如下条件：

  • $a+b=c$
  • $a−b=c$

那么这三个数就很 nice。

此时，你需要判断这三个数满足哪类 nice。

若 $a+b=c$，则输出 +

若 $a-b=c$，则输出 -

输入

第一行一个整数 t（$1\le t\le162$）表示有 t 组数据。

接下来 t 行，每行三个数 a，b，c （$1\le a,b\le9$, $−8\le c\le18$），数据保证 a，b，c 一定 nice。

输出

For each test case, output either + or - on a new line, representing the correct equation.

样例

输入

1
2
3
4
5
6
7
8
9
10
11
12
11
1 2 3
3 2 1
2 9 -7
3 4 7
1 1 2
1 1 0
3 3 6
9 9 18
9 9 0
1 9 -8
1 9 10

输出

1
2
3
4
5
6
7
8
9
10
11
+
-
-
+
+
-
+
+
-
-
+

提示

请从标准输入读入数据，将结果输出到标准输出。

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
using namespace std;

int main(){
    int t;
    scanf("%d",&t);
    for(int i=0;i<t;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        if(a+b==c){
            printf("+\n");
        }else{
            printf("-\n");
        }
    }
}

9.cp（基础）

描述

阿离和阿信是很好的朋友，他们经常在一起玩好玩的游戏。这一天，他们玩了一个关于糖果的游戏：

有 n 包糖果，每包有 $a_i$ 糖果，如果该包糖果数是偶数，阿离会拿走，否则阿信会拿走。

两人会按照顺序依次拿走 $a_1,a_2…a_n$，现在可以对数列重新排序，问是否存在一种情况，使得任意时刻阿离拿到的糖果数严格大于阿信拿到的。

输入

第一行一个整数 t（$1\le t\le1000$）表示有 t 组数据。

每一组数据，第一行为一个整数 n（$1\le n\le100$）。

第二行为 n 个整数，其中第 i 个数为 $a_i$（$1\le a_i\le100$）表示每个包内的糖果数。

输出

对于每组数据，输出“YES”表示存在一种情况使得任意时刻阿离拿到的糖果数严格大于阿信拿到的，反之，输出“NO”。

样例

输入

1
2
3
4
5
6
7
3
4
1 2 3 4
4
1 1 1 2
3
1 4 3

输出

1
2
3
YES
NO
NO

提示

请从标准输入读入数据，将结果输出到标准输出。

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
using namespace std;

int main(){
    int t;
    scanf("%d",&t);
    for(int i=0;i<t;i++){
        int n;
        scanf("%d",&n);
        int even=0,odd=0;
        for(int j=0;j<n;j++){
            int ai;
            scanf("%d",&ai);
            if(ai%2==0){
                even+=ai;
            }else{
                odd+=ai;
            }
        }
        if(even>odd)printf("YES\n");
        else printf("NO\n");
    }
}

10.sum（基础）

描述

给你三个数，判断其中一个数是不是另外两个数的和。

输入

第一行一个整数 t（$1\le t\le9261$）表示有 t 组数据。

接下来 t 行，每行三个数 a，b，c（$0\le a,b,c\le20$）。

输出

对于每组数据，判断这三个数中其中一个数是不是另外两个数的和。若是，则输出”YES“；否则，输出”NO“。

样例

输入

1
2
3
4
5
6
7
8
7
1 4 3
2 5 8
9 11 20
0 0 0
20 20 20
4 12 3
15 7 8

输出

1
2
3
4
5
6
7
YES
NO
YES
YES
NO
NO
YES

提示

In the first test case, $1+3=4$.

In the second test case, none of the numbers is the sum of the other two.

In the third test case, $9+11=20$.

请从标准输入读入数据，将结果输出到标准输出。

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
using namespace std;

int max(int a,int b){
    return a>b?a:b;
}

int main(){
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        int m = max(max(a,b),max(b,c));
        if(a+b+c==2*m){
            printf("YES\n");
        }else{
            printf("NO\n");
        }
    }
}

11.A+B problem（分支）

描述

注：在代码实现上，本题需使用至少一个 switch 判断语句。

大佬 Aux 看到隔壁 RiziFAN 正在写 A+B Problem，“你这刚学 0.0001 皮秒的人都会写”，并决定把题目升级一下。

一种计算器使用逐步计算的方式计算式子的值，你要做的就是实现这个简单计算器的加、减、乘、整除功能。

计算器初始时计算结果为 $0$，有 $n$ 个操作序列，前 $n-1$ 个操作序列包含一个字符 $op$ 和一个整数 $x$，表示将当前计算结果和 $x$ 进行 $op$ 运算，你需要对于每个操作序列算出每步的计算结果并覆盖上一步的计算结果。最后一个操作序列仅包含一个字符 # 表示关机（结束操作）。

特别地，如果 $op$ 并不是集合 ${\texttt+,\texttt-,\texttt*,\texttt/}$ 中字符的任意一个，输出一行 invalid input，计算结果不变。

如果发生除以 $0$ 操作，输出一行 divided by zero，计算结果不变。

定义“正常计算”为处理完毕一句操作序列之后，输出了一个数而不是一行仅由字母和空白符组成的字符串。

Aux 决定使用这个计算器进行神秘通信，受宇宙射线影响，计算器每正常计算两次，下一次正常计算的计算结果将被翻转，且此次计算不能被认为是正常计算。翻转时数字正负性不变且负号不翻转到数字最后，不保留前导零。此时计算结果被翻转后的数字覆盖，输出时也需要打印出翻转后的数。

输入

$n$ 行，是 $n$ 个操作序列，每个操作序列占一行，包含一个半角字符 $op$ 和一个正整数 $x$。

保证最后一个操作序列仅包含一个 #。

输出

共 $n$ 行，每行对对应的操作序列输出一个整数或一个字符串

样例

输入 1：

1
2
3
4
5
+3
-9
*5
/3
#

输出 1：

1
2
3
4
3
-6
-3
-1

解释 1：

第三次正常计算结果本为 $-30$，但是受宇宙射线影响输出 $-3$，此时存储的计算结果也为 $-3$。

输入 2：

1
2
3
4
5
6
+5
%99999
+3
/0
+4
#

输出 2：

1
2
3
4
5
5
invalid input
8
divided by zero
21

提示

数据范围： $n\leq200$ ，数据保证使用 int 存储所有变量能通过本题。

请从标准输入读入数据，将结果输出到标准输出。

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
#include <iostream>
using namespace std;

int reverse(int num){
    int flag = num>=0?1:-1;
    num=num<0?-num:num;
    int result = 0;
    while (num>0)
    {
        result=result*10+num%10;
        num/=10;
    }
    return result*flag;
    
}

int main(){
    int result=0;
    int turn = 0;
    while (1)
    {
        char op;
        int input;
        scanf("%c",&op);
        if(op=='#')break;
        scanf("%d",&input);
        getchar();
        switch (op)
        {
        case '+':
        {
            result+=input;
            if(turn==2){
                turn=0;
                result = reverse(result);
            }else{
                turn++;
            }
            printf("%d\n",result);
            break;
        }
        case '-':
        {
            result-=input;
            if(turn==2){
                turn=0;
                result = reverse(result);
            }else{
                turn++;
            }
            printf("%d\n",result);
            break;
        }
        case '*':
        {
            result*=input;
            if(turn==2){
                turn=0;
                result = reverse(result);
            }else{
                turn++;
            }
            printf("%d\n",result);
            break;
        }
        case '/':
        {
            if(input==0){
                printf("divided by zero\n");
                break;
            }
            result/=input;
            if(turn==2){
                turn=0;
                result = reverse(result);
            }else{
                turn++;
            }
            printf("%d\n",result);
            break;
        }
        default:
            printf("invalid input\n");
            break;
        }
    }
    return 0;
}

12.那个什么日（分支）

描述

众所周知在一场那个什么日举办的那个什么比赛中，那个什么出题人在那个什么第一题中出了一个那个什么模拟题，导致无数那个什么人因此痛失那个什么奖。于是 Vuler：“我深有那个什么体会”，遂撰此题。

UNIX 时间戳从 1970 年 1 月 1 日开始，到 2038 年 1 月 19 日（3 时 14 分 7 秒）结束。

定义“第 $x$ 个那个什么日”为从 1970 年 1 月 1 日之后 $x$ 天的日期，求第 $x$ 个那个什么日。

注：当一个年份能被 4 整除但是不能被 100 整除时为闰年，本年 2 月有 29 天而不是 28 天。特别地，能被 400 整除的年份必定为闰年。

输入

仅一行，一个整数 $x$。

输出

仅一行，一个字符串表示第 $x$ 个那个什么日的日期。

字符串格式为 年-月-日，且保留前导 0。

样例

输入 1：

1
1

输出 1：

1
1970-01-02

输入 2：

1
19631

输出 2：

1
2023-10-01

提示

数据范围：$0\leq x\leq10^9$。

请注意，一般的计算机 1 秒内只能处理大约 $2\times10^8 \sim 7\times10^8$ 次运算。

你可以使用 break; 语句在循环的任何时候跳出距离此语句最内层的循环。

请从标准输入读入数据，将结果输出到标准输出。

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <iostream>
using namespace std;

int is_lunarYear(int num){
    if(num%400==0){
        return 1;
    }
    if(num%4==0&&num%100!=0){
        return 1;
    }else{
        return 0;
    }
}

int main(){
    int month_day[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
    int x;
    scanf("%d",&x);
    int pri_year = 1970;
    while (x>=0)
    {
        month_day[1]=28+is_lunarYear(pri_year);
        for(int i=1;i<=12;i++){
            if(x>=month_day[i-1]){
                x-=month_day[i-1];
            }else{
                x++;
                printf("%d-%02d-%02d",pri_year,i,x);
                return 0;
            }
        }
        pri_year++;
    }
    
}

13.一种基于科学的打牌方式（分支）

描述

“雀魂，启动！”

谁也没想到 emyin 卷到这来了，他使用了一种科学方法对每步操作的效率进行分析，结果：

“六饼是现物啊！怎么会这样…？”

你无意中进入了房间，现在你手里有 $n$ 张牌，用 $1$ 到 $n$ 的数字表示。

定义“能打的牌”为，在 $[l,r]$ 里，打出这张牌输的概率会小很多的牌。

emyin 说过，编号能被 $x$ 和 $y$ 整除的牌是能打的牌。

StepNeuro64 认为，编号能被 $x$ 或 $y$ 整除的牌是能打的牌。

你需要分别计算在 $[l,r]$ 里，emyin 和 StepNeuro64 认为能打的牌的编号之和是多少。

输入

仅一行，五个整数 $n,x,y,l,r$，表示牌数，属性 $x,y$ 和区间 $[l,r]$。

输出

两个整数，分别表示 emyin 和 StepNeuro64 认为能打的牌的编号之和。

样例

输入

1
5 1 4 1 5

输出

1
4 15

提示

数据范围：$n\leq 1000,1\leq l\leq r \leq n,1\leq x,y\leq n$。

请从标准输入读入数据，将结果输出到标准输出。

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
using namespace std;

int main(){
    int n,x,y,l,r;
    scanf("%d%d%d%d%d",&n,&x,&y,&l,&r);
    int emyin=0,StepNeuro64=0;
    for(int i=l;i<=r;i++){
        if(i%x==0){
            StepNeuro64+=i;
            if(i%y==0){
                emyin+=i;
            }
        }else{
            if(i%y==0){
                StepNeuro64+=i;
            }
        }
    }
    printf("%d %d",emyin,StepNeuro64);
}

14.法师（分支）

描述

注：在代码实现上，

  • 本题不能使用数组等超纲内容。
  • 本题须至少定义并使用一个函数。

Hshww：你们从哪变出的面条？

Wcoctob：哦，他们学编程啥都没学会，但是学会了魔法，于是变成法师了。面条是他们变出来的。

sbnp 是一名法师，他有一本仅由字母和数字组成的咒语。

当然，sbnp 知道你已经熟练掌握了查询字数的能力，于是他准备在咒语本上安装一个沃德用于查询字数。

咒语本上沃德的图标：

  • 由 $n$ 行组成，每行 $n$ 个字符。

  • 在第 $i$ 行第 $j$ 列的字符是 * 当且仅当 $j \operatorname{mod} t_i =0$。

给定 $n$ 和 $t_i$，请打印对应边长的沃德图标。

输入

共两行。

第一行为一个整数 $n$。

接下来 $n$ 个数，为 $t_i$。

输出

共 $n$ 行，表示边长为 $n$ 的沃德图标。

样例

输入

1
2
7
1 2 3 4 5 6 7

输出

1
2
3
4
5
6
7
*******
 * * * 
  *  * 
   *   
    *  
     * 
      *

提示

数据范围：$n\leq 128$。

如果将变量定义在 main 函数以外，则此变量能在定义位置往后所有语句内互通使用。

定义没有返回值的函数时，可以将 int 改为 void，结尾不需要写 return 返回值; 或者仅写 return;。

如果你输入的 $n$ 很大，且 $t_i=i$，那么输出的图案将会非常美观。

请从标准输入读入数据，将结果输出到标准输出。

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
using namespace std;

void print_line(int x,int ti){
    for(int i=1;i<=x;i++){
        if(i%ti==0){
            printf("*");
        }else{
            printf(" ");
        }
    }
    printf("\n");
}

int main(){
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        int ti;
        scanf("%d",&ti);
        print_line(n,ti);
    }

}

15.猿神，起洞（分支）

描述

相传，孙悟空被五指山压了 500 年后大喊一声：猿神，起洞！

唐僧看见孙悟空的一万个分身后说：原来你也万猿身！

在游戏《猿神》中，主角孙悟空原名冰心，浙江周树人，后改名步惊云，恶魔果实能力者。经过 DNA 电泳分析可得，他统一三国的概率取决于应急食品里 42 号混凝土的质量。为了不影响挖掘机的扭矩，他利用缩聚反应产生的高能蛋白收集七个葫芦娃在羊村召唤青眼白龙终于获得了 Concrete Math 中的相关函数。

f(x)={x−⌊x⌋,2k≤x≤2k+1,k∈Z⌊x⌋−x+1,2k+1≤x≤2k+2,k∈Z

孙悟空现在有一个浮点数 $x$，他找到了已经掌握条件语句的你，让你帮忙求 $f(x)$，以便知道他统一三国的概率。

输入

仅一行，一个浮点数 $x$，保证 $x$ 仅保留两位小数。

输出

仅一行，为 $f(x)$，保留两位小数后输出。

样例

输入 1：

1
0.59

输出 1：

1
0.59

输入 2：

1
1.73

输出 2：

1
0.27

提示

数据范围：$|x|\leq 10^9$。

还记得附录 A 里的数学库函数吗？

使用 printf("%.2f",x) 以快速方便地输出保留两位小数后的单精度浮点数 $x$。

请从标准输入读入数据，将结果输出到标准输出。

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
#include <cmath>
#include <cstdio>

using namespace std;

int main() {
    double x;
    cin >> x;
    int intPart = floor(x);
    double fracPart = x - intPart;
    if (intPart % 2 == 0) {
        printf("%.2f\n", fracPart);
    } else {
        printf("%.2f\n", intPart - x + 1);
    }
    return 0;
}
编程月练习（1-15题）
https://www.blog.jeanhua.cn/2025/04/29/fc8d9704a323/
本文作者
jeanhua
发布于
2025年4月29日
更新于
2025年5月3日
许可协议
CC BY-NC-SA 4.0
署名-非商业性使用-相同方式共享 4.0 国际。

更新于：2025年5月3日

C++

编程月

算法

评论