Posted on Edited on

7-1 重要的话说三遍

分数 5

作者 陈越

单位 浙江大学

这道超级简单的题目没有任何输入。

你只需要把这句很重要的话 —— “I’m gonna WIN!”——连续输出三遍就可以了。

注意每遍占一行，除了每行的回车不能有任何多余字符。

代码长度限制

16 KB

时间限制

400 ms

内存限制

代码如下：

1
2
3
4
5
6
7
#include <stdio.h>
int main(){
    printf("I'm gonna WIN!\n");
    printf("I'm gonna WIN!\n");
    printf("I'm gonna WIN!\n");
    return 0;
}

7-2 I Love GPLT

这道超级简单的题目没有任何输入。

你只需要把这句很重要的话 —— I Love GPLT ——竖着输出就可以了。

所谓“竖着输出”，是指每个字符占一行（包括空格），即每行只能有1个字符和回车。

代码长度限制

16 KB

时间限制

400 ms

内存限制

代码如下：

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
int main(){
    char a[50]={"I Love GPLT"};
    int i=0;
    while(a[i]!='\0'){
        printf("%c\n",a[i]);
        i++;
    }
    return 0;
}

7-3 输出带框文字

本题要求编写程序，输出指定的带框文字。

输入格式：

本题无输入

输出格式：

按照下列格式输出带框文字。

1
2
3
************
  Welcome
************

代码长度限制

16 KB

时间限制

400 ms

内存限制

6

代码如下：

1
2
3
4
5
6
7
8
#include <stdio.h>
int main(){
    char a[50]={"************"};
    char b[50]={"Welcome"};
    printf("%s\n  %s\n%s",a,b,a);

    return 0;
}

7-4 输出菱形图案

本题要求编写程序，输出指定的由“A”组成的菱形图案。

输入格式：

本题无输入

输出格式：

按照下列格式输出由“A”组成的菱形图案。

1
2
3
  A
A   A
  A

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
#include <stdio.h>
int main(){
    printf("  A\nA   A\n  A");
    return 0;
}

7-5 输出倒三角图案

本题要求编写程序，输出指定的由“*”组成的倒三角图案。

输入格式:

本题目没有输入。

输出格式:

按照下列格式输出由“*”组成的倒三角图案。

1
2
3
4
* * * *
 * * *
  * *
   *

代码长度限制

16 KB

时间限制

400 ms

内存限制

代码如下：

1
2
3
4
5
#include <stdio.h>
int main(){
    printf("* * * *\n * * *\n  * *\n   *");
    return 0;
}

7-6 厘米换算英尺英寸

如果已知英制长度的英尺foot和英寸inch的值，那么对应的米是(foot+inch/12)×0.3048。现在，如果用户输入的是厘米数，那么对应英制长度的英尺和英寸是多少呢？别忘了1英尺等于12英寸。

输入格式：

输入在一行中给出1个正整数，单位是厘米。

输出格式：

在一行中输出这个厘米数对应英制长度的英尺和英寸的整数值，中间用空格分开。英寸的值应小于12。

输入样例：

1
170

输出样例：

1
5 6

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
int main(){
    int height=0;
    scanf("%d",&height);
    float m_height=height/100.0;
    float  foot=m_height/0.3048;
    int p_foot=foot,inch=(foot-p_foot)*12;
    printf("%d %d",p_foot,inch);
    return 0;
}

7-7 计算摄氏温度

给定一个华氏温度F，本题要求编写程序，计算对应的摄氏温度C。计算公式：C=5×(F−32)/9。题目保证输入与输出均在整型范围内。

输入格式:

输入在一行中给出一个华氏温度。

输出格式:

在一行中按照格式“Celsius = C”输出对应的摄氏温度C的整数值。

输入样例:

1
150

输出样例:

1
Celsius = 65

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
#include <stdio.h>
int main(){
    int F=0;
    scanf("%d",&F);
    float C=5.0*(F-32)/9.0;
    int True_C=C;
    printf("Celsius = %d",True_C);
    return 0;
}

7-8 是不是太胖了

据说一个人的标准体重应该是其身高（单位：厘米）减去100、再乘以0.9所得到的公斤数。已知市斤的数值是公斤数值的两倍。现给定某人身高，请你计算其标准体重应该是多少？（顺便也悄悄给自己算一下吧……）

输入格式：

输入第一行给出一个正整数H（100 < H ≤ 300），为某人身高。

输出格式：

在一行中输出对应的标准体重，单位为市斤，保留小数点后1位。

输入样例：

1
169

输出样例：

1
124.2

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
#include <stdio.h>
int main(){
    int height=0;
    scanf("%d",&height);
    float result=(height-100)*0.9*2.0;
    printf("%.1lf",result);
    return 0;
}

7-9 求整数均值

本题要求编写程序，计算4个整数的和与平均值。题目保证输入与输出均在整型范围内。

输入格式:

输入在一行中给出4个整数，其间以空格分隔。

输出格式:

在一行中按照格式“Sum = 和; Average = 平均值”顺序输出和与平均值，其中平均值精确到小数点后一位。

输入样例:

1
1 2 3 4

输出样例:

1
Sum = 10; Average = 2.5

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
int main(){
    int a=0,b=0,c=0,d=0,sum=0;
    float average=0;
    scanf("%d %d %d %d",&a,&b,&c,&d);
    sum=a+b+c+d;
    average=sum/4.0;
    printf("Sum = %d; Average = %.1lf",sum,average);
    return 0;
}

7-10 算术入门之加减乘除

对于输入的两个整数，按照要求输出其和差积商。

输入格式:

在一行内输入两个不超过100的非负整数a和b，中间以一个空格间隔，且保证b不为0。

输出格式:

共四行，格式是：

1
2
3
4
[a] + [b] = [a+b]
[a] - [b] = [a-b]
[a] * [b] = [a*b]
[a] / [b] = [a/b]

其中，带有方括号的内容（如[a]、[b]、[a+b]等）表示相应整数或运算结果的值，在输出时要用实际的值代替。

并且：如果a能够被b整除，那么a/b应输出为整数格式，否则a/b输出为带两位小数的格式。

提示：注意表达式中的空格。

输入样例1:

1
6 3

输出样例1:

1
2
3
4
6 + 3 = 9
6 - 3 = 3
6 * 3 = 18
6 / 3 = 2

输入样例2:

1
8 6

输出样例2:

1
2
3
4
8 + 6 = 14
8 - 6 = 2
8 * 6 = 48
8 / 6 = 1.33

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
int main(){
    int a=0,b=0;
    float c=0;
    scanf("%d %d",&a,&b);
    printf("%d + %d = %d\n%d - %d = %d\n%d * %d = %d\n",a,b,a+b,a,b,a-b,a,b,a*b);
    if(a%b==0)  printf("%d / %d = %d",a,b,a/b);
    else    printf("%d / %d = %.2lf",a,b,a*1.0/b);
    return 0;
}

7-11 计算平均分

已知某位学生的数学、英语和计算机课程的成绩分别是87分、72分和93分，求该生3门课程的平均成绩（结果按整型输出）。

输入格式：

本题无输入

1

输出格式：

按照下列格式输出结果：

1
math = 87, eng = 72, comp = 93, average = 计算所得的平均成绩

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
#include <stdio.h>
int main(){
    printf("math = 87, eng = 72, comp = 93, average = %d",(87+72+93)/3);
    return 0;
}

7-12 日期格式化

世界上不同国家有不同的写日期的习惯。比如美国人习惯写成“月-日-年”，而中国人习惯写成“年-月-日”。下面请你写个程序，自动把读入的美国格式的日期改写成中国习惯的日期。

输入格式：

输入在一行中按照“mm-dd-yyyy”的格式给出月、日、年。题目保证给出的日期是1900年元旦至今合法的日期。

输出格式：

在一行中按照“yyyy-mm-dd”的格式给出年、月、日。

输入样例：

1
03-15-2017

输出样例：

1
2017-03-15

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
#include <stdio.h>
int main(){
    int mm=0,dd=0,yyyy=0;
    scanf("%d-%d-%d",&mm,&dd,&yyyy);
    printf("%d-%02d-%02d",yyyy,mm,dd);
    return 0;
}

7-13 后天

如果今天是星期三，后天就是星期五；如果今天是星期六，后天就是星期一。我们用数字1到7对应星期一到星期日。给定某一天，请你输出那天的“后天”是星期几。

输入格式：

输入第一行给出一个正整数D（1 ≤ D ≤ 7），代表星期里的某一天。

输出格式：

在一行中输出D天的后天是星期几。

输入样例：

1
3

输出样例：

1
5

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
#include <stdio.h>
int main(){
    int m=0;
    scanf("%d",&m);
    if((m+2)%7==0)  printf("7");
    else    printf("%d",(m+2)%7);
    return 0;
}

7-14 然后是几点

有时候人们用四位数字表示一个时间，比如 1106 表示 11 点零 6 分。现在，你的程序要根据起始时间和流逝的时间计算出终止时间。

读入两个数字，第一个数字以这样的四位数字表示当前时间，第二个数字表示分钟数，计算当前时间经过那么多分钟后是几点，结果也表示为四位数字。当小时为个位数时，没有前导的零，例如 5 点 30 分表示为 530；0 点 30 分表示为 030。注意，第二个数字表示的分钟数可能超过 60，也可能是负数。

输入格式：

输入在一行中给出 2 个整数，分别是四位数字表示的起始时间、以及流逝的分钟数，其间以空格分隔。注意：在起始时间中，当小时为个位数时，没有前导的零，即 5 点 30 分表示为 530；0 点 30 分表示为 030。流逝的分钟数可能超过 60，也可能是负数。

输出格式：

输出不多于四位数字表示的终止时间，当小时为个位数时，没有前导的零。题目保证起始时间和终止时间在同一天内。

输入样例：

1
1120 110

输出样例：

1
1310

鸣谢燕山大学穆运峰老师、用户任钰补充数据！

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#include <stdio.h>
int main() {
    int hh = 0, mm = 0;
    int beg = 0, end = 0;
    scanf("%d %d", &beg, &end);
    int index_h = 1, index_m = 1;
    for (int i = 0; i < 4; ++i) {
        if (i <= 1) {
            mm = mm + (beg % 10) * index_m;
            index_m *= 10;
        }
        else {
            hh = hh + (beg % 10) * index_h;
            index_h *= 10;
        }
        beg /= 10;
    }
    if (mm + end < 0) {
        int abs = -(mm + end);
        if (abs % 60 == 0)  hh = hh - abs / 60;
        else hh = hh - abs / 60 - 1;
        mm = 60 - abs % 60;
    }
    else if (mm + end >= 60) {
        int abs = (mm + end);
        hh = hh + abs / 60;
        mm = abs % 60;
    }
    else {
        mm = mm + end;
    }
    printf("%03d", mm + hh * 100);
    return 0;
}

7-15 BCD解密

BCD数是用一个字节来表达两位十进制的数，每四个比特表示一位。所以如果一个BCD数的十六进制是0x12，它表达的就是十进制的12。但是小明没学过BCD，把所有的BCD数都当作二进制数转换成十进制输出了。于是BCD的0x12被输出成了十进制的18了！

现在，你的程序要读入这个错误的十进制数，然后输出正确的十进制数。提示：你可以把18转换回0x12，然后再转换回12。

输入格式：

输入在一行中给出一个[0, 153]范围内的正整数，保证能转换回有效的BCD数，也就是说这个整数转换成十六进制时不会出现A-F的数字。

输出格式：

输出对应的十进制数。

输入样例：

1
18

输出样例：

1
12

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<stdio.h>
int main() {
	int result = 0;
	scanf("%d", &result);
	int p = 0,index=1;
	while (result) {
		int t = result % 16 * index;
		p += t;
		index *= 10;
		result /= 16;
	}
	printf("%d", p);
	return 0;
}

7-16 计算符号函数的值

对于任一整数n，符号函数sig**n(n)的定义如下：

记录

请编写程序计算该函数对任一输入整数的值。

输入格式:

输入在一行中给出整数n。

输出格式:

在一行中按照格式“sign(n) = 函数值”输出该整数n对应的函数值。

输入样例1:

1
10

输出样例1:

1
sign(10) = 1

输入样例2:

1
0

输出样例2:

1
sign(0) = 0

输入样例3:

1
-98

输出样例3:

1
sign(-98) = -1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
	int p = 0,t=0;
	scanf("%d", &p);
	t = p;
	if (p < 0)	p = -1;
	else if (p > 0)	p = 1;
	else p = 0;
	printf("sign(%d) = %d",t,p);
	return 0;
}

7-17 成绩转换

本题要求编写程序将一个百分制成绩转换为五分制成绩。转换规则：

  • 大于等于90分为A；
  • 小于90且大于等于80为B；
  • 小于80且大于等于70为C；
  • 小于70且大于等于60为D；
  • 小于60为E。

输入格式:

输入在一行中给出一个整数的百分制成绩。

输出格式:

在一行中输出对应的五分制成绩。

输入样例:

1
90

输出样例:

1
A

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
	int p = 0,t=0;
	scanf("%d", &p);
	if (p >= 90)	printf("A");
	else if (p < 90 && p >= 80)	printf("B");
	else if (p < 80 && p>=70)	printf("C");
	else if (p < 70 && p>=60)	printf("D");
	else printf("E");
	return 0;
}

7-18 出租车计价

本题要求根据某城市普通出租车收费标准编写程序进行车费计算。具体标准如下：

  • 起步里程为3公里，起步费10元；
  • 超起步里程后10公里内，每公里2元；
  • 超过10公里以上的部分加收50%的回空补贴费，即每公里3元；
  • 营运过程中，因路阻及乘客要求临时停车的，按每5分钟2元计收（不足5分钟则不收费）。

输入格式:

输入在一行中给出输入行驶里程（单位为公里，精确到小数点后1位）与等待时间（整数，单位为分钟），其间以空格分隔。

输出格式:

在一行中输出乘客应支付的车费（单位为元），结果四舍五入，保留到元。

输入样例1:

1
2.6 2

输出样例1:

1
10

输入样例2:

1
5.1 4

输出样例2:

1
14

输入样例3:

1
12.5 9

输出样例3:

1
34

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
	float road = 0;
	int mm = 0, pirce = 0;
	scanf("%f %d", &road, &mm);
	if (mm >= 5) {
		if (mm % 5 == 0)	pirce = mm / 5 * 2;
		else	pirce = mm / 5 * 2 + 2;
	}
	pirce += 10;
	if (road > 3 && road <= 10) {
		road -= 3;
		road = (int)road;
		pirce = pirce + road * 2;
	}
	if (road > 10) {
		road -= 10;
		pirce += 14;
		road = (int)road;
		pirce = pirce + road * 3;
	}
	printf("%d", pirce);
	return 0;
}

7-19 计算天数

本题要求编写程序计算某年某月某日是该年中的第几天。

输入格式:

输入在一行中按照格式“yyyy/mm/dd”（即“年/月/日”）给出日期。注意：闰年的判别条件是该年年份能被4整除但不能被100整除、或者能被400整除。闰年的2月有29天。

输出格式:

在一行输出日期是该年中的第几天。

输入样例1:

1
2009/03/02

输出样例1:

1
61

输入样例2:

1
2000/03/02

输出样例2:

1
62

鸣谢湖北汽车工业学院袁科老师、用户潘明智补充数据！

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
	int mm[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
	int y = 0, m = 0, d = 0,res=0;
	scanf("%d/%d/%d", &y, &m, &d);
	if ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0)	mm[1] = 29;
	for (int i = 0; i <m - 1; i++) {
		res += mm[i];
	}
	res += d;
	printf("%d", res);
	return 0;
}

7-20 简单计算器

模拟简单运算器的工作。假设计算器只能进行加减乘除运算，运算数和结果都是整数，四种运算符的优先级相同，按从左到右的顺序计算。

输入格式:

输入在一行中给出一个四则运算算式，没有空格，且至少有一个操作数。遇等号”=”说明输入结束。

输出格式:

在一行中输出算式的运算结果，或者如果除法分母为0或有非法运算符，则输出错误信息“ERROR”。

输入样例:

1
1+2*10-10/2=

输出样例:

1
10

代码长度限制

16 KB

时间限制

400 ms

内存限制

代码如下：

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
#include <stdio.h>
int main()
{
    int n1, n2;
    char ch;
    scanf("%d", &n1); // 不管怎样先输入一个数
    while(1)
    {
        scanf("%c", &ch);
        if(ch=='='){ 
        // 如果输入的操作符为等号则直接输出而不必进行后续操作了
            printf("%d\n", n1);
            break;
        }
        else{
        // 否则继续输入第二个操作数
            scanf("%d", &n2);
        }
        if(ch=='+')
            n1 += n2;
        else if(ch=='-')
            n1 -= n2;
        else if(ch=='*')
            n1 *= n2;
        else if(ch=='/')
        {
            if(n2==0)
            {
                printf("ERROR\n");
                break;
            }
            else
            {
                n1 /= n2;
            }
        }
        else
        {
            printf("ERROR\n");
            break;
        }
    }

    return 0;
}

7-21 超速判断

模拟交通警察的雷达测速仪。输入汽车速度，如果速度超出60 mph，则显示“Speeding”，否则显示“OK”。

输入格式：

输入在一行中给出1个不超过500的非负整数，即雷达测到的车速。

输出格式：

在一行中输出测速仪显示结果，格式为：Speed: V - S，其中V是车速，S或者是Speeding、或者是OK。

输入样例1：

1
40

输出样例1：

1
Speed: 40 - OK

输入样例2：

1
75

输出样例2：

1
Speed: 75 - Speeding

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
	int speed = 0;
	scanf("%d", &speed);
	if (speed > 60)
		printf("Speed: %d - Speeding", speed);
	else
		printf("Speed: %d - OK", speed);
	return 0;
}

7-22 用天平找小球

三个球A、B、C，大小形状相同且其中有一个球与其他球重量不同。要求找出这个不一样的球。

输入格式：

输入在一行中给出3个正整数，顺序对应球A、B、C的重量。

输出格式：

在一行中输出唯一的那个不一样的球。

输入样例：

1
1 1 2

输出样例：

1
C

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
	int a = 0, b = 0, c = 0;
	scanf("%d %d %d", &a, &b, &c);
	if (a == b)	printf("C");
	else if (a == c)	printf("B");
	else printf("A");
	return 0;
}

7-23 分段计算居民水费

为鼓励居民节约用水，自来水公司采取按用水量阶梯式计价的办法，居民应交水费y（元）与月用水量x（吨）相关：当x不超过15吨时，y=4x/3；超过后，y=2.5x−17.5。请编写程序实现水费的计算。

输入格式：

输入在一行中给出非负实数x。

输出格式：

在一行输出应交的水费，精确到小数点后2位。

输入样例1：

1
12

输出样例1：

1
16.00

输入样例2：

1
16

输出样例2：

1
22.50

代码长度限制

16 KB

时间限制

400 ms

内存限制

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//当x不超过15吨时，y=4x/3；超过后，y=2.5x−17.5
int main(void) {
	int x = 0;
	float y = 0;
	scanf("%d", &x);
	if (x <= 15)	y = 4 * x / 3.0;
	else  y = x * 2.5 - 17.5;
	printf("%.2f", y);
	return 0;
}

7-24 猜数字游戏

猜数字游戏是令游戏机随机产生一个100以内的正整数，用户输入一个数对其进行猜测，需要你编写程序自动对其与随机产生的被猜数进行比较，并提示大了（“Too big”），还是小了（“Too small”），相等表示猜到了。如果猜到，则结束程序。程序还要求统计猜的次数，如果1次猜出该数，提示“Bingo!”；如果3次以内猜到该数，则提示“Lucky You!”；如果超过3次但是在N（>3）次以内（包括第N次）猜到该数，则提示“Good Guess!”；如果超过N次都没有猜到，则提示“Game Over”，并结束程序。如果在到达N次之前，用户输入了一个负数，也输出“Game Over”，并结束程序。

输入格式:

输入第一行中给出两个不超过100的正整数，分别是游戏机产生的随机数、以及猜测的最大次数N。最后每行给出一个用户的输入，直到出现负数为止。

输出格式:

在一行中输出每次猜测相应的结果，直到输出猜对的结果或“Game Over”则结束。

输入样例:

1
2
3
4
5
6
7
58 4
70
50
56
58
60
-2

输出样例:

1
2
3
4
Too big
Too small
Too small
Good Guess!

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
/*Too big
Too small
Too small
*/
int main(void) {
	int num = 0, frequency = 0;
	int gres = 0, gresfre = 0, flag = 0;
	scanf("%d %d", &num, &frequency);
	while (gresfre<=frequency) {
		scanf("%d", &gres);
		gresfre++;
		if (gres < 0) {
			printf("Game Over");
			return 0;
		}
		if (gres == num) {
			flag = 1;
			break;
		}
		else if (gres < num)	printf("Too small\n");
		else  printf("Too big\n");
	}
	if (gresfre > frequency) {
		printf("Game Over");
		return 0;
	}
	if (gres == 1)	printf("Bingo!");
	else if (gresfre <= 3)	printf("Lucky You!");
	else if (flag == 1)	printf("Good Guess!");
	else printf("Game Over");
	return 0;
}

7-25 求奇数和

本题要求计算给定的一系列正整数中奇数的和。

输入格式:

输入在一行中给出一系列正整数，其间以空格分隔。当读到零或负整数时，表示输入结束，该数字不要处理。

输出格式:

在一行中输出正整数序列中奇数的和。

输入样例:

1
8 7 4 3 70 5 6 101 -1

输出样例:

1
116

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
	int res = 0, a = 0;
	scanf("%d", &a);
	while (a > 0) {
		if (a % 2 != 0)	res +=a;
		scanf("%d", &a);
	}
	printf("%d", res);
	return 0;
}

7-26 最大公约数和最小公倍数

本题要求两个给定正整数的最大公约数和最小公倍数。

输入格式:

输入在一行中给出两个正整数M和N（≤1000）。

输出格式:

在一行中顺序输出M和N的最大公约数和最小公倍数，两数字间以1空格分隔。

输入样例:

1
511 292

输出样例:

1
73 2044

鸣谢安阳师范学院段晓云老师和软件工程五班李富龙同学补充测试数据！

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
	int M = 0, N = 0, gcd = 0, lcm = 0;
	//gcd是最大公约数，lcm是最小公倍数
	//greatest common measure   lowest common multiple
	scanf("%d %d", &M, &N);
	if (M > N) {
		gcd = N;
		lcm = M;
	}
	else {
		gcd = M;
		lcm = N;
	}
	for (int i = gcd; i >= 1; --i) {
		if (M % i == 0 && N % i == 0) {
			gcd = i;
			break;
		}
	}
	for (int i = lcm; i <= M * N; ++i) {
		if (i % M == 0 && i % N == 0) {
			lcm = i;
			break;
		}
	}
	printf("%d %d", gcd, lcm);
	return 0;
}

7-27 兔子繁衍问题

一对兔子，从出生后第3个月起每个月都生一对兔子。小兔子长到第3个月后每个月又生一对兔子。假如兔子都不死，请问第1个月出生的一对兔子，至少需要繁衍到第几个月时兔子总数才可以达到N对？

输入格式:

输入在一行中给出一个不超过10000的正整数N。

输出格式:

在一行中输出兔子总数达到N最少需要的月数。

输入样例:

1
30

输出样例:

1
9

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
    int a = 0, b = 1, temp, N, month = 1;//b 代表累加的和（总兔子的只数），初始值为1
    scanf("%d", &N);

    while (b < N) {
        month++;
        temp = a;//a 表示新生的兔子对数
        a = b;
        b = b + temp;
    }
    printf("%d\n", month);

    return 0;
}

7-28 求整数的位数及各位数字之和

对于给定的正整数N，求它的位数及其各位数字之和。

输入格式：

输入在一行中给出一个不超过109的正整数N。

输出格式：

在一行中输出N的位数及其各位数字之和，中间用一个空格隔开。

输入样例：

1
321

输出样例：

1
3 6

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
    int bit = 0, bitsum = 0, num = 0;
    scanf("%d", &num);
    while (num) {
        bitsum += num % 10;
        num /= 10;
        bit++;
    }
    printf("%d %d", bit, bitsum);
    return 0;
}

7-29 二分法求多项式单根

二分法求函数根的原理为：如果连续函数f(x)在区间[a,b]的两个端点取值异号，即f(a)f(b)<0，则它在这个区间内至少存在1个根r，即f(r)=0。

二分法的步骤为：

  • 检查区间长度，如果小于给定阈值，则停止，输出区间中点(a+b)/2；否则
  • 如果f(a)f(b)<0，则计算中点的值f((a+b)/2)；
  • 如果f((a+b)/2)正好为0，则(a+b)/2就是要求的根；否则
  • 如果f((a+b)/2)与f(a)同号，则说明根在区间[(a+b)/2,b]，令a=(a+b)/2，重复循环；
  • 如果f((a+b)/2)与f(b)同号，则说明根在区间[a,(a+b)/2]，令b=(a+b)/2，重复循环。

本题目要求编写程序，计算给定3阶多项式f(x)=a3x3+a2x2+a1x+a0在给定区间[a,b]内的根。

输入格式：

输入在第1行中顺序给出多项式的4个系数a3、a2、a1、a0，在第2行中顺序给出区间端点a和b。题目保证多项式在给定区间内存在唯一单根。

输出格式：

在一行中输出该多项式在该区间内的根，精确到小数点后2位。

输入样例：

1
2
3 -1 -3 1
-0.5 0.5

输出样例：

1
0.33

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//double a3 = 0, a2 = 0, a1 = 0, a = 0;
double funct(double a3, double a2, double a1, double a, double x) {
    return a3 * x * x * x + a2 * x * x + a1 * x + a;
}
int main(void) {
    double left = 0, right = 0, mid = 0;
    double a3 = 0, a2 = 0, a1 = 0, a = 0;
    scanf("%lf %lf %lf %lf %lf %lf", &a3, &a2, &a1, &a, &left, &right);
    while (right - left >= 0.001 && funct(a3,a2,a1,a,left) * funct(a3,a2,a1,a,right) <= 0) {
        //right-left>=0.001，就是我们人为设置的极限
        if (funct(a3,a2,a1,a,left) == 0) {
            mid = left;
            break;
        }
        if (funct(a3,a2,a1,a,right) == 0) {
            mid = right;
            break;
        }
        mid = (left + right) / 2.0;
        //if (funct(a3,a2,a1,a,a3, a2, a1, a, mid) == 0) {
        //    printf("%0.2f", mid);
        //    return 0;
        //}
        if (funct(a3,a2,a1,a,left) * funct(a3,a2,a1,a,mid) > 0) {
            left = mid;
        }
        else  right = mid;
    }
    printf("%.2lf", mid);
    return 0;
}

7-30 念数字

输入一个整数，输出每个数字对应的拼音。当整数为负数时，先输出fu字。十个数字对应的拼音如下：

1
2
3
4
5
6
7
8
9
10
0: ling
1: yi
2: er
3: san
4: si
5: wu
6: liu
7: qi
8: ba
9: jiu

输入格式：

输入在一行中给出一个整数，如：1234。

提示：整数包括负数、零和正数。

输出格式：

在一行中输出这个整数对应的拼音，每个数字的拼音之间用空格分开，行末没有最后的空格。如
yi er san si。

输入样例：

1
-600

输出样例：

1
fu liu ling ling

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int dit(int num) {
    int ditnum = 0;
    while (num) {
        num /= 10;
        ditnum++;
    }
    return ditnum;
}
int Mi(int num) {
    int res = 1;
    for (int i = 0; i < num-1; ++i) {
        res *= 10;
    }
    return res;
}
int main(void) {
    int num = 0, ditnum = 0,flag=0;
    scanf("%d", &num);
    if (num < 0) {
        printf("fu ");
        num = -num;
    }
    else if (num == 0) {
        printf("ling");
        //return 0;       //这个return ，是为了和1230这种情况冲突，所以提前就结束了
    }
    ditnum = dit(num);
    while (ditnum) {
        int res = 0;
        if (flag == 0) flag = 1;
        else printf(" ");
        if (num == 0)  res = 0;
        else
            res = num / Mi(ditnum);
        switch (res) {
        case 1:
            printf("yi");
            break;
        case 2:
            printf("er");
            break;
        case 3:
            printf("san");
            break;
        case 4:
            printf("si");
            break;
        case 5:
            printf("wu");
            break;
        case 6:
            printf("liu");
            break;
        case 7:
            printf("qi");
            break;
        case 8:
            printf("ba");
            break;
        case 9:
            printf("jiu");
            break;
        case 0:
            printf("ling");
            break;
        }
        num = num - res * Mi(ditnum);
        ditnum--;
    }
    return 0;
}

7-31 掉入陷阱的数字

对任意一个自然数N0，先将其各位数字相加求和，再将其和乘以3后加上1，变成一个新自然数N1；然后对N1重复这种操作，可以产生新自然数N2；……多次重复这种操作，运算结果最终会得到一个固定不变的数N**k，就像掉入一个数字“陷阱”。

本题要求对输入的自然数，给出其掉入“陷阱”的过程。

输入格式:

在一行内给出一个自然数N0（N0<30000）。

输出格式:

对于输入的N0，逐行输出其掉入陷阱的步骤。第i行描述N掉入陷阱的第i步，格式为： i:N**i （i≥1）。当某一步得到的自然数结果N**k(k≥1)与上一步N**k−1相同时，停止输出。

输入样例:

1
5

输出样例:

1
2
3
4
1:16
2:22
3:13
4:13

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int digsum(int x) {
    int sum = 0;
    while (x) {
        sum += x % 10;
        x /= 10;
    }
    return sum;
}
int main(void) {
    int x = 0, time = 1, next = 13;  //设置成默认的13是为了方便一步到位的情况
    scanf("%d", &x);
    while (digsum(x) * 3 + 1 != x) {
        next = digsum(x) * 3 + 1;
        printf("%d:%d\n", time, next);
        time++;
        x = digsum(x) * 3 + 1;
    }
    printf("%d:%d\n", time, next);
    return 0;
}

7-32 求交错序列前N项和

本题要求编写程序，计算交错序列 1-2/3+3/5-4/7+5/9-6/11+… 的前N项之和。

输入格式:

输入在一行中给出一个正整数N。

输出格式:

在一行中输出部分和的值，结果保留三位小数。

输入样例:

1
5

输出样例:

1
0.917

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
float Judge(int  i) {
    if (i % 2 == 1)  return -1.0;
    else return 1.0;
}
int main(void) {
    int n = 0;
    float sum = 1;
    scanf("%d", &n);
    for (float i = 1; i < n; ++i) 
        sum+= Judge(i) * ((1+i) / (2*i+1));
    printf("%0.3f", sum);
    return 0;
}

7-33 统计素数并求和

本题要求统计给定整数M和N区间内素数的个数并对它们求和。

输入格式:

输入在一行中给出两个正整数M和N（1≤M≤N≤500）。

输出格式:

在一行中顺序输出M和N区间内素数的个数以及它们的和，数字间以空格分隔。

输入样例:

1
10 31

输出样例:

1
7 143

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int isPrime(int num) {
	if (num == 1)	return 0;
	for (int i = 2; i <=num / 2; ++i) {
		if (num % i == 0)	return 0;
	}
	return 1;
}
int main(void) {
	int m = 0, n = 0,times=0,sum=0;
	scanf("%d %d", &m, &n);
	for (int i = m; i <=n; ++i) {
		if (isPrime(i) == 1) {
			times++;
			sum += i;
		}
	}
	printf("%d %d", times, sum);
	return 0;
}

7-34 求分数序列前N项和

本题要求编写程序，计算序列 2/1+3/2+5/3+8/5+… 的前N项之和。注意该序列从第2项起，每一项的分子是前一项分子与分母的和，分母是前一项的分子。

输入格式:

输入在一行中给出一个正整数N。

输出格式:

在一行中输出部分和的值，精确到小数点后两位。题目保证计算结果不超过双精度范围。

输入样例:

1
20

输出样例:

1
32.66

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
    double n = 0, nmt = 2, dmt = 1, nmts = 0, dmts = 0,sum=0;
    //nmt是前一个分子，dmt是前一个分母
    scanf("%lf", &n);
    for (int i = 1; i <=n; ++i) {
        if (i == 1)    sum += 2;
        else {
            nmts = nmt + dmt;
            dmts = nmt;
            sum += nmts / dmts;
            nmt = nmts;
            dmt = dmts;
        }
    }
    printf("%0.2lf", sum);
    return 0;
}

7-35 猴子吃桃问题

一只猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个；第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半加一个。到第N天早上想再吃时，见只剩下一个桃子了。问：第一天共摘了多少个桃子？

输入格式:

输入在一行中给出正整数N（1<N≤10）。

输出格式:

在一行中输出第一天共摘了多少个桃子。

输入样例:

1
3

输出样例:

1
10

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
    int day = 0, sum = 1;
    scanf("%d", &day);
    for (int i = 0; i < day-1; ++i) {
        sum = (sum + 1) * 2;
    }
    printf("%d", sum);
    return 0;
}

7-36 韩信点兵

在中国数学史上，广泛流传着一个“韩信点兵”的故事：韩信是汉高祖刘邦手下的大将，他英勇善战，智谋超群，为汉朝建立了卓越的功劳。据说韩信的数学水平也非常高超，他在点兵的时候，为了知道有多少兵，同时又能保住军事机密，便让士兵排队报数：

  • 按从1至5报数，记下最末一个士兵报的数为1；
  • 再按从1至6报数，记下最末一个士兵报的数为5；
  • 再按从1至7报数，记下最末一个士兵报的数为4；
  • 最后按从1至11报数，最末一个士兵报的数为10；

请编写程序计算韩信至少有多少兵。

输入格式：

本题无输入

输出格式：

输出韩信至少拥有的士兵人数。

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
    for (int i = 0; i < 5*6*7*11; i++) {
        if (i % 5 == 1 && i % 6 == 5 && i % 7 == 4 && i % 11 == 10) {
            printf("%d", i);
        }
    }
    return 0;
}

7-37 输出整数各位数字

本题要求编写程序，对输入的一个整数，从高位开始逐位分割并输出它的各位数字。

输入格式：

输入在一行中给出一个长整型范围内的非负整数。

输出格式：

从高位开始逐位输出该整数的各位数字，每个数字后面有一个空格。

输入样例：

1
123456

输出样例：

1
1 2 3 4 5 6

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int dit(long t) {
    int ditnum = 0;
    while (t) {
        t /= 10;
        ditnum++;
    }
    return ditnum;
}
int mi(int t) {
    int res = 1;
    for (int i = 0; i < t - 1; ++i) {
        res *= 10;
    }
    return res;
}
int main(void) {
    long t = 0;
    int dig = 0;
    scanf("%ld", &t);
    if (t == 0)printf("0 ");
    dig = dit(t);
    while (dig) {
        printf("%ld ", t / mi(dig));
        t = t - (t / mi(dig)) * mi(dig);
        dig--;
    }
    return 0;
}

7-38 支票面额

一个采购员去银行兑换一张y元f分的支票，结果出纳员错给了f元y分。采购员用去了n分之后才发觉有错，于是清点了余额尚有2y元2f分，问该支票面额是多少？

输入格式：

输入在一行中给出小于100的正整数n。

输出格式：

在一行中按格式y.f输出该支票的原始面额。如果无解，则输出No Solution。

输入样例1：

1
23

输出样例1：

1
25.51

输入样例2：

1
22

输出样例2：

1
No Solution

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
    int y = 0, f = 0, n = 0,flag=0;
    scanf("%d", &n);
    for (int y = 0; y < 49; y++) {
        for (int f = 0; f < 100; f++) {
            if (98 * f - 199 * y == n) {
                flag = 1;
                printf("%d.%d", y, f);
            }
        }
    }
    if (!flag)   printf("No Solution");
    return 0;
}

7-39 龟兔赛跑

乌龟与兔子进行赛跑，跑场是一个矩型跑道，跑道边可以随地进行休息。乌龟每分钟可以前进3米，兔子每分钟前进9米；兔子嫌乌龟跑得慢，觉得肯定能跑赢乌龟，于是，每跑10分钟回头看一下乌龟，若发现自己超过乌龟，就在路边休息，每次休息30分钟，否则继续跑10分钟；而乌龟非常努力，一直跑，不休息。假定乌龟与兔子在同一起点同一时刻开始起跑，请问T分钟后乌龟和兔子谁跑得快？

输入格式：

输入在一行中给出比赛时间T（分钟）。

输出格式：

在一行中输出比赛的结果：乌龟赢输出@_@，兔子赢输出^_^，平局则输出-_-；后跟1空格，再输出胜利者跑完的距离。

输入样例：

1
242

输出样例：

1
@_@ 726

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
    int turtle = 0, rabbit = 0, t = 0, run = 0, sleeptime = 0;
    //run代表兔子是否睡觉，兔子一开始不是睡觉的.sleeptime的意思是，一开始睡觉的时候
    scanf("%d", &t);
    for (int i = 1; i <= t; ++i)
    {
        turtle += 3;        //乌龟一定是在跑步的
        if (run == 0)       //兔子不睡觉是0
            rabbit += 9;
        if ((i % 10 == 0) && (rabbit > turtle) && (run == 0))   
            //如果兔子还在跑的状态，而且已经比乌龟快，正好在检查点上
        {
            run = 1;    //改变兔子的状态
            sleeptime = i;  //睡觉的时间，就等于i，目前的时间
        }
        if (i == sleeptime + 30)    //如果已经过了30分钟的话
        {
            run = 0;                //设置兔子醒过来继续跑
        }
    }
    if (rabbit > turtle)   printf("^_^ %d", rabbit);
    else if (rabbit == turtle) printf("-_- %d", rabbit);
    else printf("@_@ %d", turtle);
    return 0;
}

7-40 到底是不是太胖了

据说一个人的标准体重应该是其身高（单位：厘米）减去100、再乘以0.9所得到的公斤数。真实体重与标准体重误差在10%以内都是完美身材（即 | 真实体重 − 标准体重 | < 标准体重×10%）。已知市斤是公斤的两倍。现给定一群人的身高和实际体重，请你告诉他们是否太胖或太瘦了。

输入格式：

输入第一行给出一个正整数N（≤ 20）。随后N行，每行给出两个整数，分别是一个人的身高H（120 < H < 200；单位：厘米）和真实体重W（50 < W ≤ 300；单位：市斤），其间以空格分隔。

输出格式：

为每个人输出一行结论：如果是完美身材，输出You are wan mei!；如果太胖了，输出You are tai pang le!；否则输出You are tai shou le!。

输入样例：

1
2
3
4
3
169 136
150 81
178 155

输出样例：

1
2
3
You are wan mei!
You are tai shou le!
You are tai pang le!

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
	float N = 0, H = 0, W = 0;
	scanf("%f", &N);
	for (int i = 0; i < N; ++i) {
		scanf("%f%f", &H, &W);
		float PerferW = 2 * (H - 100) * 0.9 ;	//完美体重
		float DecterW = 0;	//这个是误差的值
		if (W > PerferW&& W - PerferW>=PerferW*0.1) {		//真实体重大于实际体重
			printf("You are tai pang le!\n");
		}
		else  if (W <= PerferW && PerferW - W >= PerferW * 0.1) {
			printf("You are tai shou le!\n");
		}
		else {
			printf("You are wan mei!\n");
		}
		
	}
}

7-41 计算阶乘和

对于给定的正整数N，需要你计算 S=1!+2!+3!+…+N!。

输入格式：

输入在一行中给出一个不超过10的正整数N。

输出格式：

在一行中输出S的值。

输入样例：

1
3

输出样例：

1
9

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int factorial(int n) {
	int sum = 1;
	for (int i = 1; i <= n; ++i) {
		sum *= i;
	}
	return sum;
}
int main(void) {
	int n = 0, sum = 0;
	scanf("%d", &n);
	for (int i = 1; i <=n; ++i) {
		sum += factorial(i);
	}
	printf("%d", sum);
}

7-42 整除光棍

这里所谓的“光棍”，并不是指单身汪啦~ 说的是全部由1组成的数字，比如1、11、111、1111等。传说任何一个光棍都能被一个不以5结尾的奇数整除。比如，111111就可以被13整除。 现在，你的程序要读入一个整数x，这个整数一定是奇数并且不以5结尾。然后，经过计算，输出两个数字：第一个数字s，表示x乘以s是一个光棍，第二个数字n是这个光棍的位数。这样的解当然不是唯一的,题目要求你输出最小的解。

提示：一个显然的办法是逐渐增加光棍的位数，直到可以整除x为止。但难点在于，s可能是个非常大的数 —— 比如，程序输入31，那么就输出3584229390681和15，因为31乘以3584229390681的结果是111111111111111，一共15个1。

输入格式：

输入在一行中给出一个不以5结尾的正奇数x（<1000）。

输出格式：

在一行中输出相应的最小的s和n，其间以1个空格分隔。

输入样例：

1
31

输出样例：

1
3584229390681 15

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
 
int main(){
    int x,y = 1;
    scanf("%d",&x);
    int s=1;         //用来表示光棍数
    int n=0;         //记录位数
    while(s<x){
        s=s*10+1;  // 先找出大于x的最小光棍数
        n++;
    }
    do {
        y=s%x;  // 储存余数
        printf("%d",s/x);
        s=y*10+1;  // 更新光棍数
        n++;
    } while(y!=0);  // 如果余数为0，说明找到了光棍数字，直接结束循环
    printf(" %d",n);  // 输出位数
 
    return 0;
}

7-43 Shuffling Machine

Shuffling is a procedure used to randomize a deck of playing cards. Because standard shuffling techniques are seen as weak, and in order to avoid “inside jobs” where employees collaborate with gamblers by performing inadequate shuffles, many casinos employ automatic shuffling machines. Your task is to simulate a shuffling machine.

The machine shuffles a deck of 54 cards according to a given random order and repeats for a given number of times. It is assumed that the initial status of a card deck is in the following order:

1
2
3
4
5
S1, S2, ..., S13, 
H1, H2, ..., H13, 
C1, C2, ..., C13, 
D1, D2, ..., D13, 
J1, J2

where “S” stands for “Spade”, “H” for “Heart”, “C” for “Club”, “D” for “Diamond”, and “J” for “Joker”. A given order is a permutation of distinct integers in [1, 54]. If the number at the i-th position is j, it means to move the card from position i to position j. For example, suppose we only have 5 cards: S3, H5, C1, D13 and J2. Given a shuffling order {4, 2, 5, 3, 1}, the result will be: J2, H5, D13, S3, C1. If we are to repeat the shuffling again, the result will be: C1, H5, S3, J2, D13.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer K (≤20) which is the number of repeat times. Then the next line contains the given order. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print the shuffling results in one line. All the cards are separated by a space, and there must be no extra space at the end of the line.

Sample Input:

1
2
2
36 52 37 38 3 39 40 53 54 41 11 12 13 42 43 44 2 4 23 24 25 26 27 6 7 8 48 49 50 51 9 10 14 15 16 5 17 18 19 1 20 21 22 28 29 30 31 32 33 34 35 45 46 47

Sample Output:

1
S7 C11 C10 C12 S1 H7 H8 H9 D8 D9 S11 S12 S13 D10 D11 D12 S3 S4 S6 S10 H1 H2 C13 D2 D3 D4 H6 H3 D13 J1 J2 C1 C2 C3 C4 D1 S5 H5 H11 H12 C6 C7 C8 C9 S2 S8 S9 H10 D5 D6 D7 H4 H13 C5

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main() {
    int card[55] = { 0 }, pcard[55] = { 0 }, random[55] = { 0 },k=0;
    for (int i = 0; i < 55; ++i)   card[i] = i;
    scanf("%d", &k);
    for (int i = 1; i <= 54; ++i)
        scanf("%d", &random[i]);
    while (k) {
        for (int i = 1; i <= 54; ++i) {
            pcard[random[i]] = card[i];
        }
        for (int i = 1; i <= 54; ++i)
            card[i] = pcard[i];
        k--;
    }
    for (int i = 1; i <= 54; ++i) {
        if (card[i] >= 1 && card[i] <= 13) printf("S%d", card[i]);
        else if (card[i] > 13 && card[i] <= 26)   printf("H%d", card[i] - 13);
        else if (card[i] > 26 && card[i] <= 39)  printf("C%d", card[i] - 26);
        else if (card[i] > 39 && card[i] <= 52)  printf("D%d", card[i] - 39);
        else printf("J%d", card[i] - 52);
        if (i!=54)    printf(" ");
    }
    return 0;
}

7-44 黑洞数

黑洞数也称为陷阱数，又称“Kaprekar问题”，是一类具有奇特转换特性的数。

任何一个各位数字不全相同的三位数，经有限次“重排求差”操作，总会得到495。最后所得的495即为三位黑洞数。所谓“重排求差”操作即组成该数的数字重排后的最大数减去重排后的最小数。（6174为四位黑洞数。）

例如，对三位数207：

  • 第1次重排求差得：720 - 27 ＝ 693；
  • 第2次重排求差得：963 - 369 ＝ 594；
  • 第3次重排求差得：954 - 459 ＝ 495；

以后会停留在495这一黑洞数。如果三位数的3个数字全相同，一次转换后即为0。

任意输入一个三位数，编程给出重排求差的过程。

输入格式：

输入在一行中给出一个三位数。

输出格式：

按照以下格式输出重排求差的过程：

1
序号: 数字重排后的最大数 - 重排后的最小数 = 差值

序号从1开始，直到495出现在等号右边为止。

输入样例：

1
123

输出样例：

1
2
3
4
5
1: 321 - 123 = 198
2: 981 - 189 = 792
3: 972 - 279 = 693
4: 963 - 369 = 594
5: 954 - 459 = 495

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int Max(int x) {
    int a[3];
    for (int i = 0; i < 3; ++i) {
        a[i] = x % 10;
        x /= 10;
    }
    if (a[1] > a[0]) {      //要确保a[0]是最大的
        int t = a[1];
        a[1] = a[0];
        a[0] = t;
    }
    if (a[2] > a[0]) {      
        int t = a[2];
        a[2] = a[0];
        a[0] = t;
    }
    if (a[2] > a[1]) {
        int t = a[2];
        a[2] = a[1];
        a[1] = t;
    }
    return a[0] * 100 + a[1] * 10 + a[2];
}
int Min(int x) {
    int a[3];
    for (int i = 0; i < 3; ++i) {
        a[i] = x % 10;
        x /= 10;
    }
    if (a[1] > a[0]) {      //要确保a[0]是最大的
        int t = a[1];
        a[1] = a[0];
        a[0] = t;
    }
    if (a[2] > a[0]) {
        int t = a[2];
        a[2] = a[0];
        a[0] =t;
    }
    if (a[2] > a[1]) {
        int t = a[2];
        a[2] = a[1];
        a[1] =t;
    }
    return a[0] + a[1] * 10 + a[2]*100;
}
int main() {
    int max = 0, min = 0, x = 0, time = 1;
    scanf("%d",&x);
    while (max - min != 495) {
        max = Max(x);
        min = Min(x);
        printf("%d: %d - %d = %d\n", time, max, min, max - min);
        time++;
        x = max - min;
    }
    return 0;
}

7-45 找完数

所谓完数就是该数恰好等于除自身外的因子之和。例如：6=1+2+3，其中1、2、3为6的因子。本题要求编写程序，找出任意两正整数m和n之间的所有完数。

输入格式：

输入在一行中给出2个正整数m和n（1<m≤n≤10000），中间以空格分隔。

输出格式：

逐行输出给定范围内每个完数的因子累加形式的分解式，每个完数占一行，格式为“完数 = 因子1 + 因子2 + … + 因子k”，其中完数和因子均按递增顺序给出。若区间内没有完数，则输出“None”。

输入样例：

1
2 30

输出样例：

1
2
6 = 1 + 2 + 3
28 = 1 + 2 + 4 + 7 + 14

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int judge(int x) {
    int sum = 1;
    for (int i = 2; i <= x / 2; ++i) {
        if (x % i == 0)  sum += i;
    }
    if (sum == x)  return 1;
    else return 0;
}
int main() {
    int begin = 0, end = 0,flag=0;
    scanf("%d %d", &begin, &end);
    for (int i = begin; i <= end; ++i) {
        if (judge(i)) {
            flag = 1;
            printf("%d = 1", i);
            for (int j = 2; j <= i / 2; ++j) {
                if (i % j == 0)  printf(" + %d", j);
            }
            printf("\n");
        }
    }
    if (!flag)   printf("None\n");
    return 0;
}

7-46 爬动的蠕虫

一条蠕虫长1寸，在一口深为N寸的井的底部。已知蠕虫每1分钟可以向上爬U寸，但必须休息1分钟才能接着往上爬。在休息的过程中，蠕虫又下滑了D寸。就这样，上爬和下滑重复进行。请问，蠕虫需要多长时间才能爬出井？

这里要求不足1分钟按1分钟计，并且假定只要在某次上爬过程中蠕虫的头部到达了井的顶部，那么蠕虫就完成任务了。初始时，蠕虫是趴在井底的（即高度为0）。

输入格式：

输入在一行中顺序给出3个正整数N、U、D，其中D<U，N不超过100。

输出格式：

在一行中输出蠕虫爬出井的时间，以分钟为单位。

输入样例：

1
12 3 1

输出样例：

1
11

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//一条蠕虫长1寸，在一口深为N寸的井的底部。已知蠕虫每1分钟可以向上爬U寸，
//但必须休息1分钟才能接着往上爬。在休息的过程中，蠕虫又下滑了D寸。就这样，
//上爬和下滑重复进行。请问，蠕虫需要多长时间才能爬出井？
//这里要求不足1分钟按1分钟计，并且假定只要在某次上爬过程中蠕虫的头部到达了井的顶部，
//那么蠕虫就完成任务了。初始时，蠕虫是趴在井底的（即高度为0）。
//入在一行中顺序给出3个正整数N、U、D，其中D < U，N不超过100。
//    在一行中输出蠕虫爬出井的时间，以分钟为单位。
int main() {
    int n = 0, u = 0, d = 0, time = 0,sleep=0,road=0;  //一开始不是睡觉的
    //road就是蠕虫爬行的长度
    scanf("%d %d %d", &n, &u, &d);
    while (road < n) {
        time++;
        if (!sleep) {   //蠕虫还没有睡觉
            road += u;
            sleep = 1;
        }
        else {
            road -= d;
            sleep = 0;
        }
    }
    printf("%d", time);
    return 0;
}

7-47 二进制的前导的零

计算机内部用二进制来表达所有的值。一个十进制的数字，比如24，在一个32位的计算机内部被表达为00000000000000000000000000011000。可以看到，从左边数过来，在第一个1之前，有27个0。我们把这些0称作前导的零。

现在，你的任务是写一个程序，输入一个整数，输出在32位表达下它前导的零的个数。

输入格式:

一个整数，在32位的整数可以表达的范围内。

输出格式:

一个整数，表达输入被表达为一个32位的二进制数时，在第一个1之前的0的数量。

输入样例:

1
256

输出样例:

1
23

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main() {
    int n = 0,time=0;
    scanf("%d", &n);
    if (n < 0) printf("0");
    else {
        while (n) {
            n /= 2;
            time++;
        }
        printf("%d", 32 - time);
    }
    return 0;
}

7-48 求组合数

本题要求编写程序，根据公式Cnm=m!(n−m)!n!算出从n个不同元素中取出m个元素（m≤n）的组合数。

建议定义和调用函数fact(n)计算n!，其中n的类型是int，函数类型是double。

输入格式:

输入在一行中给出两个正整数m和n（m≤n），以空格分隔。

输出格式:

按照格式“result = 组合数计算结果”输出。题目保证结果在double类型范围内。

输入样例:

1
2 7

输出样例:

1
result = 21

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
double fact(int n) {
    double sum = 1;
    for (int i = 1; i <= n; ++i)   sum *= i;
    return sum;
}
int main() {
    int n = 0, m = 0;
    scanf("%d %d", &m, &n);
    double res = fact(n) / (fact(m) * (fact(n - m)) );
    printf("result = %.0lf", res);
    return 0;
}

7-49 Have Fun with Numbers

Notice that the number 123456789 is a 9-digit number consisting exactly the numbers from 1 to 9, with no duplication. Double it we will obtain 246913578, which happens to be another 9-digit number consisting exactly the numbers from 1 to 9, only in a different permutation. Check to see the result if we double it again!

Now you are suppose to check if there are more numbers with this property. That is, double a given number with k digits, you are to tell if the resulting number consists of only a permutation of the digits in the original number.

Input Specification:

Each input contains one test case. Each case contains one positive integer with no more than 20 digits.

Output Specification:

For each test case, first print in a line “Yes” if doubling the input number gives a number that consists of only a permutation of the digits in the original number, or “No” if not. Then in the next line, print the doubled number.

Sample Input:

1
1234567899

Sample Output:

1
2
Yes
2469135798

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#include <stdio.h>
#define _CRT_SECURE_NO_WARNINGS
int book[10];
int main() {
    char num[22];
    scanf("%s", num);
    int flag = 0, len = strlen(num);
    for (int i = len - 1; i >= 0; i--) {
        int temp = num[i] - '0';
        book[temp]++;
        temp = temp * 2 + flag;
        flag = 0;
        if (temp >= 10) {
            temp = temp - 10;
            flag = 1;
        }
        num[i] = (temp + '0');
        book[temp]--;
    }
    int flag1 = 0;
    for (int i = 0; i < 10; i++) {
        if (book[i] != 0)
            flag1 = 1;
    }
    printf("%s", (flag == 1 || flag1 == 1) ? "No\n" : "Yes\n");
    if (flag == 1) printf("1");
    printf("%s", num);
    return 0;
}

7-50 输出华氏-摄氏温度转换表

输入2个正整数lower和upper（lower≤upper≤100），请输出一张取值范围为[lower，upper]、且每次增加2华氏度的华氏-摄氏温度转换表。

温度转换的计算公式：C=5×(F−32)/9，其中：C表示摄氏温度，F表示华氏温度。

输入格式:

在一行中输入2个整数，分别表示lower和upper的值，中间用空格分开。

输出格式:

第一行输出：”fahr celsius”

接着每行输出一个华氏温度fahr（整型）与一个摄氏温度celsius（占据6个字符宽度，靠右对齐，保留1位小数）。

若输入的范围不合法，则输出”Invalid.”。

输入样例1:

1
32 35

输出样例1:

1
2
3
fahr celsius
32   0.0
34   1.1

输入样例2:

1
40 30

输出样例2:

1
Invalid.

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main() {
	int lower = 0, upper = 0;
	scanf("%d %d", &lower, &upper);
	
	if ( lower>upper) {
		printf("Invalid.\n");
		return 0;
	}
	printf("fahr celsius\n");
	for (int i = lower; i <= upper; i += 2) {
		printf("%d%6.1f\n", i, 5 * (i - 32) / 9.0);
	}
}

7-51 求奇数分之一序列前N项和

本题要求编写程序，计算序列 1 + 1/3 + 1/5 + … 的前N项之和。

输入格式:

输入在一行中给出一个正整数N。

输出格式:

在一行中按照“sum = S”的格式输出部分和的值S，精确到小数点后6位。题目保证计算结果不超过双精度范围。

输入样例:

1
23

输出样例:

1
sum = 2.549541

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下:

1
2
3
4
5
6
7
8
9
10
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main() {
	double sum = 0, n = 0;
	scanf("%lf", &n);
	for (int i = 1; i <= n; ++i) {
		sum += 1.0 / (2*i-1);
	}
	printf("sum = %.6lf", sum);
}

7-52 求简单交错序列前N项和

本题要求编写程序,计算序列 1 - 1/4 + 1/7 - 1/10 + … 的前N项之和。

输入格式:

输入在一行中给出一个正整数N。

输出格式:

在一行中按照“sum = S”的格式输出部分和的值S，精确到小数点后三位。题目保证计算结果不超过双精度范围。

输入样例:

1
10

输出样例:

1
sum = 0.819

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main() {
	double sum = 0, n = 0,t=0;
	scanf("%lf", &n);
	for (int i = 1; i <= n; ++i) {
		t= 1.0 / (3*i-2);
		if (i % 2 == 0)	t *= -1;
		sum += t;
	}
	printf("sum = %.3lf", sum);
}

7-53 生成3的乘方表

输入一个非负整数n，生成一张3的乘方表，输出30~3n的值。可调用幂函数计算3的乘方。

输入格式:

输入在一行中给出一个非负整数n。

输出格式:

按照幂的递增顺序输出n+1行，每行格式为“pow(3,i) = 3的i次幂的值”。题目保证输出数据不超过长整型整数的范围。

输入样例:

1
3

输出样例:

1
2
3
4
pow(3,0) = 1
pow(3,1) = 3
pow(3,2) = 9
pow(3,3) = 27

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
long Mi(int n) {
	long sum = 1;
	if(!sum)
		return sum = 1;
	for (int i = 1; i <= n; ++i)	sum *= 3;
	return sum;
}
int main() {
	int n = 0;
	scanf("%d", &n);
	for (int i = 0; i <= n; ++i) {
		printf("pow(3,%d) = %ld\n", i, Mi(i));
	}
}

7-54 求阶乘序列前N项和

本题要求编写程序，计算序列 1!+2!+3!+⋯ 的前N项之和。

输入格式:

输入在一行中给出一个不超过12的正整数N。

输出格式:

在一行中输出整数结果。

输入样例:

1
5

输出样例:

1
153

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int fac(int n) {
	int sum = 1;
	for (int i = 1; i <= n; ++i) {
		sum *= i;
	}
	return sum;
}
int main() {
	int n = 0,sum=0;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		sum += fac(i);
	}
	printf("%d", sum);
	return 0;
}

7-55 查询水果价格

给定四种水果，分别是苹果（apple）、梨（pear）、桔子（orange）、葡萄（grape），单价分别对应为3.00元/公斤、2.50元/公斤、4.10元/公斤、10.20元/公斤。

首先在屏幕上显示以下菜单：

1
2
3
4
5
[1] apple
[2] pear
[3] orange
[4] grape
[0] exit

用户可以输入编号1~4查询对应水果的单价。当连续查询次数超过5次时，程序应自动退出查询；不到5次而用户输入0即退出；输入其他编号，显示价格为0。

输入格式:

输入在一行中给出用户连续输入的若干个编号。

输出格式:

首先在屏幕上显示菜单。然后对应用户的每个输入，在一行中按格式“price = 价格”输出查询结果，其中价格保留两位小数。当用户连续查询次数超过5次、或主动输入0时，程序结束。

输入样例1:

1
3 -1 0 2

输出样例1:

1
2
3
4
5
6
7
[1] apple
[2] pear
[3] orange
[4] grape
[0] exit
price = 4.10
price = 0.00

输入样例2:

1
1 2 3 3 4 4 5 6 7 8

输出样例2:

1
2
3
4
5
6
7
8
9
10
[1] apple
[2] pear
[3] orange
[4] grape
[0] exit
price = 3.00
price = 2.50
price = 4.10
price = 4.10
price = 10.20

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main() {
	double a[7] = { 0,3,2.5,4.1,10.2,-1};
	printf("[1] apple\n[2] pear\n[3] orange\n[4] grape\n[0] exit\n");
	for (int i = 1; i <= 5; ++i) {
		int t = 0;
		scanf("%d", &t);
		if (t >= 1 && t <= 4)	printf("price = %.2lf\n", a[t]);
		else if (t == 0)	return 0;
		else printf("price = 0.00\n");
	}
	return 0;
}

7-56 求给定精度的简单交错序列部分和

本题要求编写程序，计算序列部分和 1 - 1/4 + 1/7 - 1/10 + … 直到最后一项的绝对值不大于给定精度eps。

输入格式:

输入在一行中给出一个正实数eps。

输出格式:

在一行中按照“sum = S”的格式输出部分和的值S，精确到小数点后六位。题目保证计算结果不超过双精度范围。

输入样例1:

1
4E-2

输出样例1:

1
sum = 0.854457

输入样例2:

1
0.02

输出样例2:

1
sum = 0.826310

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
89
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <stdlib.h>
double Mi(int d) {
	double sum = 1;
	for (int i = 1; i < d; ++i) {
		sum *= 10;
	}
	if (d < 0) {
		for (int i = 1; i < -d; ++i) {
			sum *= 0.1;
		}
	}
	return sum;
}
double chartodbl(char* a) {
	int dit = strlen(a),sum=0;
	for (int i = 0; i < strlen(a); i++) {
		sum += (a[i] - '0') * Mi(dit);
		dit--;
	}
	return sum;
}
double strtodbl(char *a) {
	int dit = 0,flag=0;	//0表示在E之前的数字
	char num[50] = { ' ' }, mi[50] = {' '};
	int index = 0,num2=0;
	double num1 = 0;
	for (int i = 0; i < strlen(a); i++) {
		if (!flag) {
			if (a[i] > '0' && a[i] < '9')
				num[i] = a[i];
		}
		if (a[i] == 'E') {
			flag = 1;
			num1 = chartodbl(num);
		}
		if (flag) {
			if (a[i] > '0' && a[i] < '9') {
				mi[index] = a[i];
				index++;
			}
		}
	}
	num2 = chartodbl(mi);
	for (int i = 1; i <=num2; ++i) {
		num1 *= 0.1;
	}
	return num1;
}
//用来判断是不是科学计数法
int judge(char* a) {
	for (int i = 0; i < strlen(a); ++i) {
		if (a[i] == 'E')	return 0;
	}
	return 1;
}
double nor(char* a) {
	for (int i = 0; i < strlen(a); ++i) {

	}
}
int main() {
	double sum=0, n = 0, t = 1,i=1;
	char str[100] = { ' ' };
	scanf("%s", str);
	if (!judge(str)) {
		n = strtodbl(str);
	}
	else
		n = atof(str);
	if (n >= 1)	sum = 1;
	//printf("%lf\n", n);
	while (t - n >0) {
		t = 1.0 / (3 * i - 2);
		if ((int)i % 2 == 0)	t *= -1;
		//printf("i is %lf   t is %lf\n", i, t);
		sum += t;
		i++;
		if (t < 0)	t = -t;
	}
	//printf("t is %.8lf\n", t);
	//t = 1.0 / (3 * i - 2);
	//if ((int)i % 2 == 0)	t *= -1;
	//sum += t;
	printf("sum = %.6lf", sum);
}

7-57 求e的近似值

自然常数 e 可以用级数 1+1/1!+1/2!+⋯+1/n!+⋯ 来近似计算。本题要求对给定的非负整数 n，求该级数的前 n+1 项和。

输入格式:

输入第一行中给出非负整数 n（≤1000）。

输出格式:

在一行中输出部分和的值，保留小数点后八位。

输入样例:

1
10

输出样例:

1
2.71828180

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
double fac(double n) {
    double sum = 1;
    for (double i = 1; i <= n; ++i)
        sum *= i;
    return 1.0 / sum;
}
int main(void){
    double n = 0,sum=1;
    scanf("%lf", &n);
    for (double i = 1; i <= n; ++i) {
        sum += fac(i);
    }
    printf("%.8lf", sum);
    return 0;
}

7-58 求幂级数展开的部分和

已知函数e**x可以展开为幂级数1+x+x2/2!+x3/3!+⋯+x**k/k!+⋯。现给定一个实数x，要求利用此幂级数部分和求e**x的近似值，求和一直继续到最后一项的绝对值小于0.00001。

输入格式:

输入在一行中给出一个实数x∈[0,5]。

输出格式:

在一行中输出满足条件的幂级数部分和，保留小数点后四位。

输入样例:

1
1.2

输出样例:

1
3.3201

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
double DIF = 0.00001;
double fac(double n) {
    double sum = 1;
    for (double i = 1; i <= n; ++i)
        sum *= i;
    return sum;
}
double pow(double x, int exp) {
    double sum = 1;
    for (int i = 1; i <= exp; ++i) {
        sum *= x;
    }
    return sum;
}
int main(void) {
    double x = 0, sum = 1, time = 1, p = 0;
    scanf("%lf", &x);
    p = pow(x, time) / fac(time);
    while (p >= DIF) {
        p = pow(x, time) / fac(time);
        sum += p;
        time++;
    }
    printf("%.4lf", sum);
    return 0;
}

7-59 打印菱形图案

本题要求编写程序，打印一个高度为n的、由“*”组成的正菱形图案。

输入格式:

输入在一行中给出一个正的奇数n。

输出格式:

输出由n行星号“*”组成的菱形，如样例所示。每个星号后跟一个空格。

输入样例:

1
7

输出样例:

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

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
    int n;
    scanf("%d", &n);
    int i;
    int j;
    for (i = 1; i <= n / 2 + 1; i++)
    {
        for (j = 1; j <= n + 1 - 2 * i; j++)        //  不管怎么样，先输出5个空格
            printf(" ");
        for (j = 1; j <= 2 * i - 1; j++)            // 然后在输出对应的*
            printf("* ");

        printf("\n");
    }
    for (i = 1; i <= n / 2; i++)
    {
        for (j = 1; j <= 2 * i; j++)
            printf(" ");
        for (j = 2 * (n / 2) - 1 - 2 * (i - 1); j >= 1; j--)
            printf("* ");
        printf("\n");
    }
    return 0;
}

7-60 Welcome to You!

本题要求编写程序，输出一个短句“Welcome to You!”。

输入格式:

本题目没有输入。

输出格式:

在一行中输出短句“Welcome to You!”。

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
    printf("Welcome to You!");
    return 0;
}

7-61 Programming in C is fun!

本题要求编写程序，输出一个短句“Programming in C is fun!”。

输入格式:

本题目没有输入。

输出格式:

在一行中输出短句“Programming in C is fun!”。

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
    printf("Programming in C is fun!");
    return 0;
}

7-62 计算物体自由下落的距离

一个物体从100米的高空自由落下。编写程序，求它在前3秒内下落的垂直距离。设重力加速度为10米/秒2。

输入格式:

本题目没有输入。

输出格式:

按照下列格式输出

1
height = 垂直距离值

结果保留2位小数。

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
#include<stdio.h>
int main(void) {
	printf("height = %.2lf", 0.5 * 10 * 3 * 3);
}

7-63 高空坠球

皮球从某给定高度自由落下，触地后反弹到原高度的一半，再落下，再反弹，……，如此反复。问皮球在第n次落地时，在空中一共经过多少距离？第n次反弹的高度是多少？

输入格式:

输入在一行中给出两个非负整数，分别是皮球的初始高度和n，均在长整型范围内。

输出格式:

在一行中顺序输出皮球第n次落地时在空中经过的距离、以及第n次反弹的高度，其间以一个空格分隔，保留一位小数。题目保证计算结果不超过双精度范围。

注意：n为 0 时表示球未开始下落。

输入样例:

1
33 5

输出样例:

1
94.9 1.0

鸣谢中山职业技术学院邱维阳老师完善题面。

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
double road(double n,double h) {
	double hei = h;
	for (int i = 1; i < n; ++i) {
		hei*= 0.5;
	}
	return hei;
}
int main(void) {
	double h = 0, n = 0,sum=0;
	scanf("%lf %lf", &h, &n);
	for (int i = 1; i <= n; ++i) {
		if (i == 1)	sum += road(i, h);
		else sum += road(i, h) * 2;
		//printf("%lf\n",road(i, h));
	}
	if (n == 0)	printf("0.0 0.0");
	else 
		printf("%.1lf %.1lf", sum, road(n, h)/2);
}

7-64 统计大写辅音字母

英文辅音字母是除A、E、I、O、U以外的字母。本题要求编写程序，统计给定字符串中大写辅音字母的个数。

输入格式：

输入在一行中给出一个不超过80个字符、并以回车结束的字符串。

输出格式：

输出在一行中给出字符串中大写辅音字母的个数。

输入样例：

1
HELLO World!

输出样例：

1
4

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	char str[88];
	int sum = 0;
	fgets(str, sizeof(str), stdin);
	//scanf("%s", str);
	//printf("%s", str);
	for (int i = 0; i < strlen(str); ++i) {
		if (str[i] > 'A' && str[i] <='Z'&&str[i]!='E'&&str[i]!='I'&&str[i]!='O'&&str[i]!='U') {
			//printf("%c\n", str[i]);
			sum++;
		}
	}
	printf("%d", sum);
}

7-65 字符串替换

本题要求编写程序，将给定字符串中的大写英文字母按以下对应规则替换：

原字母 对应字母
A Z
B Y
C X
D W
… …
X C
Y B
Z A

输入格式：

输入在一行中给出一个不超过80个字符、并以回车结束的字符串。

输出格式：

输出在一行中给出替换完成后的字符串。

输入样例：

1
Only the 11 CAPItaL LeTtERS are replaced.

输出样例：

1
Lnly the 11 XZKRtaO OeGtVIH are replaced.

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	char str[88];
	int sum = 0;
	fgets(str, sizeof(str), stdin);
	//scanf("%s", str);
	//printf("%s", str);
	for (int i = 0; i < strlen(str); ++i) {
		if (str[i] >='A' && str[i] <='Z') {
			str[i]=155-str[i];
		}
	}
	printf("%s", str);
}

7-66 时间换算

本题要求编写程序，以hh:mm:ss的格式输出某给定时间再过n秒后的时间值（超过23:59:59就从0点开始计时）。

输入格式：

输入在第一行中以hh:mm:ss的格式给出起始时间，第二行给出整秒数n（<60）。

输出格式：

输出在一行中给出hh:mm:ss格式的结果时间。

输入样例：

1
2
11:59:40
30

输出样例：

1
12:00:10

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	int h = 0, m = 0, s = 0,ps=0,index=0;
	scanf("%d:%d:%d", &h, &m, &s);
	scanf("%d", &ps);
	if (s + ps < 60) 
		s = s + ps;
	else {
		index = (s + ps) / 60;
		s = (s + ps) % 60;
		if (m + index < 60) 
			m = m + index;
		else {
			index = (m + index) / 60;
			m = (m + index) % 60;
			if (h + index < 24)
				h += index;
			else {
				h = h + index - 24;
			}
		}
	}
	printf("%02d:%02d:%02d", h, m, s);
}

7-67 What is a computer?

本题要求编写程序，输出一个短句“What is a computer?”。

输入格式:

本题目没有输入。

输出格式:

在一行中输出短句“What is a computer?”。

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	printf("What is a computer?");
	return 0;
}

7-68 求N分之一序列前N项和

本题要求编写程序，计算序列 1 + 1/2 + 1/3 + … 的前N项之和。

输入格式:

输入在一行中给出一个正整数N。

输出格式:

在一行中按照“sum = S”的格式输出部分和的值S，精确到小数点后6位。题目保证计算结果不超过双精度范围。

输入样例:

1
6

输出样例:

1
sum = 2.450000

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	int n = 0;
	double sum = 0;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		sum += 1.0 / i;
	}
	printf("sum = %.6lf", sum);
	return 0;
}

7-69 换硬币

将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？

输入格式:

输入在一行中给出待换的零钱数额x∈(8,100)。

输出格式:

要求按5分、2分和1分硬币的数量依次从大到小的顺序，输出各种换法。每行输出一种换法，格式为：“fen5:5分硬币数量, fen2:2分硬币数量, fen1:1分硬币数量, total:硬币总数量”。最后一行输出“count = 换法个数”。

输入样例:

1
13

输出样例:

1
2
3
4
5
fen5:2, fen2:1, fen1:1, total:4
fen5:1, fen2:3, fen1:2, total:6
fen5:1, fen2:2, fen1:4, total:7
fen5:1, fen2:1, fen1:6, total:8
count = 4

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	int fen5 = 1, fen2=1, fen1 = 1,x=0,total=0;
	scanf("%d", &x);
	for (int i = (x - 2 - 1) / 5; i >= 1; i--) {
		for (int j = (x - 5 - 1) / 2; j >= 1; j--) {
			for (int z = (x - 5 - 2) / 1; z >= 1; z--) {
				if (5 * i + 2 * j + z == x) {
					total++;
					printf("fen5:%d, fen2:%d, fen1:%d, total:%d\n", i, j, z, i + j + z);
				}
			}
		}
	}
	printf("count = %d", total);
	return 0;
}

7-70 输出三角形面积和周长

本题要求编写程序，根据输入的三角形的三条边a、b、c，计算并输出面积和周长。注意：在一个三角形中， 任意两边之和大于第三边。三角形面积计算公式：area=s(s−a)(s−b)(s−c)，其中s=(a+b+c)/2。

输入格式：

输入为3个正整数，分别代表三角形的3条边a、b、c。

输出格式：

如果输入的边能构成一个三角形，则在一行内，按照

1
area = 面积; perimeter = 周长

的格式输出，保留两位小数。否则，输出

1
These sides do not correspond to a valid triangle

输入样例1：

1
5 5 3

输出样例1：

1
area = 7.15; perimeter = 13.00

输入样例2：

1
1 4 1

输出样例2：

1
These sides do not correspond to a valid triangle

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int judge(int a, int b, int c) {
	if (a + b > c && a + c > b && b + c > a)	return 1;
	else return 0;
}
int main(void) {
	int a = 0, b = 0, c = 0;
	double s = 0,area=0,per=0;
	scanf("%d %d %d", &a, &b, &c);
	if (!judge(a,b,c))
		printf("These sides do not correspond to a valid triangle");
	else {
		per = a + b + c;
		s = per / 2.0;
		area = s * (s - a) * (s - b) * (s - c);
		area = sqrt(area);
		printf("area = %.2lf; perimeter = %.2lf",area,per);
	}
	return 0;
}

7-71 求平方与倒数序列的部分和

本题要求对两个正整数m和n（m≤n）编写程序，计算序列和m2+1/m+(m+1)2+1/(m+1)+⋯+n2+1/n。

输入格式:

输入在一行中给出两个正整数m和n（m≤n），其间以空格分开。

输出格式:

在一行中按照“sum = S”的格式输出部分和的值S，精确到小数点后六位。题目保证计算结果不超过双精度范围。

输入样例:

1
5 10

输出样例:

1
sum = 355.845635

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
double fac(int n) {
	double sum = 0;
	return n * n + 1.0 / n;
}
int main(void) {
	int m = 0, n = 0;
	scanf("%d %d", &m, &n);
	double sum = 0;
	for (int i = m; i <= n; ++i) {
		sum += fac(i);
	}
	printf("sum = %.6lf", sum);
	return 0;
}

7-72 三天打鱼两天晒网

中国有句俗语叫“三天打鱼两天晒网”。假设某人从某天起，开始“三天打鱼两天晒网”，问这个人在以后的第N天中是“打鱼”还是“晒网”？

输入格式：

输入在一行中给出一个不超过1000的正整数N。

输出格式：

在一行中输出此人在第N天中是“Fishing”（即“打鱼”）还是“Drying”（即“晒网”），并且输出“in day N”。

输入样例1：

1
103

输出样例1：

1
Fishing in day 103

输入样例2：

1
34

输出样例2：

1
Drying in day 34

鸣谢内蒙古师范大学张志平老师补充数据

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下:

1
2
3
4
5
6
7
8
9
10
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main(void) {
	int n = 0;
	scanf("%d", &n);
	if (n % 5 <= 3&&n%5>0)printf("Fishing in day %d", n);
	else printf("Drying in day %d", n);
	return 0;
}

7-73 比较大小

本题要求将输入的任意3个整数从小到大输出。

输入格式:

输入在一行中给出3个整数，其间以空格分隔。

输出格式:

在一行中将3个整数从小到大输出，其间以“->”相连。

输入样例:

1
4 2 8

输出样例:

1
2->4->8

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main(void) {
	int a = 0, b = 0, c = 0;
	scanf("%d %d %d", &a, &b, &c);
	if(a > b) {
		int t = a;
		a = b;
		b = t;
	}
	if (a > c) {
		int t = a;
		a = c;
		c = t;
	}
	if (b > c) {
		int t = b;
		b = c;
		c = t;
	}
	printf("%d->%d->%d", a, b, c);
	return 0;
}

7-74 三角形判断

给定平面上任意三个点的坐标(x1,y1)、(x2,y2)、(x3,y3)，检验它们能否构成三角形。

输入格式:

输入在一行中顺序给出六个[−100,100]范围内的数字，即三个点的坐标x1、y1、x2、y2、x3、y3。

输出格式:

若这3个点不能构成三角形，则在一行中输出“Impossible”；若可以，则在一行中输出该三角形的周长和面积，格式为“L = 周长, A = 面积”，输出到小数点后2位。

输入样例1:

1
4 5 6 9 7 8

输出样例1:

1
L = 10.13, A = 3.00

输入样例2:

1
4 6 8 12 12 18

输出样例2:

1
Impossible

代码长度限制

16 KB

时间限制

200 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
double judge(double a, double b, double c) {
	if (a + b > c && a + c > b && b + c > a)	return 1;
	else return 0;
}
double side(double x1, double y1, double x2, double y2) {
	double x = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
	//printf("x is %lf\n", x);
	return sqrt(x);
}
int main(void) {
	double x1=0,y1=0,x2=0,y2=0,x3=0,y3=0;
	double a = 0, b = 0, c = 0;
	double s = 0, area = 0, per = 0;
	scanf("%lf %lf %lf %lf %lf %lf", &x1,&y1,&x2,&y2,&x3,&y3);
	a = side(x1, y1, x2, y2);
	b = side(x1, y1, x3, y3);
	c = side(x2, y2, x3, y3);
	//printf("a,b,c is %lf %lf %lf\n", a, b, c);
	if (!judge(a, b, c))
		printf("Impossible");
	else {
		per = a + b + c;
		s = per / 2.0;
		area = s * (s - a) * (s - b) * (s - c);
		area = sqrt(area);
		printf("L = %.2lf, A = %.2lf", per, area);
	}
	return 0;
}

7-75 整数152的各位数字

本题要求编写程序，输出整数152的个位数字、十位数字和百位数字的值。

输入格式：

本题无输入。

输出格式：

按照以下格式输出：

1
152 = 个位数字 + 十位数字*10 + 百位数字*100

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main(void) {
	printf("152 = 2 + 5*10 + 1*100");
	return 0;
}

7-76 计算分段函数[3]

本题目要求计算下列分段函数f(x)的值：

输入格式：

输入在一行中给出实数x。

输出格式：

在一行中按“f(x) = result”的格式输出，其中x与result都保留一位小数。

输入样例1：

1
10

输出样例1：

1
f(10.0) = 0.1

输入样例2：

1
234

输出样例2：

1
f(234.0) = 234.0

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main(void) {
	double sum = 0,x=0;
	scanf("%lf", &x);
	if (x == 10)	sum = 1.0 / x;
	else sum = x;
	printf("f(%.1lf) = %.1lf", x, sum);
	return 0;
}

7-77 求1到100的和

本题要求编写程序，计算表达式 1 + 2 + 3 + … + 100 的值。

输入格式：

本题无输入。

输出格式：

按照以下格式输出：

1
sum = 累加和

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main(void) {
	int sum = 0;
	for (int i = 1; i <= 100; i++) {
		sum += i;
	}
	printf("sum = %d", sum);
	return 0;
}

7-78 计算油费

现在90号汽油6.95元/升、93号汽油7.44元/升、97号汽油7.93元/升。为吸引顾客，某自动加油站推出了“自助服务”和“协助服务”两个服务等级，分别可得到5%和3%的折扣。

本题要求编写程序，根据输入顾客的加油量a，汽油品种b（90、93或97）和服务类型c（m - 自助，e - 协助），计算并输出应付款。

输入格式：

输入在一行中给出两个整数和一个字符，分别表示顾客的加油量a，汽油品种b（90、93或97）和服务类型c（m - 自助，e - 协助）。

输出格式：

在一行中输出应付款额，保留小数点后2位。

输入样例：

1
40 97 m

输出样例：

1
301.34

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main() {
    char t= ' ';
    double a = 6.95, b = 7.44, c = 7.93, x = 0, oil = 0,sum=0;
    scanf("%lf %lf %c", &x,&oil,&t);
    if (oil == 90) {
        if (t == 'm')  sum = x * a * 0.95;
        else sum = x * a * 0.97;
    }
    else if (oil == 93) {
        if (t == 'm')  sum = x * b * 0.95;
        else sum = x * b * 0.97;
    }
    else
        if (t == 'm')  sum = x * c * 0.95;
        else sum = x * c * 0.97;
    printf("%.2lf", sum);
    return 0;
}

7-79 N个数求和

本题的要求很简单，就是求N个数字的和。麻烦的是，这些数字是以有理数分子/分母的形式给出的，你输出的和也必须是有理数的形式。

输入格式：

输入第一行给出一个正整数N（≤100）。随后一行按格式a1/b1 a2/b2 ...给出N个有理数。题目保证所有分子和分母都在长整型范围内。另外，负数的符号一定出现在分子前面。

输出格式：

输出上述数字和的最简形式 —— 即将结果写成整数部分 分数部分，其中分数部分写成分子/分母，要求分子小于分母，且它们没有公因子。如果结果的整数部分为0，则只输出分数部分。

输入样例1：

1
2
5
2/5 4/15 1/30 -2/60 8/3

输出样例1：

1
3 1/3

输入样例2：

1
2
2
4/3 2/3

输出样例2：

1
2

输入样例3：

1
2
3
1/3 -1/6 1/8

输出样例3：

1
7/24

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//求最大公倍数数
long lcd(long a, long b) {
    long m = 0;
    if (a > b) m = a;
    else m = b;
    for (long i = m; i <= a * b; ++i) {
        if (i % a == 0 && i % b == 0)   return i;
    }
    return 0;
}
//最小公约数
long gcd(long a, long b) {
    long m = 0;
    if (a < 0)  a = -a;
    if (a < b) m = a;
    else m = b;
    for (long i = m; i >= 1; i--) {
        if (a % i == 0 && b % i == 0)  return i;
    }
    return 0;
}
//化简
long gcdmyself(long* a, long* b) {
    long mlcd = gcd(*a, *b);
    //printf("mcld is %ld\n", mlcd);
    *a = *a / mlcd;
    *b = *b / mlcd;
    return;
}
void add(long* n, long* a, long* b, long* a1, long* b1) {
    long blcd = lcd(*b, *b1);
    long alcd = (blcd / *b) * (*a) + (blcd / *b1) * (*a1) + (*n) * blcd;
    long tgcd = gcd(alcd,blcd);
    if (alcd != 0) {
        *a = alcd / tgcd;
        *b = blcd / tgcd;
        *n = *a / (*b);
        *a = *a - (*n) * (*b);
    }
    else {
        *n = 0;
        *a = 0;
        *b = 1;
    }
    return 0;
}
//输出
void put(long num, long a, long b) {
    if (a == 0 && num == 0) {
        printf("0");
        return ;
    }
    if (a != 0) {
        if (num != 0)
            printf("%ld %ld/%ld", num, a, b);
        else
            printf("%ld/%ld", a, b);
    }
    else
        printf("%ld", num);
}
int main() {
    int n = 0;
    scanf("%d", &n);
    long a[101] = { 0 }, b[101] = { 0 }, num = 0;
    scanf("%ld/%ld", &a[1], &b[1]);
    gcdmyself(&a[1], &b[1]);
    for (int i = 2; i <= n; ++i) {
        scanf("%ld/%ld", &a[i], &b[i]);
        gcdmyself(&a[i], &b[i]);    
        add(&num, &a[1], &b[1], &a[i], &b[i]);
    }
    put(num, a[1], b[1]);
    return 0;
}

7-80 打折

去商场淘打折商品时，计算打折以后的价钱是件颇费脑子的事情。例如原价 ￥988，标明打 7 折，则折扣价应该是 ￥988 x 70% = ￥691.60。本题就请你写个程序替客户计算折扣价。

输入格式：

输入在一行中给出商品的原价（不超过1万元的正整数）和折扣（为[1, 9]区间内的整数），其间以空格分隔。

输出格式：

在一行中输出商品的折扣价，保留小数点后 2 位。

输入样例：

1
988 7

输出样例：

1
691.60

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
    int n = 0, price = 0;
    double sum = 0;
    scanf("%d %d", &n, &price);
    sum = n * 1.0 * price / 10;
    printf("%.02lf", sum);
    return 0;
}

7-81 2018我们要赢

2018年天梯赛的注册邀请码是“2018wmyy”，意思就是“2018我们要赢”。本题就请你用汉语拼音输出这句话。

输入格式：

本题没有输入。

输出格式：

在第一行中输出：“2018”；第二行中输出：“wo3 men2 yao4 ying2 !”。

输入样例：

1
本题没有输入。

输出样例：

1
2
2018
wo3 men2 yao4 ying2 !

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
    printf("2018\nwo3 men2 yao4 ying2 !");
    return 0;
}

7-82 打印沙漏

本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”，要求按下列格式打印

1
2
3
4
5
*****
 ***
  *
 ***
*****

所谓“沙漏形状”，是指每行输出奇数个符号；各行符号中心对齐；相邻两行符号数差2；符号数先从大到小顺序递减到1，再从小到大顺序递增；首尾符号数相等。

给定任意N个符号，不一定能正好组成一个沙漏。要求打印出的沙漏能用掉尽可能多的符号。

输入格式:

输入在一行给出1个正整数N（≤1000）和一个符号，中间以空格分隔。

输出格式:

首先打印出由给定符号组成的最大的沙漏形状，最后在一行中输出剩下没用掉的符号数。

输入样例:

1
19 *

输出样例:

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

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
    char c=' ';
    int h = 1, n = 0,sum=1;
    scanf("%d %c", &n,&c);
    while(sum<=n){
        h++;
        sum += (2 * h - 1) * 2;
    }
    sum -= (2 * h - 1) * 2;
    h--;
    //printf("h is %d\n", h);
    //上半部分
    for (int i = 1; i <= h; ++i) {
        for (int j = 1; j < i;++j) {
            printf(" ");
        }
        for (int j = 1; j <= 2*h-2*i+1; j++) {
            printf("%c",c);
        }
        printf("\n");
    }
    //printf("h is %d\n", h);
    for (int i = 1; i <= h-1; ++i) {
        for (int j = 1; j <=h-i-1; ++j) {
            printf(" ");
        }
        for (int j = 1; j <= 2*i+1; j++) {
            printf("%c",c);
        }
        printf("\n");
    }
    printf("%d", abs(n - sum));
    return 0;
}

7-83 币值转换

输入一个整数（位数不超过9位）代表一个人民币值（单位为元），请转换成财务要求的大写中文格式。如23108元，转换后变成“贰万叁仟壹百零捌”元。为了简化输出，用小写英文字母a-j顺序代表大写数字0-9，用S、B、Q、W、Y分别代表拾、百、仟、万、亿。于是23108元应被转换输出为“cWdQbBai”元。

输入格式：

输入在一行中给出一个不超过9位的非负整数。

输出格式：

在一行中输出转换后的结果。注意“零”的用法必须符合中文习惯。

输入样例1：

1
813227345

输出样例1：

1
iYbQdBcScWhQdBeSf

输入样例2：

1
6900

输出样例2：

1
gQjB

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
char num[10] = { 'a', 'b', 'c', 'd', 'e', 'f','g', 'h', 'i', 'j' };
char Cnum[5] = { 'S','B','Q','W','Y'};
int main() {
    char n[10] = { ' ' };
    long long int t=0,dit=0;
    scanf("%s", &n);
    dit = strlen(n);
    //printf("dis %d\n", dit);
    //数字为0的情况
    if (dit == 1 && n[0] - '0' == 0) {
        printf("a");
        return 0;
    }

    for (int i = 0; i <dit; ++i) {
        if (n[i]-'0' != 0) {
            if(dit-i==9)    printf("%cY", num[n[i] - '0']);
            else if (dit - i > 5 && dit-i <= 8) {
                printf("%c%c", num[n[i] - '0'], Cnum[dit - i - 6]);
               
            }
            else if (dit-i == 5) {
                if (dit-i == 5)  printf("%cW", num[n[i] - '0']);
            }
            else if (dit - i >0 && dit - i <5) {
                printf("%c%c", num[n[i] - '0'], Cnum[dit - i - 2]);
            }
            else {
                printf("%c", num[n[i] - '0']);
            }
        }
        else {
            if (dit - i == 5)    printf("W");
            else {
                int flag = 1,j=0;
                for (j = i+1; j < dit; j++) {
                    if (n[j] != n[i]) {
                        flag = 0;
                        break;
                    }
                }
                if (flag)    i = j;
                else {
                    printf("a");
                    i = j-1;
                }
            }
        }
        
    }
 
    return 0;
}

7-84 连续因子

一个正整数 N 的因子中可能存在若干连续的数字。例如 630 可以分解为 3×5×6×7，其中 5、6、7 就是 3 个连续的数字。给定任一正整数 N，要求编写程序求出最长连续因子的个数，并输出最小的连续因子序列。

输入格式：

输入在一行中给出一个正整数 N（1<N<231）。

输出格式：

首先在第 1 行输出最长连续因子的个数；然后在第 2 行中按 因子1*因子2*……*因子k 的格式输出最小的连续因子序列，其中因子按递增顺序输出，1 不算在内。

输入样例：

1
630

输出样例：

1
2
3
5*6*7

鸣谢用户 漏穿雪 补充数据！

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>

long int num, temp;
int main() {
    scanf("%ld", &num);
    int first = 0, len = 0, maxn = sqrt(num) + 1;
    for (int i = 2; i <= maxn; i++) {
        int j;
        temp = 1;
        for (j = i; j <= maxn; j++) {
            temp *= j;
            if (num % temp != 0) break;
        }
        if (j - i > len) {
            len = j - i;
            first = i;
        }
    }
    if (first == 0) {
        printf("1\n%ld", num);
    }
    else {
        printf("%d\n", len);
        for (int i = 0; i < len; i++) {
            printf("%d", first + i);
            if (i != len - 1) printf("*");
        }
    }
    return 0;
}

7-85 温度转换

本题要求编写程序，计算华氏温度150°F对应的摄氏温度。计算公式：C=5×(F−32)/9，式中：C表示摄氏温度，F表示华氏温度，输出数据要求为整型。

输入格式:

本题目没有输入。

输出格式:

按照下列格式输出

1
fahr = 150, celsius = 计算所得摄氏温度的整数值

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>
int main() {
	printf("fahr = 150, celsius = %d", 5 * (150 - 32) / 9);
}

7-86 整数四则运算

本题要求编写程序，计算2个正整数的和、差、积、商并输出。题目保证输入和输出全部在整型范围内。

输入格式:

输入在一行中给出2个正整数A和B。

输出格式:

在4行中按照格式“A 运算符 B = 结果”顺序输出和、差、积、商。

输入样例:

1
3 2

输出样例:

1
2
3
4
3 + 2 = 5
3 - 2 = 1
3 * 2 = 6
3 / 2 = 1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>
int main() {
	int a = 0, b = 0;
	scanf("%d %d", &a, &b);
	printf("%d + %d = %d\n%d - %d = %d\n%d * %d = %d\n%d / %d = %d", a, b, a + b, a, b, a - b, a, b, a * b, a, b, a / b);
}

7-87 计算分段函数[1]

本题目要求计算下列分段函数f(x)的值：

输入格式:

输入在一行中给出实数x。

输出格式:

在一行中按“f(x) = result”的格式输出，其中x与result都保留一位小数。

输入样例1:

1
10

输出样例1:

1
f(10.0) = 0.1

输入样例2:

1
0

输出样例2:

1
f(0.0) = 0.0

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>
int main() {
	double x = 0,sum=0;
	scanf("%lf", &x);
	if (x != 0)	sum = 1 / x;
	else sum = 0;
	printf("f(%.01lf) = %.01lf",x,sum);
}

7-88 计算分段函数[2]

本题目要求计算下列分段函数f(x)的值：

注：可在头文件中包含math.h，并调用sqrt函数求平方根，调用pow函数求幂。

输入格式:

输入在一行中给出实数x。

输出格式:

在一行中按“f(x) = result”的格式输出，其中x与result都保留两位小数。

输入样例1:

1
10

输出样例1:

1
f(10.00) = 3.16

输入样例2:

1
-0.5

输出样例2:

1
f(-0.50) = -2.75

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>
int main() {
	double x = 0,sum=0;
	scanf("%lf", &x);
	if (x >= 0)	sum = sqrt(x);
	else sum = pow(x + 1, 2) + 2 * x + 1 / x;
	printf("f(%.02lf) = %.02lf",x,sum);
}

7-89 阶梯电价

为了提倡居民节约用电，某省电力公司执行“阶梯电价”，安装一户一表的居民用户电价分为两个“阶梯”：月用电量50千瓦时（含50千瓦时）以内的，电价为0.53元/千瓦时；超过50千瓦时的，超出部分的用电量，电价上调0.05元/千瓦时。请编写程序计算电费。

输入格式:

输入在一行中给出某用户的月用电量（单位：千瓦时）。

输出格式:

在一行中输出该用户应支付的电费（元），结果保留两位小数，格式如：“cost = 应付电费值”；若用电量小于0，则输出”Invalid Value!”。

输入样例1:

1
10

输出样例1:

1
cost = 5.30

输入样例2:

1
100

输出样例2:

1
cost = 55.50

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>
//为了提倡居民节约用电，某省电力公司执行“阶梯电价”，安装一户一表的居民用户电价分为两个“阶梯”：
//月用电量50千瓦时（含50千瓦时）以内的，电价为0.53元 / 千瓦时；
//超过50千瓦时的，超出部分的用电量，电价上调0.05元 / 千瓦时。请编写程序计算电费。
int main() {
	double x = 0,sum=0;
	scanf("%lf", &x);
	if (x <= 50&&x>0)	sum = 0.53 * x;
	else if(x>50){
		sum = 0.53 * 50;
		sum += (x - 50) * 0.58;
	}
	else {
		printf("Invalid Value!");
		return 0;
	}
	printf("cost = %.02lf",sum);
	return 0;
}

7-90 统计字符

本题要求编写程序，输入10个字符，统计其中英文字母、空格或回车、数字字符和其他字符的个数。

输入格式:

输入为10个字符。最后一个回车表示输入结束，不算在内。

输出格式:

在一行内按照

1
letter = 英文字母个数, blank = 空格或回车个数, digit = 数字字符个数, other = 其他字符个数

的格式输出。

输入样例:

1
2
aZ &
09 Az

输出样例:

1
letter = 4, blank = 3, digit = 2, other = 1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>

int main() {
	int let = 0, blk = 0, dig = 0, other = 0;
	char str[11] = { ' ' };
	for (int i = 0; i < 10; ++i) {
		str[i] = getchar();
	}


	for (int i = 0; i < strlen(str); ++i) {
		if ((str[i] >= 'A' && str[i] <= 'Z') || (str[i] >= 'a' && str[i] <= 'z'))	let++;
		else if (str[i] == ' ' || str[i] == '\n')	blk++;
		else if (str[i] >= '0' && str[i] <= '9')	dig++;
		else other++;
	}
	printf("letter = %d, blank = %d, digit = %d, other = %d",let,blk,dig,other);
	return 0;
}

7-91 输出闰年

输出21世纪中截止某个年份以来的所有闰年年份。注意：闰年的判别条件是该年年份能被4整除但不能被100整除、或者能被400整除。

输入格式:

输入在一行中给出21世纪的某个截止年份。

输出格式:

逐行输出满足条件的所有闰年年份，即每个年份占一行。输入若非21世纪的年份则输出”Invalid year!”。若不存在任何闰年，则输出“None”。

输入样例1:

1
2048

输出样例1:

1
2
3
4
5
6
7
8
9
10
11
12
2004
2008
2012
2016
2020
2024
2028
2032
2036
2040
2044
2048

输入样例2:

1
2000

输出样例2:

1
Invalid year!

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>

int main() {
	int year = 0,flag=0;
	scanf("%d", &year);
	if (year > 2000 && year <= 2100) {
		for (int i = 2001; i <= year; ++i) {
			if (i % 400 == 0 || (i % 4 == 00 && i % 100 != 0)) {
				printf("%d\n", i);
				flag = 1;
			}
		}
		if (!flag)	printf("None");
	}
	else
		printf("Invalid year!");
	return 0;
}

7-92 特殊a串数列求和

给定两个均不超过9的正整数a和n，要求编写程序求a+aa+aaa++⋯+aa⋯a（n个a）之和。

输入格式：

输入在一行中给出不超过9的正整数a和n。

输出格式：

在一行中按照“s = 对应的和”的格式输出。

输入样例：

1
2 3

输出样例：

1
s = 246

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>

int main() {
	int a = 0, n = 0,sum = 0;
	scanf("%d %d", &a, &n);
	for (int i = 1; i <= n; ++i) {
		sum += (pow(10, i) - 1) / 9;
	}
	sum *= a;
	printf("s = %d", sum);
	return 0;
}

7-93 水仙花数

水仙花数是指一个N位正整数（N≥3），它的每个位上的数字的N次幂之和等于它本身。例如：153=13+53+33。 本题要求编写程序,计算所有N位水仙花数。

输入格式:

输入在一行中给出一个正整数N（3≤N≤7）。

输出格式:

按递增顺序输出所有N位水仙花数，每个数字占一行。

输入样例:

1
3

输出样例:

1
2
3
4
153
370
371
407

代码长度限制

16 KB

时间限制

2500 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>
int mypow(int a, int b) {
	int sum = 1;
	for (int i = 1; i <= b; ++i) {
		sum *= a;
	}
	return sum;
}
int judge(int n,int mi) {
	int sum = 0, t = n;
	while (n) {
		sum += mypow(n % 10, mi);
		if (sum > t)	return 0;
		n /= 10;
	}
	if (t == sum)	return 1;
	else return 0;
}
int main() {
	int n = 0;
	scanf("%d", &n);
	for (int i = mypow(10, n - 1); i < mypow(10, n); ++i) {
		if (judge(i,n))	printf("%d\n", i);
	}
	//if (judge(153))	printf("153\n");
	return 0;
}

7-94 计算华氏温度

本题要求编写程序，计算摄氏温度26°C 对应的华氏温度。计算公式：F=9×C/5+32，式中：C表示摄氏温度，F表示华氏温度，输出数据要求为整型。

输入格式:

本题目没有输入。

输出格式:

按照下列格式输出

1
celsius = 26, fahr = 对应的华氏温度整数值

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>
int main() {
	printf("celsius = 26, fahr = %d", 9 * 26 / 5 + 32);
	return 0;
}

7-95 计算火车运行时间

本题要求根据火车的出发时间和达到时间，编写程序计算整个旅途所用的时间。

输入格式：

输入在一行中给出2个4位正整数，其间以空格分隔，分别表示火车的出发时间和到达时间。每个时间的格式为2位小时数（00-23）和2位分钟数（00-59），假设出发和到达在同一天内。

输出格式：

在一行输出该旅途所用的时间，格式为“hh:mm”，其中hh为2位小时数、mm为2位分钟数。

输入样例：

1
1201 1530

输出样例：

1
03:29

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>
int hh(int x) {
	return x / 100;
}
int mm(int x) {
	return x - hh(x) * 100;
}
int main() {
	int beg = 0, end = 0,h=0,m=0,flag=0;
	scanf("%d %d", &beg, &end);
	if (mm(end) < mm(beg)) {
		m = mm(end) + 60 - mm(beg);
		flag = 1;
	}
	else
		m = mm(end) - mm(beg);
	h = hh(end) - hh(beg) - flag;
	printf("%02d:%02d", h, m);
	return 0;
}

7-96 计算存款利息

本题目要求计算存款利息，计算公式为interes**t=mon**ey×(1+rat**e)year−mon**ey，其中interes**t为存款到期时的利息（税前），mon**ey是存款金额，year是存期，rat**e是年利率。

输入格式：

输入在一行中顺序给出三个正实数mon**ey、year和rat**e，以空格分隔。

输出格式：

在一行中按“interest = 利息”的格式输出，其中利息保留两位小数。

输入样例：

1
1000 3 0.025

输出样例：

1
interest = 76.89

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>
int hh(int x) {
	return x / 100;
}
int mm(int x) {
	return x - hh(x) * 100;
}
int main() {
	double money = 0, year = 0, rate = 0;
	scanf("%lf %lf %lf", &money, &year, &rate);
	printf("interest = %.02lf", pow(1 + rate, year) * money - money);
	return 0;
}

7-97 计算个人所得税

假设个人所得税为：税率×(工资−1600)。请编写程序计算应缴的所得税，其中税率定义为：

  • 当工资不超过1600时，税率为0；
  • 当工资在区间(1600, 2500]时，税率为5%；
  • 当工资在区间(2500, 3500]时，税率为10%；
  • 当工资在区间(3500, 4500]时，税率为15%；
  • 当工资超过4500时，税率为20%。

输入格式:

输入在一行中给出非负工资。

输出格式:

在一行输出个人所得税，精确到小数点后2位。

输入样例1:

1
1600

输出样例1:

1
0.00

输入样例2:

1
1601

输出样例2:

1
0.05

输入样例3:

1
3000

输出样例3:

1
140.00

输入样例4:

1
4000

输出样例4:

1
360.00

输入样例5:

1
5000

输出样例5:

1
680.00

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>

int main() {
	double money = 0, taxes = 0;
	scanf("%lf", &money);
	if (money > 1600 && money <= 2500)	taxes = (money-1600)* 0.05;
	else if (money > 2500 && money <= 3500)	taxes = (money-1600)* 0.1;
	else if (money > 3500 && money <= 4500)	taxes = (money-1600)* 0.15;
	else if (money > 4500)	taxes = (money-1600)* 0.2;
	printf("%.02lf", taxes);
	return 0;
}

7-98 两个数的简单计算器

本题要求编写一个简单计算器程序，可根据输入的运算符，对2个整数进行加、减、乘、除或求余运算。题目保证输入和输出均不超过整型范围。

输入格式：

输入在一行中依次输入操作数1、运算符、操作数2，其间以1个空格分隔。操作数的数据类型为整型，且保证除法和求余的分母非零。

输出格式：

当运算符为+、-、*、/、%时，在一行输出相应的运算结果。若输入是非法符号（即除了加、减、乘、除和求余五种运算符以外的其他符号）则输出ERROR。

输入样例1：

1
-7 / 2

输出样例1：

1
-3

输入样例2：

1
3 & 6

输出样例2：

1
ERROR

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>

int main() {
	int a = 0, b = 0;
	char c = 0;
	scanf("%d %c %d", &a, &c, &b);
	//printf("%d %c %d\n", a, c, b);
	if (c == '+')printf("%d", a + b);
	else if (c == '-')	printf("%d", a - b);
	else if (c == '*')	printf("%d", a * b);
	else if (c == '/')printf("%d", a / b);
	else if (c == '%')printf("%d", a % b);
	else
		printf("ERROR");
	return 0;
}

7-99 打印九九口诀表

下面是一个完整的下三角九九口诀表：

1
2
3
4
5
6
7
8
9
1*1=1   
1*2=2   2*2=4   
1*3=3   2*3=6   3*3=9   
1*4=4   2*4=8   3*4=12  4*4=16  
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25  
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36  
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49  
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64  
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81

本题要求对任意给定的一位正整数N，输出从1*1到N*N的部分口诀表。

输入格式：

输入在一行中给出一个正整数N（1≤N≤9）。

输出格式：

输出下三角N*N部分口诀表，其中等号右边数字占4位、左对齐。

输入样例：

1
4

输出样例：

1
2
3
4
1*1=1   
1*2=2   2*2=4   
1*3=3   2*3=6   3*3=9   
1*4=4   2*4=8   3*4=12  4*4=16

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>

int main() {
	int n = 0;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= i; ++j) {
			printf("%d*%d=%-4d", j, i, i * j);
		}
		printf("\n");
	}
	return 0;
}

7-100 逆序的三位数

程序每次读入一个正3位数，然后输出按位逆序的数字。注意：当输入的数字含有结尾的0时，输出不应带有前导的0。比如输入700，输出应该是7。

输入格式：

每个测试是一个3位的正整数。

输出格式：

输出按位逆序的数。

输入样例：

1
123

输出样例：

1
321

鸣谢安阳师范学院软件学院李康康同学补充数据！

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>

int main() {
	int n = 0,flag=0;
	scanf("%d", &n);
	while (n != 0) {
		if (n % 10 != 0) {
			printf("%d", n % 10);
			flag = 1;
		}
		else {
			if (flag)	printf("%d", n % 10);
		}

		n /= 10;
	}
	return 0;
}

7-101 人民币兑换

1元5角钱人民币兑换5分、2分和1分的硬币（每一种都要有）共100枚，会有很多种兑换方案。请编写程序给出各种兑换方案。

输入格式:

输入为一个正整数n，表示要求输出前n种可能的方案。方案的顺序，是按照5分硬币从少到多排列的。

输出格式:

显示前n种方案中5分、2分、1分硬币各多少枚。每行显示一种方案，数字之间空一格，最后一个数字后没有空格。

注意：如果全部方案不到n种，就顺序输出全部可能的方案。

输入样例:

1
5

输出样例:

1
2
3
4
5
1 46 53  
2 42 56  
3 38 59  
4 34 62  
5 30 65

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	int fen5 = 1, fen2 = 1, fen1 = 1, n = 0, t = 0;
	scanf("%d", &n);
	for (int i = 1; i <= (150 - 1 - 2) / 5; i++) {
		for (int j = 1; j <= (150 - 5 - 2) / 2; j++) {
			if (5 * i + 2 * j + (100 - i - j) == 150&&t<n) {
				printf("%d %d %d\n", i, j, 100 - i - j);
				t++;
			}
		}
	}
	//printf("count = %d", total);
	return 0;
}

7-102 大笨钟

微博上有个自称“大笨钟V”的家伙，每天敲钟催促码农们爱惜身体早点睡觉。不过由于笨钟自己作息也不是很规律，所以敲钟并不定时。一般敲钟的点数是根据敲钟时间而定的，如果正好在某个整点敲，那么“当”数就等于那个整点数；如果过了整点，就敲下一个整点数。另外，虽然一天有24小时，钟却是只在后半天敲1~12下。例如在23:00敲钟，就是“当当当当当当当当当当当”，而到了23:01就会是“当当当当当当当当当当当当”。在午夜00:00到中午12:00期间（端点时间包括在内），笨钟是不敲的。

下面就请你写个程序，根据当前时间替大笨钟敲钟。

输入格式：

输入第一行按照hh:mm的格式给出当前时间。其中hh是小时，在00到23之间；mm是分钟，在00到59之间。

输出格式：

根据当前时间替大笨钟敲钟，即在一行中输出相应数量个Dang。如果不是敲钟期，则输出：

1
Only hh:mm.  Too early to Dang.

其中hh:mm是输入的时间。

输入样例1：

1
19:05

输出样例1：

1
DangDangDangDangDangDangDangDang

输入样例2：

1
07:05

输出样例2：

1
Only 07:05.  Too early to Dang.

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
void dang() {
	printf("Dang");
	return;
}
int main(void) {
	int hh = 0, mm = 0;
	scanf("%d:%d", &hh, &mm);
	if (hh < 12||(hh==12&&mm==0)) {
		printf("Only %02d:%02d.  Too early to Dang.", hh, mm);
	}
	else {
		int sum = 0;
		if (mm != 0)sum++;
		sum += hh - 12;
		for (int i = 1; i <= sum; ++i)	dang();
	}
	return 0;
}

7-103 A除以B

真的是简单题哈 —— 给定两个绝对值不超过100的整数A和B，要求你按照“A/B=商”的格式输出结果。

输入格式：

输入在第一行给出两个整数A和B（−100≤A,B≤100），数字间以空格分隔。

输出格式：

在一行中输出结果：如果分母是正数，则输出“A/B=商”；如果分母是负数，则要用括号把分母括起来输出；如果分母为零，则输出的商应为Error。输出的商应保留小数点后2位。

输入样例1：

1
-1 2

输出样例1：

1
-1/2=-0.50

输入样例2：

1
1 -3

输出样例2：

1
1/(-3)=-0.33

输入样例3：

1
5 0

输出样例3：

1
5/0=Error

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	int a = 0, b = 0;
	scanf("%d %d", &a, &b);
	if (b == 0)printf("%d/%d=Error",a,b);
	else if (b < 0)printf("%d/(%d)=%.02lf", a, b, a * 1.0 / b);
	else printf("%d/%d=%.02lf", a, b, a * 1.0 / b);
	return 0;
}

7-104 新世界

这道超级简单的题目没有任何输入。

你只需要在第一行中输出程序员钦定名言“Hello World”，并且在第二行中输出更新版的“Hello New World”就可以了。

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	printf("Hello World\nHello New World");
	return 0;
}

7-105 寻找250

对方不想和你说话，并向你扔了一串数…… 而你必须从这一串数字中找到“250”这个高大上的感人数字。

输入格式：

输入在一行中给出不知道多少个绝对值不超过1000的整数，其中保证至少存在一个“250”。

输出格式：

在一行中输出第一次出现的“250”是对方扔过来的第几个数字（计数从1开始）。题目保证输出的数字在整型范围内。

输入样例：

1
888 666 123 -233 250 13 250 -222

输出样例：

1
5

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	int n = 0, t = 0;
	while (scanf("%d", &n)) {
		t++;
		if (n == 250) {
			break;
		}
	}
	printf("%d", t);
	return 0;
}

7-106 求平方根序列前N项和

本题要求编写程序，计算平方根序列1+2+3+⋯的前N项之和。可包含头文件math.h，并调用sqrt函数求平方根。

输入格式:

输入在一行中给出一个正整数N。

输出格式:

在一行中按照“sum = S”的格式输出部分和的值S，精确到小数点后两位。题目保证计算结果不超过双精度范围。

输入样例:

1
10

输出样例:

1
sum = 22.47

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
#include<math.h>
int main(void) {
	double n = 0, sum = 0;
	scanf("%lf", &n);
	for (int i = 1; i <= n; ++i) {
		sum += sqrt(i);
	}
	printf("sum = %.02lf", sum);
	return 0;
}

7-107 找出最小值

本题要求编写程序，找出给定一系列整数中的最小值。

输入格式：

输入在一行中首先给出一个正整数n，之后是n个整数，其间以空格分隔。

输出格式：

在一行中按照“min = 最小值”的格式输出n个整数中的最小值。

输入样例：

1
4 -2 -123 100 0

输出样例：

1
min = -123

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<limits.h>
#include<math.h>
int main(void) {
	int n = 0, min = INT_MAX,t;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d", &t);
		if (t < min)	min = t;
	}
	printf("min = %d", min);
	return 0;
}

7-108 将x的平方赋值给y

假设x的值为3，计算x的平方并赋值给y，分别以“y = x ∗ x”和“x ∗ x = y”的形式输出x和y的值。

输入格式：

本题无输入

输出格式：

按照下列格式输出代入x=3的结果：

1
2
y = x * x
x * x = y

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<limits.h>
#include<math.h>
int main(void) {
	printf("9 = 3 * 3\n3 * 3 = 9");
	return 0;
}

7-109 计算工资

某公司员工的工资计算方法如下：一周内工作时间不超过40小时，按正常工作时间计酬；超出40小时的工作时间部分，按正常工作时间报酬的1.5倍计酬。员工按进公司时间分为新职工和老职工，进公司不少于5年的员工为老职工，5年以下的为新职工。新职工的正常工资为30元/小时，老职工的正常工资为50元/小时。请按该计酬方式计算员工的工资。

输入格式：

输入在一行中给出2个正整数，分别为某员工入职年数和周工作时间，其间以空格分隔。

输出格式：

在一行输出该员工的周薪，精确到小数点后2位。

输入样例1：

1
5 40

输出样例1：

1
2000.00

输入样例2：

1
3 50

输出样例2：

1
1650.00

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
	int year = 0;
	double time = 0;
	scanf("%d %lf", &year, &time);
	if (year < 5)printf("%.02lf", time > 40 ? 40 * 30 + (time - 40) * 30 * 1.5 : time * 30);
	else printf("%.02lf", time > 40 ? 40 * 50 + (time - 40) * 50 * 1.5 : time * 50);
	return 0;
}

7-110 求符合给定条件的整数集

给定不超过6的正整数A，考虑从A开始的连续4个数字。请输出所有由它们组成的无重复数字的3位数。

输入格式：

输入在一行中给出A。

输出格式：

输出满足条件的的3位数，要求从小到大，每行6个整数。整数间以空格分隔，但行末不能有多余空格。

输入样例：

1
2

输出样例：

1
2
3
4
234 235 243 245 253 254
324 325 342 345 352 354
423 425 432 435 452 453
523 524 532 534 542 543

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main()
{
	int i, j, k;
	int n;
	int count = 0;
	scanf("%d", &n);
	for (i = n; i <= n + 3; i++)
	{
		for (j = n; j <= n + 3; j++)
			for (k = n; k <= n + 3; k++)
				if (i != j && j != k && i != k)
				{
					count++;
					if (count % 6 == 0)
						printf("%d%d%d\n", i, j, k);
					else
						printf("%d%d%d ", i, j, k);
				}
	}
	return 0;
}

7-111 求特殊方程的正整数解

本题要求对任意给定的正整数N，求方程X2+Y2=N的全部正整数解。

输入格式：

输入在一行中给出正整数N（≤10000）。

输出格式：

输出方程X2+Y2=N的全部正整数解，其中X≤Y。每组解占1行，两数字间以1空格分隔，按X的递增顺序输出。如果没有解，则输出No Solution。

输入样例1：

1
884

输出样例1：

1
2
10 28
20 22

输入样例2：

1
11

输出样例2：

1
No Solution

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main()
{
	int n = 0, y = 0, x = 0, flag=0;
	scanf("%d", &n);
	for (int y = sqrt(n); y >= 1; y--) {
		x = sqrt(n - y * y);
		if (x > y)	break;
		if (x * x + y * y == n && x != 0) {
			printf("%d %d\n", x, y);
			flag = 1;
		}
	}
	if (!flag)	printf("No Solution");
	return 0;
}

7-112 约分最简分式

分数可以表示为分子/分母的形式。编写一个程序，要求用户输入一个分数，然后将其约分为最简分式。最简分式是指分子和分母不具有可以约分的成分了。如6/12可以被约分为1/2。当分子大于分母时，不需要表达为整数又分数的形式，即11/8还是11/8；而当分子分母相等时，仍然表达为1/1的分数形式。

输入格式：

输入在一行中给出一个分数，分子和分母中间以斜杠/分隔，如：12/34表示34分之12。分子和分母都是正整数（不包含0，如果不清楚正整数的定义的话）。

提示：

  • 对于C语言，在scanf的格式字符串中加入/，让scanf来处理这个斜杠。
  • 对于Python语言，用a,b=map(int, input().split('/'))这样的代码来处理这个斜杠。

输出格式：

在一行中输出这个分数对应的最简分式，格式与输入的相同，即采用分子/分母的形式表示分数。如
5/6表示6分之5。

输入样例：

1
66/120

输出样例：

1
11/20

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int gcd(int a, int b) {
	return b == 0 ? a : gcd(b, a % b);
}
int main()
{
	int a = 0, b = 0;
	scanf("%d/%d", &a, &b);
	printf("%d/%d", a / gcd(a, b), b / gcd(a, b));
	return 0;
}

7-113 单词长度

你的程序要读入一行文本，其中以空格分隔为若干个单词，以.结束。你要输出每个单词的长度。这里的单词与语言无关，可以包括各种符号，比如it's算一个单词，长度为4。注意，行中可能出现连续的空格；最后的.不计算在内。

输入格式：

输入在一行中给出一行文本，以.结束

提示：用scanf("%c",...);来读入一个字符，直到读到.为止。

输出格式：

在一行中输出这行文本对应的单词的长度，每个长度之间以空格隔开，行末没有最后的空格。

输入样例：

1
It's great to see you here.

输出样例：

1
4 5 2 3 3 4

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>

int main()
{
	int i = 0,beg=0,leg=0,flag=0,frist=0;
	char c[1000] = { ' ' };
	scanf("%c", &c[i]);
	while (c[i] != '.') {
		if (c[i] == ' ') {
			//碰到连续字符后的第一个空格
			if (flag) {
				leg = i - beg;
				if (leg != 0) {
					if (frist!=0)printf(" ");
					else frist = 1;
					printf("%d", leg);
				}
				flag = 0;
			}
			
		}
		else {
			//非0之后的一个字符
			if (!flag) {
				beg = i;
				flag = 1;
			}
		}
		i++;
		scanf("%c", &c[i]);
	}
	if (flag) {
		leg = i - beg;
		if (leg != 0) {
			if (frist == 0)	printf("%d", leg);
			else
				printf(" %d", leg);
		}
	}
	return 0;
}

7-114 谁先倒

划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为：每人口中喊出一个数字，同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和，谁就输了，输家罚一杯酒。两人同赢或两人同输则继续下一轮，直到唯一的赢家出现。

下面给出甲、乙两人的酒量（最多能喝多少杯不倒）和划拳记录，请你判断两个人谁先倒。

输入格式：

输入第一行先后给出甲、乙两人的酒量（不超过100的非负整数），以空格分隔。下一行给出一个正整数N（≤100），随后N行，每行给出一轮划拳的记录，格式为：

1
甲喊 甲划 乙喊 乙划

其中喊是喊出的数字，划是划出的数字，均为不超过100的正整数（两只手一起划）。

输出格式：

在第一行中输出先倒下的那个人：A代表甲，B代表乙。第二行中输出没倒的那个人喝了多少杯。题目保证有一个人倒下。注意程序处理到有人倒下就终止，后面的数据不必处理。

输入样例：

1
2
3
4
5
6
7
8
1 1
6
8 10 9 12
5 10 5 10
3 8 5 12
12 18 1 13
4 16 12 15
15 1 1 16

输出样例：

1
2
A
1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main()
{
	int n = 0, a = 0, b = 0,drka=0,drkb=0;
	scanf("%d %d", &a, &b);
	scanf("%d", &n);
	//printf(" a b n is %d %d %d\n", a, b, n);
	int grsa = 0, grsb = 0,rela=0,relb=0;
	for (int i = 1; i <= n; ++i) {
		scanf("%d %d %d %d", &grsa, &rela, &grsb, &relb);
		if (rela != relb) {
			if (rela == grsa + grsb )	drka++;
			if (relb == grsa + grsb )	drkb++;
			if (drkb > b) {
				printf("B\n%d", drka);
				return 0;
			}
			if (drka > a) {
				printf("A\n%d", drkb);
				return 0;
			}
		}
	}
	return 0;
}

7-115 小于m的最大的10个素数

给定一个整数m（50<m<20000），找出小于m的最大的10个素数。

输入格式:

输入在一行中给出一个正整数m（50<m<20000）。

输出格式:

在一行中按递减顺序输出10个满足条件的素数，每个素数输出占6列。没有其它任何附加格式和字符。

输入样例:

1
229

输出样例:

1
227   223   211   199   197   193   191   181   179   173

感谢中国青年政治学院的同学修正数据！

代码长度限制

1000 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int judge(int n) {
	for (int i = 2; i <= n / 2; ++i) {
		if (n % i == 0)	return 0;
	}
	return 1;
}
int main()
{
	int n = 0,t=10;
	scanf("%d", &n);
	n = n % 2 == 0 ? n - 1 : n-2;
	
	for (int i =n; i >= 2; --i) {
		if (judge(i)&&t) {
			printf("%6d", i);
			t--;
		}
	}
	return 0;
}

7-116 计算圆周率

根据下面关系式，求圆周率的值，直到最后一项的值小于给定阈值。

2π=1+31+3×52!+3×5×73!+⋯+3×5×7×⋯×(2n+1)n!+⋯

输入格式：

输入在一行中给出小于1的阈值。

输出格式：

在一行中输出满足阈值条件的近似圆周率，输出到小数点后6位。

输入样例：

1
0.01

输出样例：

1
3.132157

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
double monomial(double n) {
	double num = 1, den = 1;
	for (int i = 1; i <= n; ++i)	num *= i;
	for (int i = 1; i <= n; ++i) {
		den *= (i * 2 + 1);
	}
	return num*1.0 / den;
}
int main()
{
	double n = 0;
	scanf("%lf", &n);
	double sum = 1,t=1;
	while (monomial(t) >= n) {
		sum += monomial(t);
		t++;
	}
	sum += monomial(t);
	printf("%.06lf", sum * 2);
	return 0;
}

7-117 整数的分类处理

给定 N 个正整数，要求你从中得到下列三种计算结果：

  • A1 = 能被 3 整除的最大整数
  • A2 = 存在整数 K 使之可以表示为 3K+1 的整数的个数
  • A3 = 存在整数 K 使之可以表示为 3K+2 的所有整数的平均值（精确到小数点后 1 位）

输入格式：

输入首先在第一行给出一个正整数 N，随后一行给出 N 个正整数。所有数字都不超过 100，同行数字以空格分隔。

输出格式：

在一行中顺序输出 A1、A2、A3的值，其间以 1 个空格分隔。如果某个数字不存在，则对应输出NONE。

输入样例 1：

1
2
8
5 8 7 6 9 1 3 10

输出样例 1：

1
9 3 6.5

输入样例 2：

1
2
8
15 18 7 6 9 1 3 10

输出样例 2：

1
18 3 NONE

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
int main()
{	
	double a3 = 0;
	int n = 0, a1 = INT_MIN, a2 = 0,p=0,t=0;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d", &p);
		if (p % 3 == 0 && p > a1)	a1 = p;
		else if (p % 3 == 1)	a2++;
		else if(p%3==2){
			a3 += p;
			t++;
		}
	}
	if(t!=0)	a3 = a3 * 1.0 / t;
	//printf("t is %d\na3 is %lf\n", t,a3);
	if (a1 == INT_MIN)printf("NONE ");
	else printf("%d ", a1);
	if (a2 == 0)printf("NONE ");
	else printf("%d ", a2);
	if (a3 == 0)printf("NONE");
	else printf("%.01lf", a3);
	return 0;
}

7-118 分队列

班级第一次列队，通常老师会让同学按身高排成一列，然后1、2报数，喊到1的同学向前一步，就这样，队伍就变成两列了。假设现在一个班级有n个同学，并且他们已经按身高排成了一列，同学按身高从1到n编号，你能告诉我最后哪些编号的同学站在了第一列么?

输入格式:

输入一个正整数n，表示班级的人数。

输出格式:

按顺序输出所有在第一列的同学对应的编号，每两个编号之间用一个空格隔开。

输入样例:

1
11

输出样例:

1
1 3 5 7 9 11

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
int main()
{	
	int n = 0,first=0;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		if (i % 2 == 1) {
			if (first)	printf(" ");
			else first = 1;
			printf("%d", i);
		}
	}
	return 0;
}

7-119 我是升旗手

一年一度的升旗手选拔又要到了，学校要求每个班级选出一位同学做升旗手的候选人。因
为升旗手对身高有严格的要求，所以班主任决定选班级里个子最高的同学(如果两位同学
一样高，则选任意一位)。你能很快地给老师答案么?

输入格式:

输入包括两行。 第一行:包括一个整数n，表示班级里共有n位同学。 第二行:包含n个三位数，表示每一位同学的身高。

输出格式:

输出身高最高的同学的身高。

输入样例:

1
2
4
130 125 129 140

输出样例:

1
140

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
int main()
{	
	int n = 0,max=INT_MIN,t=0;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d", &t);
		if (t > max)	max = t;
	}
	printf("%d", max);
	return 0;
}

7-120 兔子繁殖问题

已知有一对兔子，每个月可以生一对兔子，而小兔子一个月后又可以生一对小兔子(比如:2月份出生的小兔子4月份可以生育)。也就是说，兔子的对数为：第一个月1对，第二个月2对，第三个月3对，第四个月5对…..假设兔子的生育期为两年，且不死。那么问题来了，你能说出每个月的兔子数么?

输入格式:

输入一个数n，表示第n个月，1<=n<=24。

输出格式:

输出这个月兔子的数目。

输入样例:

1
4

输出样例:

1
5

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
int main()
{	
	int a[27] = { 0,1,2 }, n = 0;
	scanf("%d", &n);
	for (int i = 3; i <= n; ++i) {
		a[i] = a[i - 1] + a[i - 2];
	}
	printf("%d", a[n]);
	return 0;
}

7-121 作品评分

全国中小学生Scratch作品大赛拉开了序幕。每个参赛选手可以通过网络直接上传作品。本次比赛人人可做评委。每个网络评委可以通过网络对每一件作品进行打分。评分系统也是请程序高手设计的，能自动去掉一个最高分和一个最低分，求出平均分。

输入格式:

输入数据包括两行: 第一行为n，表示n个评委，n>2。
第二行是n个评委的打分，分数之间有一个空格。打分是可以带有小数部分的。

输出格式:

输出平均分，结果保留两位小数。

输入样例:

1
2
6
10 9 8 7.9 9 9.5

输出样例:

1
8.88

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	double sum = 0, min = DBL_MAX,max = DBL_MIN,t=0;
	for (int i = 1; i <= n; ++i) {
		scanf("%lf", &t);
		if (t > max)	max = t;
		if (t < min)	min = t;
		sum += t;
	}
	sum = sum - max - min;
	printf("%.02lf", sum / (n - 2));
	return 0;
}

7-122 3n+1

有这样一个猜想：对于任意大于1的自然数n，若n为奇数，则将n变成3n+1,否则变成n的一半。经过若干次这样的变换，一定会使n变为1。例如3->10->5->16->8->4->2->1。对于n=1的情况，当然就不用变化了。

输入格式:

输入一个正整数n，n的范围是[1,999999]。

输出格式:

输出变换的次数。

输入样例:

1
3

输出样例:

1
7

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	int n = 0, t = 0;
	scanf("%d", &n);
	while (n!=1) {
		if (n % 2 == 1)	n = 3 * n + 1;
		else n = n / 2;
		t++;
	}
	printf("%d", t);
	return 0;
}

7-123 空心字母金字塔

输入一个大写的英文字母，输出空心的字母金字塔。

输入格式:

一个大写英文字母。

输出格式:

一个空心的大写英文字母金字塔，其中第1层的“A”在第1行的第40列，列从1开始计数。

输入样例:

1
E

输出样例:

1
2
3
4
5
    A
   B B
  C   C
 D     D
EEEEEEEEE

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	char c = ' ';
	scanf("%c", &c);
	for (int i = 1; i <= 39; ++i)	printf(" ");
	printf("A\n");
	for (int i = 1; i <= c - 'B'+1; ++i) {
		for (int j = 1; j <= 39-i; ++j) {
			printf(" ");
		}
		printf("%c", 'A' + i);

		if (i != c - 'B' + 1) {
			for (int j = 1; j <= 2 * i - 1; ++j) {
				printf(" ");
			}
			printf("%c\n", 'A' + i);
		}
		else {
			for (int j = 1; j <= 2 * i ; ++j) {
				printf("%c",'A'+i);
			}
		}
	}
	return 0;
}

7-124 上三角数字三角形

输入一个正整数n，输出具有n层的上三角数字三角形。

输入格式:

只有一个正整数n，1<=n<=100。

输出格式:

一个上三角数字三角形，每个数字占四个字符位置。

输入样例:

1
5

输出样例:

1
2
3
4
5
 1   2   3   4   5
 6   7   8   9
10  11  12
13  14
15

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	int n = 0,t=1;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		if (i != 1)	printf("\n");
		for (int j = 1; j <= n - i + 1; ++j) {
			printf("%4d", t);
			t++;
		}
	}
	return 0;
}

7-125 又来一个上三角数字三角形

输入一个正整数n，输出具有n层的上三角数字三角形。

输入格式:

只有一个正整数n，1<=n<=100。

输出格式:

一个上三角数字三角形，每个数字占四个字符位置。

输入样例:

1
5

输出样例:

1
2
3
4
5
1   6  10  13  15
2   7  11  14
3   8  12
4   9
5

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	int n = 0,t=1,p=0;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		if (i != 1)	printf("\n");
		for (int j = 1; j <= n - i + 1; ++j) {
			if (j == 1) {
				t = i;
				p = n;
				printf("%4d", t);
			}
			else {
				t += p;
				p--;
				printf("%4d", t);
			}
		}
	}
	return 0;
}

7-126 时间差

10点半到11点45之间，有几小时几分钟呢？

你要写一个程序，读入两个时间，计算它们之间的时间差，输出相差几小时几分钟。

输入

输入两个时间，均以24小时制表达，每个时间以“小时:分钟”的形式表达，第二个时间一定比第一个时间晚或相同，而且一定在同一天内。

输出

输出表示两个时间之间的时间差的两个数字，第一个数字是时间差中的小时数，第二个数字是时间差中的分钟数。

输入例子

1
10:30 11:45

输出例子

1
1 15

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	int ha = 0, ma = 0, hb = 0, mb = 0,hh=0,mm=0;
	scanf("%d:%d %d:%d", &ha, &ma, &hb, &mb);
	hh = (hb * 60 + mb - ma - ha * 60) / 60;
	mm = (hb * 60 + mb - ma - ha * 60) - hh * 60;
	printf("%d %d", hh, mm);
	return 0;
}

7-127 Sum of the digits

Given a none-negative number, print out the sum of its digits.

Input Format:

A none-negative integer number.

Output Format:

The sum of its all digits.

Sample Input:

1
123

Sample Output:

1
6

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	int n = 0,sum=0;
	scanf("%d", &n);
	while (n) {
		sum += n % 10;
		n /= 10;
	}
	printf("%d", sum);
	return 0;
}

7-128 大于m的最小素数

编程求出大于m的最小素数。

输入格式:

直接输入一个正整数

输出格式:

直接输出结果，没有任何附加格式控制。

输入样例:

1
12

输出样例:

1
13

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int judge(int n) {
	int flag = 0;
	for (int i = 2; i <= n / 2; ++i) {
		if (n % i == 0) {
			flag = 1;
			break;
		}
	}
	return flag;
}
int main()
{
	int n = 0,sum=0;
	scanf("%d", &n);
	n++;
	while (judge(n)) {
		n++;
	}
	printf("%d", n);
	return 0;
}

7-129 最佳情侣身高差

专家通过多组情侣研究数据发现，最佳的情侣身高差遵循着一个公式：（女方的身高）×1.09 =（男方的身高）。如果符合，你俩的身高差不管是牵手、拥抱、接吻，都是最和谐的差度。

下面就请你写个程序，为任意一位用户计算他/她的情侣的最佳身高。

输入格式：

输入第一行给出正整数N（≤10），为前来查询的用户数。随后N行，每行按照“性别 身高”的格式给出前来查询的用户的性别和身高，其中“性别”为“F”表示女性、“M”表示男性；“身高”为区间 [1.0, 3.0] 之间的实数。

输出格式：

对每一个查询，在一行中为该用户计算出其情侣的最佳身高，保留小数点后2位。

输入样例：

1
2
3
2
M 1.75
F 1.8

输出样例：

1
2
1.61
1.96

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
double best(double n,char c) {
	if (c == 'M')	return n / 1.09;
	if (c == 'F')	return n * 1.09;
}
int main()
{
	char c = ' ';
	double t = 0,n = 0;
	scanf("%lf", &n);
	for (int i = 1; i <= n; ++i) {
		scanf(" %c %lf", &c, &t);
		printf("%.02lf\n", best(t, c));
	}
	return 0;
}

7-130 累加器

请你实现一个累加器。输入 n 个非负整数，输出他们的和。 1≤n<1000，而每个数则 <10000。

输入格式:

输入包括两行。 第一行：包括一个整数 n，表示总共有 n 个数。 第二行：包含 n 个整数。

输出格式:

输出 n 个数的和。

输入样例:

1
2
4
3 2 1 4

输出样例:

1
10

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	long long n = 0, sum = 0,t=0;
	scanf("%lld", &n);
	for (long long i = 1; i <= n; ++i) {
		scanf("%lld", &t);
		sum += t;
	}
	printf("%lld", sum);
	return 0;
}

7-131 等腰直角三角形

等腰直角三角形是指一个角是直角，且两条直角边相等的三角形。这里我们输出直角边长为n的等腰直角三角形的格式如下所示: 比如n=1，则输出:

1
*

n=2，输出:

1
2
*
**

n=3，输出:

1
2
3
*
** 
***

那么，你能用程序来实现么?

输入格式:

输入一个数n，表示三角形的边长。1<n<1000。

输出格式:

输出对应的用*表示的等腰直角三角形。

输入样例:

1
4

输出样例:

1
2
3
4
*
**
***
****

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= i; ++j)	printf("*");
		printf("\n");
	}
	return 0;
}

7-132 画菱形

菱形是一种特殊的平行四边形，是四条边均相等的平行四边形。题目给出菱形的边长n，用*画出菱形。如n=1，输出:

1
*

n=2，输出:

1
2
3
 *
*** 
 *

n=3，输出:

1
2
3
4
5
  * 
 ***
*****
 ***
  *

那么，你能用程序来实现么?

输入格式:

输入菱形的边长n，1<n<100。

输出格式:

输出对应的用*表示的菱形。

输入样例:

1
4

输出样例:

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

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n-i; ++j) {
			printf(" ");
		}
		for (int j = 1; j <= 2 * i - 1; ++j)	printf("*");
		printf("\n");
	}
	for (int i = 1; i <= n - 1; ++i) {
		for (int j = 1; j <= i; ++j)	printf(" ");
		for (int j = 1; j <= 2 * n - 1 - 2 * i; ++j)	printf("*");
		printf("\n");
	}
	return 0;
}

7-133 666

中国人非常喜欢6这个数字，因为大家总爱说66大顺啊。数学狂人李某人喜欢把什么都数字化，于是她把顺利这个词也定义了数量级，6代表1级顺利，66代表2级顺利，666代表3级顺利，以此类推。你看，数学狂人的世界总是让人无法理解。今天，李某人决定将数学进行到底，现在她设前n级顺利的和是sn。

1
sn=6+66+666+...+66..66(n个6)。

假设你已经知道了数字n，那么，你能帮李某人求出sn么?

输入格式:

输入一个正整数n，n的范围是[0,10)。

输出格式:

输出Sn的值。

输入样例:

1
2

输出样例:

1
72

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
long long pow(long x, long n) {
	long sum = 1;
	for (int i = 1; i <= n; ++i) {
		sum *= x;
	}
	return sum;
}
long long res(int n) {
	if (n == 1)	return 1;
	else {
		return pow(10, n-1)+res(n-1);
	}
}
int main()
{
	long long sum = 0;
	int n = 0;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		sum += res(i);
		//printf("res(i) %lld\n", res(i));
	}
	//printf("sum is %lld\n", sum);
	printf("%lld", sum * 6);
	return 0;
}

7-134 倒顺数字串

输入正整数n，输出它的倒顺数字串。如n=6时，输出

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

输入格式:

输入一个正整数n，n的范围是[1,50]。

输出格式:

n的倒顺数字串，每两个数字之间只用一个空格隔开。

输入样例:

1
6

输出样例:

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

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		if (i != 1)	printf(" ");
		printf("%d", i);
	}
	for (int i = n - 1; i >= 1; --i)	printf(" %d", i);
	return 0;
}

7-135 数字金字塔

输入正整数n，输出n层数字金字塔。

输入格式:

正整数n，1<=n<=9。

输出格式:

n层的金字塔，其中第1层的“1”在第1行的第39列（列从1开始计数）。

输入样例:

1
5

输出样例:

1
2
3
4
5
    1
   121
  12321
 1234321
123454321

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	for (int i = 1; i <= 38; ++i)	printf(" ");
	printf("1\n");
	for (int i = 2; i <= n; ++i) {
		for (int j = 1; j <= 39 - i; ++j)		printf(" ");
		for (int j = 1; j <= i; ++j)	printf("%d", j);
		for (int j = 1; j <= i - 1; ++j)	printf("%d", i - j);
		printf("\n");
	}
	return 0;
}

7-136 穷举问题-搬砖

某工地需要搬运砖块，已知男人一人搬3块，女人一人搬2块，小孩两人搬1块。如果想用n人正好搬n块砖，问有多少种搬法？

输入格式:

输入在一行中给出一个正整数n。

输出格式:

输出在每一行显示一种方案，按照”men = cnt_m, women = cnt_w, child = cnt_c“的格式，输出男人的数量cnt_m，女人的数量cnt_w，小孩的数量cnt_c。请注意，等号的两侧各有一个空格，逗号的后面也有一个空格。

如果找不到符合条件的方案，则输出”None“

输入样例:

1
45

输出样例:

1
2
3
4
men = 0, women = 15, child = 30
men = 3, women = 10, child = 32
men = 6, women = 5, child = 34
men = 9, women = 0, child = 36

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	int n = 0,flag=0;
	scanf("%d", &n);
	for (int i = 0; i <= n / 3; ++i) {
		for (int j = n / 2; j >= 0; --j) {
			int z = n - i - j;
			if (3 * i + j * 2 + z / 2 == n && z % 2 == 0) {
				printf("men = %d, women = %d, child = %d\n", i, j, z);
				flag = 1;
			}
		}
	}
	if (!flag)	printf("None");
	return 0;
}

7-137 Average

You are going to read a serial of none-negative integers, which ends with a negative number that does not count as one of the data. Your program calculates the average of all the none-negative integers, and prints the average which rounds to two decimal places.

When there’s no valid data at all, your program prints out:

1
None

输入格式：

A serial of none-negative integers, ending with a negative number, which is not one of the valide data.

输出格式：

A number rounds to two decimal places, which is the average of the serial.

The printf for this case is:

1
printf("%.2f\n", (double)sum/count);

输入例子

1
1 2 3 4 5 6 -1

输出例子

1
3.50

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int main()
{
	int sum = 0, count = 0, n = 0;
	scanf("%d", &n);
	while (n >= 0) {
		sum += n;
		count++;
		scanf("%d", &n);
	}
	if (sum == 0)printf("None");
	else
		printf("%.2f\n", (double)sum / count);
	return 0;
}

7-138 质因子分解

本题目要求读入一个大于1的整数，编程将其分解成若干个质因子（素数因子）积的形式。

输入格式:

大于1的整数一个。

输出格式:

将输入的正整数分解成若干个质因子积的形式，质因子的出现顺序按从小到大排列。如：40=222*5；如果整数本身为质数或素数，直接输出，如：13=13。

输入样例:

1
12480

输出样例:

1
12480=2*2*2*2*2*2*3*5*13

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
#include<float.h>
int isPrime(int n) {		//1就代表是素数，0，就代表不是
	int flag = 1;
	for (int i = 2; i <= n / 2; ++i) {
		if (n % i == 0) {
			flag = 0;
			break;
		}
	}
	return flag;
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	printf("%d=", n);
	while (!isPrime(n)) {
		for (int i = 2; i <= n / 2; ++i) {
			if (n % i == 0) {
				printf("%d*",i);
				n = n / i;
				break;
			}
		}
	}
	printf("%d", n);
	return 0;
}

7-139 手机话费

小明的手机每天消费1元，每消费K元就可以获赠1元，一开始小明有M元，问最多可以用多少天？

输入格式:

每个测试实例包括2个整数M，K（2<=k<=M<=1000)。

输出格式:

对于每个测试实例输出一个整数，表示M元可以用的天数。

输入样例:

1
2 2

输出样例:

1
3

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
int main(){
    int m,k,i=0;
    scanf("%d %d",&m,&k);
    while(m>0){
        m--;
        i++;
        if(i%k==0)m++;
    }
    printf("%d",i);
   
}

7-140 斐波那契数列第n项

输出斐波那契数列第n项（假设n<1000）。斐波那契数列：0,1，1，2，3，5，8，13……

输入格式:

一个正整数n,表示斐波那契数列第n项。

输出格式:

斐波那契数列第n项的值

输入样例:

在这里给出一组输入。例如：

1
1

输出样例:

在这里给出相应的输出。例如：

1
0

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
	int i = 1, j = 1,n=0,t=0,res=0;
	scanf("%d", &n);
	if (n == 1)	printf("0");
	else if (n == 2 || n == 3)	printf("1");
	else {
		for (int z = 4; z <= n; ++z) {
			res = i + j;
			i = j;
			j = res;
		}
		printf("%d", res);
	}
	return 0;
}

7-141 统计一行文本的单词个数

本题目要求编写程序统计一行字符中单词的个数。所谓“单词”是指连续不含空格的字符串，各单词之间用空格分隔，空格数可以是多个。

输入格式:

输入给出一行字符。

输出格式:

在一行中输出单词个数。

输入样例:

1
Let's go to room 209.

输出样例:

1
5

鸣谢用户 张麦麦 补充数据！

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	char str[9999];
	int sum = 0,flag=0,t=0;
	fgets(str, sizeof(str), stdin);
	for (int i = 0; i < strlen(str); ++i) {
		if (str[i] != ' '&&!flag&&str[i]!='\n') {
			flag = 1;
			t++;
		}
		if (str[i] == ' ' && flag)	flag = 0;
	}
	printf("%d", t);
}

7-142 判断上三角矩阵

上三角矩阵指主对角线以下的元素都为0的矩阵；主对角线为从矩阵的左上角至右下角的连线。

本题要求编写程序，判断一个给定的方阵是否上三角矩阵。

输入格式：

输入第一行给出一个正整数T，为待测矩阵的个数。接下来给出T个矩阵的信息：每个矩阵信息的第一行给出一个不超过10的正整数n。随后n行，每行给出n个整数，其间以空格分隔。

输出格式：

每个矩阵的判断结果占一行。如果输入的矩阵是上三角矩阵，输出“YES”，否则输出“NO”。

输入样例：

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

输出样例：

1
2
3
YES
NO
NO

鸣谢中水七局机电安装分局喻春桥补充数据！

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	int t = 0, n = 0,p=0,flag=1;
	scanf("%d", &t);
	for (int z = 1; z <= t; ++z) {
		scanf("%d", &n);
		flag = 1;
		for (int i = 1; i <= n; ++i) {
			for (int j = 1; j <= n; ++j) {
				scanf("%d", &p);
				if (i >= 2 && j <= i - 1 && p != 0 && flag) 	flag = 0;	
			}
		}
		if (flag)	printf("YES\n");
		else printf("NO\n");
	}
}

7-143 字符串排序

本题要求编写程序，读入5个字符串，按由小到大的顺序输出。

输入格式：

输入为由空格分隔的5个非空字符串，每个字符串不包括空格、制表符、换行符等空白字符，长度小于80。

输出格式：

按照以下格式输出排序后的结果：

1
2
After sorted:
每行一个字符串

输入样例：

1
red yellow blue black white

输出样例：

1
2
3
4
5
6
After sorted:
black
blue
red
white
yellow

鸣谢贵州民族大学张玉全老师修正数据！

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
int main(void) {
	char a[5][100],temp[100];

	for (int i = 0; i < 5; ++i)	scanf("%s", &a[i]);
	for (int i = 0; i < 5-1; ++i) {
		for (int j = 0; j < 5 - i - 1; ++j) {
			if (strcmp(a[j], a[j + 1]) > 0) {
				strcpy(temp, a[j]);
				strcpy(a[j], a[j+1]);
				strcpy(a[j+1], temp);
			}
		}
	}
	printf("After sorted:\n");
	for (int i = 0; i < 5; ++i)	printf("%s\n", a[i]);
}

7-144 藏头诗

本题要求编写一个解密藏头诗的程序。

注：在 2022 年 7 月 14 日 16 点 50 分以后，该题数据修改为 UTF-8 编码。

输入格式：

输入为一首中文藏头诗，一共四句，每句一行。注意：一个汉字占三个字节。

输出格式：

取出每句的第一个汉字并连接在一起形成一个字符串并输出。同时在末尾输入一个换行符。

输入样例：

1
2
3
4
一叶轻舟向东流
帆稍轻握杨柳手
风纤碧波微起舞
顺水任从雅客流

输出样例：

1
一帆风顺

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <string.h>

int main() {
    char c[100][3];
    for (int i = 1; i <= 4; ++i) {
        scanf("%s", c);
        printf("%c%c%c", c[0][0], c[0][1], c[0][2]);
    }

    return 0;
}

7-145 点赞

微博上有个“点赞”功能，你可以为你喜欢的博文点个赞表示支持。每篇博文都有一些刻画其特性的标签，而你点赞的博文的类型，也间接刻画了你的特性。本题就要求你写个程序，通过统计一个人点赞的纪录，分析这个人的特性。

输入格式：

输入在第一行给出一个正整数N（≤1000），是该用户点赞的博文数量。随后N行，每行给出一篇被其点赞的博文的特性描述，格式为“K F1⋯F**K”，其中1≤K≤10，F**i（i=1,⋯,K）是特性标签的编号，我们将所有特性标签从1到1000编号。数字间以空格分隔。

输出格式：

统计所有被点赞的博文中最常出现的那个特性标签，在一行中输出它的编号和出现次数，数字间隔1个空格。如果有并列，则输出编号最大的那个。

输入样例：

1
2
3
4
5
4
3 889 233 2
5 100 3 233 2 73
4 3 73 889 2
2 233 123

输出样例：

1
233 3

代码长度限制

16 KB

时间限制

200 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<limits.h>
int Feature[1001] = {0};
int main() {
    for (int i = 1; i <= 1000; ++i)    Feature[i] = 0;
    int n = 0, t = 0,temp=0;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        scanf("%d",&t);
        for (int j = 1; j <= t; ++j) {
            scanf("%d", &temp);
            Feature[temp]++;
        }
    }
    int max = INT_MIN,index=0;
    for (int i = 1; i <= 1000; ++i) {
        if (Feature[i] >= max) {
            index = i;
            max = Feature[i];
        }
    }
    printf("%d %d", index, max);
    return 0;
}

7-146 稳赢

大家应该都会玩“锤子剪刀布”的游戏：两人同时给出手势，胜负规则如图所示：

现要求你编写一个稳赢不输的程序，根据对方的出招，给出对应的赢招。但是！为了不让对方输得太惨，你需要每隔K次就让一个平局。

输入格式：

输入首先在第一行给出正整数K（≤10），即平局间隔的次数。随后每行给出对方的一次出招：ChuiZi代表“锤子”、JianDao代表“剪刀”、Bu代表“布”。End代表输入结束，这一行不要作为出招处理。

输出格式：

对每一个输入的出招，按要求输出稳赢或平局的招式。每招占一行。

输入样例：

1
2
3
4
5
6
7
8
9
2
ChuiZi
JianDao
Bu
JianDao
Bu
ChuiZi
ChuiZi
End

输出样例：

1
2
3
4
5
6
7
Bu
ChuiZi
Bu
ChuiZi
JianDao
ChuiZi
Bu

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<limits.h>
int main() {
    char str[100];
    int n = 0,index=0;
    scanf("%d", &n);
    scanf("%s", str);
    while (strcmp(str,"End")!=0) {
        index++;
        if (index % (n+1) == 0)  printf("%s\n", str);
        else {
            if (strcmp(str, "ChuiZi")==0)  printf("Bu\n");
            else if (strcmp(str, "JianDao")==0)   printf("ChuiZi\n");
            else printf("JianDao\n");
        }
        scanf("%s", str);
    }
    return 0;
}

7-147 比较大小

本题要求将输入的任意3个整数从小到大输出。

输入格式:

输入在一行中给出3个整数，其间以空格分隔。

输出格式:

在一行中将3个整数从小到大输出，其间以“->”相连。

输入样例:

1
4 2 8

输出样例:

1
2->4->8

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<limits.h>
int main() {
    int a = 0, b = 0, c = 0,temp=0;
    scanf("%d %d %d", &a, &b, &c);
    if (a > b) {
        temp = a;
        a = b;
        b = temp;
    }
    if (a > c) {
        temp = a;
        a = c;
        c = temp;
    }
    if (b > c) {
        temp = b;
        b = c;
        c = temp;
    }
    printf("%d->%d->%d", a, b, c);
    return 0;
}

7-148 编程团体赛

编程团体赛的规则为：每个参赛队由若干队员组成；所有队员独立比赛；参赛队的成绩为所有队员的成绩和；成绩最高的队获胜。

现给定所有队员的比赛成绩，请你编写程序找出冠军队。

输入格式：

输入第一行给出一个正整数 N（≤104），即所有参赛队员总数。随后 N 行，每行给出一位队员的成绩，格式为：队伍编号-队员编号 成绩，其中队伍编号为 1 到 1000 的正整数，队员编号为 1 到 10 的正整数，成绩为 0 到 100 的整数。

输出格式：

在一行中输出冠军队的编号和总成绩，其间以一个空格分隔。注意：题目保证冠军队是唯一的。

输入样例：

1
2
3
4
5
6
7
6
3-10 99
11-5 87
102-1 0
102-3 100
11-9 89
3-2 61

输出样例：

1
11 176

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<limits.h>
int team[1001] = { 0 };
int main() {
    int n = 0, index = 0,max=INT_MIN;
    for (int i = 1; i <= 1000; ++i)    team[i] = 0;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        int teami = 0, peoplei = 0, grade = 0;
        scanf("%d-%d %d", &teami, &peoplei, &grade);
        team[teami] += grade;
    }
    for (int i = 1; i <= 1000; ++i) {
       
        if (team[i] > max) {
            max = team[i];
            index = i;
        }
    }
    printf("%d %d", index, max);
    return 0;
}

7-149 Hello World

这道超级简单的题目没有任何输入。

你只需要在一行中输出著名短句“Hello World!”就可以了。

输入样例：

1
无

输出样例：

1
Hello World!

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<limits.h>
int team[1001] = { 0 };
int main() {

    printf("Hello World!");
    return 0;
}

7-150 打印沙漏

本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”，要求按下列格式打印

1
2
3
4
5
*****
 ***
  *
 ***
*****

所谓“沙漏形状”，是指每行输出奇数个符号；各行符号中心对齐；相邻两行符号数差2；符号数先从大到小顺序递减到1，再从小到大顺序递增；首尾符号数相等。

给定任意N个符号，不一定能正好组成一个沙漏。要求打印出的沙漏能用掉尽可能多的符号。

输入格式:

输入在一行给出1个正整数N（≤1000）和一个符号，中间以空格分隔。

输出格式:

首先打印出由给定符号组成的最大的沙漏形状，最后在一行中输出剩下没用掉的符号数。

输入样例:

1
19 *

输出样例:

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

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<limits.h>
int num(int n) {
    int sum = 1;
    if (n == 1)    return 1;
    else {
        for (int i = 2; i <= n; ++i) {
            sum += (2 * i - 1) * 2;
        }
    }
    return sum;
}
int main() {
    char c = ' ';
    int n = 0, index = 1;
    scanf("%d %c", &n,&c);
    while (num(index) < n) {
        index++;
    }
    index--;
    for (int i = 1; i <= index; ++i) {
        for (int j = 1; j < i; ++j)    printf(" ");

        for (int j = 1; j <= 2 * index - 2 * i + 1; ++j)   printf("%c",c);
        printf("\n");
    }
    for (int i = 1; i <= index - 1; ++i) {
        for (int j = 1; j <= index-1-i; ++j)   printf(" ");
        for (int j = 1; j <= 2 * i + 1; ++j)   printf("%c",c);
        printf("\n");
    }
    if (n == 1)    printf("%c\n", c);
    printf("%d", n - num(index));
    return 0;
}

7-151 个位数统计

给定一个 k 位整数 N=d**k−110k−1+⋯+d1101+d0 (0≤d**i≤9, i=0,⋯,k−1, d**k−1>0)，请编写程序统计每种不同的个位数字出现的次数。例如：给定 N=100311，则有 2 个 0，3 个 1，和 1 个 3。

输入格式：

每个输入包含 1 个测试用例，即一个不超过 1000 位的正整数 N。

输出格式：

对 N 中每一种不同的个位数字，以 D:M 的格式在一行中输出该位数字 D 及其在 N 中出现的次数 M。要求按 D 的升序输出。

输入样例：

1
100311

输出样例：

1
2
3
0:2
1:3
3:1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
char num[1001] = { ' ' };
int dig[10] = { 0 };
int main() {
    for (int i = 0; i < 10; ++i)   dig[i] = 0;
    scanf("%s", num);
    for (int i = 0; i < strlen(num); ++i) {
        dig[num[i] - '0']++;
    }
    for (int i = 0; i < 10; ++i) {
        if (dig[i] != 0)  printf("%d:%d\n", i, dig[i]);
    }
    return 0;
}

7-152 考试座位号

每个 PAT 考生在参加考试时都会被分配两个座位号，一个是试机座位，一个是考试座位。正常情况下，考生在入场时先得到试机座位号码，入座进入试机状态后，系统会显示该考生的考试座位号码，考试时考生需要换到考试座位就座。但有些考生迟到了，试机已经结束，他们只能拿着领到的试机座位号码求助于你，从后台查出他们的考试座位号码。

输入格式：

输入第一行给出一个正整数 N（≤1000），随后 N 行，每行给出一个考生的信息：准考证号 试机座位号 考试座位号。其中准考证号由 16 位数字组成，座位从 1 到 N 编号。输入保证每个人的准考证号都不同，并且任何时候都不会把两个人分配到同一个座位上。

考生信息之后，给出一个正整数 M（≤N），随后一行中给出 M 个待查询的试机座位号码，以空格分隔。

输出格式：

对应每个需要查询的试机座位号码，在一行中输出对应考生的准考证号和考试座位号码，中间用 1 个空格分隔。

输入样例：

1
2
3
4
5
6
7
4
3310120150912233 2 4
3310120150912119 4 1
3310120150912126 1 3
3310120150912002 3 2
2
3 4

输出样例：

1
2
3310120150912002 2
3310120150912119 1

代码长度限制

16 KB

时间限制

200 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>

int main() {
    int d[1001] = { 0 },n=0;
    scanf("%d", &n);
    long long num[1001] = { 0 };
    for (int i = 0; i < 1001; ++i)
    {
        num[i] = 0;
        d[i] = 0;
    }
    for (int i = 1; i <= n; ++i) {
        long long tean = 0;
        int tsn = 0, esn = 0;
        scanf("%lld %d %d", &tean, &tsn, &esn);
        num[tsn] = tean;
        d[tsn] = esn;
    }
    int t = 0;
    scanf("%d", &t);
    for (int i = 1; i <= t; ++i) {
        int p = 0;
        scanf("%d", &p);
        printf("%lld %d\n", num[p], d[p]);
    }
    return 0;
}

7-153 念数字

输入一个整数，输出每个数字对应的拼音。当整数为负数时，先输出fu字。十个数字对应的拼音如下：

1
2
3
4
5
6
7
8
9
10
0: ling
1: yi
2: er
3: san
4: si
5: wu
6: liu
7: qi
8: ba
9: jiu

输入格式：

输入在一行中给出一个整数，如：1234。

提示：整数包括负数、零和正数。

输出格式：

在一行中输出这个整数对应的拼音，每个数字的拼音之间用空格分开，行末没有最后的空格。如
yi er san si。

输入样例：

1
-600

输出样例：

1
fu liu ling ling

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
void prt(int n) {
    if (n == 0)    printf("ling");
    else if (n == 1)   printf("yi");
    else if (n == 2)   printf("er");
    else if (n == 3)   printf("san");
    else if (n == 4)   printf("si");
    else if (n == 5)   printf("wu");
    else if (n == 6)   printf("liu");
    else if (n == 7)   printf("qi");
    else if (n == 8)   printf("ba");
    else    printf("jiu");
}
int main() {
    char n[100];
    scanf("%s", n);
    for (int i = 0; i < strlen(n); ++i) {
        if (i)  printf(" ");
        if (n[i] == '-')   printf("fu");
        else prt(n[i] - '0');
    }
    return 0;
}

7-154 求整数段和

给定两个整数A和B，输出从A到B的所有整数以及这些数的和。

输入格式：

输入在一行中给出2个整数A和B，其中−100≤A≤B≤100，其间以空格分隔。

输出格式：

首先顺序输出从A到B的所有整数，每5个数字占一行，每个数字占5个字符宽度，向右对齐。最后在一行中按Sum = X的格式输出全部数字的和X。

输入样例：

1
-3 8

输出样例：

1
2
3
4
   -3   -2   -1    0    1
    2    3    4    5    6
    7    8
Sum = 30

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 M

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>

int main() {
    int a = 0, b = 0,sum=0;
    scanf("%d%d", &a, &b);
    for (int i = a; i <= b; ++i) {
        printf("%5d", i);
        sum += i;
        if ((i + 1 - a) % 5 == 0)    printf("\n");
    }
    if ((b - a + 1) % 5 != 0)    printf("\n");
    printf("Sum = %d", sum);
    return 0;
}

7-155 N个数求和

本题的要求很简单，就是求N个数字的和。麻烦的是，这些数字是以有理数分子/分母的形式给出的，你输出的和也必须是有理数的形式。

输入格式：

输入第一行给出一个正整数N（≤100）。随后一行按格式a1/b1 a2/b2 ...给出N个有理数。题目保证所有分子和分母都在长整型范围内。另外，负数的符号一定出现在分子前面。

输出格式：

输出上述数字和的最简形式 —— 即将结果写成整数部分 分数部分，其中分数部分写成分子/分母，要求分子小于分母，且它们没有公因子。如果结果的整数部分为0，则只输出分数部分。

输入样例1：

1
2
5
2/5 4/15 1/30 -2/60 8/3

输出样例1：

1
3 1/3

输入样例2：

1
2
2
4/3 2/3

输出样例2：

1
2

输入样例3：

1
2
3
1/3 -1/6 1/8

输出样例3：

1
7/24

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//求最大公倍数数
long lcd(long a, long b) {
    long m = 0;
    if (a > b) m = a;
    else m = b;
    for (long i = m; i <= a * b; ++i) {
        if (i % a == 0 && i % b == 0)   return i;
    }
    return 0;
}
//最小公约数
long gcd(long a, long b) {
    long m = 0;
    if (a < 0)  a = -a;
    if (a < b) m = a;
    else m = b;
    for (long i = m; i >= 1; i--) {
        if (a % i == 0 && b % i == 0)  return i;
    }
    return 0;
}
//化简
long gcdmyself(long* a, long* b) {
    long mlcd = gcd(*a, *b);
    //printf("mcld is %ld\n", mlcd);
    *a = *a / mlcd;
    *b = *b / mlcd;
    return;
}
void add(long* n, long* a, long* b, long* a1, long* b1) {
    long blcd = lcd(*b, *b1);
    long alcd = (blcd / *b) * (*a) + (blcd / *b1) * (*a1) + (*n) * blcd;
    long tgcd = gcd(alcd,blcd);
    if (alcd != 0) {
        *a = alcd / tgcd;
        *b = blcd / tgcd;
        *n = *a / (*b);
        *a = *a - (*n) * (*b);
    }
    else {
        *n = 0;
        *a = 0;
        *b = 1;
    }
    return 0;
}
//输出
void put(long num, long a, long b) {
    if (a == 0 && num == 0) {
        printf("0");
        return ;
    }
    if (a != 0) {
        if (num != 0)
            printf("%ld %ld/%ld", num, a, b);
        else
            printf("%ld/%ld", a, b);
    }
    else
        printf("%ld", num);
}
int main() {
    int n = 0;
    scanf("%d", &n);
    long a[101] = { 0 }, b[101] = { 0 }, num = 0;
    scanf("%ld/%ld", &a[1], &b[1]);
    gcdmyself(&a[1], &b[1]);
    for (int i = 2; i <= n; ++i) {
        scanf("%ld/%ld", &a[i], &b[i]);
        gcdmyself(&a[i], &b[i]);    
        add(&num, &a[1], &b[1], &a[i], &b[i]);
    }
    put(num, a[1], b[1]);
    return 0;
}

7-156 A-B

本题要求你计算A−B。不过麻烦的是，A和B都是字符串 —— 即从字符串A中把字符串B所包含的字符全删掉，剩下的字符组成的就是字符串A−B。

输入格式：

输入在2行中先后给出字符串A和B。两字符串的长度都不超过104，并且保证每个字符串都是由可见的ASCII码和空白字符组成，最后以换行符结束。

输出格式：

在一行中打印出A−B的结果字符串。

输入样例：

1
2
I love GPLT!  It's a fun game!
aeiou

输出样例：

1
I lv GPLT!  It's  fn gm!

代码长度限制

16 KB

时间限制

150 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int containsAny(char* a, char c) {
    for (int i = 0; i < strlen(a); ++i) {
        if (a[i] == c) return 1;
    }
    return 0;
}
int main() {
    int index = 0;
    char a[99999], b[99999], c[99999];
    fgets(a, sizeof(a), stdin);
    fgets(b, sizeof(b), stdin);
    for (int i = 0; i < strlen(a); ++i) {
        if (!containsAny(b,a[i])) {
            c[index] = a[i];
            index++;
        }
    }
    c[index] = '\0';
    printf("%s", c);
    return 0;
}

7-157 计算指数

真的没骗你，这道才是简单题 —— 对任意给定的不超过 10 的正整数 n，要求你输出 2n。不难吧？

输入格式：

输入在一行中给出一个不超过 10 的正整数 n。

输出格式：

在一行中按照格式 2^n = 计算结果 输出 2n 的值。

输入样例：

1
5

输出样例：

1
2^5 = 32

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>

int main() {
    int n = 0, res = 1;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        res *= 2;
    }
    printf("2^%d = %d", n, res);
    return 0;
}

7-158 计算阶乘和

对于给定的正整数N，需要你计算 S=1!+2!+3!+…+N!。

输入格式：

输入在一行中给出一个不超过10的正整数N。

输出格式：

在一行中输出S的值。

输入样例：

1
3

输出样例：

1
9

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int fac(int n) {
    int res = 1;
    for (int i = 1; i <= n; ++i)   res *= i;
    return res;
}
int main() {
    int n = 0, sum = 0;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        sum += fac(i);
    }
    printf("%d", sum);
    return 0;
}

7-159 简单题

这次真的没骗你 —— 这道超级简单的题目没有任何输入。

你只需要在一行中输出事实：This is a simple problem. 就可以了。

输入样例：

1
无

输出样例：

1
This is a simple problem.

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main() {
    printf("This is a simple problem.");
    return 0;
}

7-160 跟奥巴马一起画方块

美国总统奥巴马不仅呼吁所有人都学习编程，甚至以身作则编写代码，成为美国历史上首位编写计算机代码的总统。2014年底，为庆祝“计算机科学教育周”正式启动，奥巴马编写了很简单的计算机代码：在屏幕上画一个正方形。现在你也跟他一起画吧！

输入格式：

输入在一行中给出正方形边长N（3≤N≤21）和组成正方形边的某种字符C，间隔一个空格。

输出格式：

输出由给定字符C画出的正方形。但是注意到行间距比列间距大，所以为了让结果看上去更像正方形，我们输出的行数实际上是列数的50%（四舍五入取整）。

输入样例：

1
10 a

输出样例：

1
2
3
4
5
aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main() {
    int n = 0,t=0;
    char c = 0;
    scanf("%d %c", &n, &c);
    t = n % 2 == 0 ? n / 2 : n / 2 + 1;
    for (int i = 1; i <= t; ++i) {
        for (int j = 1; j <= n; ++j)   printf("%c", c);
        printf("\n");
    }
    return 0;
}

7-161 帅到没朋友

当芸芸众生忙着在朋友圈中发照片的时候，总有一些人因为太帅而没有朋友。本题就要求你找出那些帅到没有朋友的人。

输入格式：

输入第一行给出一个正整数N（≤100），是已知朋友圈的个数；随后N行，每行首先给出一个正整数K（≤1000），为朋友圈中的人数，然后列出一个朋友圈内的所有人——为方便起见，每人对应一个ID号，为5位数字（从00000到99999），ID间以空格分隔；之后给出一个正整数M（≤10000），为待查询的人数；随后一行中列出M个待查询的ID，以空格分隔。

注意：没有朋友的人可以是根本没安装“朋友圈”，也可以是只有自己一个人在朋友圈的人。虽然有个别自恋狂会自己把自己反复加进朋友圈，但题目保证所有K超过1的朋友圈里都至少有2个不同的人。

输出格式：

按输入的顺序输出那些帅到没朋友的人。ID间用1个空格分隔，行的首尾不得有多余空格。如果没有人太帅，则输出No one is handsome。

注意：同一个人可以被查询多次，但只输出一次。

输入样例1：

1
2
3
4
5
6
3
3 11111 22222 55555
2 33333 44444
4 55555 66666 99999 77777
8
55555 44444 10000 88888 22222 11111 23333 88888

输出样例1：

1
10000 88888 23333

输入样例2：

1
2
3
4
5
6
3
3 11111 22222 55555
2 33333 44444
4 55555 66666 99999 77777
4
55555 44444 22222 11111

输出样例2：

1
No one is handsome

代码长度限制

16 KB

时间限制

200 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int people[1000000] = { 0 };
int main() {
    for (int i = 0; i < 1000000; ++i)   people[i] = 0;
    int n = 0, k = 0;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &k);
        for (int j = 1; j <= k; ++j) {
            int  temp = 0;
            scanf("%d", &temp);
            if(k>=2)    people[temp] = 1;
        }
    }
    int m = 0,flag=0,judge=0;
    scanf("%d", &m);
    for (int i = 1; i <= m; ++i) {
        int temp = 0;
        scanf("%d", &temp);
        if (!people[temp]) {
            if (flag)    printf(" ");
            else flag = 1;
            printf("%05d", temp);
            people[temp] = 1;
            judge = 1;
        }
    }
    if (!judge)  printf("No one is handsome");
    return 0;
}

7-162 检查密码

本题要求你帮助某网站的用户注册模块写一个密码合法性检查的小功能。该网站要求用户设置的密码必须由不少于6个字符组成，并且只能有英文字母、数字和小数点 .，还必须既有字母也有数字。

输入格式：

输入第一行给出一个正整数 N（≤ 100），随后 N 行，每行给出一个用户设置的密码，为不超过 80 个字符的非空字符串，以回车结束。

注意： 题目保证不存在只有小数点的输入。

输出格式：

对每个用户的密码，在一行中输出系统反馈信息，分以下5种：

  • 如果密码合法，输出Your password is wan mei.；
  • 如果密码太短，不论合法与否，都输出Your password is tai duan le.；
  • 如果密码长度合法，但存在不合法字符，则输出Your password is tai luan le.；
  • 如果密码长度合法，但只有字母没有数字，则输出Your password needs shu zi.；
  • 如果密码长度合法，但只有数字没有字母，则输出Your password needs zi mu.。

输入样例：

1
2
3
4
5
6
5
123s
zheshi.wodepw
1234.5678
WanMei23333
pass*word.6

输出样例：

1
2
3
4
5
Your password is tai duan le.
Your password needs shu zi.
Your password needs zi mu.
Your password is wan mei.
Your password is tai luan le.

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
//1代表就是合法的，0代表没有
int legal(char* a) {
    for (int i = 0; i < strlen(a) ; ++i) {
        if (!isdigit(a[i]) && !isalpha(a[i]) && a[i] != '.')
            return 0;
    }
    return 1;
}
//1就代表有数字，0代表没有
int checkdig(char* a) {
    for (int i = 0; i < strlen(a) ; ++i) {
        if (isdigit(a[i]))
            return 1;
    }
    return 0;
}
//1就代表有字母，0代表没有
int checkalpha(char* a) {
    for (int i = 0; i < strlen(a) ; ++i) {
        if (isalpha(a[i]))
            return 1;
    }
    return 0;
}
int main() {
    char str[100];
    int n = 0;
    scanf("%d\n", &n);
    for (int i = 1; i <= n; ++i) {
        gets(str);
        if (strlen(str) < 6)   printf("Your password is tai duan le.\n");
        else {
            if (!legal(str)) {
                printf("Your password is tai luan le.\n");
                continue;
            }
            if (checkdig(str) && !checkalpha(str)) printf("Your password needs zi mu.\n");
            if (!checkdig(str) && checkalpha(str))   printf("Your password needs shu zi.\n");
            if (legal(str) && checkdig(str) && checkalpha(str))
                printf("Your password is wan mei.\n");
            if (legal(str) && !checkdig(str) && !checkalpha(str))
                printf("Your password is wan mei.\n");
        }
        //printf("\n");
    }
    return 0;
}

7-163 谷歌的招聘

2004 年 7 月，谷歌在硅谷的 101 号公路边竖立了一块巨大的广告牌（如下图）用于招聘。内容超级简单，就是一个以 .com 结尾的网址，而前面的网址是一个 10 位素数，这个素数是自然常数 e 中最早出现的 10 位连续数字。能找出这个素数的人，就可以通过访问谷歌的这个网站进入招聘流程的下一步。

自然常数 e 是一个著名的超越数，前面若干位写出来是这样的：e = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427427466391932003059921… 其中粗体标出的 10 位数就是答案。

本题要求你编程解决一个更通用的问题：从任一给定的长度为 L 的数字中，找出最早出现的 K 位连续数字所组成的素数。

输入格式：

输入在第一行给出 2 个正整数，分别是 L（不超过 1000 的正整数，为数字长度）和 K（小于 10 的正整数）。接下来一行给出一个长度为 L 的正整数 N。

输出格式：

在一行中输出 N 中最早出现的 K 位连续数字所组成的素数。如果这样的素数不存在，则输出 404。注意，原始数字中的前导零也计算在位数之内。例如在 200236 中找 4 位素数，0023 算是解；但第一位 2 不能被当成 0002 输出，因为在原始数字中不存在这个 2 的前导零。

输入样例 1：

1
2
20 5
23654987725541023819

输出样例 1：

1
49877

输入样例 2：

1
2
10 3
2468001680

输出样例 2：

1
404

鸣谢用户 大冰 补充数据！

代码长度限制

16 KB

时间限制

200 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
//1就代表是素数，0代表不是
int prime(int n) {
    if (n <2 )    return 0;
    for (int i = 2; i*i<= n ; ++i) {
        if (n % i == 0)  return 0;
    }
    return 1;
}
int main() {
    long long temp = 0;
    int l = 0, k = 0, flag = 0;
    char str[1001];
    char tc[1001];
    scanf("%d %d ", &l, &k);
    scanf("%s", str);
    for (int i = 0; i + k <= l; ++i) {
        strncpy(tc, str + i, k);
        tc[k]='\0';
        if (prime(atoi(tc))) {
            flag = 1;
            printf("%s", tc);
            return 0;
        }
    }
    printf("404");
    return 0;
}

7-164 冠军魔术

2018年FISM（世界魔术大会）近景总冠军简纶廷的表演中有一个情节：以桌面上一根带子为界，当他将纸牌从带子的一边推到另一边时，纸牌会变成硬币；把硬币推回另一边会变成纸牌。

这里我们假设纸牌会变成等量的硬币，而硬币变成纸牌时，纸牌的数量会加倍。那么给定纸牌的初始数量，当他来回推了 N 次（来/回各算一次）后，手里拿的是纸牌还是硬币？数量是多少？

输入格式：

输入在一行里给出两个正整数，分别是纸牌的初始数量和魔术师推送的次数。这里假设初始状态下魔术师手里全是纸牌。

输出格式：

如果最后魔术师手里是纸牌，输出 0 和纸牌数量；如果是硬币，则输出 1 和硬币数量。数字间须有 1 个空格。题目保证结果数值不超出整型范围（即 231−1）。

输入样例 1：

1
3 7

输出样例 1：

1
1 24

输入样例 2：

1
8 4

输出样例 2：

1
0 32

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int pow(int n) {
    int sum = 1;
    for (int i = 1; i <= n; ++i)    sum *= 2;
    return sum;
}
int main() {
    int coins = 0, card = 0,n=0;
    scanf("%d %d", &card, &n);
    if (n % 2 == 1) printf("1 %d", card * pow(n / 2));
    else printf("0 %d", card * pow(n / 2));
    return 0;
}

7-165 不变初心数

不变初心数是指这样一种特别的数，它分别乘 2、3、4、5、6、7、8、9 时，所得乘积各位数之和却不变。例如 18 就是这样的数：18 的 2 倍是 36，3+6=9；18 的 3 倍是 54，5+4=9；…… 18 的 9 倍是 162，1+6+2=9。对于 18 而言，9 就是它的初心。本题要求你判断任一个给定的数是否有不变的初心。

输入格式：

输入在第一行中给出一个正整数 N（≤ 100）。随后 N 行，每行给出一个不超过 105 的正整数。

输出格式：

对每个给定的数字，如果它有不变的初心，就在一行中输出它的初心；否则输出 NO。

输入样例：

1
2
3
4
5
4
18
256
99792
88672

输出样例：

1
2
3
4
9
NO
36
NO

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下:

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int digsum(int n) {
    int sum = 0;
    while (n) {
        sum += n % 10;
        n /= 10;
    }
    return sum;
}
int judge(int n) {
    if (digsum(n * 2) == digsum(n * 3) && digsum(n * 3) == digsum(n * 4) && digsum(n * 4) == digsum(n * 5) && digsum(n * 5) == digsum(n * 6) && digsum(n * 6) == digsum(n * 7) && digsum(n * 7) == digsum(n * 8) && digsum(n * 8) == digsum(n * 9)) {
        return 1;
    }
    return 0;
}
int main() {
    int n=0, t = 0;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &t);
        if (judge(t))    printf("%d\n", digsum(t));
        else printf("NO\n");
    }
    return 0;
}

7-166 均是素数

在给定的区间 [m,n] 内，是否存在素数 p、q、r（p<q<r），使得 pq+r、q**r+p、r**p+q 均是素数？

输入格式：

输入给出区间的两个端点 0<m<n≤1000，其间以空格分隔。

输出格式：

在一行中输出满足条件的素数三元组的个数。

输入样例：

1
1 35

输出样例：

1
10

样例解读

满足条件的 10 组解为：

1
2
3
4
5
6
7
8
9
10
2, 3, 5
2, 3, 7
2, 3, 13
2, 3, 17
2, 5, 7
2, 5, 13
2, 5, 19
2, 5, 31
2, 7, 23
2, 13, 17

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int isprime(int n) {
    if (n < 2) return 0;
    for (int i = 2; i * i <= n; ++i) {
        if (n % i == 0)  return 0;
    }
    return 1;
}
// p、q、r（p<q<r） pq+r、qr+p、rp+q 
int main() {
    int m = 0, n = 0,sum=0;
    scanf("%d %d", &m, &n);
    for (int p = m; p <=n - 2; p++) {
        if (isprime(p)) {
            for (int q = p + 1; q <= n - 2; q++) {
                if (isprime(q)) {
                    for (int r = q + 1; r <= n; ++r) {
                        if (isprime(r) && isprime(p * q + r) && isprime(q * r + p) && isprime(r * p + q))
                            sum++;
                    }
                }
            }
        }
    }
    printf("%d", sum);
    return 0;
}

7-167 考试周

考试周快到了，浙江大学的电子屏又调皮了…… 本题请你帮小编写一个自动倒计时的程序，对给定的日期（例如“腊八”就对应 8）和倒计时天数（例如电子屏上的“四天之后”就对应 4），自动调整公式里的分母（例如 8/2=4 里面的那个 2）。

输入格式：

输入在一行中给出两个正整数：A 是给定的日期，不超过 30；B 是倒计时天数，不超过 10。

输出格式：

在一行中输出公式 A/X=B，其中 X 是满足等式的数字，输出时保留小数点后 1 位即可。

输入样例：

1
8 3

输出样例：

1
8/2.7=3

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
// p、q、r（p<q<r） pq+r、qr+p、rp+q 
int main() {
    int a = 0, b = 0;
    scanf("%d %d", &a, &b);
    printf("%d/%.01lf=%d", a,(double)a / b,b);
    return 0;
}

7-168 Cassels方程

Cassels方程是一个在数论界产生了巨大影响的不定方程：x2+y2+z2=3x**yz。该方程有无穷多自然数解。

本题并不是要你求解这个方程，只是判断给定的一组 (x,y,z) 是不是这个方程的解。

输入格式：

输入在第一行给出一个不超过 10 的正整数 N，随后 N 行，每行给出 3 个正整数 0<x≤y≤z≤1000。

输出格式：

对于每一组输入，如果是一组解，就在一行中输出 Yes，否则输出 No。

输入样例：

1
2
3
2
1 1 1
5 6 7

输出样例：

1
2
Yes
No

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
// p、q、r（p<q<r） pq+r、qr+p、rp+q 
int main() {
    int n = 0;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        int x = 0, y = 0, z = 0;
        scanf("%d %d %d", &x, &y, &z);
        if (x * x + y * y + z * z == 3 * x * y * z)printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}

7-169 矩阵列平移

给定一个 n×n 的整数矩阵。对任一给定的正整数 k<n，我们将矩阵的偶数列的元素整体向下依次平移 1、……、k、1、……、k、…… 个位置，平移空出的位置用整数 x 补。你需要计算出结果矩阵的每一行元素的和。

输入格式：

输入第一行给出 3 个正整数：n（<100）、k（<n）、x（<100），分别如题面所述。

接下来 n 行，每行给出 n 个不超过 100 的正整数，为矩阵元素的值。数字间以空格分隔。

输出格式：

在一行中输出平移后第 1 到 n 行元素的和。数字间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

1
2
3
4
5
6
7
8
7 2 99
11 87 23 67 20 75 89
37 94 27 91 63 50 11
44 38 50 26 40 26 24
73 85 63 28 62 18 68
15 83 27 97 88 25 43
23 78 98 20 30 81 99
77 36 48 59 25 34 22

输出样例：

1
440 399 369 421 302 386 428

样例解读

需要平移的是第 2、4、6 列。给定 k=2，应该将这三列顺次整体向下平移 1、2、1 位（如果有更多列，就应该按照 1、2、1、2 …… 这个规律顺次向下平移），顶端的空位用 99 来填充。平移后的矩阵变成：

1
2
3
4
5
6
7
11 99 23 99 20 99 89
37 87 27 99 63 75 11
44 94 50 67 40 50 24
73 38 63 91 62 26 68
15 85 27 26 88 18 43
23 83 98 28 30 25 99
77 78 48 97 25 81 22

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
#define Max_N 101
int arr[Max_N][Max_N];
int main() {
    for (int i = 0; i < Max_N; ++i) {
        for (int j = 0; j < Max_N; ++j) {
            arr[i][j] = 0;
        }
    }
    int n = 0, k = 0, x = 0;
    scanf("%d%d%d", &n, &k, &x);
    int p_arr[Max_N];
    for (int i = 0; i < Max_N; ++i)    p_arr[i] = 0;
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j)   scanf("%d", &arr[i][j]);
    }


    //printf("\n\n");
    //for (int i = 1; i <= n; ++i) {
    //    for (int j = 1; j <= n; ++j)   printf("%d ", arr[i][j]);
    //    printf("\n");
    //}
    int p_k = 1;
    int t = 1;
    for (int j = 2; j <= n; j += 2) {
        for (int i = 1; i <= n; ++i)   p_arr[i] = arr[i][j];    //一个一个的赋值
        int p = (t-1) % k+1;
        for (int i = 1; i <= p; ++i) {
            arr[i][j] = x;
        }
        int new_i = 1;
        for (int i = p + 1; i <= n; ++i) {
            arr[i][j] = p_arr[new_i];
            new_i++;
        }
        t++;
    }

    //测试代码
    //printf("\n\n");
    //for (int i = 1; i <= n; ++i) {
    //    for (int j = 1; j <= n; ++j)   printf("%d ", arr[i][j]);
    //    printf("\n");
    //} 
    for (int i = 1; i <= n; ++i) {
        int sum = 0;
        for (int j = 1; j <= n; ++j)   sum += arr[i][j];
        if (i != 1)    printf(" ");
        printf("%d", sum);
    }

    return 0;
}

7-170 真的恭喜你

当别人告诉你自己考了 x 分的时候，你要回答说：“恭喜你考了 x 分！”比如小明告诉你他考了90分，你就用汉语拼音打出来 gong xi ni kao le 90 fen!。

但是如果小明没考好，比如只考了 20 分，你也“恭喜”人家就不对了。这时候你应该安慰他说：“考了 20 分别泄气！”用汉语拼音写出来就是 kao le 20 fen bie xie qi!。

输入格式：

输入在一行里给出一位小朋友的分数。这个分数是一个 0 到 100 之间的整数。

输出格式：

在一行中输出你对这位小朋友说的话。如果人家考到不低于 90 分，就说 gong xi ni kao le X fen!；如果不到 90 分，就说 kao le X fen bie xie qi!。其中 X 是小朋友输入的分数。

输入样例 1：

1
95

输出样例 1：

1
gong xi ni kao le 95 fen!

输入样例 2：

1
89

输出样例 2：

1
kao le 89 fen bie xie qi!

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int main() {
    int n = 0;
    scanf("%d", &n);
    if (n >= 90)   printf("gong xi ni kao le %d fen!", n);
    else printf("kao le %d fen bie xie qi!", n);
    return 0;
}

7-171 判断一个三位数是否为水仙花数

本题要求编写程序，判断一个给定的三位数是否为水仙花数。三位水仙花数，即其个位、十位、百位数字的立方和等于该数本身。

输入格式:

输入在一行中给出一个需要判断的整数 N（100≤N≤999）。

输出格式:

如果N是水仙花数，则在一行中输出Yes，否则输出No。如果N不是三位数，则输出Invalid Value.。

输入样例1:

1
153

输出样例1:

1
Yes

输入样例2:

1
500

输出样例2:

1
No

输入样例3:

1
-2

输出样例3:

1
Invalid Value.

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int mi(int n) {
    return n * n * n;
}
int main() {
    int n = 0,sum=0,n_copy=0;
    scanf("%d", &n);
    n_copy = n;
    if (n < 100 || n>999) {
        printf("Invalid Value.");
        return 0;
    }
    while (n) {
        sum += mi(n % 10);
        n /= 10;
    }
    if (sum == n_copy) printf("Yes");
    else printf("No");
    return 0;
}

7-172 简单求阶乘问题

本题要求编写程序，计算N的阶乘。

输入格式:

输入在一行中给出一个不超过12的正整数N。

输出格式:

在一行中输出阶乘的值。

输入样例:

1
4

输出样例:

1
24

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int mi(int n) {
    int sum = 1;
    for (int i = 1; i <= n; ++i)   sum *= i;
    return sum;
}
int main() {
    int n = 0;
    scanf("%d", &n);
    printf("%d", mi(n));
    return 0;
}

7-173 英文字母替换加密（大小写转换+后移1位）

本题要求编写程序，将英文字母替换加密。为了防止信息被别人轻易窃取，需要把电码明文通过加密方式变换成为密文。变换规则是：将明文中的所有英文字母替换为字母表中的后一个字母，同时将小写字母转换为大写字母，大写字母转换为小写字母。例如，字母a->B、b->C、…、z->A、A->b、B->c、…、Z->a。输入一行字符，将其中的英文字母按照以上规则转换后输出，其他字符按原样输出。

输入格式:

输入一行字符，以回车符 ‘\n’作为 结束符。

输出格式:

将输入的一行字符中的所有英文字母替换为字母表中的后一个字母，同时将小写字母转换为大写字母，大写字母转换为小写字母后输出，其他字符按原样输出。

输入样例:

在这里给出一组输入。例如：

1
Reold  Z123?

输出样例:

在这里给出相应的输出。例如：

1
sFPME  a123?

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
#define Max_arr 99999
int main() {
    char arr[Max_arr] = "";
    char c = ' ';
    int i = 0;
    scanf("%c", &c);
    while (c != '\n') {
        arr[i] = c;
        ++i;
        scanf("%c", &c);
    }
    arr[i] = '\n';
    //for (int i = 0; i < Max_arr; ++i) {
    //    if (arr[i] >= 'a' && arr[i] <= 'z')    arr[i] = (arr[i] - 95) % 26 + 64;
    //    else if(arr[i] >= 'A' && arr[i] <= 'Z') arr[i] = (arr[i] - 63) % 26 + 96;
    //}
    i = 0;
    while (arr[i] != '\n') {
        if (arr[i] >= 'a' && arr[i] <= 'z')    arr[i] = ((arr[i] - 97) + 1) % 26 + 65;
        else if (arr[i] >= 'A' && arr[i] <= 'Z') arr[i] = ((arr[i] - 65) + 1) % 26 + 97;
        printf("%c", arr[i]);
        i++;
    }
    return 0;
}

7-174 字母串

英语老师要求学生按照如下规则写一串字母：

  • 如果写了某个大写字母，下一个就必须写同个字母的小写，或者写字母表中下一个字母的大写；
  • 如果写了某个小写字母，下一个就必须写同个字母的大写，或者写字母表中前一个字母的小写；
  • 当然也可以什么都不写，就结束这个字母串。

例如 aAaABCDdcbBC 就是一个合法的字母串；而 dEFfeFGhI 就是非法的。注意 a 没有前一个字母， Z 也没有下一个字母。

现在面对全班学生交上来的作业，老师请你写个程序自动批改。

输入格式：

输入在第一行给出一个不超过 100 的正整数 N。随后 N 行，每行给出一位学生的作业，即仅由英文字母组成的非空字母串，长度不超过 2×106。

输出格式：

对每位学生的作业，如果正确就在一行中输出 Y，否则输出 N。

输入样例：

1
2
3
2
aAaABCDdcbBC
dEFfeFGhI

输出样例：

1
2
Y
N

代码长度限制

16 KB

时间限制

800 ms

内存限制

64 MB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int judge(char a, char b) {
    if (a >= 'a' && a <= 'z') {
        if (b == a - 32 || (b == a - 1 && a >= 'b'))  return 1;
        else return 0;
    }
    if (a >= 'A' && a <= 'Z') {
        if (b == a + 32 || (b == a + 1 && a <= 'Y'))  return 1;
        else return 0;
    }
}
int main() {
    int n = 0;  //学生的人数
    scanf("%d", &n);
    while (n) {
        char a[3000000];
        int res = 0;
        scanf("%s", a);
        for (int i = 0; i < strlen(a) - 1; ++i) {
            char b = a[i];
            char c = a[i + 1];
            if (judge(b, c) == 0) {
                res = 1;
                break;
            }
        }
        if (res == 0)  printf("Y\n");
        else printf("N\n");
        n--;
    }
    return 0;
}

7-175 口罩发放

为了抗击来势汹汹的 COVID19 新型冠状病毒，全国各地均启动了各项措施控制疫情发展，其中一个重要的环节是口罩的发放。

某市出于给市民发放口罩的需要，推出了一款小程序让市民填写信息，方便工作的开展。小程序收集了各种信息，包括市民的姓名、身份证、身体情况、提交时间等，但因为数据量太大，需要根据一定规则进行筛选和处理，请你编写程序，按照给定规则输出口罩的寄送名单。

输入格式:

输入第一行是两个正整数 D 和 P（1≤D,P≤30），表示有 D 天的数据，市民两次获得口罩的时间至少需要间隔 P 天。

接下来 D 块数据，每块给出一天的申请信息。第 i 块数据（i=1,⋯,D）的第一行是两个整数 T**i 和 S**i（1≤T**i,S**i≤1000），表示在第 i 天有 T**i 条申请，总共有 S**i 个口罩发放名额。随后 T**i 行，每行给出一条申请信息，格式如下：

1
姓名 身份证号 身体情况 提交时间

给定数据约束如下：

  • 姓名 是一个长度不超过 10 的不包含空格的非空字符串；
  • 身份证号 是一个长度不超过 20 的非空字符串；
  • 身体情况 是 0 或者 1，0 表示自觉良好，1 表示有相关症状；
  • 提交时间 是 hh:mm，为24小时时间（由 00:00 到 23:59。例如 09:08。）。注意，给定的记录的提交时间不一定有序；
  • 身份证号 各不相同，同一个身份证号被认为是同一个人，数据保证同一个身份证号姓名是相同的。

能发放口罩的记录要求如下：

  • 身份证号 必须是 18 位的数字（可以包含前导0）；
  • 同一个身份证号若在第 i 天申请成功，则接下来的 P 天不能再次申请。也就是说，若第 i 天申请成功，则等到第 i+P+1 天才能再次申请；
  • 在上面两条都符合的情况下，按照提交时间的先后顺序发放，直至全部记录处理完毕或 S**i 个名额用完。如果提交时间相同，则按照在列表中出现的先后顺序决定。

输出格式:

对于每一天的申请记录，每行输出一位得到口罩的人的姓名及身份证号，用一个空格隔开。顺序按照发放顺序确定。

在输出完发放记录后，你还需要输出有合法记录的、身体状况为 1 的申请人的姓名及身份证号，用空格隔开。顺序按照申请记录中出现的顺序确定，同一个人只需要输出一次。

输入样例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
4 2
5 3
A 123456789012345670 1 13:58
B 123456789012345671 0 13:58
C 12345678901234567 0 13:22
D 123456789012345672 0 03:24
C 123456789012345673 0 13:59
4 3
A 123456789012345670 1 13:58
E 123456789012345674 0 13:59
C 123456789012345673 0 13:59
F F 0 14:00
1 3
E 123456789012345674 1 13:58
1 1
A 123456789012345670 0 14:11

输出样例:

1
2
3
4
5
6
7
8
D 123456789012345672
A 123456789012345670
B 123456789012345671
E 123456789012345674
C 123456789012345673
A 123456789012345670
A 123456789012345670
E 123456789012345674

样例解释：

输出中，第一行到第三行是第一天的部分；第四、五行是第二天的部分；第三天没有符合要求的市民；第六行是第四天的部分。最后两行按照出现顺序输出了可能存在身体不适的人员。

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_PEOPLE 1010     // 每天最多申请口罩的人数
#define MAX_MAYBE 30010     // 总共可能有症状的人的最大数量
#define MAX_NAME 11         // 姓名的最大长度
#define MAX_ID 21           // 身份证号的最大长度
#define HASH_SIZE 10007     // 哈希表的大小

// 定义存储每个申请人的信息的结构体
typedef struct {
    char name[MAX_NAME];  // 申请人的姓名
    char id[MAX_ID];      // 申请人的身份证号
    int st;               // 身体状况 (0: 良好, 1: 有症状)
    int h;                // 提交时间的小时部分
    int m;                // 提交时间的分钟部分
    int no;               // 申请人在当天的序号
} People;

// 定义存储可能有症状的人的信息的结构体
typedef struct {
    char name[MAX_NAME];  // 可能有症状的人的姓名
    char id[MAX_ID];      // 可能有症状的人的身份证号
} Maybe;

// 定义存储申请记录的结构体，用于哈希表
typedef struct Record {
    char id[MAX_ID];      // 申请人的身份证号
    int day;              // 最后一次领取口罩的天数
    struct Record *next;  // 指向下一个记录的指针
} Record;

People people[MAX_PEOPLE];      // 存储每天申请人的信息
Maybe maybe[MAX_MAYBE];         // 存储所有可能有症状的人的信息
Record *hash_table[HASH_SIZE];  // 哈希表，用于快速查找申请记录
int idx = 0;                    // 记录可能有症状的人的数量

// 比较函数，用于qsort对申请人按时间和序号进行排序
int compare_people(const void *a, const void *b) {
    People *pa = (People *)a;
    People *pb = (People *)b;
    // 先按小时排序
    if (pa->h != pb->h) return pa->h - pb->h;
    // 小时相同则按分钟排序
    if (pa->m != pb->m) return pa->m - pb->m;
    // 时间相同则按当天的序号排序
    return pa->no - pb->no;
}

// 检查身份证号是否有效，必须为18位且全为数字
bool check(const char *id) {
    if (strlen(id) != 18) return false;
    for (int i = 0; i < 18; i++) {
        if (id[i] < '0' || id[i] > '9') return false;
    }
    return true;
}

// 将时间字符串转换为小时和分钟
void convert(int *h, int *m, const char *str) {
    sscanf(str, "%d:%d", h, m);
}

// 哈希函数，将字符串转换为哈希值
unsigned int hash(const char *str) {
    unsigned int hash = 0;
    while (*str) {
        hash = (hash * 31) + *str++;
    }
    return hash % HASH_SIZE;
}

// 在哈希表中查找记录
Record* find_record(const char *id) {
    unsigned int index = hash(id);
    Record *entry = hash_table[index];
    while (entry != NULL) {
        if (strcmp(entry->id, id) == 0) {
            return entry;
        }
        entry = entry->next;
    }
    return NULL;
}

// 向哈希表中插入记录
void insert_record(const char *id, int day) {
    unsigned int index = hash(id);
    Record *entry = (Record *)malloc(sizeof(Record));
    strcpy(entry->id, id);
    entry->day = day;
    entry->next = hash_table[index];
    hash_table[index] = entry;
}

// 清空哈希表，释放内存
void clear_records() {
    for (int i = 0; i < HASH_SIZE; i++) {
        Record *entry = hash_table[i];
        while (entry != NULL) {
            Record *temp = entry;
            entry = entry->next;
            free(temp);
        }
        hash_table[i] = NULL;
    }
}

int main() {
    int d = 0, p = 0;
    // 读取天数d和最少间隔天数p
    scanf("%d %d", &d, &p);

    // 处理每一天的数据
    for (int i = 1; i <= d; i++) {
        int n = 0, cnt = 0;
        // 读取当天申请人数n和可发放口罩的数量cnt
        scanf("%d %d", &n, &cnt);
        int k = 0;

        // 读取每个申请人的信息
        for (int j = 0; j < n; j++) {
            char name[MAX_NAME], id[MAX_ID], str[10];
            int h = 0, m = 0, st = 0;
            // 读取申请人的姓名、身份证号、身体状况和提交时间
            scanf("%s %s %d %s", name, id, &st, str);
            // 将时间字符串转换为小时和分钟
            convert(&h, &m, str);
            // 检查身份证号是否有效
            if (check(id)) {
                // 将有效申请人的信息存储到people数组中
                strcpy(people[k].name, name);
                strcpy(people[k].id, id);
                people[k].st = st;
                people[k].h = h;
                people[k].m = m;
                people[k].no = j;
                k++;
                // 如果有症状，将信息存储到maybe数组中
                if (st) {
                    strcpy(maybe[idx].name, name);
                    strcpy(maybe[idx].id, id);
                    idx++;
                }
            }
        }

        // 按提交时间和顺序对申请人进行排序
        qsort(people, k, sizeof(People), compare_people);

        // 发放口罩
        for (int j = 0; j < k && cnt > 0; j++) {
            Record *record = find_record(people[j].id);
            // 检查是否符合发放条件
            if (record == NULL || i >= record->day + p + 1) {
                // 打印领取口罩的人的姓名和身份证号
                printf("%s %s\n", people[j].name, people[j].id);
                if (record == NULL) {
                    insert_record(people[j].id, i);
                } else {
                    record->day = i;
                }
                cnt--;
            }
        }
    }

    // 输出可能有症状的人的信息，去重
    for (int j = 0; j < idx; j++) {
        Record *record = find_record(maybe[j].id);
        if (record == NULL || record->day != d + 1) {
            // 打印可能有症状的人的姓名和身份证号
            printf("%s %s\n", maybe[j].name, maybe[j].id);
            if (record == NULL) {
                insert_record(maybe[j].id, d + 1);
            } else {
                record->day = d + 1;
            }
        }
    }

    // 清空记录，释放内存
    clear_records();
    return 0;
}

7-176 降价提醒机器人

小 T 想买一个玩具很久了，但价格有些高，他打算等便宜些再买。但天天盯着购物网站很麻烦，请你帮小 T 写一个降价提醒机器人，当玩具的当前价格比他设定的价格便宜时发出提醒。

输入格式：

输入第一行是两个正整数 N 和 M (1≤N≤100,0≤M≤1000)，表示有 N 条价格记录，小 T 设置的价格为 M。

接下来 N 行，每行有一个实数 P**i（−1000.0<P**i<1000.0），表示一条价格记录。

输出格式：

对每一条比设定价格 M 便宜的价格记录 P，在一行中输出 On Sale! P，其中 P 输出到小数点后 1 位。

输入样例：

1
2
3
4
5
4 99
98.0
97.0
100.2
98.9

输出样例：

1
2
3
On Sale! 98.0
On Sale! 97.0
On Sale! 98.9

代码长度限制

16 KB

Java (javac)

时间限制

600 ms

内存限制

64 MB

其他编译器

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
	float n = 0, m = 0;
	scanf("%f%f", &n, &m);
	for (int i = 1; i <= n; ++i) {
		float p = 0;
		scanf("%f", &p);
		if (p < m)	printf("On Sale! %.01f\n", p);
	}
	return 0;
}

7-177 整数算术运算

本题要求编写程序，计算并输出2个正整数的和、差、积、商与余数。题目保证输入和输出全部在整型范围内。

输入格式:

输入在一行中给出2个正整数A和B。

输出格式:

在5行中按照格式“A 运算符 B = 结果”顺序输出和、差、积、商与余数。

输入样例:

1
5 3

输出样例:

在这里给出相应的输出。例如：

1
2
3
4
5
5 + 3 = 8
5 - 3 = 2
5 * 3 = 15
5 / 3 = 1
5 % 3 = 2

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
	int n = 0, m = 0;
	scanf("%d%d", &n, &m);
	printf("%d + %d = %d\n", n, m, n + m);
	printf("%d - %d = %d\n", n, m, n - m);
	printf("%d * %d = %d\n", n, m, n * m);
	printf("%d / %d = %d\n", n, m, n / m);
	printf("%d %% %d = %d\n", n, m, n % m);
	return 0;
}

7-178 找出三位水仙花数

本题要求编写程序，输出给定正整数M和N区间内的所有三位水仙花数。三位水仙花数，即其个位、十位、百位数字的立方和等于该数本身。

输入格式:

输入在一行中给出两个正整数M和N（100≤M≤N≤999）。

输出格式:

顺序输出M和N区间内所有三位水仙花数，每一行输出一个数。若该区间内没有三位水仙花数，则无输出。

如果M或者N不符合题目的要求，则输出Invalid Value.。

输入样例1:

1
100 400

输出样例1:

1
2
3
153
370
371

输入样例2:

1
500 600

输出样例2:

1

输入样例3：

1
990 101

输出样例3：

1
Invalid Value.

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int Narcissistic(int n) {
	int sum = 0;
	int t = n;
	while (n) {
		int i = n % 10;
		sum += i * i * i;
		n /= 10;
	}
	if (sum == t)	return 1;
	else return 0;
}
int main(void) {
	int m = 0, n = 0;
	scanf("%d%d", &m, &n);
	if (m >= 100 && n <= 999 && n >= m) {
		for (int i = m; i <= n; ++i) {
			if (Narcissistic(i))	printf("%d\n", i);
		}
	}
	else {
		printf("Invalid Value.");
	}
	return 0;
}

7-179 统计MOOC证书

本题要求编写程序，输入N个学生的MOOC成绩，统计优秀、合格证书的数量，以及没有获得证书的数量。学生修读程序设计MOOC，85分及以上获得优秀证书，不到85分但是60分及以上获得合格证书，不到60分则没有证书。

输入格式:

输入在第一行中给出非负整数N，即学生人数。第二行给出N个非负整数，即这N位学生的成绩，其间以空格分隔。

输出格式:

在一行中依次输出优秀证书、合格证书、没有获得证书的数量，中间以空格分隔。请注意，最后一个数字后没有空格。

输入样例1:

1
2
7
85 59 86 60 84 61 45

输出样例1:

1
2 3 2

输入样例2:

1
2
4
91  100  88 75

输出样例2:

1
3 1 0

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main(void) {
	int m = 0, per = 0, good = 0, bad = 0;
	scanf("%d", &m);
	for (int i = 1; i <= m; ++i) {
		int t = 0;
		scanf("%d", &t);
		if (t >= 85)	per++;
		else if (t >= 60)	good++;
		else  bad++;
	}
	printf("%d %d %d", per, good, bad);
	return 0;
}

7-180 嫑废话上代码

Linux 之父 Linus Torvalds 的名言是：“Talk is cheap. Show me the code.”（嫑废话，上代码）。本题就请你直接在屏幕上输出这句话。

输入格式：

本题没有输入。

输出格式：

在一行中输出 Talk is cheap. Show me the code.。

输入样例：

1
无

输出样例：

1
Talk is cheap. Show me the code.

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
	printf("Talk is cheap. Show me the code.");
	return 0;
}

7-181 猫是液体

测量一个人的体积是很难的，但猫就不一样了。因为猫是液体，所以可以很容易地通过测量一个长方体容器的容积来得到容器里猫的体积。本题就请你完成这个计算。

输入格式：

输入在第一行中给出 3 个不超过 100 的正整数，分别对应容器的长、宽、高。

输出格式：

在一行中输出猫的体积。

输入样例：

1
23 15 20

输出样例：

1
6900

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
	int a = 0, b = 0, c = 0;
	scanf("%d%d%d", &a, &b, &c);
	printf("%d", a * b * c);
	return 0;
}

7-182 洛希极限

科幻电影《流浪地球》中一个重要的情节是地球距离木星太近时，大气开始被木星吸走，而随着不断接近地木“刚体洛希极限”，地球面临被彻底撕碎的危险。但实际上，这个计算是错误的。

洛希极限（Roche limit）是一个天体自身的引力与第二个天体造成的潮汐力相等时的距离。当两个天体的距离少于洛希极限，天体就会倾向碎散，继而成为第二个天体的环。它以首位计算这个极限的人爱德华·洛希命名。（摘自百度百科）

大天体密度与小天体的密度的比值开 3 次方后，再乘以大天体的半径以及一个倍数（流体对应的倍数是 2.455，刚体对应的倍数是 1.26），就是洛希极限的值。例如木星与地球的密度比值开 3 次方是 0.622，如果假设地球是流体，那么洛希极限就是 0.622×2.455=1.52701 倍木星半径；但地球是刚体，对应的洛希极限是 0.622×1.26=0.78372 倍木星半径，这个距离比木星半径小，即只有当地球位于木星内部的时候才会被撕碎，换言之，就是地球不可能被撕碎。

本题就请你判断一个小天体会不会被一个大天体撕碎。

输入格式：

输入在一行中给出 3 个数字，依次为：大天体密度与小天体的密度的比值开 3 次方后计算出的值（≤1）、小天体的属性（0 表示流体、1 表示刚体）、两个天体的距离与大天体半径的比值（>1 但不超过 10）。

输出格式：

在一行中首先输出小天体的洛希极限与大天体半径的比值（输出小数点后2位）；随后空一格；最后输出 ^_^ 如果小天体不会被撕碎，否则输出 T_T。

输入样例 1：

1
0.622 0 1.4

输出样例 1：

1
1.53 T_T

输入样例 2：

1
0.622 1 1.4

输出样例 2：

1
0.78 ^_^

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
	double a = 0, b = 0,c=0;
	scanf("%lf%lf%lf", &a, &b,&c);
	if (b == 0)	a *= 2.455;
	else a *= 1.26;
	printf("%.02lf ", a);
	if (a > c)	printf("T_T");
	else printf("^_^");
	return 0;
}

7-183 调和平均

N 个正数的算数平均是这些数的和除以 N，它们的调和平均是它们倒数的算数平均的倒数。本题就请你计算给定的一系列正数的调和平均值。

输入格式：

每个输入包含 1 个测试用例。每个测试用例第 1 行给出正整数 N (≤1000)；第 2 行给出 N 个正数，都在区间 [0.1,100] 内。

输出格式：

在一行中输出给定数列的调和平均值，输出小数点后2位。

输入样例：

1
2
8
10 15 12.7 0.3 4 13 1 15.6

输出样例：

1
1.61

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main(void) {
	int n = 0;
	double m = 0,sum=0;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%lf", &m);
		sum += 1.0 / m;
	}
	printf("%.02lf", 1/(sum/n));
	return 0;
}

7-184 胎压监测

小轿车中有一个系统随时监测四个车轮的胎压，如果四轮胎压不是很平衡，则可能对行车造成严重的影响。

让我们把四个车轮 —— 左前轮、右前轮、右后轮、左后轮 —— 顺次编号为 1、2、3、4。本题就请你编写一个监测程序，随时监测四轮的胎压，并给出正确的报警信息。报警规则如下：

  • 如果所有轮胎的压力值与它们中的最大值误差在一个给定阈值内，并且都不低于系统设定的最低报警胎压，则说明情况正常，不报警；
  • 如果存在一个轮胎的压力值与它们中的最大值误差超过了阈值，或者低于系统设定的最低报警胎压，则不仅要报警，而且要给出可能漏气的轮胎的准确位置；
  • 如果存在两个或两个以上轮胎的压力值与它们中的最大值误差超过了阈值，或者低于系统设定的最低报警胎压，则报警要求检查所有轮胎。

输入格式：

输入在一行中给出 6 个 [0, 400] 范围内的整数，依次为 1~4 号轮胎的胎压、最低报警胎压、以及胎压差的阈值。

输出格式：

根据输入的胎压值给出对应信息：

  • 如果不用报警，输出 Normal；
  • 如果有一个轮胎需要报警，输出 Warning: please check #X!，其中 X 是出问题的轮胎的编号；
  • 如果需要检查所有轮胎，输出 Warning: please check all the tires!。

输入样例 1：

1
242 251 231 248 230 20

输出样例 1：

1
Normal

输入样例 2：

1
242 251 232 248 230 10

输出样例 2：

1
Warning: please check #3!

输入样例 3：

1
240 251 232 248 240 10

输出样例 3：

1
Warning: please check all the tires!

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
int main(void) {
	int ary[4] = {0}, min = 0, min_n = 0,max=INT_MIN;
	for (int i = 0; i < 4; ++i) {
		scanf("%d", &ary[i]);
	}
	scanf("%d%d", &min, &min_n);
	for (int i = 0; i < 4; ++i) {
		if (ary[i] > max)	max = ary[i];
	}
	int wrong[4] = { 0 };
	for (int i = 0; i < 4; ++i)	wrong[i] = 0;
	for (int i = 0; i < 4; ++i) {
		if (ary[i]<min || max - ary[i]>min_n)	wrong[i] = 1;
	}
	if (wrong[0] + wrong[1] + wrong[2] + wrong[3] >= 2) {
		printf("Warning: please check all the tires!");
	}
	else if(wrong[0] + wrong[1] + wrong[2] + wrong[3] >= 1) {
		for (int i = 0; i < 4; ++i) {
			if(wrong[i])
				printf("Warning: please check #%d!\n", i + 1);
		}
	}
	else
	{
		printf("Normal");
	}
	return 0;
}

7-185 吃火锅

这种天气你有什么破事打电话给我基本没用。但是如果你说“吃火锅”，那就厉害了，我们的故事就开始了。

本题要求你实现一个程序，自动检查你朋友给你发来的信息里有没有 chi1 huo3 guo1。

输入格式：

输入每行给出一句不超过 80 个字符的、以回车结尾的朋友信息，信息为非空字符串，仅包括字母、数字、空格、可见的半角标点符号。当读到某一行只有一个英文句点 . 时，输入结束，此行不算在朋友信息里。

输出格式：

首先在一行中输出朋友信息的总条数。然后对朋友的每一行信息，检查其中是否包含 chi1 huo3 guo1，并且统计这样厉害的信息有多少条。在第二行中首先输出第一次出现 chi1 huo3 guo1 的信息是第几条（从 1 开始计数），然后输出这类信息的总条数，其间以一个空格分隔。题目保证输出的所有数字不超过 100。

如果朋友从头到尾都没提 chi1 huo3 guo1 这个关键词，则在第二行输出一个表情 -_-#。

输入样例 1：

1
2
3
4
5
6
Hello!
are you there?
wantta chi1 huo3 guo1?
that's so li hai le
our story begins from chi1 huo3 guo1 le
.

输出样例 1：

1
2
5
3 2

输入样例 2：

1
2
3
4
5
6
Hello!
are you there?
wantta qi huo3 guo1 chi1huo3guo1?
that's so li hai le
our story begins from ci1 huo4 guo2 le
.

输出样例 2：

1
2
5
-_-#

题目引用自团体程序设计天梯赛真题（2020年）。

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<math.h>

int main() {
	char str[82], substr[] = "chi1 huo3 guo1";
	int time = 0, begin = 0,all=0;
	do {
		time++;
		//读入一行字符串的函数
		fgets(str, sizeof(str), stdin);
		char* pos = strstr(str, substr);
		//printf("%s", ary);
		if (pos != NULL) {
			if(begin==0){
				begin=time;
			}
			all++;
		}
	} while (strcmp(str,".\n")!=0);
	if (begin != 0) {
		printf("%d\n%d %d", time - 1, begin, all);
	}
	else {
		printf("%d\n-_-#", time - 1);
	}
	return 0;
}

7-186 前世档案

网络世界中时常会遇到这类滑稽的算命小程序，实现原理很简单，随便设计几个问题，根据玩家对每个问题的回答选择一条判断树中的路径（如下图所示），结论就是路径终点对应的那个结点。

现在我们把结论从左到右顺序编号，编号从 1 开始。这里假设回答都是简单的“是”或“否”，又假设回答“是”对应向左的路径，回答“否”对应向右的路径。给定玩家的一系列回答，请你返回其得到的结论的编号。

输入格式：

输入第一行给出两个正整数：N（≤30）为玩家做一次测试要回答的问题数量；M（≤100）为玩家人数。

随后 M 行，每行顺次给出玩家的 N 个回答。这里用 y 代表“是”，用 n 代表“否”。

输出格式：

对每个玩家，在一行中输出其对应的结论的编号。

输入样例：

1
2
3
4
5
3 4
yny
nyy
nyn
yyn

输出样例：

1
2
3
4
3
5
6
2

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>
#include <math.h>
int main()
{
    // input
    int n, m; scanf("%d%d", &n, &m);
    for (int i=0; i<m; i++){
        // 读走换行符
        getchar();
        // input + process
        // 叶子结点从1开始编号
        int sum = 1;
        for (int j=0; j<n; j++){
            char ch = getchar();
            if (ch == 'n')
              sum += pow(2, n-1-j); // 计数
        }
        // output
        printf("%d\n", sum);
    }
    return 0;
}

7-187 统计字符[2]

本题要求编写程序，输入N个字符，统计其中英文字母、空格或回车、数字字符和其他字符的个数。

输入格式:

输入在第一行中给出正整数N，第二行输入N个字符，最后一个回车表示输入结束，不算在内。

输出格式:

在一行内按照

1
letter = 英文字母个数, blank = 空格或回车个数, digit = 数字字符个数, other = 其他字符个数

的格式输出。请注意，等号的左右各有一个空格，逗号后有一个空格。

输入样例:

1
2
3
10
aZ &
09 Az

输出样例:

1
letter = 4, blank = 3, digit = 2, other = 1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include <ctype.h>
int main() {
	int m = 0, letter = 0, blank = 0, digit = 0, other = 0,i;
	scanf("%d", &m);
	char c = ' ';
	c = getchar();
	for (i = 1; i <=m; ++i) {
		c = getchar();
		if (isdigit(c))	digit++;
		else if (c == ' '||c=='\n')	blank++;
		else if (isalpha(c))	letter++;
		else other++;
	}
	//printf("\n%d\n", i);
	printf("letter = %d, blank = %d, digit = %d, other = %d", letter, blank, digit, other);
	return 0;
}

7-188 统计数字字符和空格

本题要求编写程序，输入一行字符，统计其中数字字符、空格和其他字符的个数。建议使用switch语句编写。

输入格式:

输入在一行中给出若干字符，最后一个回车表示输入结束，不算在内。

输出格式:

在一行内按照

1
blank = 空格个数, digit = 数字字符个数, other = 其他字符个数

的格式输出。请注意，等号的左右各有一个空格，逗号后有一个空格。

输入样例:

在这里给出一组输入。例如：

1
Reold 12 or 45T

输出样例:

在这里给出相应的输出。例如：

1
blank = 3, digit = 4, other = 8

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include <ctype.h>
int main() {
	char str[100];
	int blank = 0, digit = 0, other = 0,i;
	fgets(str, 100, stdin);
	//printf("%s", str);
	//printf("%d\n", strlen(str));
	for (i = 0; i <strlen(str); ++i) {
		char c = ' ';
		c = str[i];
		if (isdigit(c))	digit++;
		else if (c == ' ')	blank++;
		//else if (isalpha(c))	letter++;
		else other++;
	}
	//printf("\n%d\n", i);
	printf("blank = %d, digit = %d, other = %d", blank, digit, other-1);
	return 0;
}

7-189 西安距离

小明来到了古都西安，想去参观大唐西市！

西安的道路可以看做是与x轴或y轴垂直的直线，小明位于(a,b)，而目的地位于(c,d)，问最少几步可以到达。

输入格式:

一行中四个整数，a,b,c,d，表示坐标为(a,b)与(c,d)，这里0<=a,b,c,d<=1000

输出格式:

输出这两个点的西安距离。

输入样例:

1
0 0 3 4

输出样例:

1
7

代码长度限制

1 KB

时间限制

200 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main() {
	int res = 0;
	int a = 0, b = 0, c = 0, d = 0;
	scanf("%d%d%d%d", &a, &b, &c, &d);
	//printf("%d%d%d%d\n", a, b, c, d);
	res = abs(d - b) + abs(c - a);
	//printf("%d\n", res);
	printf("%d", res);
	return 0;
}

7-190 凯撒密码

为了防止信息被别人轻易窃取，需要把电码明文通过加密方式变换成为密文。输入一个以回车符为结束标志的字符串（少于80个字符），再输入一个整数offset，用凯撒密码将其加密后输出。恺撒密码是一种简单的替换加密技术，将明文中的所有字母都在字母表上偏移offset位后被替换成密文，当offset大于零时，表示向后偏移；当offset小于零时，表示向前偏移。

输入格式:

输入第一行给出一个以回车结束的非空字符串（少于80个字符）；第二行输入一个整数offset。

输出格式:

输出加密后的结果字符串。

输入样例1:

1
2
Hello Hangzhou
2

输出样例1:

1
Jgnnq Jcpibjqw

输入样例2:

1
2
a=x+y
-1

输出样例2:

1
z=w+x

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main() {
	int off = 0;
	char str[82] = " ";
	fgets(str, sizeof(str), stdin);
	scanf("%d", &off);
	if (off < 0) {
		off = -off;
		off = off - off / 26 * 26;
		off = ((off-1) % 25) + 1;
		off = 26 - off;
	}
	//printf("\n%d\n", off);
	//printf("%s%d", str, off);
	for (int i = 0; i < strlen(str) - 1; ++i) {
		char c = str[i];
		if (islower(c)) {
			c = (c - 'a' + off) % 26 + 'a';
			printf("%c", c);
		}
		else if (isupper(c)) {
			c = (c - 'A' + off) % 26 + 'A';
			printf("%c", c);
		}
		else
			printf("%c", c);
	}
	return 0;
}

7-191 吉老师的回归

曾经在天梯赛大杀四方的吉老师决定回归天梯赛赛场啦！

为了简化题目，我们不妨假设天梯赛的每道题目可以用一个不超过 500 的、只包括可打印符号的字符串描述出来，如：Problem A: Print "Hello world!"。

众所周知，吉老师的竞赛水平非常高超，你可以认为他每道题目都会做（事实上也是……）。因此，吉老师会按照顺序看题并做题。但吉老师水平太高了，所以签到题他就懒得做了（浪费时间），具体来说，假如题目的字符串里有 qiandao 或者 easy（区分大小写）的话，吉老师看完题目就会跳过这道题目不做。

现在给定这次天梯赛总共有几道题目以及吉老师已经做完了几道题目，请你告诉大家吉老师现在正在做哪个题，或者吉老师已经把所有他打算做的题目做完了。

提醒：天梯赛有分数升级的规则，如果不做签到题可能导致团队总分不足以升级，一般的选手请千万不要学习吉老师的酷炫行为！

输入格式：

输入第一行是两个正整数 N,M (1≤M≤N≤30)，表示本次天梯赛有 N 道题目，吉老师现在做完了 M 道。

接下来 N 行，每行是一个符合题目描述的字符串，表示天梯赛的题目内容。吉老师会按照给出的顺序看题——第一行就是吉老师看的第一道题，第二行就是第二道，以此类推。

输出格式：

在一行中输出吉老师当前正在做的题目对应的题面（即做完了 M 道题目后，吉老师正在做哪个题）。如果吉老师已经把所有他打算做的题目做完了，输出一行 Wo AK le。

输入样例 1：

1
2
3
4
5
6
5 1
L1-1 is a qiandao problem.
L1-2 is so...easy.
L1-3 is Easy.
L1-4 is qianDao.
Wow, such L1-5, so easy.

输出样例 1：

1
L1-4 is qianDao.

输入样例 2：

1
2
3
4
5
6
5 4
L1-1 is a-qiandao problem.
L1-2 is so easy.
L1-3 is Easy.
L1-4 is qianDao.
Wow, such L1-5, so!!easy.

输出样例 2：

1
Wo AK le

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
#include<string.h>
int main() {
	char str1[] = "qiandao", str2[] = "easy";
	char ary[510] = "",res[510]="";
	int n=0, m = 0;
	scanf("%d%d", &n, &m);
	int cnt = 0;
	scanf(" ");
	for (int i = 1; i <= n; ++i) {
		fgets(ary, sizeof(ary), stdin);
		ary[strlen(ary) - 1] = '\0';	
		if (!(strstr(ary, str1))&& !(strstr(ary, str2))) {
			cnt++;
			for (int i = 0; i < strlen(ary); ++i)	res[i] = ary[i];
			//printf("%s", res);
			//printf("%s", res);
		}
	}
	//printf("cnt is %d\n", cnt);
	if (cnt <= m) {
		strcpy(res, "Wo AK le");
	}
	printf("%s", res);
	return 0;
}

7-192 人与神

跨界大神 L. Peter Deutsch 有一句名言：“To iterate is human, to recurse divine.”（迭代的是人，递归的是神）。本题就请你直接在屏幕上输出这句话。

输入格式：

本题没有输入。

输出格式：

在一行中输出 To iterate is human, to recurse divine.。

输入样例：

1
无

输出样例：

1
To iterate is human, to recurse divine.

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
#include<string.h>
int main() {
	printf("To iterate is human, to recurse divine.");
	return 0;
}

7-193 两小时学完C语言

知乎上有个宝宝问：“两个小时内如何学完 C 语言？”当然，问的是“学完”并不是“学会”。

假设一本 C 语言教科书有 N 个字，这个宝宝每分钟能看 K 个字，看了 M 分钟。还剩多少字没有看？

输入格式：

输入在一行中给出 3 个正整数，分别是 N（不超过 400 000），教科书的总字数；K（不超过 3 000），是宝宝每分钟能看的字数；M（不超过 120），是宝宝看书的分钟数。

题目保证宝宝看完的字数不超过 N。

输出格式：

在一行中输出宝宝还没有看的字数。

输入样例：

1
100000 1000 72

输出样例：

1
28000

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
#include<string.h>
int main() {
	int n = 0, k = 0, m = 0;
	scanf("%d%d%d", &n, &k, &m);
	printf("%d", n - k * m);
	return 0;
}

7-194 强迫症

小强在统计一个小区里居民的出生年月，但是发现大家填写的生日格式不统一，例如有的人写 199808，有的人只写 9808。有强迫症的小强请你写个程序，把所有人的出生年月都整理成 年年年年-月月 格式。对于那些只写了年份后两位的信息，我们默认小于 22 都是 20 开头的，其他都是 19 开头的。

输入格式：

输入在一行中给出一个出生年月，为一个 6 位或者 4 位数，题目保证是 1000 年 1 月到 2021 年 12 月之间的合法年月。

输出格式：

在一行中按标准格式 年年年年-月月 将输入的信息整理输出。

输入样例 1：

1
9808

输出样例 1：

1
1998-08

输入样例 2：

1
0510

输出样例 2：

1
2005-10

输入样例 3：

1
196711

输出样例 3：

1
1967-11

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
#include<string.h>
int main() {
	int c;
	scanf("%d", &c);
	if (c > 100000) {
		printf("%02d-%02d", c / 100, c % 100);
	}
	else {
		//int a = 0;
		//a = c / 100;
		if (c / 100 < 22)	printf("20%02d-%02d", c / 100, c % 100);
		else printf("19%02d-%02d", c / 100, c % 100);
	}
	return 0;
}

7-195 大笨钟的心情

有网友问：未来还会有更多大笨钟题吗？笨钟回复说：看心情……

本题就请你替大笨钟写一个程序，根据心情自动输出回答。

输入格式：

输入在一行中给出 24 个 [0, 100] 区间内的整数，依次代表大笨钟在一天 24 小时中，每个小时的心情指数。

随后若干行，每行给出一个 [0, 23] 之间的整数，代表网友询问笨钟这个问题的时间点。当出现非法的时间点时，表示输入结束，这个非法输入不要处理。题目保证至少有 1 次询问。

输出格式：

对每一次提问，如果当时笨钟的心情指数大于 50，就在一行中输出 心情指数 Yes，否则输出 心情指数 No。

输入样例：

1
2
3
4
5
6
80 75 60 50 20 20 20 20 55 62 66 51 42 33 47 58 67 52 41 20 35 49 50 63
17
7
3
15
-1

输出样例：

1
2
3
4
52 Yes
20 No
50 No
58 Yes

代码长度限制

16 KB

Java (javac)

时间限制

600 ms

内存限制

64 MB

其他编译器

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
#include<string.h>
int main() {
	int a[24] = { 0 },c=0;
	for (int i = 0; i < 24; ++i)	a[i] = 0;
	for (int i = 0; i <= 23; ++i)	scanf("%d", &a[i]);
	do {
		//int c = 0;
		scanf("%d", &c);
		if (c >= 0 && c <= 23) {
			if (a[c] > 50)	printf("%d Yes\n",a[c]);
			else printf("%d No\n",a[c]);
		}
	} while (c >= 0 && c <= 23);
	return 0;
}

7-196 天梯赛的善良

天梯赛是个善良的比赛。善良的命题组希望将题目难度控制在一个范围内，使得每个参赛的学生都有能做出来的题目，并且最厉害的学生也要非常努力才有可能得到高分。

于是命题组首先将编程能力划分成了 106 个等级（太疯狂了，这是假的），然后调查了每个参赛学生的编程能力。现在请你写个程序找出所有参赛学生的最小和最大能力值，给命题组作为出题的参考。

输入格式：

输入在第一行中给出一个正整数 N（≤2×104），即参赛学生的总数。随后一行给出 N 个不超过 106 的正整数，是参赛学生的能力值。

输出格式：

第一行输出所有参赛学生的最小能力值，以及具有这个能力值的学生人数。第二行输出所有参赛学生的最大能力值，以及具有这个能力值的学生人数。同行数字间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

1
2
10
86 75 233 888 666 75 886 888 75 666

输出样例：

1
2
75 3
888 2

代码长度限制

16 KB

时间限制

200 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<limits.h>
int ary[1000001] = { 0 };
int main() {
	int min = INT_MAX, max = INT_MIN;
	//printf("%d %d", min, max);
	int n=0;
	scanf("%d", &n);
	for (int i = 0; i < 1000001; ++i) {
		ary[i] = 0;
	}
	int c = 0;
	//for (int i = 0; i < 1000001; ++i)	printf("%d", ary[i]);
	for (int i = 1; i <= n; ++i) {
		//int c = 0;
		scanf("%d", &c);
		if (c > max)max = c;
		if (c < min)min = c;
		ary[c]++;
		//ary[min]++;
	}

	printf("%d %d\n%d %d", min, ary[min], max, ary[max]);
	return 0;
}

7-197 乘法口诀数列

本题要求你从任意给定的两个 1 位数字 a1 和 a2 开始，用乘法口诀生成一个数列 {a**n}，规则为从 a1 开始顺次进行，每次将当前数字与后面一个数字相乘，将结果贴在数列末尾。如果结果不是 1 位数，则其每一位都应成为数列的一项。

输入格式：

输入在一行中给出 3 个整数，依次为 a1、a2 和 n，满足 0≤a1,a2≤9，0<n≤103。

输出格式：

在一行中输出数列的前 n 项。数字间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

1
2 3 10

输出样例：

1
2 3 6 1 8 6 8 4 8 4

样例解释：

数列前 2 项为 2 和 3。从 2 开始，因为 2×3=6，所以第 3 项是 6。因为 3×6=18，所以第 4、5 项分别是 1、8。依次类推…… 最后因为第 6 项有 6×8=48，对应第 10、11 项应该是 4、8。而因为只要求输出前 10 项，所以在输出 4 后结束。

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
	int ary[1001];
	int a = 0, b = 0, n = 0;
	scanf("%d%d%d", &a, &b, &n);
	ary[1] = a;
	ary[2] = b;
	int i = 3,index=3;
	while (i <= n) {
		if (ary[index - 1] * ary[index - 2] < 10) {
			ary[i] = ary[index- 1] * ary[index - 2];
		}
		else {
			int c = ary[index - 1] * ary[index - 2];
			ary[i] = c / 10;
			i++;
			ary[i] = c % 10;
		}
		i++;
		index++;
	}
	for (int i = 1; i <= n; ++i) {
		printf("%d", ary[i]);
		if (i != n)printf(" ");
	}
	return 0;
}

7-198 自动编程

输出语句是每个程序员首先要掌握的语句。Python 的输出语句很简单，只要写一个 print(X) 即可，其中 X 是需要输出的内容。

本题就请你写一个自动编程机，对任何一个要输出的整数 N，给出输出这个整数的 Python 语句。

输入格式：

输入给出一个不超过 105 的正整数。

输出格式：

在一行中打印输出这个整数的 Python 语句，其中不包含任何空格。

输入样例：

1
520

输出样例：

1
print(520)

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
	int i;
	scanf("%d", &i);
	printf("print(%d)\n", i);
	return 0;
}

7-199 太神奇了

“告诉大家一个神奇的消息，太神奇了：明年全世界所有的人都同岁，全部都等于2022。明年的日子很特别，大概每1000年才会有一次。明年你的周岁年龄+你的出生年，每个人都是2022年。例如：你明年57加上1965年生的，加起来就是2022年。特别奇怪，连中外专家都无法解释！你计算一下，看看是不是2022。真是千年等一回呀！真准！转朋友圈，让大伙都算一下吧！”

据说这个“电子包浆”贴每年都会出现。本题就请你根据发贴人提到的周岁年龄和出生年，判断其发贴的时候是哪一年。

输入格式：

输入在第一行中给出两个正整数，即周岁年龄和出生年，其中年龄在 (0, 200) 区间内，出生年在 (1900, 2022) 区间内。

输出格式：

在一行中输出发贴年份。

输入样例：

1
57 1965

输出样例：

1
2021

样例说明

因为贴子里说“明年全世界所有的人都同岁”，所以发贴是在今年，即 2021 年。

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main() {
	int age = 0, bri = 0;
	scanf("%d%d", &age, &bri);
	printf("%d", age + bri - 1);
	return 0;
}

7-200 今天我要赢

2018 年我们曾经出过一题，是输出“2018 我们要赢”。今年是 2022 年，你要输出的句子变成了“我要赢！就在今天！”然后以比赛当天的日期落款。

输入格式：

本题没有输入。

输出格式：

输出分 2 行。在第一行中输出 I'm gonna win! Today!，在第二行中用 年年年年-月月-日日 的格式输出比赛当天的日期。已知比赛的前一天是 2022-04-22。

输入样例：

1
无

输出样例（第二行的内容要你自己想一想，这里不给出）：

1
2
I'm gonna win! Today!
这一行的内容我不告诉你…… 你要自己输出正确的日期呀~

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main() {
	int age = 0, bri = 0;
	printf("I'm gonna win! Today!\n2022-04-23");

	return 0;
}

7-201 种钻石

2019年10月29日，中央电视台专题报道，中国科学院在培育钻石领域，取得科技突破。科学家们用金刚石的籽晶片作为种子，利用甲烷气体在能量作用下形成碳的等离子体，慢慢地沉积到钻石种子上，一周“种”出了一颗 1 克拉大小的钻石。

本题给出钻石的需求量和人工培育钻石的速度，请你计算出货需要的时间。

输入格式：

输入在一行中给出钻石的需求量 N（不超过 107 的正整数，以微克拉为单位）和人工培育钻石的速度 v（1≤v≤200，以微克拉/天为单位的整数）。

输出格式：

在一行中输出培育 N 微克拉钻石需要的整数天数。不到一天的时间不算在内。

输入样例：

1
102000 130

输出样例：

1
784

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main() {
	int n = 0, v = 0;
	scanf("%d%d", &n, &v);
	printf("%d", n / v);
	return 0;
}

7-202 谁能进图书馆

为了保障安静的阅读环境，有些公共图书馆对儿童入馆做出了限制。例如“12 岁以下儿童禁止入馆，除非有 18 岁以上（包括 18 岁）的成人陪同”。现在有两位小/大朋友跑来问你，他们能不能进去？请你写个程序自动给他们一个回复。

输入格式：

输入在一行中给出 4 个整数：

1
禁入年龄线 陪同年龄线 询问者1的年龄 询问者2的年龄

这里的禁入年龄线是指严格小于该年龄的儿童禁止入馆；陪同年龄线是指大于等于该年龄的人士可以陪同儿童入馆。默认两个询问者的编号依次分别为 1 和 2；年龄和年龄线都是 [1, 200] 区间内的整数，并且保证 陪同年龄线 严格大于 禁入年龄线。

输出格式：

在一行中输出对两位询问者的回答，如果可以进就输出 年龄-Y，否则输出 年龄-N，中间空 1 格，行首尾不得有多余空格。

在第二行根据两个询问者的情况输出一句话：

  • 如果两个人必须一起进，则输出 qing X zhao gu hao Y，其中 X 是陪同人的编号， Y 是小孩子的编号；
  • 如果两个人都可以进但不是必须一起的，则输出 huan ying ru guan；
  • 如果两个人都进不去，则输出 zhang da zai lai ba；
  • 如果一个人能进一个不能，则输出 X: huan ying ru guan，其中 X 是可以入馆的那个人的编号。

输入样例 1：

1
12 18 18 8

输出样例 1：

1
2
18-Y 8-Y
qing 1 zhao gu hao 2

输入样例 2：

1
12 18 10 15

输出样例 2：

1
2
10-N 15-Y
2: huan ying ru guan

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main() {
	int yang = 0, old = 0, a = 0, b = 0;
	scanf("%d%d%d%d", &yang, &old, &a, &b);
	if (yang > a && yang > b)
		printf("%d-N %d-N\nzhang da zai lai ba", a, b);
	else if (a >= yang && b >=yang)
		printf("%d-Y %d-Y\nhuan ying ru guan", a, b);
	else if (a >= yang && a < old&&b<yang ) {
		printf("%d-Y %d-N\n1: huan ying ru guan", a, b);
	}
	else if( b >= yang && b < old&&a<yang){
		printf("%d-N %d-Y\n2: huan ying ru guan", a, b);
	}
	else {
		printf("%d-Y %d-Y", a, b);
		if (a > b)	printf("\nqing 1 zhao gu hao 2");
		if (b > a)	printf("\nqing 2 zhao gu hao 1");
	}
		
	return 0;
}

7-203 拯救外星人

你的外星人朋友不认得地球上的加减乘除符号，但是会算阶乘 —— 正整数 N 的阶乘记为 “N!”，是从 1 到 N 的连乘积。所以当他不知道“5+7”等于多少时，如果你告诉他等于“12!”，他就写出了“479001600”这个答案。

本题就请你写程序模仿外星人的行为。

输入格式：

输入在一行中给出两个正整数 A 和 B。

输出格式：

在一行中输出 (A+B) 的阶乘。题目保证 (A+B) 的值小于 12。

输入样例：

1
3 6

输出样例：

1
362880

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
	int a = 0, b = 0,sum=1;
	scanf("%d%d", &a, &b);
	for (int i = 1; i <= a + b; ++i) {
		sum *= i;
	}
	printf("%d", sum);
	return 0;
}

7-204 试试手气

我们知道一个骰子有 6 个面，分别刻了 1 到 6 个点。下面给你 6 个骰子的初始状态，即它们朝上一面的点数，让你一把抓起摇出另一套结果。假设你摇骰子的手段特别精妙，每次摇出的结果都满足以下两个条件：

  • 1、每个骰子摇出的点数都跟它之前任何一次出现的点数不同；
  • 2、在满足条件 1 的前提下，每次都能让每个骰子得到可能得到的最大点数。

那么你应该可以预知自己第 n 次（1≤n≤5）摇出的结果。

输入格式：

输入第一行给出 6 个骰子的初始点数，即 [1,6] 之间的整数，数字间以空格分隔；第二行给出摇的次数 n（1≤n≤5）。

输出格式：

在一行中顺序列出第 n 次摇出的每个骰子的点数。数字间必须以 1 个空格分隔，行首位不得有多余空格。

输入样例：

1
2
3 6 5 4 1 4
3

输出样例：

1
4 3 3 3 4 3

样例解释：

这 3 次摇出的结果依次为：

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

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
	int a[7] = { 0 }, n = 0;
	for (int i = 1; i <= 6; ++i)
		scanf("%d", &a[i]);
	scanf("%d", &n);
	for (int i = 1; i <= 6; ++i) {
		if (a[i] >=(6-n+1))	printf("%d", 6 - n);
		else printf("%d", 6 - n+1);
		if (i != 6)	printf(" ");
	}
	return 0;
}

7-205 静静的推荐

天梯赛结束后，某企业的人力资源部希望组委会能推荐一批优秀的学生，这个整理推荐名单的任务就由静静姐负责。企业接受推荐的流程是这样的：

  • 只考虑得分不低于 175 分的学生；
  • 一共接受 K 批次的推荐名单；
  • 同一批推荐名单上的学生的成绩原则上应严格递增；
  • 如果有的学生天梯赛成绩虽然与前一个人相同，但其参加过 PAT 考试，且成绩达到了该企业的面试分数线，则也可以接受。

给定全体参赛学生的成绩和他们的 PAT 考试成绩，请你帮静静姐算一算，她最多能向企业推荐多少学生？

输入格式：

输入第一行给出 3 个正整数：N（≤105）为参赛学生人数，K（≤5×103）为企业接受的推荐批次，S（≤100）为该企业的 PAT 面试分数线。

随后 N 行，每行给出两个分数，依次为一位学生的天梯赛分数（最高分 290）和 PAT 分数（最高分 100）。

输出格式：

在一行中输出静静姐最多能向企业推荐的学生人数。

输入样例：

1
2
3
4
5
6
7
8
9
10
11
10 2 90
203 0
169 91
175 88
175 0
175 90
189 0
189 0
189 95
189 89
256 100

输出样例：

1
8

样例解释：

第一批可以选择 175、189、203、256 这四个分数的学生各一名，此外 175 分 PAT 分数达到 90 分的学生和 189 分 PAT 分数达到 95 分的学生可以额外进入名单。第二批就只剩下 175、189 两个分数的学生各一名可以进入名单了。最终一共 8 人进入推荐名单。

代码长度限制

16 KB

Java (javac)

时间限制

1300 ms

内存限制

256 MB

Python (python3)

时间限制

400 ms

内存限制

64 MB

其他编译器

时间限制

200 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

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

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {
	int a[999] = {0};
	int sum = 0;
	for (int i = 0; i < 999; ++i)	a[i] = 0;
	int n = 0, k = 0, s = 0;
	scanf("%d%d%d", &n, &k, &s);
	for (int i = 1; i <= n; ++i) {
		int all = 0, pta = 0;
		scanf("%d%d", &all, &pta);
		if (all >= 175 && pta >= s)	sum++;
		else if (all >= 175)	a[all]++;
	}
	for (int j = 1; j <= k;++j) {
		for (int i = 175; i <= 400; ++i) {
			if (a[i]) {
				sum++;
				a[i]--;
			}
		}
	}
	printf("%d", sum);
	return 0;
}

7-206 斯德哥尔摩火车上的题

上图是新浪微博上的一则趣闻，是瑞典斯德哥尔摩火车上的一道题，看上去是段伪代码：

1
2
3
4
5
6
7
8
s = ''
a = '1112031584'
for (i = 1; i < length(a); i++) {
  if (a[i] % 2 == a[i-1] % 2) {
    s += max(a[i], a[i-1])
  }
}
goto_url('www.multisoft.se/' + s)

其中字符串的 + 操作是连接两个字符串的意思。所以这道题其实是让大家访问网站 www.multisoft.se/112358（注意：比赛中千万不要访问这个网址！！！）。

当然，能通过上述算法得到 112358 的原始字符串 a 是不唯一的。本题就请你判断，两个给定的原始字符串，能否通过上述算法得到相同的输出？

输入格式：

输入为两行仅由数字组成的非空字符串，长度均不超过 104，以回车结束。

输出格式：

对两个字符串分别采用上述斯德哥尔摩火车上的算法进行处理。如果两个结果是一样的，则在一行中输出那个结果；否则分别输出各自对应的处理结果，每个占一行。题目保证输出结果不为空。

输入样例 1：

1
2
1112031584
011102315849

输出样例 1：

1
112358

输入样例 2：

1
2
111203158412334
12341112031584

输出样例 2：

1
2
1123583
112358

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<stdio.h>
#include<string.h>
int main(){
    int i,la,lb,j=0;
    char aa[10001],aayi[10001],bb[10001],bbyi[10001];
    la=strlen(gets(aa));       //gets()获得键盘输入的字符串，以换行符结束；strlen()求字符串长度
    for(i=1;i<la;i++){
        if((aa[i]-'0')%2==(aa[i-1]-'0')%2)            //减 ‘0’是为了把ASCII码转换成对应数字
            aayi[j++]= aa[i]>aa[i-1]?aa[i]:aa[i-1];   //三目运算，取二者中大的那个
    }
    lb=strlen(gets(bb));
    j=0;
    for(i=1;i<lb;i++){
        if((bb[i]-'0')%2==(bb[i-1]-'0')%2)            //同上
            bbyi[j++]= bb[i]>bb[i-1]?bb[i]:bb[i-1];   //同上     
    }
    if(strcmp(aayi,bbyi)==0)        //strcmp()函数是比较两个字符串是否相等
        printf("%s\n",aayi);
    else
        printf("%s\n%s\n",aayi,bbyi);    
}

7-207 机工士姆斯塔迪奥

在 MMORPG《最终幻想14》的副本“乐欲之所瓯博讷修道院”里，BOSS 机工士姆斯塔迪奥将会接受玩家的挑战。

你需要处理这个副本其中的一个机制：N×M 大小的地图被拆分为了 N×M 个 1×1 的格子，BOSS 会选择若干行或/及若干列释放技能，玩家不能站在释放技能的方格上，否则就会被击中而失败。

给定 BOSS 所有释放技能的行或列信息，请你计算出最后有多少个格子是安全的。

输入格式:

输入第一行是三个整数 N,M,Q (1≤N×M≤105，0≤Q≤1000)，表示地图为 N 行 M 列大小以及选择的行/列数量。

接下来 Q 行，每行两个数 T**i,C**i，其中 T**i=0 表示 BOSS 选择的是一整行，T**i=1 表示选择的是一整列，C**i 为选择的行号/列号。行和列的编号均从 1 开始。

输出格式:

输出一个数，表示安全格子的数量。

输入样例:

1
2
3
4
5 5 3
0 2
0 4
1 3

输出样例:

1
12

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码如下：

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
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() {
	int line[100005], fox[100005];
	for (int i = 0; i < 100005; i++) {
		line[i] = 0;
		fox[i] = 0;
	}
	int n = 0, m = 0, q = 0;
	int a = 0, b = 0;
	scanf("%d%d%d", &n, &m, &q);
	for (int i = 1; i <= q; ++i) {
		int c = 0, q = 0;
		scanf("%d%d", &c, &q);
		if (c == 0 && line[q] == 0) {
			a++;
			line[q] = 1;
		}
		else if (c == 1 && fox[q] == 0) {
			b++;
			fox[q] = 1;
		}
	}
	//printf("a is %d\n", a);
	printf("%d", n * m - (a * m + b * n) + a * b);
	return 0;
}