2024XDOJ题目及答案（将停止更新，详见注意）

---

注意

本文于11-05后更新的代码，如没有专门说明，均使用GNU作为提交的类别。
即除基本计算，流程控制两组题目外，均使用GNU。

预告一下：据读者反映，本文打开会卡住。个人推测是文字量太大（毕竟已经将近十万字了，笑哭），加载困难的原因，因此这里提前说明。
本文将停止更新
同时，我会将所有题目按类别集合发布，以便查看和复习。

前言

笔者为一名XDU新生，为了学好C++，将自己做的XDOJ题目的答案放在这里备用，待日后复习。本人水平浅陋，写的不好，如读者有更好的解决方案，欢迎前来讨论。 题目会不定期陆续更新。

事先声明：
1.该文章仅用于个人学习，谢绝未经本人同意和任何用于商业用途的搬运。
2.学校时不时地会更新题库，导致题目可能会有差异，请各位参照答案的同学对照好题目要求，切莫直接抄袭。

---

2.题目2：数列分段

问题描述
　　给定一个整数数列，数列中连续相同的最长整数序列算成一段，问数列中共有多少段？
输入格式
　　输入的第一行包含一个整数n，表示数列中整数的个数。
　　第二行包含n个整数a1, a2, …, an，表示给定的数列，相邻的整数之间用一个空格分隔。
输出格式
　　输出一个整数，表示给定的数列有多个段。
样例输入
8
8 8 8 0 12 12 8 0
样例输出
5
样例说明
　　8 8 8是第一段，0是第二段，12 12是第三段，倒数第二个整数8是第四段，最后一个0是第五段。
评测用例规模与约定
1 ≤ n ≤ 1000，0 ≤ ai ≤ 1000。

#include<stdio.h>
int main(){
    int n,a[1000],j,i;
    int k=0;
    scanf("%d",&n);
    for ( i = 0; i < n; i++)
    {
        scanf("%d",&a[i]);
    }
    //将输入的数列整合为一个数组
    for ( j = 0; j < n-1; j++)
    {
        if (a[j]!=a[j+1])
        {
            k++;
        }     
    }
    //得到断点数
    printf("%d",k+1);
 
    return 0;
}

3.题目 3：最小差值

问题描述
给定 n 个数，请找出其中相差（差的绝对值）最小的两个数，输出它们的差值的绝对值。
输入格式
输入第一行包含一个整数 n。
第二行包含 n 个正整数，相邻整数之间使用一个空格分隔。
输出格式
输出一个整数，表示最小差值。
样例 1 输入
5
1 5 4 8 20
样例 1 输出
1
样例说明
相差最小的两个数是 5 和 4，它们之间的差值是 1。
样例 2 输入
5
9 3 6 1 3
样例 2 输出
0
样例说明
有两个相同的数 3，它们之间的差值是 0。
数据规模和约定
对于所有评测用例，2 ≤ n ≤ 1000，每个给定的整数都是不超过 10000 的正整数。

#include <stdio.h>
#include <cmath>
int get_smaller(int a,int b){
	int temp = (a<b) ? a : b;
	return temp;
}
int main(){
	int n,a[1000],dif = 10000;
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		scanf("%d", &a[i]);
	}
	for (int i = 0;i < n;i++){
		for (int j = i + 1;j < n;j++){
			dif = get_smaller(dif,(int)abs(a[i]-a[j]));
		}
	}
	printf("%d", dif);
	return 0;
}

5.题目 5：消除类游戏

问题描述
消除类游戏是深受大众欢迎的一种游戏，游戏在一个包含有 n 行 m 列的游戏棋盘上进
行，棋盘的每一行每一列的方格上放着一个有颜色的棋子，当一行或一列上有连续三个或更
多的相同颜色的棋子时，这些棋子都被消除。当有多处可以被消除时，这些地方的棋子将同
时被消除。
现在给你一个 n 行 m 列的棋盘，棋盘中的每一个方格上有一个棋子，请给出经过一次
消除后的棋盘。
请注意：一个棋子可能在某一行和某一列同时被消除。
输入格式
输入的第一行包含两个整数 n, m，用空格分隔，分别表示棋盘的行数和列数。
接下来 n 行，每行 m 个整数，用空格分隔，分别表示每一个方格中的棋子的颜色。颜
色使用 1 至 9 编号。
输出格式
输出 n 行，每行 m 个整数，相邻的整数之间使用一个空格分隔，表示经过一次消除后
的棋盘。如果一个方格中的棋子被消除，则对应的方格输出 0，否则输出棋子的颜色编号。
样例输入 1
4 5
2 2 3 1 2
3 4 5 1 4
2 3 2 1 3
2 2 2 4 4
样例输出 1
2 2 3 0 2
3 4 5 0 4
2 3 2 0 3
0 0 0 4 4
样例说明
棋盘中第 4 列的 1 和第 4 行的 2 可以被消除，其他的方格中的棋子均保留。
样例输入 2
4 5
2 2 3 1 2
3 1 1 1 1
2 3 2 1 3
2 2 3 3 3
样例输出 2
2 2 3 0 2
3 0 0 0 0
2 3 2 0 3
2 2 0 0 0
样例说明
棋盘中所有的 1 以及最后一行的 3 可以被同时消除，其他的方格中的棋子均保留。
评测用例规模与约定
所有的评测用例满足：1 ≤ n, m ≤ 30。

#include <stdio.h>
int main(){
	int n,m,a[30][30] = {0},token,row[30][30] = {0},column[30][30] = {0};
	scanf("%d %d", &n, &m);
	for (int y = 0;y < n;y++){
		for (int x = 0;x < m;x++){
			scanf("%d",&a[y][x]);
		}
	}
	for (int y = 0;y < n;y++){
		for (int x = 0;x < m;x++){
			if (a[y][x] == a[y][x + 1] && a[y][x] == a[y][x + 2]){
				row[y][x] = 1;
				row[y][x + 1] = 1;
				row[y][x + 2] = 1;
			}
		}
	}
	//按行搜寻 
	for (int x = 0;x < m;x++){
		for (int y = 0;y < n;y++){
			if (a[y][x] == a[y + 1][x] && a[y][x] == a[y + 2][x]){
				column[y][x] = 1;
				column[y + 1][x] = 1;
				column[y + 2][x] = 1;
			}
		}
	}
	//按列搜寻 
	for (int y = 0;y < n;y++){
		for (int x = 0;x < m;x++){
			if (row[y][x] != 0 || column[y][x] != 0){
				a[y][x] = 0;
			}
		}
	}
	//消除 
	for (int y = 0;y < n;y++){
		for (int x = 0;x < m;x++){
			printf("%d ",a[y][x]);
		}
		printf("\n");
	}
} 

7.题目名称 车牌限行

问题描述
受雾霾天气影响，某市决定当雾霾指数超过设定值时对车辆进行限行，假设车牌号全为数字，
且长度不超过6位，限行规则如下：
（1）限行时间段只包括周一至周五，周六周日不限行；
（2）如果雾霾指数低于200，不限行；
（3）如果雾霾指数大于等于200且低于400，每天限行两个尾号的汽车，周一限行1和6，
周二限行2和7，周三限行3和8，周四限行4和9，周五限行5和0；
（4） 如果雾霾指数大于等于400，每天限行五个尾号的汽车，周一、周三和周五限行1,3,5,7,9，
周二和周四限行0,2,4,6,8。
现在给出星期几、雾霾指数和车牌号，判断该车牌号是否限行。
输入说明
输入分为三个整数，第一个整数表示星期几（1~7，1表示周一，2表示周二，依次类推，7
表示周日），第二个整数表示雾霾指数（0~600），第三个整数表示车牌号，整数之间用空格
分隔。
输出说明
输出为两个部分，第一部分为车牌最后一位数字，第二部分为限行情况，限行输出yes，不
限行输出no。
输入样例1
4 230 80801
输出样例1
1 no
输入样例2
3 300 67008
输出样例2
8 yes

#include <stdio.h>
int main(){
	int week,degree,number;
	scanf("%d %d %d", &week, &degree, &number);
	if (week==6 || week==7 || degree<200){
		printf("%d no", number%10);
	}
	//若为周末或指数低于200，不限行 
	else{
		if (degree<400 ){
			if (number%10==week || number%10==(week+5)%10){
				printf("%d yes",number%10);
			}
			else{
				printf("%d no",number%10);
			}
		//若指数大于等于200，小于400 
		}
		else{
			if ((week+number%10)%2==0){
				printf("%d yes",number%10);
			}
			else{
				printf("%d no",number%10);
			} 
		}
	}
}

9.题目：计算球体重量

问题描述： 已知铁的比重是7.86(克/立方厘米)，金的比重是19.3(克/立方厘米)。写一个程序， 分别计算出给定直径的铁球与金球的质量，假定PI=3.1415926。

输入说明： 输入两个整数，分别表示铁球与金球的直径（单位为毫米）。

输出说明： 输出两个浮点数，分别表示铁球与金球的质量（单位为克），小数点后保留3位 小数，两个浮点数之间用空格分隔。

输入样例： 100 100

输出样例： 4115.486 10105.456

用例规模与约定： 输入表示球体直径的整数均于1000。 提示 用scanf 输入，用printf 输出，保留3位小数的格式控制字符为%.3f。

答案：`​
​

#include <stdio.h>
int main()
{
	int da,db;
	scanf("%d%d",&da,&db);
	double Ma, Mb;
	double ra, rb, Pi=3.1415926; 
	ra=da/20.0,rb=db/20.0;
	Ma=7.86*ra* ra* ra* Pi* 4/3;
	Mb=19.3*rb* rb* rb* Pi* 4/3;
	printf("%.3f %.3f\n",Ma,Mb);
	return 0;
} 

​

10.题目：温度转换

问题描述： 已知华氏温度到摄氏温度的转换公式为：摄氏温度= (华氏温度- 32)×5/9，编写程序，将给定的华氏温度转换为摄氏温度输出。

输入说明： 只有一个整数，表示输入的华氏温度。

输出说明： 输出一个表示摄氏温度的实数，小数点后保留2位有效数字。

输入样例： 50

输出样例： 10.00

用例规模与约定： 输入表示华氏温度的整数在冰点32℉至沸点212℉之间。 提示： 用scanf 输入，用printf 输出，保留2位小数的格式控制字符为%.2f。

答案：​

#include <stdio.h>
int main()
{	int F;
	scanf("%d", &F);
	double C=5.0/ 9* (F- 32.0);
	printf("%.2f\n", C);
		
 } 

​

11.题目：整数简单运算

问题描述：
编写程序，计算用户输入的两个整数的和、差、乘积（*）和商（/）。
输入格式：
输入两个整数，整数之间用空格分隔。
输出格式：
输出四个整数结果，分别表示和、差、积和商，每输出一个结果换行。
输入样例：
3 4
输出样例：
7
-1
12
0
用例规模与约定：
输入的两个整数在区间[-10000, 10000]之内。
代码如下（示例）：

#include <stdio.h>
int main()
{	int A,B,Sum,Dif,Pro,Quo;
	scanf("%d %d",& A,& B);
	Sum=A+ B;
	Dif=A- B;
	Pro=A* B;
	Quo=A/ B;
	printf("%d \n%d \n%d \n%d", Sum, Dif, Pro, Quo);
}

15.题目：A+B+C

问题描述：
通过键盘输入三个整数a，b，c，求3个整数之和。
输入说明：
三个整型数据通过键盘输入，输入的数据介于-100000和100000之间，整数
之间以空格分隔。
输出说明：
输出3个数的和。
输入样例：
-6 0 39
输出样例：
33

#include <stdio.h>
int main()
{	int a,b,c,Sum;
	scanf("%d %d %d",& a,& b,& c);
	Sum=a+b+c;
	printf("%d",Sum);
}

16.题目：字符输入输出

问题描述：
通过键盘输入5个大写字母，输出其对应的小写字母，并在末尾加上“！”。
输入说明：
5 个大写字母通过键盘输入，字母之间以竖线“|”分隔。
输出说明：
输出5个大写字母对应的小写字母，之间无分隔，并在末尾加上‘！’。
输入样例：
H|E|L|L|O
输出样例：
hello!

#include <stdio.h>
int main()
{	char a,b,c,d,e;
	scanf("%c|%c|%c|%c|%c",&a, &b, &c, &d, &e);
	a+=32;	
	b+=32;
	c+=32;
	d+=32;
	e+=32;
	printf("%c%c%c%c%c!",a,b,c,d,e);
}

19.题目：实数运算

问题描述：
通过键盘输入长方体的长、宽、高，求长方体的体积V。
输入说明：
输入三个实数，分别表示长方体的长、宽、高，输入数据间用空格分隔。
输出说明：
单精度形式输出长方体体积V，保留小数点后3位，左对齐。
输入样例：
15 8.12 6.66
输出样例：
811.188

#include <stdio.h>
int main()
{	double l,s,h;
	scanf("%lf%lf%lf", &l, &s, &h);
	float V=1.0*l*s*h;
	printf("%.3f\n",V); 
 } 

20.题目：四则运算

问题描述：
输入两个整数和一个四则运算符，根据运算符计算并输出其运算结果（和、
差、积、商、余之一）。注意做整除及求余运算时，除数不能为零。
输入说明：
使用scanf()函数输入两个整数和一个运算符，格式见输入样例，数字和运算
符之间没有空格。
注意：运算符包含+（加）、-（减）、*（乘）、/（除）和%（求余）几种。
输出说明：
输出使用printf()函数，格式见输出样例。
输入样例：
5%2
输出样例：
5%2=1
用例规模与约定：
输入整数在区间[-5000, 5000]之内，且作为整除和求余运算的操作数时，保证
除数不为0。

#include<stdio.h>
int main(){
	int n1,n2,final;
	char token;
	scanf("%d%c%d", &n1,&token, &n2);
	if (token=='+'){
		final=n1+n2;
	}
	if (token=='-'){
		final=n1-n2;
	}
	if (token=='%'){
		final=n1%n2;
	}
	if (token=='/'){
		final=n1/n2;
	}
	if (token=='*'){
		final=n1*n2;
	}
	printf("%d%c%d=%d",n1,token,n2,final);
} 

21.题目：数位输出

问题描述：
输入一个5位的整数，求出其各数位数值，并按照从高位到低位的顺序输出，
如：输入12345，输出为1 2 3 4 5。
输入说明：
输入一个五位正整数。
输出说明：
按数位从高到低依次输出，各数位之间以一个空格相分隔。
输入样例：
96237
输出样例：
9 6 2 3 7

#include <stdio.h>
int main()
{	int A,a,b,c,d,e;
	scanf("%d",&A);
	a=A/10000;
	b=A/1000-10*a;
	c=A/100-100*a-10*b;
	d=A/10-1000*a-100*b-10*c;
	e=A%10;
	printf("%d %d %d %d %d ",a,b,c,d,e);
	
 } 

27.题目：阶梯电价计费

问题描述：
电价分三个档次，[0, 110]度电，每度电0.5元；(110, 210]度电，超出110部
分每度电0.55元，超过210度电，超出210部分每度电0.70元，给出一个家庭
一月用电量，请计算出应缴的电费（保留小数点后两位小数）。
输入说明：
输入数据为一个正实数，表示一月用电量
输出说明：
输出应缴电费，保留2位小数。
输入样例1
100
输出样例1
50.00
输入样例2
200
输出样例2
104.50
输入样例3
329
输出样例3
193.30
输入样例3说明：
一个月用电量329度，超出210度的部分为119度，应缴费119×0.7=83.3
元；110~210 度的部分为 100 度，应缴费100×0.55=55 元；低于 110 度的部分
为110度，应缴费110×0.5=55元。综上，合计缴费83.3+55+55=193.3元。
用例规模与约定：
一个月用电量不超过1000度。

#include<stdio.h>
int main(){
	double a,fare;
	scanf("%lf", &a);
	if (a>210){
		fare+=(a-210)*0.7;
		a=210;
	}
	if (a>110){
		fare+=(a-110)*0.55;
		a=110;
	}
	fare+=0.5*a;
	printf("%.2f",fare);
}

28.标题：计算某月天数

问题描述：
每年的1，3，5，7，8，10，12月有31天，4，6，9，11月有30天，闰年
2 月29天，其他年份2月28天，给定年份和月份求该月的天数。
输入说明：
输入由两个正整数a和b构成，a表示年份，b表示月份，a和b之间用空格
分隔。
输出说明：
根据年份和月份计算该月天数并输出。
输入样例1
2000 3
输出样例1
31
输入样例2
2001 2
输出样例2
28
样例规模与约定：
输入年份a在[1900, 2030]区间，月份b在[1, 12]区间。

#include <stdio.h>
int main(){
	int a,b,day;
	scanf("%d %d", &a, &b);
	if (b==1 || b==3 || b==5 || b==7 || b==8 || b==10 || b==12){
		day=31;
	}
	if (b==4 || b==6 || b==9 || b==11){
		day=30;
	}
	if (b==2){
		if (a%4==0 && a%100!=0 || a%400==0){
			day=29;
		}
		else {
			day=28;
		}
	}
	printf("%d",day);
}

29.标题：计算整数各位数字之和

问题描述:
假设n是一个由最多9位数字（d9, …, d1）组成的正整数。编写一个程序计
算n的各位数字之和。
输入说明:
输入数据为一个正整数n。
输出说明:
对整数n输出它的各位数字之和后换行。
输入样例:
3704
输出样例:
14

#include <stdio.h>
int main(){
	int n,S=0;
	scanf("%d",&n);
	while(n!=0){
		S+=n%10;
		n/=10;
	}
	printf("%d",S);
}

30.标题: 完数

问题描述:
请写一个程序，给出指定整数范围[a，b]内的所有完数，0 < a < b < 10000。
一个数如果恰好等于除它本身外的所有因子之和，这个数就称为"完数"。例如6
是完数，因为6=1＋2＋3。
输入说明
输入为两个整数a和b，a和b之间用空格分隔。
输出说明
输出[a，b]内的所有完数，每输出一个完数换行。
输入样例
1 10
输出样例
6
该题提供两种解法。
解法一：

#include<stdio.h>
int main(){
    unsigned int a,b;
    int sum=0;
    scanf("%d%d",&a,&b);
    for(int i=a;i<=b;i++){
        sum=i;
        for(int j=1;j<i/2+1;j++){
            if(i%j==0){
                sum-=j;
            }
        }
        if(sum==0){
            printf("%d\n",i);
        }
    }
    return 0;
}

解法二：此版答案在导入XDOJ时需使用GNU C++的方式，否则会编译错误。

#include <stdio.h>
int judge(int number){
	int i=1,S=0;
	for(i;i<number;i++){
		if (number%i==0){
			S+=i;
		} 
	}
	if (S==number){
		return 1;
	}
	else{
		return 0;
	}
}
//定义函数，判断是否为完数 
main(){
	int a,b;
	scanf("%d %d", &a, &b);
	for(a;a<=b;a++){
		if (judge(a)){
			printf("%d\n",a);
		}
	} 
	return 0;
}

31.标题: 最大公约数

问题描述:
最大公约数（GCD）指某几个整数共有因子中最大的一个，最大公约数具有
如下性质，
gcd(a,0)=a
gcd(a,1)=1
因此当两个数中有一个为0时，gcd是不为0的那个整数，
当两个整数互质时最大公约数为1。
输入两个整数a和b，求最大公约数。
输入说明：
输入为两个非负整数a和b（0<=a,b<10000）， a和b之间用空格分隔。
输出说明：
输出其最大公约数。
样例1输入
2 4
样例1输出
2
样例2输入：
12 6
样例2输出
6
样例3输入：
3 5
样例3输出
1

#include <stdio.h>
int main(){
	int a,b,c;
	scanf("%d %d", &a, &b);
	do{
		if (a == 0){
			printf("%d", b);
			break;
		} 
		if (b == 0){
			printf("%d", a);
			break;
		} 
		c=a%b;
		if (c == 0){
			printf("%d", b);
		}
		a = b;
		b = c;
	}while(c != 0);
}

32.标题:角谷定理

问题描述:
角谷定理定义如下：
对于一个大于1的整数n，如果n是偶数，则n = n / 2。如果n是奇数，则n =
3 * n +1，反复操作后，n一定为1。
例如输入22的变化过程： 22 ->11 -> 34 -> 17 -> 52 -> 26 -> 13 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1，数据变化次数为15。
输入一个大于1的整数，求经过多少次变化可得到自然数1。
输入说明
输入为一个整数n，1<n<100000。
输出说明
输出变为1需要的次数。
样例1输入
22
样例1输出
15
样例2输入
33
样例2输出
26

#include <stdio.h>
int main(){
	int n, N=0;
	scanf("%d", &n);
	while (n!=1){
		if (n%2==0){
			n/=2;
			N+=1;
		}
		else{
			n=n*3+1;
			N+=1;
		}
	}
	printf("%d", N);
	return 0;
}

33.标题:递归数列

问题描述
一个数列A定义如下
A(1)=1，
A(2)=1/(1+A(1))，
A(3)=1/(1+A(2))，
……
A(n)=1/(1+A(n-1))。
定义一个函数function用来计算数列第n项的值，函数声明如下：
double function(int n);
注意：函数声明已包含在主程序中，只需要提交自定义的函数代码。
主程序如下：
#include<stdio.h>
double function(int n);
int main()
{
int n;
scanf(“%d”,&n);
printf(“%f\n”,function(n));
return 0;
}
主函数输入说明：
输入为1个正整数n，n<=10。
主函数输出说明
function函数返回数列A第n项的值给主函数。 主函数自行完成输出。

主函数输入样例
5
主函数输出样例
0.625000

提示
所有浮点数使用双精度浮点型来运算。

double function(int n){
	double sum = 0;
	while (n != 0){
		sum = 1.0 / (sum + 1);
		n -= 1;
		if (n == 0){
			return sum;
		} 	
	}
}

35.标题：歌德巴赫猜想

问题描述：
歌德巴赫猜想：任意一个大偶数都能分解为两个素数的和。对于输入的一个正偶数，写一
个程序来验证歌德巴赫猜想。由于每个正偶数可能分解成多组素数和，仅输出分解值分别是
最小和最大素数的一组。
输入说明
输入一个正偶数n，1<n<1000。
输出说明
输出两个整数，分别表示分解出的最小和最大素数，整数之间以空格分隔。
输入样例
10
输出样例
3 7

#include <stdio.h>
#include <cmath>
int main(){
	int n,a,b,token1=0,token2=0;
	scanf("%d", &n);
	for (a=2; a<=n/2+1;a++ ){
		token1=0,token2=0;
		b=n-a;
		for (int i=2; i<sqrt(a)+1;i++){
			if (a%i==0){
				token1=1;
			}
			if (a==2 && i==2){
				token1=0;
			}
		}
		for (int i=2; i<sqrt(b)+1;i++){
			if (b%i==0){
				token2=1;
			}
			if (b==2 && i==2){
				token2=0;
			}	
		}
		if (token1==0 && token2==0){
			printf("%d %d", a, b);
			return 0;		
		}			
	}	

36.标题: 矩阵元素求和并排序

问题描述
请写一个程序，对于一个 m 行 m 列（2＜m＜20）的方阵，求其每一行、每一列及主、
辅对角线元素之和，然后按照从大到小的顺序依次输出这些值。
注：主对角线是方阵从左上角到右下角的一条斜线，辅对角线是方阵从右上角到左下角
的一条斜线。
输入说明
输入数据的第一行为一个正整数 m；
接下来为 m 行、每行 m 个整数表示方阵的元素。
输出说明
从大到小排列的一行整数，每个整数后跟一个空格，最后换行。
输入样例
4
15 8 -2 6
31 24 18 71
-3 -9 27 13
17 21 38 69
输出样例
159 145 144 135 81 60 44 32 28 27
样例说明：每行的元素之和分别为：27,144,28,145；每列的元素之和分别为：60,44,81,159；
主辅对角线元素之和分别为：135,32。这 10 个和值按照从大到小排列的顺序为：
159,145,144,135,81,60,44,32,28,27。

#include <stdio.h>
int main(){
	int a[20][20],m,total[42] = {0},i = 0,j = 0,temp;
	scanf("%d", &m);
	for (i;i < m;i++){
		for (j = 0;j < m;j++){
			scanf("%d",&a[i][j]);
		}
	}
	for (i = 0;i < m;i++){
		for (j = 0;j < m;j++){
			total[i] += a[i][j];
		}
	}
	for (j = 0;j < m;j++){
		for (i = 0;i < m;i++){
			total[m + j] += a[i][j];
		}
	}
	for (i = 0,j = 0;i < m;i++,j++){
		total[2 * m] += a[i][j];
	}
	for (i = m - 1,j = 0;i >= 0;i--,j++){
		total[2 * m + 1] += a[i][j];
	}
	for (i = 0;i < 2 * m + 1;i++){
		for (j = i + 1;j < 2 * m + 2;j++){
			if (total[i] < total[j]){
				temp = total[i];
				total[i] = total[j];
				total[j] = temp;
			}
		}
	}
	for (i = 0;i < 2 * m + 2;i++){
		printf("%d ",total[i]);
	}
}

37.标题: 按规则排序

问题描述：
给定 N 个不同的整数，要求对这 N 个整数按如下规则排序并输出。
规则一：所有的偶数排在奇数前面。
规则二：在规则一的前提下按照从大到小的顺序排序。
输入说明
数据由两行构成，第一行为整数 n（n<=100），表示待排序整数的数量。第二行是 n 个
整数，每个整数的取值区间都为[-32768~32767]，整数之间以空格间隔。
输出说明
在一行输出排好序的整数，整数之间以空格间隔。
输入样例
5
1 2 3 4 5
输出样例
4 2 5 3 1

#include <stdio.h>
int main() {
	int n, a[100], temp;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
	}
	for (int i = 0; i < n - 1; i++) {
		for (int j = i + 1; j < n; j++) {
			if (a[j] > a[i] && (a[j] + a[i]) % 2 == 0 || (a[j] % 2 == 0 && a[i] % 2 == 1)) {
				temp = a[i];
				a[i] = a[j];
				a[j] = temp;
			}
		}
	}
	for (int i = 0; i < n; i++) {
		printf("%d ", a[i]);
	}
}

38.标题：回文数

问题描述
若一个非负整数其各位数字按照正反顺序读完全相同，则称之为回文数，例如 12321。
判断输入的整数是否是回文数。若是，则输出该整数各位数字之和，否则输出 no。
输入说明
输入为一个整数 n，0<=n<1000000000。
输出说明
若该整数为回文数，则输出整数各位数字之和，否则输出 no。
输入样例 1
131
输出样例 1
5
输入样例 2
24
输出样例 2
no

#include <stdio.h>

int main() {
	int a[10], i = 0, sum = 0;
	long long n1, same, n2 = 0;
	scanf("%ld", &n1);
	same = n1;
	for (i; n1 != 0; i++) {
		a[i] = n1 % 10;
		n1 /= 10;
	}
	for (int j = 0; j < i; j++) {
		n2 = 10 * n2 + a[j];
		sum += a[j];
	}
	if (same == n2) {
		printf("%d", sum);
	} else {
		printf("no");
	}
}

39.标题：寻找马鞍点

问题描述
若一个矩阵中的某元素在其所在行最小而在其所在列最大，则该元素为矩阵的一个马鞍
点。请写一个程序，找出给定矩阵的马鞍点。
输入说明
输入数据第一行只有两个整数 m 和 n（0<m<100,0<n<100），分别表示矩阵的行数和
列数；
接下来的 m 行、每行 n 个整数表示矩阵元素（矩阵中的元素互不相同），整数之间以空
格间隔。
输出说明
在一行上输出马鞍点的行号、列号（行号和列号从 0 开始计数）及元素的值，数据之间
以空格分隔，之后换行；
若不存在马鞍点，则输出一个字符串“no”后换行。
输入样例
4 3
11 13 121
407 72 88
23 58 1
134 30 62
输出样例
1 1 72

#include <stdio.h>

int main() {
	int a[100][100], m, n, walker, flag = 1, token = 1;
	scanf("%d %d", &m, &n);
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			scanf("%d", &a[i][j]);
		}
	}
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			walker = a[i][j];
			for (int j1 = 0; j1 < n; j1++) {
				flag = 1;
				if (a[i][j1] < walker) {
					flag = 0;
					break;
				}
			}
			for (int i1 = 0; i1 < n && flag == 1; i1++) {
				if (a[i1][j] > walker) {
					flag = 0;
					break;
				}
			}
			if (flag == 1) {
				printf("%d %d %d ", i, j, a[i][j]);
				token = 0;
			}
		}
	}
	if (token) {
		printf("no");
	}
}

40.标题：等差数列

问题描述
请写一个程序，判断给定整数序列能否重组构成一个等差数列。
输入说明
输入数据由两行构成，第一行只有一个整数 n（n<100），表示整数序列长度；
第二行为 n 个整数，每个整数的取值区间都为[-32768~32767]，整数之间以空格间隔。
输出说明
对输入数据进行判断，若不能构成等差数列输出“no”，否则，输出等差数列的公差。
输入样例 1
6
23 15 4 18 35 11
输出样例 1
no
输入样例 2
5
2 6 8 4 10
输出样例 2
2
样例 2 说明：该整数序列经过重组可构成 2,4,6,8,10 的等差数列，数列公差为 2。

#include <stdio.h>

int main() {
	int n, a[100], temp, dif1, dif2;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
	}
	for (int i = 0; i < n - 1; i++) {
		for (int j = i + 1; j < n; j++) {
			if (a[j] > a[i]) {
				temp = a[i];
				a[i] = a[j];
				a[j] = temp;
			}
		}
	}
	dif1 = a[1] - a[0];
	for (int i = 0; i < n - 1 ; i++) {
		dif2 = a[i + 1] - a[i];
		if (dif1 != dif2) {
			printf("no");
			return 0;
		}
	}
	printf("%d", -1 * dif1);
	return 0;
}

41.标题：PM2.5

问题描述
给出一组PM2.5数据，按以下分级标准统计各级天气的天数，并计算出PM2.5平均值。
PM2.5 分级标准为：
一级优（0<=PM2.5<=50）
二级良（51<=PM2.5<=100为）
三级轻度污染（101<=PM2.5<=150）
四级中度污染（151<=PM2.5<=200）
五级重度污染（201<=PM2.5<=300）
六级严重污染（PM2.5>300）
输入说明
输入分为两行，
第一行是一个整数n表示天数（1<n<=100）；
第二行为n个非负整数Pi（0<=Pi<=1000），表示每天的PM2.5值，整数之间用空格分隔。
输出说明
输出两行数据，
第一行为PM2.5平均值，结果保留2位小数；
第二行依次输出一级优，二级良，三级轻度污染，四级中度污染，五级重度污染，六级严重
污染的天数，数据之间以空格分隔。
输入样例
10
50 100 120 80 200 350 400 220 180 165
输出样例
186.50
1 2 1 3 1 2

#include <stdio.h> 
int main(){
	int n,a[1000],i,S=0,output[6]={0,0,0,0,0,0};
	double N1;
	scanf("%d", &n);
	for (i=0;i<n;i++){
		scanf("%d", &a[i]);
		if (a[i]<=50){
			output[0]+=1;
		}
		else if(a[i]<=100){
			output[1]+=1;
		}
		else if(a[i]<=150){
			output[2]+=1;
		}
		else if(a[i]<=200){
			output[3]+=1;
		}
		else if(a[i]<=300){
			output[4]+=1;
		}
		else if(a[i]>300){
			output[5]+=1;
		}
		S+=a[i];
	}
	printf("%.2f\n", 1.0*S/n);
	for (i=0;i<6;i++){
		printf("%d ",output[i]);
	}
	return 0;
}

42.整除判断

问题描述
判断正整数a能否被b整数，如果不能整除，输出商和余数
输入说明
输入两个正整数a和b（0<a, b<=10000），a和b之间用空格分隔。
输出说明
如果a能被b整除，输出yes，否则在同一行输出a除以b的商和余数，商和余数之间用空格
分隔
输入样例
17 7
输出样例
2 3

#include <stdio.h>
int main()
{	int a, b, c, d;
	scanf("%d%d", &a, &b);
	c=a/ b,d=a% b;
	if (d==0)
		{printf("yes");}
	else
		{printf("%d  %d",c,d);}
 } 

43.整数分析

问题描述
给出一个整数n（0<=n<=100000000）。求出该整数的位数，以及组成该整数的所有数字中的最
大数字和最小数字。
输入说明
输入一个整数n（0<=n<=100000000）
输出说明
在一行上依次输出整数n的位数，以及组成该整数的所有数字中的最大数字和最小数字，各个
数字之间用空格分隔。
输入样例
217
输出样例
3 7 1

#include <stdio.h>
int main(){
	int n,i,maxn=0,minn=9,N=0;
	scanf("%d",&n);
	if (n==0){
		minn=0;
		N=1;
	}
	while (n!=0){
		i=n%10;
		if (maxn<i){
			maxn=i;
		}
		if (minn>i){
			minn=i;
		}
		n/=10;
		N+=1;
	} 
	printf("%d %d %d", N, maxn, minn);
	return 0;
}

也可以使用do…while 语句简化，比while更简洁，这里不再赘述。

44.斐波纳契数列素数判断

问题描述
已知一个斐波纳契数列中的数字依次为1, 1, 2, 3, 5, 8, 13, 21, 34, 55 … 。请判断该数
列中第n个数字（n从1开始计数）是不是素数。
输入说明
输入一个整数n（1<n<=40）。
输出说明
判断斐波纳契数列中的第n个数字是不是素数，如果是输出yes，否则输出该数字。
输入样例
样例1输入
6
样例2输入
4
输出样例
样例1输出
8
样例2输出
yes

#include <stdio.h>
int find(int n){
	int num1 = 1, num2 = 1, numn = 2;
	if (n == 1 || n == 2){
		return 1;
	}
	while (n != 2){
		numn = num1 + num2;
		num1 = num2;
		num2 = numn;
		n--;
	}
	return numn;
}
int judge(int numn){
	int Flag = 1;
	if (numn == 1){
		return 0;
	}
	for (int i = 2;i < numn / 2 + 1;i++){
		if (numn % i == 0){
			Flag = 0;
			break;
		}
		
	}
	return Flag;
}
int main(){
	int n;
	scanf("%d", &n);
	if (judge(find(n))){
		printf("yes");
	}
	else{
		printf("%d", find(n));
	}
	return 0;
}

45.气温波动

问题描述
最近一段时间气温波动较大。已知连续若干天的气温，请给出这几天气温的最大波动值是多少，
即在这几天中某天气温与前一天气温之差的绝对值最大是多少。
输入说明
输入数据分为两行。
第一行包含了一个整数n，表示给出了连续n天的气温值，2 ≤ n ≤ 30。
第二行包含n个整数，依次表示每天的气温，气温为-20到40之间的整数。
输出说明
输出一个整数，表示气温在这n天中的最大波动值。
输入样例
6
2 5 5 7-3 5
输出样例
10

#include <stdio.h>
int main(){
	int n,i=0,maxchange=0,change=0;
	scanf("%d", &n);
	int a[n];
	for (i;i<n;i++){
		scanf("%d", &a[i]);
		if (i>0){
			change=a[i]-a[i-1];
			if (change<0){
				change*=-1;
			}
			if (change>maxchange){
				maxchange=change;
			}
		}
	}
	printf("%d", maxchange);
}

这里注意使用GNU C/C++上传，否则会出现编译错误。

46.折点计数

问题描述
给定n个整数表示一个商店连续n天的销售量。如果某天之前销售量在增长，而后一天销售量减少，则称这一天为折点，反过来如果之前销售量减少而后一天销售量增长，也称这一天为折点，其他的天都不是折点。
给定n个整数a1,a2, …,an表示连续n天中每天的销售量。请计算出这些天总共有多少个折点。
输入说明
输入的第一行包含一个整数n。
第二行包含n个整数，用空格分隔，分别表示a1,a2, …,an。
3 ≤ n ≤ 100，每天的销售量是不超过1000的非负整数。为了减少歧义，输入数据保证：在这n天中相邻两天的销售量总是不同的，即ai-1≠ai。
输出说明
输出一个整数，表示折点数量。
输入样例
7
5 4 1 2 3 6 4
输出样例
2

#include <stdio.h>
int main(){
	int n,a[100],i,count=0;
	scanf("%d", &n);
	for (i=0;i<n;i++){
		a[i]=0;
		scanf("%d", &a[i]);
	}
	for (i=1;i<n-1;i++){
		if ((a[i]-a[i-1])*(a[i]-a[i+1])>0){
			count+=1;
		}
	}
	printf("%d", count);
	return 0;
}

47.冰箱温度预测

问题描述
编写一个程序，用于预测冰箱断电后经过时间t（以小时为单位）后的温度T。已知计算公式如下所示

（由于不知名问题，公式中的t显示为了方框+？，将就着看吧。）
输入说明
−20
输入两个整数h和m表示冰箱断电后经过的时间，h表示小时，m表示分钟
输出说明
输出冰箱断电后经过时间t（以小时为单位）后的温度T，保留两位小数
输入样例
2 0
输出样例
-16.0

#include <stdio.h>
int main()
{	int h, m;
	scanf("%d %d",&h,&m);
	double t=1.0*h+m/60.0,T=4*t*t/(t+2)-20;
	printf("%.2f",T);
	
}

48.除法计算器

问题描述
小明的弟弟刚开始学习除法，为了检查弟弟的计算结果是否正确，小明决定设计一个简单计算器程序来验算。
输入说明
输入数据由四个整数m，n，q，r构成，m为被除数，n为除数，q和r为小明的弟弟计算出的商和余数。整数之间用空格分隔，所有整数取值范围在（-100000~100000），n不为0。
输出说明
如果验算结果正确，输出yes，否则输出正确的商和余数
输入样例：
样例1：
10 3 3 1
样例2：
10 3 3 2
输出样例
样例1输出：
yes
样例2输出：
3 1

#include <stdio.h>
int main()
{	int m, n, q, r,c,d;
	scanf("%d %d %d %d", &m, &n, &q, &r);
	c=m/ n,d=m% n;
	if (c==q && d==r)
		{printf("yes");}
	else
		{printf("%d %d",c,d);}
}

49.完全平方数

问题描述
若一个整数n能表示成某个整数m的平方的形式，则称这个数为完全平方数。写一个程序判断
输入的整数是不是完全平方数。
输入说明
输入数据为一个整数n，0<=n<10000000。
输出说明
如果n是完全平方数，则输出构成这个完全平方数的整数m，否则输出no。
输入样例
样例1：
144
样例2：
15
输出样例
样例1输出：
12
样例2输出：
no

#include <stdio.h>
#include <cmath>
int main(){
	int n,m;
	scanf("%d", &n);
	m=sqrt(n);
	if (m*m==n){
		printf("%d", m);
	}
	else {
		printf("no");
	}
}

50.选号程序

问题描述
小明决定申请一个新的QQ号码，系统随机生成了若干个号码供他选择。小明的选号原则是：

1. 选择所有号码中各位数字之和最大的号码。
2. 如果有多个号码各位数字之和相同则选择数值最大的号码。
   请你写一个程序帮助小明选择一个QQ号码。
   输入说明
   输入数据由两行构成，第一行为一个整数n表示有n个待选号码(0<n<100)，第二行有n个正整
   数，表示各个待选的号码，每个号码长度不超过9位数。每个号码之间用空格分隔，且每个号
   码都不相同。
   输出说明
   输出根据小明的选号原则选出的号码。
   输入样例
   5
   10000 11111 22222 333 1234
   输出样例
   22222

#include <stdio.h>
int main() {
	int n;
	scanf("%d",&n);
	int num[100]={0};
	int i;
	for(i=0;i<n;i++)
	scanf("%d",&num[i]);
	int t,max,sum,target=num[0];
	for(i=0;i<n;i++)
	{
		t=num[i];
		sum=0;
		while(t!=0)
		{
			sum=sum+t%10;
			t=t/10;
		}
		if(max<sum)
		{
			max=sum;
			target=num[i];
		}
		else if(max==sum)
		{
			if(target<num[i])
			{
				target=num[i];
			}
		}
	}
	printf("%d",target);
	return 0;
}

50.寻找最大整数

问题描述
从键盘输入四个整数，找出其中的最大值并将其输出。
输入说明
输入4个整数，用空格分隔
输出说明
输出值最大的一个整数
输入样例
25 99-46 0
输出样例
99

#include <stdio.h>
int main(){
	int i,a[4],max=0;
	for (i=0;i<4;i++){
		scanf("%d", &a[i]);
		if (a[i]>max){
			max=a[i];
		}
	}
	printf("%d",max);
}

51.寻找最大整数

问题描述
从键盘输入四个整数，找出其中的最大值并将其输出。
输入说明
输入4个整数，用空格分隔
输出说明
输出值最大的一个整数
输入样例
25 99 -46 0
输出样例
99

#include <stdio.h>
int main(){
	int i,a[4],max=0;
	for (i=0;i<4;i++){
		scanf("%d", &a[i]);
		if (a[i]>max){
			max=a[i];
		}
	}
	printf("%d",max);
}

52.字符处理

问题描述
从键盘输入一个字符，若为小写字母，则输出其对应的大写字母；若为大写字母，则输出对应的小写字母；其他字符原样输出。
输入说明
输入一个字符
输出说明
输出一个字符
输入样例
样例1输入
a
样例2输入
B
样例3输入
2
输出样例
样例1输出
A
样例2输出
b
样例3输出
2

#include <stdio.h>
int main()
{	char A;
	scanf("%c",&A);
	if (A>64 && A<91){
		A+=32;
	}
	else if (A>96 && A<122){
		A-=32;
	}
	printf("%c",A);
}

53.成绩分级

问题描述
给出一个百分制的成绩，要求输出成绩等级’A’,‘B’,‘C’,‘D’,‘E’。90分以上为’A’，80-89分为’B’,70-79 分为’C’,60~69 分为’D’，60 分以下为’E’。
输入说明
输入一个正整数m（0<=m<=100）
输出说明
输出一个字符
输入样例
59
输出样例
E

#include <stdio.h>
int main(){
	int m;
	scanf("%d", &m);
	if (m>89){
		printf("A");
	}
	else if (m>79){
		printf("B");
	}
	else if (m>69){
		printf("C");
	}
	else if (m>59){
		printf("D");
	}
	else {
		printf("E");
	}
}

54.abc组合

问题描述
已知abc+cba=n，其中a,b,c均为一位数，1000<n<2000,编程求出满足条件的a,b,c所有组合。
输入说明
一个整数n
输出说明
按照整数a,b,c从小到大的顺序，输出a,b,c,用空格分隔，每输出一组a,b,c后换行
输入样例
1352
输出样例
3 7 9
4 7 8
5 7 7
6 7 6
7 7 5
8 7 4
9 7 3

#include<stdio.h>
int main(){
    int n,a,b,c,i;
    scanf("%d", &n);
    for(i=1;i<1000;i++){
        a=i%10;
        b=(i/10)%10;
        c=(i/100)%10;
        if(i+a*100+b*10+c==n){
            printf("%d %d %d\n",c,b,a);
        }
    }
    return 0;
}

55.数列求和

问题描述
有一分数序列：
2/1,3/2,5/3,8/5,13/8,21/13,…An/Bn
A1=2，A2=3，An=An-1+An-2；
B1=1，B2=2，Bn=Bn-1+Bn-2。
求出这个数列的前n(2<=n<=30)项之和。
输入说明
一个整数n
输出说明
输出一个实数表示数列前n项之和，结果保留2位小数（四舍五入）
输入样例
2
输出样例
3.50

问题描述
有一分数序列：
2/1,3/2,5/3,8/5,13/8,21/13,......An/Bn
 A1=2，A2=3，An=An-1+An-2；
B1=1，B2=2，Bn=Bn-1+Bn-2。
求出这个数列的前n(2<=n<=30)项之和。
输入说明
一个整数n
输出说明
输出一个实数表示数列前n项之和，结果保留2位小数（四舍五入）
输入样例
2
输出样例
3.50
*/
#include <stdio.h>
int main(){
	int n,An[30] = {2,3},Bn[30] = {1,2};
	scanf("%d", &n);
	double sum = 0;
	for (int i = 2;i < n;i++){
		An[i] = An[i-2] + An[i-1];
	}
	for (int i = 2;i < n;i++){
		Bn[i] = Bn[i-2] + Bn[i-1];
	}
	for (int i = 0;i < n;i++){
		sum += 1.0 * An[i] / Bn[i];
	}	
	printf("%.2f",sum);
}

56.直角三角形

问题描述
设直角三角形两条直角边长度为a和b，斜边长度为c，则a，b，c满足a^2+b2=c^2，
输入三个整数a，b，c，判断对应的三角形是不是直角三角形，不是则输出“no”，是则输出其
面积的2倍。
输入说明
数据由同一行的三个整数a，b，c构成，整数之间以空格分隔
输出说明
如果输入的三个整数可以构成一个直角三角形，则输出一个整数表示该三角形面积的2倍；否
则输出“no”
输入样例
样例1输入
1 1 2
样例2输入
3 4 5
输出样例
样例1输出
no
样例2输出
12

#include <stdio.h>
int main(){
	int a,b,c;
	scanf("%d %d %d", &a, &b, &c);
	if (c*c==a*a+b*b){
		printf("%d", a*b);
	}
	else {
		printf("no");
	}
}

57.Fibonacci数列

问题描述
有一种形式的Fibonacci数列定义如下：
F(0)=7
F(1)=11
F(n)=F(n-1)+F(n-2)（n>=2）
按以下声明写一个函数fib
int fib(int n);
fib函数用来计算参数n对应的F(n)。
fib(n)的返回值是F(n)
输入说明
函数参数为一个整数n（0<=n<40）。
输出说明
函数返回值为整数，表示n对应的F(n)值。
输入样例
2
输出样例
18
*/

#include <stdio.h>
int fib(int n){
	int a[41] = {7,11},i = 2;
	if (n == 0){
		return 7;
	}
	if (n == 1){
		return 11;
	}
	for (i;i <= n;i++){
		a[i] = a[i-1]+a[i-2];	
	}
	return a[i-1];
}
int main(){
	int n;
	scanf("%d", &n);
	printf("%d", fib(n));
}

63.工资计算

问题描述
小明的公司每个月给小明发工资，而小明拿到的工资为交完个人所得税之后的工资。假
设他一个月的税前工资为S元，则他应交的个人所得税按如下公式计算：
1） 个人所得税起征点为3500元，若S不超过3500，则不交税，3500元以上的部分才
计算个人所得税，令A=S-3500元；
2） A中不超过1500元的部分，税率3%；
3） A中超过1500元未超过4500元的部分，税率10%；
4） A中超过4500元未超过9000元的部分，税率20%；
5） A中超过9000元未超过35000元的部分，税率25%；
6） A中超过35000元的部分，税率30%；
例如，如果小明的税前工资为10000元，则A=10000-3500=6500元，其中不超过1500
元部分应缴税1500×3%=45 元，超过 1500 元不超过4500 元部分应缴税(4500-1500)×
10%=300 元，超过4500元部分应缴税(6500-4500)×20%=400元。总共缴税745元，税后所
得为9255元。
已知小明这个月税前所得为S元，请问他的税后工资T是多少元。
输入格式
输入为一个整数S，表示小明的税前工资。所有评测数据保证小明的税前工资为一个整
百的数。
输出格式
输出一个整数T，表示小明的税后工资。
样例输入
10000
样例输出
9255
评测用例规模与约定
对于所有评测用例，1 ≤ T ≤ 100000

#include <stdio.h>
int main(){
	int T,S,A;
	scanf("%d", &S);
	T=S;
	A=S-3500;
	if (A>35000){
		T-=(A-35000)*0.3;
		A=35000;
	}
	if (A<=35000 && A>9000){
		T-=(A-9000)*0.25;
		A=9000;
	}
	if (A<=9000 && A>4500){
		T-=(A-4500)*0.2;
		A=4500;
	}
	if (A<=4500 && A>1500){
		T-=(A-1500)*0.1;
		A=1500;
	}
	if (A>0){
		T-=A*0.03;
	}
	printf("%d", T);
}

64.自然数分解

问题描述
任何一个自然数m的立方均可写成m个连续奇数之和。例如：
13=1
23=3+5
33=7+9+11
43=13+15+17+19
编程实现：输入一自然数n，求组成n3的n个连续奇数。
输入说明
一个正整数n，0<n<30。
输出说明
输出n个连续奇数，数据之间用空格隔开，并换行
输入样例
4
输出样例
13 15 17 19

#include<stdio.h>
int main(){
    int n;
    scanf("%d",&n);
    int i=(n*n-n+1);
    for(i;i<=(n*n+n-1);i+=2){
        printf("%d ",i);
    }
    return 0;
}

65.数字处理

问题描述
编写一个程序，从键盘输入一个非零整数n（0 < n <= 1000000000），对整数n进行如下处理：
将整数的各位数字取出来相加，如果结果是一位数则输出该数，否则重复上述过程，直到得到
的结果为一位数，并输出该结果。
例如：n=456，变换过程如下
4+5+6=15
1+5=6
输出结果为6
输入说明
一个非零整数n。
输出说明
输出整数n的处理结果。
输入样例
456
输出样例
6

#include <stdio.h>
int getsum(int n){
	int sum = 0;
	while (n != 0){
		sum += n % 10;
		n /= 10;
	}
	return sum;
}
int main(){
	int n,sum;
	scanf("%d", &n);
	sum = n;
	while (1){
		sum = getsum(sum);
		if (sum < 10){
			printf("%d", sum);
			break;
		}
	}
}

66.平均数

问题描述
计算n个整数（x1,x2,x3…）的平均数，结果保留两位小数。
输入说明
第一行为整数n（1 <= n <=100），接下来是n个整数(0 <= x1,x2,x3…<= 2^31- 1)。
输出说明
输出这n个整数的平均数，结果保留两位小数。
输入样例
5
2 3 1 4 5
输出样例
3.00

#include <stdio.h>
int main(){
	int n,i;
	double S=0.00;
	scanf("%d", &n);
	int a[n];
	for (i=0;i<n;i++){
		scanf("%d", &a[i]);
		S+=a[i];
	}
	S=1.0*S/n;
	printf("%.2f", S);
}

67.查找

#include <stdio.h>

int main() {
	int n, a[100], b[100], k, j = 0, flag = 0;
	scanf("%d %d", &n, &k);
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
	}
	for (int i = 0 ; i < n; i++) {
		if (a[i] == k) {
			b[j] = i;
			flag = 1;
			j++;
		}
	}
	if (flag) {
		for (int i = 0; i < j; i++) {
			printf("%d ", b[i]);
		}
	} else {
		printf("-1");
	}
}

68.日期计算

问题描述
给定一个年份y和一个整数d，问这一年的第d天是几月几日？
注意闰年的2月有29天，且满足下面条件之一的是闰年：
1） 年份是4的整数倍，而且不是100的整数倍；
2） 年份是400的整数倍
输入说明
输入包含两个整数y和d，y表示年份，年份在1900到2018之间（包含1900和2018）。 d表
示这一年的第几天，d在1至365之间。
输出说明
在一行输出两个整数，分别表示答案的月份和日期。
输入样例
2015 80
输出样例
3 21

#include <stdio.h>
int main(){
	int i,y,d,month[12]={31,28,31,30,31,30,31,31,30,31,30,31};
	scanf("%d %d", &y, &d);
	if (y%4==0 && y%100!=0 || y%400==0){
		month[1]=29;
	}
	for (i=0;d>month[i];i++){
		if (d>month[i]){
			d-=month[i];
		}
	}
	printf("%d %d",i+1,d);
}

69.0-1矩阵

#include <stdio.h>

int main() {
	int m, n, a[100][100], b[100] = {0}, c[100] = {0}, d[100] = {0};
	scanf("%d %d", &m, &n);
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			scanf("%d", &a[i][j]);
		}
	}//输入数组
	for (int i = 0;i < m;i++){
		int count = 0, token = 0;
		for (int j = 0;j < n;j++){
			if (a[i][j] == 1){
				count++;
				token = 1;
			}
			else {
				if (count > d[i]){
					d[i] = count;
					c[i] = j - 1;//记录末尾的序号，则首项的序号便为c[i] - count + 1
					b[i] = c[i] - count + 1;//记录首项的序号 				
				}
				count = 0;//遇见0则归零 
			}
			if (a[i][j] == 1 && j == n - 1){
				if (count > d[i]){
					c[i] = j;//记录末尾的序号，则首项的序号便为c[i] - count + 1
					b[i] = c[i] - count + 1;//记录首项的序号 				
				}
			}
		}
			if (token == 0){
				printf("-1 -1\n");
			}
			else {
				printf("%d %d\n", b[i], c[i]);
			}
	} 
}

70.Z字形扫描

#include<stdio.h>
int main(){
    int n, count, i, j;//i为行，j为列，num为斜线数，count为当前斜线序号 
    scanf("%d", &n);
    int num = 2 * n - 1;
    int a[100][100];
    for(i = 0;i < 100;i++){
        for(j = 0;j < 100;j++){
            a[i][j] = 1001;//将数组内所有元素设为1001，便于后续判断越界。 
        }
    }
    for(i = 0;i < n;i++){
        for(j = 0;j < n;j++){
            scanf("%d", &a[i][j]);
        }
    }
    //输入数组
    for(count = 1;count <= num;count++){
        if(count % 2 == 0){//序号为偶数，斜线从i=0开始，从右上到左下
            for(i = 0;count - 1 - i != -1;i++){
                if(a[i][count - 1 - i] != 1001){//越界元素为1001
                    printf("%d ",a[i][count - 1 - i]);
                }
            }
        }
		else{//序号为奇数，斜线从j=0开始，从左下到右上
            for(j = 0;count - 1 - j != -1;j++){
                if(a[count - 1 - j][j] != 1001){//越界元素为1001
                    printf("%d ",a[count - 1 - j][j]);
                }
            }
        }
    }
    //利用每条斜线上的每一格，i + j = count - 1 ，实现斜线上的跑动 
    return 0;
}

71.相邻区域

输入样例 ：
6 8 8 5
1 1 2 2 2 3 3 4
1 1 2 2 2 3 3 4
1 1 2 2 2 3 3 4
1 1 5 5 5 5 5 6
1 1 5 5 5 5 5 6
7 7 7 7 7 8 8 8
输出样例
6

一道五星题，然而难度其实并没有多大。
这里笔者采用对输入的区域上下左右一行的元素进行统计的方法，上下左右四段检测代码几乎相同。

#include <stdio.h>
int main(){
	int n, m, t, k;//n为行数,m为列数,t为区域数,k为编号
	int nums[21][21] = {0}, next[49] = {-1}, a[2][400] = {0};
	//next存储相邻的区域的编号,count记录相邻区域数量,a记录输入。 
	scanf("%d %d %d %d", &n, &m, &t, &k);
	for (int i = 1;i <= n;i++){
		for (int j = 1;j <= m;j++){
			scanf("%d", &nums[i][j]);
		}//留出第一行、第一列，防止越界 
	}//输入数组
	int flag = 1;
	int n1 = 0, m1 = 0;//记录所要区域起始位置 
	int n2 = 0, m2 = 0;//记录终止位置 
	for (int i = 1;i < n + 1;i++){
		for (int j = 1;j < m + 1;j++){
			if (nums[i][j] == k && flag){
				n1 = i - 1, m1 = j - 1; 
				flag = 0;
			}
			if (nums[i][j] == k){
				n2 = i + 1, m2 = j + 1;
			}
		}
	}
	int sum = 0, runner = 0;
	for (int i = n1 + 1;i < n2;i++){
		flag = 1;
		for (int t = 0;next[t] != 0;t++){
			if (nums[i][m1] == next[t] || nums[i][m1] == 0){
				flag = 0;
				break;
			}
		}
		if (flag){	
			next[runner] = nums[i][m1];
			runner++;
			sum++;
		}		
	}//检测左边界 
	for (int i = n1 + 1;i < n2;i++){	
		flag = 1;
		for (int t = 0;next[t] != 0;t++){
			if (nums[i][m2] == next[t] || nums[i][m2] == 0){
				flag = 0;
				break;
			}
		}
		if (flag){	
			next[runner] = nums[i][m2];
			runner++;
			sum++;
		}		
	}//检测右边界 
	for (int j = m1 + 1;j < m2;j++){
		flag = 1;
		for (int t = 0;next[t] != 0;t++){
			if (nums[n1][j] == next[t] || nums[n1][j] == 0){
				flag = 0;
				break;
			}
		}	
		if (flag){
			next[runner] = nums[n1][j];
			runner++;
			sum++;
		}
	}//检测上边界 
	for (int j = m1 + 1;j < m2;j++){
		flag = 1; 
		for (int t = 0;next[t] != 0;t++){
			if (nums[n2][j] == next[t] || nums[n2][j] == 0){
				flag = 0;
				break;
			}
		}	
		if (flag){
			next[runner] = nums[n2][j];
			runner++;
			sum++;
		}	
	}//检测下边界 
	printf("%d", sum);
}

75.灰度直方图

#include <stdio.h>

int main() {
	int m, n, num[256][256], out[16][2] = {0}, count = 0;
	scanf("%d %d", &m, &n);
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			scanf("%d", &num[i][j]);
		}
	}//输入数组
	for (int i = 0; i < 16; i++) {
		out[i][0] = i;
	}//将输出的数组第一位初始化
	for (int n1 = 0; n1 <= 15; n1++) {
		count = 0;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (num[i][j] == n1) {
					count++;
				}
			}
		}
		out[n1][1] = count;
	}//统计个数
	for (int i = 0; i < 16; i++) {
		if (out[i][1] != 0) {
			printf("%d %d\n", out[i][0], out[i][1]);
		}
	}//输出
}

76.统计正整数的个数

问题描述
统计n 个正整数中每个数出现的次数。
输入说明
第一行是一个整数n（5<n<30），表示要待统计整数的个数；
第二行是n 个整数，每个整数均小于100000
输出说明
按照整数从小到大的顺序依次输出不同的整数及其出现次数，整数和出现次数之间用冒号（:）
分隔。
输入样例
12
19 223 35 321 2 33 44 223 2 19 2 19
输出样例
2:3
19:3
33:1
35:1
44:1
223:2
321:1

#include <stdio.h>

int main() {
	int num1[30], num2[30][2], n, temp, runner = 1, count;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &num1[i]);
	}//输入数组
	for (int i = 0; i < n - 1; i++) {
		for (int j = i + 1; j < n; j++) {
			if (num1[i] > num1[j]) {
				temp = num1[i];
				num1[i] = num1[j];
				num1[j] = temp;
			}
		}
	}
	//大小排序
	num2[0][0] = num1[0];
	for (int i = 1; i < n; i++) {
		if (num1[i] > num1[i - 1]) {
			num2[runner][0] = num1[i];
			runner++;
		}
	}//记录不同的值
	for (int i = 0; i < runner; i++) {
		count = 0;
		for (int j = 0; j < n; j++) {
			if (num2[i][0] == num1[j]) {
				count++;
			}
		}
		num2[i][1] = count;
	}
	for (int i = 0; i < runner; i++) {
		printf("%d:%d\n", num2[i][0], num2[i][1]);
	}
}

79.计算平均值

题目描述：
输入三个整数，编程计算它们的平均值，结果保留两位小数。
输入说明：
在一行上输入三个整数，整数之间用空格分隔。
输出说明：
在一行上输出所输入三个整数的平均值，结果保留两位小数。
输入样例：
20 42 55
输出样例：
39.00

#include <stdio.h>
int main()
{	int a,b,c;
	scanf("%d%d%d", &a, &b, &c); 
	double d=(a+b+c)/3.0;
	printf("%.2f",d);
}

83.图像旋转

#include <stdio.h>

int main() {
	int n, m, num1[100][100], num2[100][100];//m为行，n为列
	scanf("%d %d", &m, &n);
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			scanf("%d", &num1[i][j]);
		}
	}//输入数组
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			num2[i][j] = num1[m - 1 - j][i];
		}
	}
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			printf("%d ", num2[i][j]);
		}
		printf("\n");
	}
}

86.画图

#include <stdio.h>

void draw(int square[101][101], int x1, int y1, int x2, int y2) {
	for (int x = x1; x < x2; x++) {
		for (int y = y1; y < y2; y++) {
			if (square[x][y] == 0) {
				square[x][y] = 1;
			}
		}
	}
}

int main() {
	int n;
	scanf("%d", &n);
	int x1, y1, x2, y2;
	int square[101][101] = {0};
	int maxx = 0, maxy = 0;
	int count = 0;
	for (int i = 0; i < n; i++) {
		scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
		draw(square, x1, y1, x2, y2);
		if (maxx < x2) {
			maxx = x2;
		}
		if (maxy < y2) {
			maxy = y2;
		}
	}
	for (int i = 0; i <= maxx; i++) {
		for (int j = 0; j <= maxy; j++) {
			if (square[i][j] != 0) {
				count++;
			}
		}
	}
	printf("%d", count);
}

87.跳一跳

问题描述
跳一跳是一款微信小游戏，游戏规则非常简单，只需玩家要从一个方块跳到下一
个方块，如果未能成功跳到下一个方块则游戏结束。
计分规则如下：

1. 如果成功跳到下一个方块上，但未跳到方块中心，加1分；
2. 如果成功跳到下一个方块上，且刚好跳到方块中心，则第一次加 2 分，此后
   连续跳到中心时每次递增2分。也就是说，第一次跳到方块中心加2分，连续第
   二次跳到方块中心加4分，连续第三次跳到方块中心加6分，…，以此类推；
3. 如果未能成功跳到方块上，加0分，且游戏结束。
   现在给出玩家一局游戏的每次跳跃情况，请计算玩家最终得分。
   输入说明
   输入为若干个非零整数（整数个数小于1000），表示玩家每次的跳跃情况。整数
   之间用空格分隔，整数取值为0，1，2。
   0 表示未能成功跳到下一个方块上；
   1 表示成功跳到下一个方块上但未跳到方块中心；
   2 表示成功跳到下一个方块上，且刚好跳到方块中心。
   输入的数据只有最后一个整数是0，其余均非零。
   输出说明
   输出一个整数表示该玩家的最终得分。
   输入样例
   1 1 2 1 2 2 2 0
   输出样例
   17

#include <stdio.h>
int main(){
	int i=0,n=1,a[1000]={0},score=0,token=1;
	for (i;token==1;i++){
		scanf("%d", &a[i]);
		if (a[i]==1){
			score+=1;
			n=1;
		}
		else if (a[i]==2){
			score+=2*n;
			n+=1;
		}
		else if (a[i]==0){
			token=0;
		}
	}
	printf("%d", score);
} 

89.计算球体的体积

题目描述：
输入球体的半径，计算并输出球体的体积，假定pi=3.14，结果保留两位小数。
输入说明：
输入一个表示球体半径的浮点数。
输出说明：
在一行上输出球体的体积，结果保留两位小数。
输入样例：
5.50
输出样例：
696.56

#include <stdio.h>
#define pi 3.14
int main()
{	double r, V;
	scanf("%lf",&r);
	V=pi*r*r*r*4/3;
	printf("%.2f",V);
}

90.求三位整数各位数字之和

题目描述：
输入一个三位数整数，求其百位、十位和个位数字之和。
输入说明：
输入一个三位整数。
输出说明：
在一行上输出三位整数各位数字的和。
输入样例：
128
输出样例：
11

#include <stdio.h>
int main()
{	int A,a,b,c,S;
	scanf("%d",&A);
	a=A/100;
	b=A/10-10*a;
	c=A%10;
	S=a+b+c;
	printf("%d",S);
 } 

91.求三角形面积

题目描述：输入三角形的三边长，计算三角形的面积，结果保留两位小数。边长分别为a,b,c，
三角形的面积公式为s=sqrt(p(p-a)(p-b)(p-c)),其中p=(a+b+c)/2。

输入格式：共一行，输入三个数，保留两位小数，用空格隔开各个数据。

输出格式：共一行，输出面积，结果保留两位小数。

示例：
输入：3.00 4.00 5.00
输出：6.00

#include <stdio.h>
#include <cmath>
int main()
{	double a,b,c,p,S;
	scanf("%lf %lf %lf", &a, &b, &c);
	p=(a+b+c)/2.0;
	S=sqrt(p*(p-a)*(p-b)*(p-c));
	printf("%.2f", S);
}

92.工资发放

题目描述：
某公司财务要发现金工资，需要提前换取100元、50元、20元、10元、5元和
1 元的人民币，输入工资额，计算发放张数最少情况下，各面额的纸币需要多少
张。
输入说明：
输入为一个正整数，表示工资额。
输出格式：
在一行上分别输出面额为100、50、20、10、5、1元的纸币张数，用一个空格隔
开各个数据。
输入样例：
1258
输出样例：
12 1 0 0 1 3

#include <stdio.h>
int main(){
	int S, a, b, c, d, e, f;
	scanf("%d", &S);
	a=S/100;
	b=(S-100*a)/50;
	c=(S-100*a-50*b)/20;
	d=(S-100*a-50*b-20*c)/10;
	e=(S-100*a-50*b-20*c-10*d)/5;
	f=(S-100*a-50*b-20*c-10*d-5*e);
	printf("%d %d %d %d %d %d", a, b, c, d, e, f);
}

93.整数比较1

问题描述：
编写程序，对于从键盘输入的2个整数，先输出较大者的个位数字，然后输出
较小者的平方值。
输入说明：
输入两个整数，整数之间以一个空格分隔。
输出说明：
在一行上输出两个整数，整数之间以一个空格分隔，最后换行。
输入样例：
29989 372
输出样例：
9 138384

#include<stdio.h>
int main(){
    int a,b;
    scanf("%d%d",&a,&b);
    printf("%d %d",a>b?(a%10):(b%10),a>b?(b*b):(a*a));
    return 0;
}

94.整数排序

问题描述：
从键盘输入四个整数，要求按由小到大的顺序输出。
输入说明：
输入四个整数，以空格间隔。
输出说明：
输出四个整数的排序结果，整数之间以一个空格间隔。
输入样例： -99 9 99 -9
输出样例： -99 -9 9 99

#include <stdio.h>
int main(){
	int a[4],i,temp;
	for (i=0;i<4;i++){
		scanf("%d", &a[i]);
	}
	for (i=0;i<4;i++){
		for (int j=0;j<4;j++){
			if (a[i]<a[j]){
				temp=a[i];
				a[i]=a[j];
				a[j]=temp; 
			}
		}
	}
	for (i=0;i<4;i++){
		printf("%d ", a[i]);
	}
}

97.输出26个英文字母

问题描述：
编写一个程序，分别按正向和逆向输出小写字母。
输入说明：
无。
输出说明：
字母间以一个空格分隔，正向输出完换行，再逆向输出。
输入样例
无。
输出样例
无。

#include<stdio.h>
int main(){
    for(int i=97;i<=122;i++){
        printf("%c ",i);
    }
    printf("\n");
    for(int i=122;i>=97;i--){
        printf("%c ",i);
    }
    return 0;
}

98.题目：简单程序

问题描述
按输入n的不同情况，输出不同的特定文字。当n为2的倍数，且不是3、5的倍数时，
输出"Nice"；当 n 为3的倍数，且不是2、5的倍数时，输出"Good"；当n为5的倍数，且
不是2、3的倍数时，输出"Best"；其他情况，输出"Bad"。
输入格式
输入一个正整数n（n为自然数，且n≤10,000）。
输出格式
输出特定文字。
样例输入1：
9
样例输入2：
16
样例输入3：
130
样例输出1：
Good
样例输出2：
Nice
样例输出3：
Bad
样例说明
n 为自然数，且不大于10,000。
评测用例规模与约定
n 可以是2、3、5的整数倍，也可以不是。

int main()
{	int n;
	scanf("%d", &n);
	if (n%2==0 && n%3!=0 && n%5!=0)
		{printf("Nice");}
	else if(n%2!=0 && n%3==0 && n%5!=0)
		{printf("Good");}
	else if(n%2!=0 && n%3!=0 && n%5==0)
		{printf("Best");}
	else
		{printf("Bad");}
}

110.判断奇偶性

题目描述：
编写程序，输入一个正整数，判断该数的奇偶性，输出判断的结果(偶数/奇数)。
输入说明：
输入一个正整数。
输出说明：
输出“偶数”或“奇数”。
输入样例：
5
输出样例：
奇数

#include <stdio.h>
int main()
{	int n;
	scanf("%d",&n);
	if (n%2==0)
		{printf("偶数");}
	else
		{printf("奇数");}
}

111.整除判断2

题目描述：
编写程序，输入一个正整数，判断是否能被5和7同时整除，若可以，则输出yes；否则输出no。
输入格式：
输入一个正整数。
输出格式：
输出“yes”或“no”。
示例:
输入：35
输出：yes

#include <stdio.h>
int main(){
	int a;
	scanf("%d", &a);
	if(a%5==0 && a%7==0)
		{printf("yes");}
	else
		{printf("no");}
	return 0;
}

112.分段函数1

#include<stdio.h>
#include<math.h>
int main(){
    double x;
    scanf("%lf",&x);
    printf("%.2f",x>=0?sqrt(x):(pow(x+1,2)+2*x+1/x));
    return 0;
}

113.出租车计价

题目描述：
编写程序，根据某城市普通出租车收费标准进行车费计算。标准如下：
（1）起步里程为3公里，起步费10元；
（2）超出起步里程后在10公里（含）内，每公里2元；
（3）超过10公里以上的部分加收50%的回空补贴费，即每公里3元； 营运过程中，因路阻及乘客要求临时停车等待的，按每5分钟2元计费(不足5 分钟不收费)。
输入说明：
输入一个浮点数和一个整数，表示行驶里程（单位为公里，精确到小数点后1位）与等待时间（整数，单位为分钟），其间以空格分隔
输出说明：
在一行中输出乘客应支付的车费（单位为元），结果四舍五入保留整数。
输入样例：
40.0 7
输出样例:
116

#include <stdio.h>
int main()
{	double X,Y=10.0;
	int T;
	scanf("%lf %d", &X, &T);
	if (X>3 ){
		Y+=2*(X-3);
	}
	if(X>10){
		Y+=(X-10);
	}
	Y+=2*(T/5);
	printf("%.0f",Y);
}

116.阶梯电价计费

问题描述：
电价分三个档次，[0,110]度电，每度电0.5元；(110,210]度电，超出110度但不
超过210度的部分，每度电0.55元；超过210度电的部分每度电0.70元。给出
一个家庭一月用电量，请计算出应缴的电费（四舍五入，保留小数点后两位小数）。
输入说明：
输入数据为一个正实数，表示一个月的用电量。
输出说明：
输出应缴电费，保留2位小数。
输入样例1
100
输出样例1
50.00
输入样例2
200
输出样例2
104.50
输入样例3
329.75
输出样例3
193.83

#include<stdio.h>
int main(){
	double a,fare;
	scanf("%lf", &a);
	if (a>210){
		fare+=(a-210)*0.7;
		a=210;
	}
	if (a>110){
		fare+=(a-110)*0.55;
		a=110;
	}
	fare+=0.5*a;
	printf("%.2f",fare);
}

125.利率计算

问题描述：
假如我国国民生产总值的年增长率为9%，计算10年后我国国民总值与现在相比增长多少百分比。计算公式为

r 为增长率，n为年数，p为与现在相比的倍数。
输入说明：
输入两个浮点数，分别表示年增长率和年份数，两个浮点数之间用空格分隔。
输出说明：
输出一个浮点数，表示与现在相比的倍数，小数点后保留2位小数。
输入样例：
0.09 10
输出样例：
2.37

#include <stdio.h>
int main()
{	double r,n,p=1.0;
	scanf("%lf %lf", &r, &n);
	for (int i=0; i<n; i++){
		p*=(1+r);
	}
	printf("%.2f", p);
}

126.购房贷款计算

问题描述：
购房从银行贷了一笔款 d,准备每月还款额为 P，月利率为 r,计算多少月能还清。（设d为300000元， p为6000元，r为1%，对求得的月份取小数点后一位，对第2位按四舍五入处理）
提示：计算还清月数m的公式如下：

也可以将公式改写为：
输入说明：

输入三个浮点数，分别表示贷款额，每月还款额与月利率，三个浮点数之间用空格分隔。
输出说明：
输出以个浮点数，表示还清贷款的月数，小数点后保留2位小数。
输入样例：
300000 6000 0.01
输出样例：
69.66

#include <stdio.h>
#include <cmath>
int main()
{	double d,P,r,m;
	scanf("%lf%lf%lf", &d, &P, &r);
	m=(log(P/(P-d*r))/log(1+r));     
	printf("%.2f",m);
}

147.求奇数的和

题目描述：计算给定一组整数中奇数的和，直到遇到0时结束。
输入格式：共一行，输入一组整数，以空格分隔
输出格式：输出一个整数
示例：
输入：1 2 3 4 5 0 6 7
输出：9

#include<stdio.h>
int main(){
    int a,b;
    int sum=0;
    scanf("%d ",&a);
    while(a!=0){
        if(a%2!=0){
            sum=sum+a;
        }
        scanf("%d ",&a);
    }
    printf("%d",sum);
    return 0;
}

149.求交错序列前N项和

题目描述：编写程序，计算交错序列1-2/3+3/5-4/7+5/9-6/11+…的前N项之和。
输入格式：输入一个正整数
输出格式：输出计算结果，结果保留三位小数
示例：
输入：5
输出：0.917

#include <stdio.h>
int main(){
	int i=0,n,an=1,bn=1;
	double S=0;
	scanf("%d", &n);
	for (i;i<n;i++){
		if (i%2==0){
			S+=1.0*an/bn;
		}
		else {
			S-=1.0*an/bn;
		}
		an+=1;
		bn+=2;
	}
	printf("%.3f", S);
}

150.分段函数

#include <stdio.h>
int main(){
	int x;
	scanf("%d", &x);
	if (x<10 && x>=1){
		x=2*x-1;
	}
	else if (x>=10){
		x=3*x-11;
	}
	printf("%d", x);
}

177.累加和校验

问题描述
数据传输中一种常见的校验方式是累加和校验。其实现方式是在一次通讯数据包的最后加入一个字节的校验数据。
这个校验字节内容为前面数据包中所有数据按字节累加所得结果的最后一个字节。例如：
要传输的信息为： TEST（ASCII码为0x54,0x45,0x53,0x54）
四个字节的累加和为：0x54+0x45+0x53+0x54=0x140
校验和为累加和的最后一个字节，即0x40，也就是十进制的64
现在请设计一个程序计算给出的待传输信息的累加校验和
输入说明
输入为一个字符串，字符串长度不超过100个字符
输出说明
输出一个十进制整数，表示输入字符串的累加校验和。
输入样例
TEST
输出样例
64

#include <stdio.h>
#include <string.h>
int main(){
	int sum=0;
	char string[101]={'\0'};//将字符数组每一位初始化为空
	gets(string);//scanf不能接收空格，故使用gets
	for (int i=0;string[i]!='\0';i++){
		sum+=(int)string[i];
	}
	printf("%d",sum&255);//一个字节是2位16进制，则一个字节最大能存储的十进制为255
	/*此处按位与运算——对参与运算的两个数据的二进制位进行"与"运算。
	只有两位同时为1时，结果才为1，否则结果为0。
	例如：3 & 5 即 0000 0011 & 0000 0101 = 0000 0001，因此 3 & 5 的值为1。
	因为255的二进制为1111 1111，&255可将十进制的sum二进制中最后一个字节取出。
	*/
}

185.迭代法求根

#include <stdio.h>
int main(){
	double a,x1,x2=1.0;
	scanf("%lf", &a);
	for(;;){
		x1=x2;
		x2=(x1+a/x1)/2;
		if ((x2-x1)<0.00001 && (x2-x1)>-0.00001){
			printf("%.5f", x2);
			break;
		}
	}
} 

200.数组元素平移

题目描述：
已知数组array[10]={1,2,3,4,5,6,7,8,9,10};要求把下标从0到p（p从键盘输入）的数组元素平移到数组的最后，并输出平移后的数组。

输入格式：输入一个整数p；
输出格式：共一行，输出平移后的数组，数字之间用空格分隔

示例：
输入：3
输出：5 6 7 8 9 10 1 2 3 4

#include <stdio.h>

int main() {
	int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	int p;
	scanf("%d", &p);
	int out[10];
	for (int i = p + 1; i < 10; i++) {
		out[i - 1 - p] = array[i];
	}
	for (int i = 0; i <= p; i++) {
		out[10 - p - 1 + i] = array[i];
	}
	for (int i = 0; i < 10; i++) {
		printf("%d ", out[i]);
	}
}

219.题目:素数判断

问题描述：
写一个判断素数的函数，在主函数输入一个整数，输入是否为素数的信息。
输入说明：
输入一个（n>=2）的数字。
输出说明：
判断该数字是否为素数。
输入样例
3
输出样例：
YES

该题没说不是素数会怎样，大胆猜测输出NO

#include <stdio.h> 
int judge(int numn){
	int Flag = 1;
	if (numn == 1){
		return 0;
	}
	for (int i = 2;i < numn / 2 + 1;i++){
		if (numn % i == 0){
			Flag = 0;
			break;
		}		
	}
	return Flag;
}
int main(){
	int n;
	scanf("%d", &n);
	if (judge(n)){
		printf("YES");
	}
	else{
		printf("NO");
	}
	return 0;
}

221.题目：字符串元素统计

问题描述：
编写一个函数，由实参传来一个字符串，统计字符串中字母，数字的个数，在主函数中输入字符及输出上述结果。
输入说明：
随机输入一个字符串。
输出说明：
依次输出该字符串中字母，数字的个数。
输入样例
abc123
输出样例：
3,3
*/

#include <stdio.h>
#include <ctype.h>  //取得isalpha,isdigit来判断是否为字母，数字
int main(){
	char a[1000];
	int sum1 = 0,sum2 = 0;
	gets(a);
	for (int i = 0;i < 1000;i++){
		if (isalpha(a[i])){
			sum1++;
		}
		if (isdigit(a[i])){
			sum2++;
		}
		if (!(isalpha(a[i]) || isdigit(a[i]))){
			break;
		}
	}
	printf("%d,%d",sum1,sum2);
} 

223.对角线元素求和

1.求一个3×3的整形矩阵对角线元素之和

输入说明：输入3×3的整形矩阵，数据之间用空格分隔

输出说明：输出一个整数，即对角线的和

输入样例：1 2 3
4 5 6
7 8 9

输出样例：15

#include <stdio.h>

int main() {
	int num[3][3], sum = 0;
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 3; j++) {
			scanf("%d", &num[i][j]);
		}
	}
	for (int i = 0; i < 3; i++) {
		sum += num[i][i];
	}
	printf("%d", sum);
}

224.2、矩阵相乘

输入2×3矩阵A和3×2矩阵B各元素值，计算矩阵A和矩阵B相乘的结果

输入说明：输入整形数组A和数组B,数组元素用空格分隔

输出说明：输出矩阵A*B的结果，矩阵元素之间用空格分隔，数组每行元素用换行分隔

输入样例：
1 2 3
4 5 6
1 2
3 4
5 6

输出样例
22 28
49 64

#include <stdio.h>

int main() {
	int a[2][3];
	int b[3][2];
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 3; j++) {
			scanf("%d", &a[i][j]);
		}
	}
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 2; j++) {
			scanf("%d", &b[i][j]);
		}
	}
	int c1 = a[0][0] * b[0][0] + a[0][1] * b[1][0] + a[0][2] * b[2][0];
	int c2 = a[0][0] * b[0][1] + a[0][1] * b[1][1] + a[0][2] * b[2][1];
	int c3 = a[1][0] * b[0][0] + a[1][1] * b[1][0] + a[1][2] * b[2][0];
	int c4 = a[1][0] * b[0][1] + a[1][1] * b[1][1] + a[1][2] * b[2][1];
	printf("%d %d\n%d %d", c1, c2, c3, c4);
	return 0;
}

225.矩阵计算

编写程序，把3*3阶矩阵A加上矩阵A的转置，计算结果存放在矩阵B中并输出。

输入说明：输入矩阵A中的元素，数组元素用空格分隔，数组每行用换行分隔

输出说明：输出矩阵B，元素之间用空格分隔，数组每行用换行分隔

输入示例：
1 2 3
4 5 6
7 8 9

输出示例：
2 6 10
6 10 14
10 14 18

#include <stdio.h>

int main() {
	int a[3][3], b[3][3];
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 3; j++) {
			scanf("%d", &a[i][j]);
			b[i][j] = a[i][j];
		}
	}
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 3; j++) {
			b[i][j] = a[i][j] + a[j][i];
			printf("%d ", b[i][j]);
		}
		printf("\n");
	}
	return 0;
}

226.字符数组元素排序

题目描述：从键盘输入一个字符串，将此字符串按字符的ASCII码值从小到大排序，并显示排序后的字符串。

输入说明：共一行，输入一个字符串，该字符串长度小于100，不包含空格。

输出说明：共一行，输出排序后的字符串

输入样例：Fdjn4e5

输出样例：45Fdejn

#include <stdio.h>
#include <cstring>

int main() {
	char str[100] = {'\0'}, a;
	gets(str);
	int len = strlen(str);
	for (int i = 0; i < len - 1; i++) {
		for (int j = i + 1; j < len; j++) {
			if (str[i] > str[j]) {
				a = str[i];
				str[i] = str[j];
				str[j] = a;
			}
		}
	}
	for (int i = 0; i < len; i++) {
		printf("%c", str[i]);
	}
}

227.字符串查找

编写一个函数fun，求一个字符串中的英文字母的个数。
主函数中输入字符串，调用函数，输出英文字母个数

输入说明：共一行，输入字符串

输出说明：输出一个整数，为英文字母个数

输入示例：aBc456

输出示例：3
*/

#include <stdio.h>
#include <ctype.h>  //取得isalpha来判断是否为字母
int main(){
	char a[1000];
	int sum1 = 0,sum2 = 0;
	gets(a);
	for (int i = 0;i < 1000;i++){
		if (isalpha(a[i])){
			sum1++;
		}
		if (!(isalpha(a[i]) || isdigit(a[i]))){
			break;
		}
	}
	printf("%d",sum1);
} 

228.字符串筛选

编写函数fun，其功能是将字符串s下标为奇数的字符删除，字符串中剩余字符形成的新字符串放在数组t中。
主函数中输入字符串s，调用函数，输出字符数组t。

输入说明：共一行，输入字符串s

输出说明：共一行，输出字符串t

输入示例：abcd1234

输出示例：ac13
*/

#include <stdio.h>
#include <ctype.h>
int main(){
	char a[1000]={'\0'},b[1000]={'\0'};
	gets(a);
	for (int i = 0;1;i++){
		if (!(isalpha(a[2*i]) || isdigit(a[2*i]))){
			break;
		}
		b[i] = a[2*i];
	}
	printf("%s",b);
} 

229.字符串连接

编写一个函数fun实现字符串连接功能（不使用strcat函数）。
主函数输入两个字符串，调用函数，输出连接后的字符串

输入说明：共两行，每一行输入一个字符串

输出说明：共一行,输出连接后的字符串

输入示例：abcd
1234

输出示例：abcd1234
*/

#include <stdio.h>
int main(){
	char a[1000]={'\0'},b[1000]={'\0'},c[1000]={'\0'};
	gets(a);
	gets(b);
	sprintf(c,"%s%s",a,b);//利用sprintf将a，b拼接后的字符串格式化给c 
	printf("%s",c);
}

230.调用函数求素数

编写函数fun，该函数的功能是求出小于等于x(x<=1000)的所有素数放在数组y中，素数的个数由函数返回。
主函数中输入整数x，调用函数，输出所有素数的个数并列出所有素数

输入说明：输入一个整数x

输出说明：共两行，第一行输出小于等于x的所有素数的个数
第二行输出满足条件的素数，用空格分隔

输入示例：10

输出示例：4
2 3 5 7
*/

#include <stdio.h>
int y[1000] = {'\0'};
int isPrime(int a){
	if (a == 1){
		return 0;
	}
	for (int i = 2;i < a / 2 + 1;i++){
		if (a % i == 0){
			return 0;
		}
	}
	return 1;
}
int fun(int x){
	int sum = 0;
	for (int i = 2;i <= x;i++){
		if (isPrime(i)){
			y[sum] = i;
			sum++;
		}
	}
	return sum;
}
int main(){
	int x,sum,i = 0;
	scanf("%d",&x);
	sum = fun(x);
	printf("%d\n",sum);
	for (int i = 0;i < sum;i++){
		printf("%d ",y[i]);
	}
}

238.数组鞍点

输入一个4行5列的二维数组，求出数组中鞍点及其所在行与列
（鞍点：即该位置上的元素在该行中最大，在该列中最小）

输入格式：输入一个4行5列的整形数组

输出格式：如果鞍点存在，分别输出鞍点的元素值，所在行和所在列，用空格分隔；
如果鞍点不存在，输出“鞍点不存在”。

输入样例一: 1 2 3 4 5
6 7 8 9 10
1 3 5 7 9
2 4 6 8 10

输出样例一：5 1 5

输入样例二：5 4 3 2 1
1 2 3 4 5
1 3 5 7 9
2 4 6 8 10

输出样例二：鞍点不存在

#include <stdio.h>

int main() {
	int a[100][100], walker, flag = 1, token = 1;
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 5; j++) {
			scanf("%d", &a[i][j]);
		}
	}//输入数组 
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 5; j++) {
			walker = a[i][j];
			for (int j1 = 0; j1 < 5; j1++) {
				flag = 1;
				if (a[i][j1] > walker) {
					flag = 0;
					break;
				}
			}//检测是否行内最大 
			for (int i1 = 0; i1 < 4 && flag == 1; i1++) {
				if (a[i1][j] < walker) {
					flag = 0;
					break;
				}
			}//检测是否列内最小 
			if (flag == 1) {
				printf("%d %d %d ", a[i][j], i + 1, j + 1);
				token = 0;
			}
		}
	}
	if (token) {
		printf("鞍点不存在");
	}
}

239.杨辉三角

给出正整数n（2<=n<=10）,输出杨辉三角前n行
杨辉三角性质：三角形中的每个数字等于它两肩上的数字相加

输入格式：输入一个正整数n
输出格式：输出杨辉三角的前n行，元素中间用一个空格分隔，每行用换行分隔

输入样例：
4

输出样例
1
1 1
1 2 1
1 3 3 1

#include <stdio.h>
int main(){
	int num[10][10] = {0}, n;
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		num[i][0] = 1;
		num[i][i] = 1;
	}
	for (int i = 2;i < n;i++){
		for (int j = 1;j < i;j++){
			num[i][j] = num[i - 1][j] + num[i - 1][j - 1];
		}
	}
	for (int i = 0;i < n;i++){
		for (int j = 0;j <= i;j++){
			printf("%d ", num[i][j]);
		}
		printf("\n");
	}
}

240.整数转换为字符串

用递归法将一个整数n转换成字符串。

输入格式：输入一个整数

输出格式：输出一串字符串

输入样例一：123（整数）

输出样例一：123（字符串）

输入样例二：-456（整数）

输出样例二：-456（字符串）

*/

#include <stdio.h>
int main(){
	char cn[1000]={'\0'};
	int in,i = 0;
	scanf("%d",&in);
	if (in > 0){
		while (in != 0){
			cn[i] = 48 + in % 10;
			i++;
			in /= 10;
		}
		for (i-1;i >= 0;i--){
			printf("%c",cn[i]);
		}
	}
	else if(in == 0){
		cn[0] = 48;
		printf("%c",cn[0]);
	}
	else{
		while (in != 0){
			cn[i] = 48 + in % 10 * -1;
			i++;
			in /= 10;
		}
		cn[i] = '-';
		for (i;i >= 0;i--){
			printf("%c",cn[i]);
		}
	}
	return 0;
}

241.十六进制转换为十进制

编写一个函数，输入一个十六进制正整数，输出相应的十进制正整数

输入格式：输入一个十六进制正整数（不区分大小写）

输出格式：输出一个十进制正整数

输入样例：F

输出样例：15
*/

#include <stdio.h>
int main(){
	int n = 0,i = 0;
	char xn[1000]={'\0'};
	gets(xn);
	while (xn[i] != '\0'){
		if (xn[i] >= '0' && xn[i] <= '9'){
			n = 16 * n + xn[i] - '0';
		}
		else if(xn[i] >= 'A' && xn[i] <= 'Z'){
			n = 16 * n + xn[i] - 'A' +10;
		}
		else{
			n = 16 * n + xn[i] - 'a' +10;
		}
		i++;
	}
	printf("%d",n);
}

250.螺旋填数

题目描述：
创建一个m行n列的数组，将1—m*n的数字螺旋填入
方向为右下左上（顺时针方向螺旋式填充）

输入说明：
输入正整数m和n，以空格分隔

输出说明:
输出填好的数组，数组元素之间用空格分隔，数组每行之间以换行分隔

输入示例1：
4 5

输出示例1：
1 2 3 4 5
14 15 16 17 6
13 20 19 18 7
12 11 10 9 8

输入示例2：
3 3

输出示例2：
1 2 3
8 9 4
7 6 5
*/

#include<stdio.h>
int main(){
    int nums[100][100]={0}, n, m, count = 1,r = 0,c = 0;//r为行，c为列 
    scanf("%d%d", &n, &m);
    int total = n * m;
    int Right = m, Left = 0, Up = 0, Down = n; //四个边界
    //以整个螺旋为一个循环，共n次
    while(count <= total){
        while(c < Right){
            nums[r][c++] = count++;
        }c--;r++;
        while(r < Down){
            nums[r++][c] = count++;
        }r--;c--;
        while(c >= Left){
            nums[r][c--] = count++;
        }c++;r--;
        while(r > Up){
            nums[r--][c] = count++;
        }r++;c++;   
        Right--;Left++;Up++;Down--;
		//每次螺旋之后，边界缩小
    }
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            printf("%d ",nums[i][j]);
        }
        printf("\n");
    }
    return 0;
}

285.分解质因数

题目描述：
每个非素数（合数）都可以写成几个素数（也可称为质数）相乘的形式，
这几个素数就都叫做这个合数的质因数。编写程序将一个正整数分解质因数
输入描述：
输入一个正整数n（2<n<1000）
输出描述：
形如abbc，质因数按照从小到大的顺序排列
输入样例：
90
输出样例：
2335

#include <stdio.h>
int main(){
	int n,t;
	scanf("%d", &n);
	t=n;
	for (int i=2;i<t/2+1;i++){
		while (n%i==0){
			n/=i;
			printf("%d",i);
			if (n!=1){
				printf("*");
			}
		}	
	}
} 

298.差平方与平方和差

问题描述
输入两个大于4的正整数a和b，分别计算(a+b)2、(a-b)2、a2+b2,、a2-b2，并找出其最大值和最小值。
输入说明
输入为2个正整数a和ｂ，4<= a, b <1000，整数之间由空格分开
输出说明
输出两个整数，分别表示(a+b)2、(a-b)2、a2+b2,、a2-b2 中的最大值和最小值，整数之间用空格分隔。
测试样例：
输入样例1
8 10
输出样例1
324 -36
输入样例2
36 5
输出样例2
1681 961

#include <stdio.h>
int main(){
	int a,b,n1,n2,n3,n4,n[4],i,max=-1000000,min=4000000;
	scanf("%d %d", &a, &b);	
	n[0]=(a+b)*(a+b);
	n[1]=(a-b)*(a-b);
	n[2]=a*a+b*b;
	n[3]=a*a-b*b;
	for (i=0;i<4;i++){
		if (n[i]>max){
			max=n[i];
		}
		if (n[i]<min){
			min=n[i];
		}
	}
	printf("%d %d", max, min);
}

299. 奖金计算

问题描述：
企业发放的奖金根据利润提成。利润低于或等于100000元的，奖金可提10%;
利润高于100000元，低于等于200000元（100000<I≤200000）时，低于等于100000元的部分按10％提成，高于100000元的部分，可提成 7.5%;
200000<I≤400000时，低于等于200000元部分仍按上述办法提成，（下同），高于200000元的部分按5％提成；
400000<I≤600000元时，高于400000元的部分按3％提成；
600000<I≤1000000时，高于600000元的部分按1.5%提成；
I>1000000时，超过1000000元的部分按1%提成。从键盘输入当月利润I,求应发奖金总数。

输入为一个整数（≤1200000），当月利润。

输出一个整数，奖金。

输入示例
900

输出示例
90

#include <stdio.h>
#include <cmath>
int main(){
    int I,reward,t;
    scanf("%d",&I);
    t=(I-1)/1e5;
    switch(t){
    case 0:
        reward=I*0.1;
        break;
    case 1:
        reward=(I-1e5)*0.075+1e5*0.1;
        break;
    case 2:
    case 3:
        reward=(I-2e5)*0.05+1e5*0.1+1e5*0.075;
        break;
    case 4:
    case 5:
        reward=(I-4e5)*0.03+1e5*0.1+1e5*0.075+2e5*0.05;
        break;
    case 6:
    case 7:
    case 8:
    case 9:
        reward=(I-6e5)*0.015+1e5*0.1+1e5*0.075+2e5*0.05+2e5*0.03;
        break;
    default:
        reward=(I-1e6)*0.01+1e5*0.1+1e5*0.075+2e5*0.05+2e5*0.03+4e5*0.015;
    }
    printf("%d\n",reward);
    return 0;
}

300.位数判断

题目描述：
输入一个不大于9位数的非负整数m，判断m是几位数？
输入说明：
输入为一个整数m，范围0<=m<=999999999
输出说明：
输出一个整数，表示整数m的位数
输入样例：
3456
输出样例：
4

#include <stdio.h>
int main(){
	int m,count=0;
	scanf("%d", &m);
	if (m==0){
		count=1;
	}
	while (m!=0){
		if (m!=0){
			count+=1;
			m/=10;
		}
	}
	printf("%d",count);
}

301.亲和数

题目描述：
古希腊数学家毕达哥拉斯在自然数研究中发现，220 的所有真约数（即不是自身的约数）之和为：
1+2+4+5+10+11+20+22+44+55+110=284
而 284 的所有真约数为 11、22、44、7171、142142，加起来恰好为 220。人们对这样的数感到很惊奇，并称之为亲和数。
一般地讲，如果两个数中任何一个数都是另一个数的真约数之和，则这两个数就是亲和数。
你的任务就编写一个程序，判断给出的两个整数m和n是不是亲和数（m和n可以相同）。
输入说明
输入为两个整数n和m，(1<n，m≤10000)，n和m之间用空格分隔
输出说明
在同一行上输出为三项，用空格分隔。
第一项表示判断结果，如果两个数是亲和数输出yes，否则输出no；
第二项是一个整数，表示n的真约数个数；
第三项是一个整数，表示m的真约数个数。
测试样例
输入样例1：
220 284
输出样例1：
yes 11 5
输入样例2：
4 3
输出样例2：
no 2 1

#include <stdio.h>
int main(){
	int n,m,count1=0,count2=0,sumn=0,summ=0;
	scanf("%d %d", &n, &m);
	for (int i=1;i<n/2+1;i++){
		if (n%i==0){
			count1+=1;
			sumn+=i;
		}		
	}
	for (int i=1;i<m/2+1;i++){
		if (m%i==0){
			count2+=1;
			summ+=i;
		}		
	}
	if (sumn==m && summ==n){
		printf("yes");
	}
	else{
		printf("no");
	}
	printf(" %d %d", count1, count2);
}

302.质数求和

问题描述
输入一个大于20的正整数p，求出正整数范围内第p个质数(或素数，大于1且只能被1和自己整除的正整数,)到第p+10个质数之和。其中，第1个质数为2，第2个质数为3，第3个质数为5，第4个质数为7，依次类推。
输入说明
一行输入1个整数p，20< p <150。
输出说明
第p个质数到第p+10个质数之和。
输入样例：
21
输出样例：
1081

#include <stdio.h>
#include <cmath>
int judgesushu(int a){
	int flag=1;
	for (int i=2;i<=sqrt((double)a);i++){
		if (a%i==0){
			flag=0;
			break;
		}
	}
	return flag;
}
//判断是否为素数
void getsushu(int sushuzu[],int p){
	int i=0;
	for (int j=2;i<p+10;j++){
		if (judgesushu(j)){
			sushuzu[i++]=j;
		}
	}
}
//生成含有p+10个素数的数组
int main(){
	int sushuzu[150],p,sum=0;
	scanf("%d", &p);
	getsushu(sushuzu,p);
	for (int i=p-1;i<p+10;i++){
		sum+=sushuzu[i];
	}
	printf("%d", sum);
	return 0;
}

374.课堂练习-沸水降温曲线

描述：
沸腾的水（100℃）在室温下温度随时间变化的曲线如图所示，给出时间，计算
水的温度

输入：
第一行为两个整数m（m[0，100]）,s(s∈[0,59])，分表表示降温时间的分钟数
和秒数

输出：
输出一个小数，表示输入时间对应的水的温度，温度保留1位小数。

输入样例：
5 30

输出样例：
72.5

#include <stdio.h>
int main()
{	int m,s;
	scanf("%d%d", &m, &s);
	double c,t=s/60.0+m;
	if (t>0 && t<=10){
		c=100-5*t;
	}
	else if(t<=30){
		c=50-(t-10);
	}
	else if(t<=50){
		c=30-(t-30)/2;
	}
	else {
		c=20;
	}
	printf("%.1f",c);
}

375.温度统计

输入n天的摄氏温度，将其转换为华氏温度（华氏温度=9/5*摄氏温度+32），求
其平均温度、最高温度、最低温度并输出。
输入：
第一行为表示天数的整数n（0<n<=10）
第二行为n个整数（整数范围[-10,40]），表示n天的摄氏温度，整数之间用空
格分隔。
输出：
将转换后的华氏温度按行输出，每行不超过5个温度值，超过则换行，每个温度
保留一位小数，温度之间用空格分隔。
在单独一行输出最低温度，最高温度和平均温度，用空格分隔。
输入样例：
6
10 5 9 8 12 16
输出样例：
50.0 41.0 48.2 46.4 53.6
60.8
41.0 60.8 50.0

#include <stdio.h>
int main(){
	int n;
	double a[10],sum=0.0,max=14,min=104;
	scanf("%d", &n);
	for (int i=0;i<n;i++){
		scanf("%lf", &a[i]);
		a[i]=9/5.0*a[i]+32;
		printf("%.1f ", a[i]);
		if (i==4){
			printf("\n");
		}
		if (a[i]>max){
			max=a[i];
		}
		if (a[i]<min){
			min=a[i];
		}
		sum+=a[i];
	}
	printf("\n%.1f %.1f %.1f", min, max, sum/n);	
} 

378.正整数的最优分解

注意：这题的用例增加了“不少于8位数的正整数”，笔者严重怀疑增加用例的老师完全没有仔细看题干——n < 2的20次方（1048576，一个七位数），故该用例不该使用。
然而，为了得到100分，我们暂时忘记n的范围吧。

#include <stdio.h>
#include <cmath>
int main(){
	long long n;
	scanf("%lld", &n);
	if (n%2==1){
		printf("-1");
	}
	else {
		for (int i=30;i>0;i--){
			if (n>=pow(2,i)){
				printf("%lld ", (long long)pow(2,i));
				n-=pow(2,i);
			}
			if (n==0){
				break;
			}
		}
	}
	return 0;
}

注意：本题代码需要使用GNU C/C++来上传，否则会编译错误或结果错误。

381.小中大

描述：
在数据分析中最小值，最大值和中位数是常用的统计信息。中位数是指一组有序
数列中最中间的那个数，当数列个数为奇数时，取最中间那个数的值；当数列个
数为偶数时，取中间两个数的平均值。
给出n个有序偶数（升序或降序），依次输出其最大值、中位数和最小值。
输入：
输入为两行，第一行为一个整数n，表示数列有n个整数（n<105）；
第二行为n个有序偶数
输出：
依次输出数列最大值、中位数和最小值，用空格分隔
输入样例：
样例1：
3 -2 0 4
样例2：
4
8 6 2 0
输出样例：
样例1：
4 0 -2
样例2:
8 4 0

#include <stdio.h>
int main(){
	int n, a[10000];
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		scanf("%d", &a[i]);
	}
	if (a[0] > a[1]) printf("%d ", a[0]);
	else printf("%d ", a[n - 1]);  //max
	if (n % 2 == 0) printf("%d ", (a[n / 2] + a[n / 2 - 1]) / 2);
	else printf("%d ", a[(n - 1) / 2]);  //middle
	if (a[0] > a[1]) printf("%d ", a[n - 1]);
	else printf("%d ", a[0]);  //min
	return 0;
} 

382.图像旋转-2021

旋转是图像处理的基本操作，在这个问题中，你需要将一个图像逆时针旋转
90 度。
计算机中的图像表示可以用一个矩阵来表示，为了旋转一个图像，只需要将
对应的矩阵旋转即可。
输入格式
输入的第一行包含两个整数n, m（1 ≤ n, m ≤ 100），分别表示图像矩阵
的行数和列数。
接下来n行每行包含m个不超过1000的非负整数，表示输入的图像。
输出格式
输出m行，每行包含n个整数，表示原始矩阵逆时针旋转90度后的矩阵。
样例输入
2 3
1 5 3
3 2 4
样例输出
3 4
5 2
1 3
*/

#include <stdio.h>
int main(){
	int n, m;
	int n1[100][100];
	scanf("%d%d", &n, &m);
	for (int j = 0;j < n;j++){
		for (int i = m - 1;i >= 0;i--){
			scanf("%d", &n1[i][j]);
		}
	}
	for (int i = 0;i < m;i++){
		for (int j = 0;j < n;j++){
			printf("%d ", n1[i][j]);
		}
		printf("\n");
	}
	return 0;
}

384.种苹果

描述：小明在果园种了一些苹果树，为了保证苹果质量，需要进行若干轮疏果操作（既去掉
一些不好的苹果）。小明记录了初始苹果数和每一轮去掉的苹果数，在若干轮后，请帮助小
明统计一些信息。
输入：
输入为两行，第一行为一个正整数n，表示进行了n轮疏果操作，1<=n<20；
第二行为n+1个整数，第一个整数t表示初始苹果数（0<t<1000），其后n个整数为0或负
整数（每个整数绝对值不超过100），0表示本轮没有去掉苹果，负整数的绝对值表示本轮去
掉的苹果数。整数之间用空格分隔。
输出：输出最后剩余苹果数量和疏果最多的轮次（从1开始计数）
样例：
输入样例1：
2
50 -5 -8
输出样例1：
37 2
输入样例2
4
60 -10 -2 0 -4
输出样例2
44 1

#include <stdio.h>
int main(){
	int n,sum,max=0,token=1;
	scanf("%d", &n);
	int a[n+1]={0};
	for (int i=0;i<n+1;i++){
		scanf("%d", &a[i]);
	}
	sum=a[0];
	for (int i=1;i<n+1;i++){
		if (max>a[i]){
			token=i;
			max=a[i];
		}
		sum+=a[i];
	}
	printf("%d %d", sum, token);
}

注意：本题代码需要使用GNU C/C++来上传，否则会编译错误或结果错误。

385.报数游戏

描述：三位同学决定玩报数游戏来打发时间。游戏规则是从1开始轮流报数，但如果要报的
数字是7的倍数或含有7的数则跳过。此外大家约定一共报出n个数字（不含被跳过的数）
后游戏结束。现在需要你来帮忙统计游戏过程中每个人各跳过了几个数字。
输入：输入为一个整数n，表示游戏结束时共报了n个数字。（0<n<1000）
输出：输出为3个整数，分别表示每个人跳过的数字数量，用空格分隔
样例：
输入样例1：
7
输出样例1：
1 0 0
输入样例2
17
输出样例2
1 2 0

#include <stdio.h>
int judge(int a){
	int flag=0;
	if (a%7==0){
		flag=1;
	}
	while (a!=0){
		if (a%10==7){
			flag=1;
			break;
		}
		else{
			a/=10;
		}
	}
	return flag;
}
//判断是否为7的倍数或是否含7.
int main(){
	int i=1,n,jump1=0,jump2=0,jump3=0,d=0;
	scanf("%d", &n);
	while (i!=n+d+1){
		if (judge(i)){
			if (i%3==1){
				jump1+=1;
			}
			else if (i%3==2){
				jump2+=1;
			}
			else {
				jump3+=1;
			}
			d+=1;
		}
		i++;
	}
	printf("%d %d %d", jump1, jump2, jump3);
	return 0;
}

387.最小公倍数

输入两个大于1且不相等的正整数，输出其最小公倍数。
输入1：
2 6
输出1：
6
输入2：
10 5
输出2：
10

#include <stdio.h>
#include <algorithm>
using namespace std;
int main(){
	int a,b;
	scanf("%d %d", &a, &b);
	for (int i=max(a,b);;i++){
		if (i%a==0 && i%b==0){
			printf("%d", i);
			break;
		}
	}
	return 0;
}

388.统计a的个数

输入5个字符，统计其中字符a的个数。每个字符以空格间隔,大写A
也算

输入1：
a b c d e

输出1：
1

输入2：
a A b c a

输出2：
3

#include <stdio.h>
int main()
{	char a,b,c,d,e;
	scanf("%c %c %c %c %c", &a, &b, &c, &d, &e);
	int S=0;
	if (a==65 || a==97){
		S+=1;
	}
	if (b==65 || b==97){
		S+=1;
	}
	if (c==65 || c==97){
		S+=1;
	}
	if (d==65 || d==97){
		S+=1;
	}
	if (e==65 || e==97){
		S+=1;
	}
	printf("%d",S);
}

389.质数之和

已知，第一个质数是2，第二个质数是3，第三个质数是5，第四个质数是7，
第五个质数是11，第六个质数是13，第七个质数是17，输入两个不相等的
正整数a和b，求出第a个质数到第b个质数当中所有质数和。a和b之间以空格
间隔，其中a和b都小于200。
输入1：
1 4
输出1：
17
输入2：
7 2
输出2:
56

#include <stdio.h>
#include <cmath>
#include <algorithm>
using namespace std;
int judgesushu(int a){
	int flag=1;
	for (int i=2;i<=sqrt((double)a);i++){
		if (a%i==0){
			flag=0;
			break;
		}
	}
	return flag;
}
//判断是否为素数
void produce(int b,int c[]){
	int i=2;
	for (int j=0;j<b;j++){
		for (i;;i++){
			if (judgesushu(i)){
				c[j]=i;
				i+=1;
				break;
			}
		}
	}
}
//生成前b个素数
int main(){
	int a,b,sum=0;
	scanf("%d %d", &a, &b);
	int sushuzu[max(a,b)];
	produce(max(a,b),sushuzu);
	for (int i=min(a,b)-1;i<max(a,b);i++){
		sum+=sushuzu[i];
	}
	printf("%d", sum);
}

390.标题：求阶乘

题目描述：从键盘输入一个正整数n（0<n≤20）,输出1至n的阶乘。写一个函数计算整数
的阶乘。函数声明如下：unsigned long long fact(int n);
输入说明：输入一个正整数n；
输出说明：输出1至n的阶乘，数据之间以空格分隔。
输入样例：
6
输出样例：
1 2 6 24 120 720
*/

#include <stdio.h>
unsigned long long fact(int n){
    unsigned long long final=1;
    for (int i = 1;i <= n;i++){
    	final *= i;
	}
	return final;
}

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

391.标题：求Fibonacci数

题目描述：Fibonacci数列又称兔子数列，数列规律形如：1,1,2,3,5,8,13,21,34……从键盘输入一个正整数n（0<n ≤ 40）,输出第1至第n个Fibnacci数。写一个函数计算第n个Fibnacci数。函数声明如下：int fib(int n);

输入说明：输入一个正整数n；
输出说明：输出第1至第n个Fibnacci数，数据之间以空格分隔。

输入样例：
6
输出样例：
1 1 2 3 5 8
*/

#include <stdio.h>
int find(int n){
	int num1 = 1, num2 = 1, numn = 2;
	if (n == 1 || n == 2){
		return 1;
	}
	while (n != 2){
		numn = num1 + num2;
		num1 = num2;
		num2 = numn;
		n--;
	}
	return numn;
}
int main(){
	int n;
	scanf("%d", &n);
	for (int i = 1;i <= n;i++){
		printf("%d ",find(i));
	}
	return 0;
}

392.排序算法比较器

题目描述：
给定n个不同的整数，要求对这n个整数按如下规则排序并输出。
• 规则一：所有的偶数排在奇数前面。
• 规则二：在规则一的前提下按照从大到小的顺序排序
现在给出主程序，请写出用于比较两个元素大小关系的函数compare，帮助主程序实现排序
compare 函数声明如下：
int compare(int x, int y);
• 如果x大于y，返回大于0的值
• 如果x小于y，返回小于0的值
• 如果x等于y，返回0
主程序如下：
int main(){
int a[100]={0};
int n,i,j,k;
scanf(“%d”,&n);
for(i=0; i<n; i++){
scanf(“%d”,&a[i]);
}
for(i=0;i<n;i++){
for(k=i, j=i+1;j<n;j++){
if(compare(a[j],a[k])>0)
}
if(k!=i){
int t=a[i];
}
}
for(i=0;i<n;i++){
printf("%d ",a[i]);
}
return 0;
}
输入：
第一行为整数n（n<100）
a[i]=a[k];
k=j;
a[k]=t;
第二行为n个整数，用空格分隔，每个整数取值范围在[0, 10000]。
输出：
输出排序后的n个整数，用空格分隔
输入样例
5
1 2 3 4 5
输出样例
4 2 5 3 1
说明：
只需提交compare函数代码片段，函数中不需要任何输入输出语句。

本题题干十分猥琐，表面上只让你实现比大小返回±1和0，实际上还让你实现偶数优先排的功能。

int compare(int x, int y){
	if((x - y) % 2 == 1 || (x - y) % 2 == -1) {
		if (x % 2 == 0){
			return 1;
		}
		else return -1;
	}
	if (x > y) return 1;
	else if (x < y) return -1;
	else return 0;
}

394.数组中位数

描述：写一个程序，对给定的整数序列排序，然后求排序后序列的中位数。（一个有序序列的中位数是序列中间位置上的数，如果该序列长度为偶数，则中位数取中间两个数的平均值向下取整）。
输入说明：输入第一行为一个整数n（0<n<100），表示序列长度；输入第二行为n个正整数（取值范围小于100000），数据之间以空格间隔。
输出说明：输出一个整数，表示序列中位数。
输入样例1：
5
2 7 5 8 9
输出样例1：
7
输入样例2：
6
2 7 5 8 9 10
输出样例2：
7
*/

#include <stdio.h>
int main(){
	int n, a[100];
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		scanf("%d", &a[i]);
	}
	for (int i = 0;i < n - 1;i++){
		for (int j = i + 1;j < n;j++){
			if (a[j] < a[i]){
				int temp = a[j];
				a[j] = a[i];
				a[i] = temp;
			}
		}
	}//从小到大排序 
	if (n % 2 == 0) printf("%d", (a[n / 2] + a[n / 2 - 1]) / 2);
	else printf("%d", a[(n - 1) / 2]);  //middle
	return 0;
}

395.插入数组元素

描述：写一个程序，对给定的整数序列按升序排列，然后输入一个数，要求按排序好的规律将其插入数组中。
输入说明：
输入第一行为一个整数n(0<n<100)，表示序列长度；
输入第二行为n个正整数（取值范围小于100000），数据之间以空格间隔。
输入第三行为1个整数m(m<100000)，表示待插入的数。
输出说明：输出排序好的新整数序列，数据之间以空格间隔。
输入样例：
5
2 7 5 8 9
3
输出样例：
2 3 5 7 8 9
*/

#include <stdio.h>
int main(){
	int n, a[100];
	scanf("%d", &n);
	for (int i = 0;i <= n;i++){
		scanf("%d", &a[i]);
	}
	for (int i = 0;i < n;i++){
		for (int j = i + 1;j <= n;j++){
			if (a[j] < a[i]){
				int temp = a[j];
				a[j] = a[i];
				a[i] = temp;
			}
		}
	}//从小到大排序 
	for (int i = 0;i <= n;i++){
		printf("%d ", a[i]);
	}
	return 0;
}

398.标题：字符串压缩

问题描述：有一种简单的字符串压缩算法，对于字符串中连续出现的同一个英文字符，用该字符加上连续出现的次数来表示（连续出现次数小于3时不压缩）。
例如，字符串aaaaabbbabaaaaaaaaaaaaabbbb可压缩为a5b3aba13b4。
请设计一个程序，采用该压缩方法对字符串压缩并输出。请编写一个函数compress，采用该压缩方法对字符串src进行压缩。函数定义如下:
char *compress(char *src);
返回值：
指向压缩后的字符串数据
参数：
src：输入/输出参数，输入表示待压缩字符串，输出表示压缩后的字符串

注意：函数声明已包含在主程序中，不需要自己定义。只需要提交自定义的函数代码。

主程序如下：
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
char *compress(char *src);
int main()
{
char src[100];
scanf(“%s”,src);

char *ps = compress(src);

puts(ps);
return 0;

}
主函数输入说明：
输入第一行为源字符串src（长度小于100），该字符串只包含大小写字母。
主函数输出说明：
输出一个数据，表示压缩后的字符串。
主函数输入样例：
aaaaabbbabaaaaaaaaaaaaabbbb
主函数输出样例：
a5b3aba13b4

char *compress(char *src){
	static char a[1000] = {'\0'};//使用静态变量，防止函数运行结束后内存释放导致消失 
	int sum = 1,j = 0;
	for (int i = 1;i <= strlen(src);i++){
		if (src[i] == src[i - 1]){
			sum += 1;
		}
		if (src[i] != src[i - 1] || src[i] == '\0'){
			if (sum > 2 && sum < 10){	
				a[j] = src[i - 1];
				a[j + 1] = '0' + sum;
				j += 2;
			}
			else if (sum >= 10){
				a[j] = src[i - 1];
				a[j + 2] = '0' + sum % 10;
				a[j + 1] = '0' + sum / 10;
				j += 3;
			}
			else{
				int b = j + sum;
				for (j;j < b;j++){
					a[j] = src[i - 1];
				}
			} 
			sum = 1;
			
		} 
	}
	return a;
}

399.字符判断

题目描述：输入一个字符，判断是大写字母、小写字母、还是其他字符。如果是大写字母则转换成小写字母输出；如果是小写字母，则转换成大写字母输出；
如果是数字，则输出数字；如果是其他字符，则输出其他字符。
输入：从键盘上任意输入一个字符
输出： 对应的大写字母、小写字母、数字、或其他字符。
样例1：
输入：R
输出：r
样例2：
输入：！
输出：！是其他字符
样例3：
输入：6
输出：6是数字

#include <stdio.h>
int main()
{	char A;
	scanf("%c",&A);
	if (A>64 && A<91){
		A+=32;
		printf("%c", A);
	}
	else if (A>96 && A<122){
		A-=32;
		printf("%c",A);
	}
	else if (A>47 && A<58){
		printf("%c是数字", A);
	}
	else{
		printf("%c是其他字符", A);
	}
}

注意：本题代码需要使用GNU C/C++来上传，否则会编译错误或结果错误。

400.素数求和

问题描述
输入正整数N，1<N<=100000，求区间[2,N]之间的所有素数之和。若N输入异常（在要求范围之外），输出0。
输入说明
输入正整数N。
输出说明
输出整数，表示区间[2,N]之间的素数和，或者输出0。
输入样例
5
输出样例
10

#include <stdio.h>
#include <cmath>
int judgesushu(int a){
	int flag=1;
	for (int i=2;i<=sqrt((double)a);i++){
		if (a%i==0){
			flag=0;
			break;
		}
	}
	return flag;
}
void produce(int N,int sushuzu[]){
	int i=2;
	for (int j=0;;j++){
		for (i;i<=N;i++){
			if (judgesushu(i)){
				sushuzu[j]=i;
				i+=1;
				break;
			}	
		}
		if (i==N+1){
				break;
			}
	}
}
int main(){
	int N,sum=0;
	scanf("%d", &N);
	if (N>1 && N<=100000) {	
		int sushuzu[N]={0};
		produce(N,sushuzu);
		for (int i=0;i<N;i++){
			sum+=sushuzu[i];
		}
			printf("%d", sum);
	}
	else{
		printf("0");
	}	
}

本题思路与389题类似
注意：本题代码需要使用GNU C/C++来上传，否则会编译错误或结果错误。

401.阶梯电价

问题描述
电价分三个档次，一档：0_{110度(含110)，每度电0.5元；二挡：110}210度(含210)，
超出110部分每度电0.55元；三挡：210~400度(含400)电，超出210部分每度电0.7元；
四挡：超过400度电，超出400部分每度电1.0元。给出一个家庭一个月的用电量，请计算
出应缴的电费。
输入格式
输入某家庭一个月的用电量（≤1000）；
输出格式
输出当月应缴电费、档次和该档超额使用的电量度数，档次使用字母A、B、C和D表
示，分别对应一、二、三和四档，电量和电费使用浮点型，结果四舍五入，保留小数点后两
位小数。
样例输入1：
70.5
样例输入2：
115
样例输入3：
230
样例输出1：
35.25 A 0.00
样例输出2：
57.75 B 5.00
样例输出3：
124.00 C 20.00
样例说明
电量值应不大于1000。
评测用例规模与约定
输出使用%.2f格式控制。

#include<stdio.h>
int main(){
	double a,fare=0,dif=0.00;
	int rank=1;
	scanf("%lf", &a);
	if (a>400){
		fare+=(a-400);	
		rank=4;
		dif=a-400.0;
		a=400;
	}
	if (a>210){
		fare+=(a-210)*0.7;	
		if (rank<3){
			rank=3;
			dif=a-210.0;
		}
		a=210;
	}
	if (a>110){
		fare+=(a-110)*0.55;
		if (rank<2){
			rank=2;
			dif=a-110.0;
		}
		a=110;
	}
	fare+=0.5*a;	
	printf("%.2f ",fare);
	switch(rank){
		case 1:
			printf("A %.2f",dif);
			break;
		case 2:
			printf("B %.2f",dif);
			break;
		case 3:
			printf("C %.2f",dif);
			break;
		case 4:
			printf("D %.2f",dif);
			break;
	}
}

402.四位译码器

问题描述
编程完成四位译码器功能，译码转换方式：大写字母==>小写字母，小写字母==>大写
字母，数字==>，其它符号==>@。
输入格式
输入四个字符（可以是字母、数字或其它字符），字符之间不分割；
输出格式
输出译码转换后的结果。
样例输入1：
A2c&
样例输入2：
%3Ua
样例输入3：
0 W@
样例输出1：
aC@
样例输出2：
@*uA
样例输出3：
*@w@
样例说明
输入可以是大写字母、小写字母、数字或其他字符混合，也可以是单独一种。
评测用例规模与约定
输入存在单独一种字符情形。

#include <stdio.h>
int change(char A){	
	if (A > 64 && A < 91) A += 32;
	else if (A > 96 && A < 122) A -= 32;
	else if (A >='0' && A <= '9') A = '*';
	else A = '@';
	return A;
}
int main(){
	char a[5];
	gets(a);
	for (int i = 0;i < 4;i++){
		printf("%c", change(a[i]));
	}
	return 0;	
} 

403.表达式计算

问题描述
对于一个由两个正整数和一个运算符号构成的表达式，数据之间以一个空格分隔，编程
识别表达式含义，并完成计算。运算符号包括+、-、、/和%。表达式如3 5 +或4 8 等。
输入格式
输入两个整数和一个运算符号构成的表达式。
输出格式
输出一行，输出表达式及其计算结果，数据之间不分隔。如：48=32
样例输入1：
2 15 +
样例输入2：
8 7 -
样例输入3：
6 5 *
样例输出1：
2+15=17
样例输出2：
8-7=1
样例输出3：
65=30
样例说明
输入次序：正整数a、正整数b和运算符号。
评测用例规模与约定
输入数值为不大于1000的正整数。

#include <stdio.h>
int main(){
	int a,b;
	char c;
	scanf("%d %d %c", &a, &b, &c);
	if (c==42){
		printf("%d*%d=%d", a, b, a*b);
	}
	if (c==43){
		printf("%d+%d=%d", a, b, a+b);
	}
	if (c==45){
		printf("%d-%d=%d", a, b, a-b);
	}
	if (c==47){
		printf("%d/%d=%d", a, b, a/b);
	}
	if (c==37){
		printf("%d%%%d=%d", a, b, a%b);
	}
}

404.提成计算

#include <stdio.h>
int main (){
	int rank,work;
	double reward=0;
	scanf("%d %d", &rank, &work);
	switch (rank){
		case 1:
			if (work>50000){
				reward+=(work-50000)*0.03;
			}
			printf("%d 50000.0 %.1f", rank, reward);
			break;
		case 2:
			if (work>35000){
				reward+=(work-35000)*0.02;
			}
			printf("%d 35000.0 %.1f", rank, reward);
			break;
		case 3:
			if (work>20000){
				reward+=(work-20000)*0.02;
			}
			printf("%d 20000.0 %.1f", rank, reward);
			break;
		case 4:
			if (work>5000){
				reward+=(work-5000)*0.025;
			}
			printf("%d 5000.0 %.1f", rank, reward);
			break;
	}
}

405.题目：优惠促销

问题描述
现有超市顾客购物信息：整数m、n（m表示是否VIP会员，仅为1、0，n为购物总额），
结合下述优惠规则，编程完成顾客账单计算任务。优惠规则如下：
商场优惠规则
VIP 购物底数 折扣
是 500 8.0
是 350 8.5
是 200 9.0
否 500 9.0
否 350 9.5
其中，账单金额=购物总额*折扣/10，只能按最大折扣一次计算。

输入格式
输入两个整数分别表示是否是VIP会员（1为会员）和购物总额（不大于5000）。
输出格式
输出账单信息：yes或no、购物总额、账单金额和优惠金额（后3项保留1位小数），
数据之间以一个空格分隔

样例输入1：
1 380
样例输入2：
1 679
样例输入3：
0 409

样例输出1：
yes 380.0 323.0 57.0
样例输出2：
yes 679.0 543.2 135.8
样例输出3：
no 409.0 388.5 20.5

样例说明
VIP会员对应整数1，购物总额不大于5000。
评测用例规模与约定
只能按最大折扣一次计算。

#include <stdio.h>
int main()
{	int m,biao;
	double n, S;
	scanf("%d %lf", &m, &n);
	if (m==1){
		biao=1;
		if (n<200){
			S=n;
		}
		else if (n>=200 && n<350){
			S=0.9*n;
		}
		else if(n<500){
			S=0.85*n;
		}
		else if(n>500){
			S=0.8*n;
		}
	}
	//计算会员的价格
	else{
		if (n<350){
			S=n;
		}
		else if (n>=350 && n<500){
			S=0.95*n; 
		}
		else if(n>500){
			S=0.9*n;
		}
	}
	//计算非会员的价格
	if (biao==1){
		printf("yes %.1f %.1f %.1f", n, S, n-S);
	}
	else{
		printf("no %.1f %.1f %.1f", n, S, n-S);
	}
	
}

406.题目：表达式计算

问题描述
对于一个字符 c（可以是大小写字母、数字或其它字符），按照下述转换规则，编程完
成字符转换任务。转换规则如下：

输入格式
输入一个字符（可以是大小写字母、数字、空格或其他字符）。
输出格式
输出转换前后字符，数据间以一个空格分隔。
样例输入1：
B
样例输入2：
a
样例输入3：
3
样例输出1：
B Z
样例输出2：
a d
样例输出3：
3 6
样例说明
输入可以是大小写字母、数字、空格或其他字符。
评测用例规模与约定
输出转换前后字符。

#include <stdio.h>
int main()
{	char A;
	scanf("%c",&A);
	printf("%c",A);
	if (A>66 && A<91){
		A-=2;
	}
	else if(A==65 || A==66){
		A+=24;
	}
	//实现大写字母-2位
	else if (A>47 && A<58){
		A=57- A+ 48;
	}
	//利用输入数字与9的差值实现9-数字
	else if (A>95 && A<120){
		A+=3;
	}
	else if(A>119 && A<123){
		A-=23;
	}
	//实现小写字母+3
	else if(A==32){
		A+=10;
	}
	//实现空格变为*
	else{
		A=35;
	}
	printf(" %c",A);
}

407.三角形判别与计算

#include <stdio.h>
#include <cmath>
int main(){
	int a[3],i,temp,P;
	double S,c;
	for (i=0;i<3;i++){
		scanf("%d", &a[i]);
	}
	for (i=0;i<3;i++){
		for (int j=0;j<3;j++){
			if (a[i]<a[j]){
				temp=a[i];
				a[i]=a[j];
				a[j]=temp; 
			}
		}
	}
	if (a[0]+a[1]>a[2] ){
		P=a[0]+a[1]+a[2];
		c=P/2.0;
		if (a[0]*a[0]+a[1]*a[1]==a[2]*a[2]){
			printf("yes 1");
		}
		else{
			printf("yes 2");
		}
		S=sqrt((double)(c*(c-a[0])*(c-a[1])*(c-a[2])));
		printf(" %d %.2f", P, S);
	}
	else {
		printf("no 3");
	}
}

418.数位输出

问题描述
输入一个正整数N(位数小于10位)，按从小到大的顺序输出该正整数数位。
输入格式
输入一个正整数N。
输出格式
按从小到大的顺序输出正整数N的各个数位，用空格分割。
样例输入
8139345
样例输出
1 3 3 4 5 8 9

#include <stdio.h>
int main(){
	int i=0,N,count=0,t,temp;
	scanf("%d", &N);
	t=N;
	for (i;t!=0;i++){
		t/=10;
		count+=1;
	}
	int a[count];
	for (i=0;i<count;i++){
		a[i]=N%10;
		N/=10;
	}
	for (i=0;i<count;i++){
		for (int j=0;j<count;j++){
			if (a[i]<a[j]){
				temp=a[i];
				a[i]=a[j];
				a[j]=temp;
			}
		}
	}
	for (i=0;i<count;i++){
		printf("%d ", a[i]);
	}
}

注意，本题使用GNU C/C++上传

419.输出螺旋方阵

问题描述
螺旋方阵是指一个呈螺旋状的矩阵，它的数字由第一行开始到右边不断变大，向下变
大，向左变大，向上变大，下面是一个5*5阶的螺旋方阵。输入螺旋方阵的阶数N，按行
输出该螺旋方阵
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

输入格式
输入一个正整数N(1<N<=10)。
输出格式
按行输出N阶螺旋方阵的元素，每个元素最小宽度4个字符，左对齐。
输入样例
6
输出样例
1 2 3 4 5 6
20 21 22 23 24 7
19 32 33 34 25 8
18 31 36 35 26 9
17 30 29 28 27 10
16 15 14 13 12 11
提示信息
printf中的格式字符%md，m指定输出最小宽度，m<0为左对齐
*/

#include <stdio.h>
int main(){
	int n, a[10][10];
	scanf("%d", &n);
	int count = 1;
	int x = 0, y = 0;
	int L = 0, U = 0, R = n - 1, D = n - 1;//左上右下边界 
	while (count <= n * n){
		while (y <= R){
			a[x][y++] = count++;
		}x++, y--;//向右 
		while (x <= D){
			a[x++][y] = count++;
		}x--, y--;//向下 
		while (y >= L){
			a[x][y--] = count++;
		}x--, y++;//向左 
		while (x > U){
			a[x--][y] = count++;
		}x++, y++;//向上 
		L++, U++, R--, D--;
	}
	for (int i = 0;i < n;i++){
		for (int j = 0;j < n;j++){
			if (i ==0) {
				if (j == 0) printf("%d ", a[i][j]);
				else printf("%2d ", a[i][j]);
			}
			else printf("%d ", a[i][j]);
		}
		printf("\n");
	}
}

424.题目：计算给定年月日时分秒的下一秒

问题描述
编写一个函数，要求输入年月日时分秒，输出该年月日时分秒的下一秒。如输入2004
年12月31日23时59分59秒，则输出2005年1月1日0时0分0秒。
输入格式
年份
月份
天数
小时
分钟
秒数
输出格式
年份
月份
天数
小时
分钟
秒数
样例输入
1999
12
31
23
59
59
样例输出
2000
1
1
0
0
0
样例说明
1999年12月31日23时59份59秒的下一秒为：2000年1月1日0时0份0秒。
评测用例规模与约定
本题的输入，年月日时分秒均为正整数。月份在[1,12]区间内，日期在[1,31]区间内（需
要区分大小月），小时数在[0,23]区间内，分钟数和秒数均在[0,59]区间内

#include <stdio.h>
int main(){
	int year, month, day, h, min, s, tokenm=0;
	scanf("%d", &year);
	scanf("%d", &month);
	scanf("%d", &day);
	scanf("%d", &h);
	scanf("%d", &min);
	scanf("%d", &s);
	s+=1;
	if (s==60){
		min+=1;
		s=0;
		if (min==60){
			h+=1;
			min=0;
			if (h==24){
				day+=1;
				h=0;
				if (month==1 || month==3 || month==5 || month==7 || month==8 || month==10 || month==12){
					tokenm=1;
				}
				else if(month==2){
					if (year%4!=0 || year%100==0 && year%400!=0){
						tokenm=2;
					}
					else {
						tokenm=3;
					}
				}
				else{
					tokenm=4;
				}
				if (tokenm==2 && day==29){
					month+=1;
					day=1;
				}
				else if (tokenm==3 && day==30){
					month+=1;
					day=1;
				}
				else if (tokenm==4 && day==31){
					month+=1;
					day=1;
				}
				else if (tokenm==1 && day==32){
					month+=1;
					day=1;
				}
				if (month==13){
					year+=1;
					month=1;
				}
			}
		}
	}
	printf("%d\n%d\n%d\n%d\n%d\n%d\n", year, month, day, h, min, s);
}

如果使用switch函数来写，代码可以简化，这里不再赘述。

425.题目：猴子爬山

问题描述
一只顽猴想从山脚爬到山顶，途中经过一个有N阶台阶的阶梯，该猴子有个习惯，每
次只能跳1阶台阶或者3阶台阶，求猴子通过N个台阶有多少种不同的跳跃方式？
输入格式
输入只有一个整数N，表示台阶的数量
输出格式
输出一个数字，表示有多少种跳跃方式
样例输入1
50
样例输出1
122106097
样例输入2
3
样例输出2
2
评测用例规模与约定
0 <N<50

#include <stdio.h>
int main(){
	int n,a[100] = {1,1,2};
	scanf("%d", &n);
	for (int i = 0;i < n - 3;i++){
		a[i + 3] = a[i] + a[i + 2];
	}
	printf("%d", a[n-1]);
}

426.三角形的判断

题目描述：从键盘输入一个三角形的三条边，判断是否为三角形。若不是
三角形，输出“不是三角形”；若是直角三角形，则输出其面积；否则输出“其
他三角形”。
输入：三个整数，整数之间以空格分隔。
输出：不是三角形、直角三角形面积、或其他三角形。
样例1：
输入：1 2 3
输出：不是三角形
样例2：
输入： 3 4 5
输出：6
样例3：
输入： 7 4 5
输出：其他三角形

#include <stdio.h>
int main(){
	int a[3],i,temp;
	for (i=0;i<3;i++){
		scanf("%d", &a[i]);
	}
	for (i=0;i<3;i++){
		for (int j=0;j<3;j++){
			if (a[i]<a[j]){
				temp=a[i];
				a[i]=a[j];
				a[j]=temp; 
			}
		}
	}
	if (a[0]+a[1]>a[2] ){
		if (a[0]*a[0]+a[1]*a[1]==a[2]*a[2]){
			printf("%d", a[0]*a[1]/2);
		}
		else{
			printf("其他三角形");
		}
	}
	else {
		printf("不是三角形");
	}
}

427.一元二次方程求解

题目描述：计算一元二次方程ax2+bx+c=0的实根，如果有两个不同实根，分
别输出；如果有两个相同实根，则输出一个；如果不存在实根，则输出“no”。
输入：从键盘上输入方程的系数a，b，c，以空格间隔
输出：方程的根
样例1：
输入：1.0 -2.0 1.0
输出：1.0
样例2：
输入： 1.0 -3.0 2.0
输出： 2.0 1.0
样例3：
输入：4.0 2.0 5.0
输出：no

#include <stdio.h>
#include <cmath>
int main(){
	double a,b,c,x1,x2;
	double delta;
	scanf("%lf %lf %lf", &a, &b, &c);
	if (b*b-4*a*c>0){
		delta=sqrt((double)(b*b-4*a*c));
		x1=(delta-b)/2/a;
		x2=(-b-delta)/2/a;
		printf("%.1f %.1f", x1, x2);
	}
	else if(b*b-4*a*c==0){
		printf("%.1f",-b/2/a);
	}
	else {
		printf("no");
	}
}

428.党费计算

题目描述：在职党员缴纳党费的比例如下：每月工资收入（税后）在3000元以
下（含 3000 元）者，交纳月工资收入的 0.5%；3000 元以上至 5000 元（含
5000 元）者，交纳月工资收入的1%；5000元以上至10000 元（含10000 元）
者，交纳月工资收入的1.5%；10000元以上者，交纳月工资收入的2%。
输入说明：输入一个浮点型的数，表示税后工资（小于50000）。
输出说明：输出一个浮点型的数，保留小数点后1位，表示党费。
样例1：
输入：2000.0
输出：10.0
样例2：
输入： 8000.0
输出：120.0

#include <stdio.h>
int main(){
	double S,fare;
	scanf("%lf", &S);
	if (S>10000){
		fare=0.02*S;
	}
	else if (S>5000){
		fare=0.015*S;
	}
	else if (S>3000){
		fare=0.01*S;
	}
	else{
		fare=0.005*S;
	}
	printf("%.1f", fare);
}

429. 奖金计算

题目描述：企业发放奖金是根据利润计算提成。利润低于或等于100000元的，
奖金可提成10%；利润高于 100000 元且大不于 200000 元的，低于 100000 元
的提成按10%计算，高于100000 元的按7.5%计算提成；利润高于200000元且
不大于 400000 元的，低于 200000 元的部分按上述方法提成（下同），高于
400000 元的按 5%计算提成；利润高于 400000 元且不大于 800000 元的，高于
400000 元的按 3%计算提成；利润高于 800000 元的，按 1%计算提成。从键盘
输入当月利润，求应发奖金总数。
输入：输入一个浮点型的数，表示利润（小于2000000.0）
输出：输出一个浮点型的数，保留小数点后1位，表示奖金总数
样例1：
输入：80000.0
输出：8000.0
样例2：
输入： 800000.0
输出：39500.0

#include <stdio.h>
#include <cmath>
int main(){
    int t;
    double I,reward;
    scanf("%lf",&I);
    t=(I-1)/1e5;
    switch(t){
    case 0:
        reward=I*0.1;
        break;
    case 1:
        reward=(I-1e5)*0.075+1e5*0.1;
        break;
    case 2:
    case 3:
        reward=(I-2e5)*0.05+1e5*0.1+1e5*0.075;
        break;
    case 4:
    case 5: 
	case 6:
    case 7:
        reward=(I-4e5)*0.03+1e5*0.1+1e5*0.075+2e5*0.05;
        break;
    default:
        reward=(I-8e5)*0.01+1e5*0.1+1e5*0.075+2e5*0.05+4e5*0.03;
    }
    printf("%.1f\n",reward);
    return 0;
}

本题与第299题极其相似。

430.偶数平方表

描述：
编写程序，对于从键盘输入的1个正整数n，求出1~n的所有偶数的平方值。
输入说明：
输入1个正整数。
输出说明：
每行输出两个整数，分别表示1~n的数及其平方值，整数之间以一个空格分隔。
输入样例
10
输出样例
2 4
4 16
6 36
8 64
10 100

#include <stdio.h>
int main(){
	int n;
	scanf("%d", &n);
	for (int i=2;i<=n;i+=2){
		printf("%d %d\n", i, i*i);
	}
	return 0;
}

431.区间整数平方和

#include <stdio.h>
int main(){
	int m, n, sum=0;
	scanf("%d %d", &m, &n);
	for (int i=m;i<=n;i++){
		sum+=i*i;
	}
	printf("%d", sum);
	return 0;
}

432.整数位数计算

题目描述：输入一个整数n（0<=n<=100000000），求出该整数的位数。
输入说明
输入一个整数n（0<=n<=100000000）
输出说明
输出一个整数，表示整数n的位数
测试样例
输入样例1：
23
输出样例1：
2
输入样例2：
520
输出样例2：
3

#include <stdio.h>
int main(){
	int m,count=0;
	scanf("%d", &m);
	if (m==0){
		count=1;
	}
	while (m!=0){
		if (m!=0){
			count+=1;
			m/=10;
		}
	}
	printf("%d",count);
}

本题与第300题完全一致。

433.计算数列Sn

#include <stdio.h>
int main(){
	int n;
	double Sn=0;
	scanf("%d", &n);
	for (int i=1;i<=n;i++){
		Sn+=1+1.0/i;
	}
	printf("%.1f",Sn);
} 

443.真约数

问题描述
学者在自然数研究中发现：220 的所有真约数（即不含自身的约数）之和为：
1+2+4+5+10+11+20+22+44+55+110=284。而 284 的所有真约数为 1、2、4、71、142，加起
来恰好为 220。
要求编写一个程序，在某个取值范围内找出“存在两个数中任何一个数都是另一个数的真约
数之和”的所有数据对。
输入格式
输入为取值范围的上下边界（闭区间）n和m，n和m之间用空格分隔。
输出格式
每一行输出一组满足要求的数据对和其真约数个数，用逗号分隔。
（样式：数据1 数据1的真约数个数，数据2 数据2的真约数个数）
样例输入
1000 3000
样例输出
1184 11,1210 11
2620 11,2924 11
样例说明
1000是输入数据的下边界，3000是输入数据的上边界。
1000是输入数据的下边界，3000是输入数据的上边界。
评测用例规模与约定
1 ≤ n ≤ 10000，n ≤ m ≤ 10000。

#include <stdio.h>
int produce(int n){
	int m = 0;
	for (int i = 1;i < n / 2 + 1;i++){
		if (n % i == 0){
			m += i;
		}		
	}
	return m;
}
//产生n的真约数之和 
int count(int n){
	int count = 0;
	for (int i = 1;i < n / 2 + 1;i++){
		if (n % i == 0){
			count += 1;
		}		
	}
	return count;
}
//产生n的真约数个数 
int main(){
	int  n, m, t;
	scanf("%d %d", &n, &m);
	for (int i = n;i <= m;i++){
		t = produce(i);
		if (t > i){//利用大小关系，确保不重复 
			if (produce(i) == t && produce(t) == i){			
				printf("%d %d,%d %d\n", i, count(i), t, count(t));
			}		
		}
	}
}

444.题目：圆周率计算

问题描述
　　pi/4=1-1/3+1/5-1/7+…+(-1)^(n-1)*(1/(2n-1))，求pi。
输入格式
　　输入为一个整数n，表示数列的项数。
输出格式
　　输出一个浮点数，为pi的值，保留小数点后6位。
样例输入
10000
样例输出
3.141493
评测用例规模与约定
1 ≤ n ≤ 108。
本例中浮点数请定义为double类型。

#include <stdio.h>
int main() {
	int n, token = 1;
	double pi = 0;
	scanf("%d", &n);
	for (int i = 1; i <= 2 * n - 1; i += 2) {
		pi += 1.0 / i * token;
		token *= -1;
	}
	pi *= 4;
	printf("%.6f", pi);
	return 0;
}

449.题目：套餐选择

问题描述
　　套餐A无月租费，话费每分钟0.6元，套餐B月租费50元，话费每分钟0. 4元。输入一个月的通话时间，分别计算出两种套餐的费用，并判断哪一种合适。
输入格式
　　输入为一个浮点数t，表示一个月的通话时间。
输出格式
　　输出为两种套餐的费用及判断结果，结果保留两位小数。
样例输入
2000
样例输出
1200.00
850.00
B
样例说明
　　2000x0.6=1200.00；50+2000.00x0.4=850.00；套餐B更划算。
评测用例规模与约定
1 ≤ t ≤ 10000，A和B花费一样时选B。

#include <stdio.h>
int main()
{	double t, S1, S2;
	scanf("%lf", &t);
	S1=t*0.6;
	S2=50+ 0.4* t;
	if (S1>=S2){
		printf("%.2f\n%.2f\nB", S1, S2);
	}
	else{
		printf("%.2f\n%.2f\nA", S1, S2);
	}

}

462.连续因子

#include<stdio.h>
#include<cmath>
int judge(int n){
    int i;
    for(i=2; i<=sqrt(n); i++)
    {
        if(n%i==0)
            return 0;
    }
    return 1;
}
// 判断素数
int main(){
    int  n, i, j, start = 0, l = 0, s = 1;
    scanf("%d",&n);
    if(judge(n))
        printf("1\n%d\n",n);
    else {
        for(i=2; i<=sqrt(n); i++){
            s=1;//s记录乘积
            //i确定左端，j不断滑动确定右端
            for(j=i; s*j<=n; j++){
                s=s*j;
                if(n%s==0&&j-i+1>l){
                    start=i;//记录左端点
                    l=j-i+1;
                }
            }
        }
        printf("%d\n",l);
        for(i=start; i<start+l; i++){
            if(i==start){			
                printf("%lld",i);
				}
            else{
                printf("*%lld",i);
				}
        }
        printf("\n");
    }
    return 0;
}

464.求阶乘

函数printFactorial(int n)的功能是输出非负整数n的阶乘，n的值不超过1000，对于不满足输入要求的n值，输出"Invalid input"，否则在一行上输出n!。
裁判服务器中的测试程序及样例如下：
#include <stdio.h>
void printFactorial(int n);
int main()
{
int n;
scanf(“%d”, &n);
printFactorial(n);
return 0;
}
输入样例：
15
输出样例：
1307674368000

易错点：该题看似简单，实则不然，1000！显然超出了任何类型的数的范围。因此，我们采用数组记录每一位数字，最后依次输出。

void printFactorial(int n){
	int a[3000]={0},k = 0,token;   //1000！最多是3000位数 
	a[0] = 1;
	if (n > 1000 || n < 0){
		printf("Invalid input");
		return;
	} 
	if (n == 0){
		printf("0");
		return;
	}
	for (int i = 2;i <= n;i++){
		for (int j = 0;j < 3000;j++){
			a[j] = a[j] * i + k;    //实现进位 
			k = a[j] / 10;    //进位要加的数 
			a[j] %= 10;       //进位后原位的值 
		}
	} 
	for (int i = 2999;i >=0;i--){  //寻找最高位 
		if (a[i] != 0){
			token = i;
			break;
			}
		}
	for (token;token >= 0;token--){
		printf("%d",a[token]);
	}
}

474.买铅笔

问题描述
老师需要去商店买 n 支铅笔作为小朋友们的礼物。她发现商店一共有 3 种包装的铅
笔，不同包装内的铅笔数量有可能不同，价格也有可能不同。为了公平起见，老师决定只买
同一种包装的铅笔。
商店不允许将铅笔的包装拆开，因此老师可能需要购买超过 n 支铅笔才够给小朋友们
发礼物。
现在老师想知道，在商店每种包装的数量都足够的情况下，要买够至少 n 支铅笔最少
需要花费多少钱。
输入格式
第一行包含一个正整数 n ，表示需要的铅笔数量。
接下来三行，每行用 2 个正整数描述一种包装的铅笔：其中第 1 个整数表示这种包装
内铅笔的数量，第 2 个整数表示这种包装的价格。
保证所有的 7 个数都是不超过 10000 的正整数。
输出格式
1 个整数，表示老师最少需要花费的钱。
样例输入
57
2 2
50 30
30 27
样例输出
54

#include <stdio.h>
int main(){
	int N, n[3], price[3], sum[3], fare[3], token;
	long long min = 999999999;
	scanf("%d", &N);
	for (int i = 0;i<3;i++){
		scanf("%d %d", &n[i], &price[i]);
		sum[i]=N/n[i];
		if (n[i]*sum[i]<N){
			sum[i]+=1;
		}
		fare[i]=sum[i]*price[i];
		if (fare[i]<min){
			token=i;
			min=fare[i];
		}
	}
	printf("%lld", min);
	return 0;
} 

482.数根

问题描述
对于一个正整数n，我们将它的各个位相加得到一个新的数字，如果这个数字是一位数，
我们称之为n的数根，否则重复处理，直到它成为一个一位数，这个一位数也算是n的数根。
例如：考虑36，3+6=9，9就是36的数根。考虑138，1+3+8=12，1+2=3，3就是138的数
根。请编写程序，计算n的数根。
输入格式
输入一个正整数n.
输出格式
输出一个整数，表示n的数根。
样例输入
11
样例输出
2
样例说明
11 为n，2为其数根。
评测用例规模与约定
1 ≤ n ≤ 10^6

#include <stdio.h>
int main(){
	int n, sum=0;
	scanf("%d", &n);
	while (n!=0){
		sum+=n%10;
		n/=10;
		if (n==0){
			if (sum>9){
				n=sum;
				sum=0;
			}
			else {
				printf("%d", sum);
			}
		}
	}
	return 0;
}

482.猜数字游戏

问题描述
猜数字游戏是令游戏机随机产生一个 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”则结束。
样例输入
58 4
70
50
56
58
60
-2
样例输出
Too big
Too small
Too small
Good Guess!

#include <stdio.h>
int main(){
	int target, N, time = 0, guessnumber = 0;
	scanf("%d %d", &target, &N);
	while (guessnumber!=target){
		scanf("%d", &guessnumber);
		time+=1;
		if (time>N || guessnumber<0){
			printf("Game Over");
			break;
		}
		if (guessnumber>target){
			printf("Too big\n");
		}
		else if (guessnumber<target){
			printf("Too small\n");
		}
		else {
			if (time==1){
				printf("Bingo!");
			}
			else if (time<=3){
				printf("Lucky You!");
			}
			else {
				printf("Good Guess!");
			}
			break;
		}
	}
	return 0;
}

563.题目：查找编号

问题描述:
随着互联网的普及和大数据时代的到来，数据隐私和信息安全问题日益突
出。这天警察小明确定了一栋居民楼中收集用户信息实施电信诈骗的两个不法分
子，他们的住房编号均为素数，且住房编号相差为2。现在，给定该栋居民楼的
住房总数n，请从1到n的住房编号范围中帮助小明筛查出所有可疑的住房编号。
输入格式:
一个正整数n。
输出格式:
按照从小到大的顺序输出所有可疑编号组，每行输出一组。每组可疑编号为
两个相差为2的素数，中间用单个空格隔开，先输出较小的素数，后输出较大的
素数。若没有找到任何可疑的编号组，输出empty。
样例输入:
10
样例输出:
3 5
5 7
样例说明:
小于等于10的素数包括2，3，5，7。3和5相差2故而为一组可疑编号，5
和7相差2故而也为一个可疑编号。
评测用例规模与约定：
1≤n≤10000。
*/

#include <stdio.h>
#include <cmath>
int judge(int n){
	for (int i = 2;i <= sqrt((double)n);i++){
		if (n % i == 0){
			return 0;
		}
	}
	return 1;	
}
int main(){
	int n,token = 1;
	scanf("%d", &n);
	for (int i = 4;i <= n;i++){
		if (judge(i) && judge(i - 2)){
			printf("%d %d\n",i-2,i);
			token = 0;
		}
	}
	if (token == 1){
		printf("empty");
	}
	return 0;
}

625.题目：汉诺塔

问题描述
三根竖棍分别标记为a、b、c，a上穿着n个圆盘。圆盘的叠放方式为：最下
面的直径最大，最上面的直径最小，按直径大小依次叠放。现在要将所有圆盘移
动到b上，叠放方式不变。移动中要求：（1）圆盘不能放到a、b、c以外的地方；
（2）整个过程中，所有竖棍上：直径大的盘不能放在直径小的盘上面。
编写程序，用户输入正整数n，计算机打印出指令序列，指导挪动。
输入格式
一个正整数。
输出格式
a->b
b->c
样例输入
2
样例输出
a->c
a->b
c->b
*/

本题非常有趣，这里说一下思路。
首先定义一个move(n,A,C,B)函数，表示将n个盘子由A柱借助C柱移动到B柱的所有操作。方便我们进行递归。
那么我们可以将这一系列操作分为三部分：
1.将n-1个盘子从A柱借助B柱移到C柱——move(n-1,A,B,C)
2.将最大的盘子从A柱移到B柱
3.将n-1个盘子从C柱借助A柱移到B柱——move(n-1,C,A,B)
当n = 1时，只需从A柱移到B柱一次。
按照该思路来编写move函数即可得解。

#include <stdio.h>
void move(int n,char A,char C,char B){//将n个盘子由A柱借助C柱移动到B柱 
	if (n == 1){
		printf("%c->%c\n",A,B);
	}
	else{
		move(n - 1, A, B, C);//第一步，将n-1个盘子移动到C柱 
		printf("%c->%c\n",A,B);//第二步，将最大的盘子移动到B柱
		move(n - 1, C, A, B);//第三步，将n-1个盘子移动到B柱 
	}
}
int main(){
	int n;
	scanf("%d", &n);
	char A = 'a', B = 'b', C = 'c';
	move(n,A,C,B);
} 

645.题目：奇偶排序

问题描述
现有一个包含 N 个元素（1≤N≤20）的整数数列 num，将num数列做排序处理，完成前
面奇数，后面偶数，分别从小到大排序。
输入格式
第一行输入正整数N（1≤n≤20）。
第二行输入数列num的各个元素（整数，大小随机，奇偶随机，N 个元素均不大于1000）。
输出格式
输出处理后的数列 num 各个元素，各个数据之间以一个空格分隔。
样例输入 1：
5
31 28 95 17 70
样例输入 2：
8
909 918 880 817 777 700 655 632
样例输入 3：
15
20 28 27 29 21 19 18 15 12 14 52 56 50 53 57
样例输出 1：
17 31 95 28 70
样例输出 2：
655 777 817 909 632 700 880 918
样例输出 3：
15 19 21 27 29 53 57 12 14 18 20 28 50 52 56
样例说明
输入 N 个元素（1≤N≤20），数列 num 的各个元素（整数，大小随机，奇偶随机，N
个元素均不大于 1000）。
评测用例规模与约定
提交完整程序
*/

#include <stdio.h>
int odd = 0, even = 0,oddnum[20]={0},evennum[20]={0};
void getnum(int n){
	if (n % 2 == 0){
		evennum[even] = n;
		even++;
	}
	else{
		oddnum[odd] = n;
		odd++;
	}
}
void organize(int n[20],int a){
	int temp;
	for(int i = 0;i < a - 1;i++){
		for(int j = i + 1;j < a;j++){//j遍历整个数组 
			if (n[j] < n[i]){
				temp = n[i];
				n[i] = n[j];
				n[j] = temp; 
			}
		}
	}
}
int main(){
	int N,a[20];
	scanf("%d", &N);
	for(int i = 0;i < N;i++){
		scanf("%d", &a[i]);
		getnum(a[i]);
	}
	organize(oddnum,odd);
	organize(evennum,even);
	for(int i = 0;i < odd;i++){
		printf("%d ",oddnum[i]);
	}
	for(int i = 0;i < even;i++){
		printf("%d ",evennum[i]);
	}
}

646.题目：单词统计

问题描述
现有一个字符串，它是由多个长度不超过 8 的单词和空格组成的，请输出单词的个数统
计和最大、最长单词（均取第一个）。
提示：
1.) 输入一个由单词和空格组成的字符串（大小写字母、空格，长度小于 100，单词数
小于 40 个）。
2.) 完成单词数目统计，最大单词和最长单词查询，输出结果。
输入格式
输入一个由单词和空格组成的字符串（长度小于 100，单词数小于 40 个，字符串开始
可以是空格）。
输出格式
输出单词个数、最大单词和最长单词，数据之间以一个空格分隔。
样例输入 1：
There are three men and four dogs
样例输入 2：
One Two Three Four Five Six Seven Eight Nine Ten
样例输入 3：
one tree two men.
样例输出 1：
7 three There
样例输出 2：
10 Two Three
样例输出 3：
4 two tree
样例说明
输入的字符串是由单词和空格构成的，字符串开始可以是空格。

本题显然题干理解才是最大的问题——最大的单词是啥玩意？笔者在反复阅读题干和思考后终于找出答案：翻开牛津字典，越在字典后方的单词越大。即逐位比较ASCII码。知道这点，题目便迎刃而解了。显然需要利用< ctring >头文件中的strcmp。

#include <stdio.h>
#include <ctype.h>
#include <cstring>
int main(){
	int count = 0,flag = 1, i = 0;
	char str[40][8] = {'\0'}, max[8],longword[8];
	for (i;scanf("%s", str[i]) != EOF ;i++){
		count++;
	}	//本题scanf比gets有明显的优越性————无需考虑空格的干扰
	strcpy(max,str[0]);
	strcpy(longword,str[0]);
	for (int i = 0;i < count;i++){
		if (strcmp(max,str[i]) < 0){
			strcpy(max,str[i]);
		}
	}//找出最大单词
	for (int i = 0;i < count;i++){
		if (strlen(str[i]) > strlen(longword)){
			strcpy(longword,str[i]);
		}
	}//找出最长单词
	printf("%d %s %s", count, max, longword);
	return 0;
}

647.题目：回文字符串

问题描述
一串仅由大小写字母构成的字符串（长度小于 50，忽略大小写，a 与A 相同），编写程
序完成该字符串是否为回文字符串的判断任务。
回文字符串：字符串中，收尾字符一个个的均相同，如 abcba、AbcBa，忽略字符大小
时，均是回文字符串。
输入格式
输入字符串（长度小于 50，仅由大小写字母构成）。
输出格式
输出信息"yes"或"no"。如果是回文则输"yes"，否则输出"no" (不带引号)
样例输入 1：
There
样例输入 2：
TwoHOwt
样例输入 3：
AbCdefKfeDcba
样例输出 1：
no
样例输出 2：
yes
样例输出 3：
yes
样例说明
输入的字符串仅含大小写字母。
评测用例规模与约定
忽略大小写字母的差别。
*/

#include <stdio.h>
#include <ctype.h>
#include <cstring>
int main(){
	char a[1000] = {'\0'},b[1000] = {'\0'};
	gets(a);
	for (int i = 0;i < strlen(a);i++){
		if (a[i] < 'a'){
			a[i] = tolower(a[i]);	
		}
		b[strlen(a) - 1 - i] = a[i];
	}
	for (int i = 0;i < strlen(a);i++){
		if (a[i] != b[i]){
			printf("no");
			return 0;
		}
	}
	printf("yes");
	return 0;
} 

648.题目：奇偶判别

问题描述
一个由 N 位数字字符构成的字符串，表示 N 位整数（N 的位数不超过 9 位，可以为 1），
编写程序完成对该整数的分析任务，判别 N 的位数、求出各位数字之和、判别和数为奇数
或偶数。
输入格式
输入字符串（含 N 个数字字符，1≤N≤9）。
输出格式
输出位数、和数、1 或 0（偶数为 1）的信息，数据之间以一个空格分隔。
样例输入 1：
123456789
样例输入 2：
665588
样例输入 3：
100100100
样例输出 1：
9 45 0
样例输出 2：
6 38 1
样例输出 3：
9 3 0
样例说明
输入的字符串中仅含数字字符。
评测用例规模与约定
使用字符数组，可以使用 string.h 库中的函数。
*/

#include <stdio.h>
#include <cstring>
int main(){
	char a[9]={'\0'};
	gets(a);
	int sum = 0,count = strlen(a),flag = 1;
	for (int i = 0;i < count;i++){
		sum += a[i] - '0';
	}
	if (sum % 2 == 1){
		flag = 0;	
	}
	printf("%d %d %d",count,sum,flag);
	return 0;
}

649.题目：和数转换二进制

问题描述
一个由 N 位数字字符构成的字符串，表示 N 位整数（N 的位数不超过 9 位，可以为 1
位），编程完成该整数的分析转换任务，求出各位数字之和并将和数转换为二进制数。
输入格式
输入 N 位数字字符构成的字符串。
输出格式
输出二进制数，数据之间不分割。
样例输入 1：
19530428
样例输入 2：
20231108
样例输入 3：
1901
样例输出 1：
100000
样例输出 2：
10001
样例输出 3：
1011
样例说明
输入的字符串仅包含若干位数字字符，可以是一位至九位。
评测用例规模与约定
提交完整程序
*/

#include <stdio.h>
#include <cstring>
int main(){
	char a[9]={'\0'};
	gets(a);
	if (a[0] == '0' && strlen(a) == 1){
		printf("0");
	}
	int sum = 0,count = strlen(a),num[30] = {0},i,flag = 1;
	for (i = 0;i < count;i++){
		sum += a[i] - '0';
	}
	i = 0;
	while(sum != 0){
		num[i] = sum % 2;
		sum /= 2;
		i++;
	}
	for (i -= 1;i >= 0;i--){
		if (num[i] == 0 && flag){
			continue;
		}
		else{
			flag = 0;
			printf("%d",num[i]);
		}
	}
	return 0;
}

650.题目：和数最大质约数

问题描述
一个由 N 位数字字符构成的字符串，表示 N 位整数（N 的位数不超过 9 位，可以为 1
位），编程完成该整数的分析处理任务，求出各位数字之和，在求出和数（大于 2 时）的最
大质约（可以是自身）。
输入格式
输入 N 位数字字符构成的字符串。
输出格式
若和数小于等于 2 时，输出"sum <=2."，否则，输出最大质约数。
样例输入 1：
135007
样例输入 2：
100001
样例输入 3：
3530274
样例输出 1：
2
样例输出 2：
sum <=2.
样例输出 3：
3
样例说明
输入的字符串仅包含若干位数字字符，可以是一位至九位。
*/

#include <stdio.h>
#include <cstring>
int judge(int numn){
	int Flag = 1;
	if (numn == 1){
		return 0;
	}
	//排除numn = 1的情况
	for (int i = 2;i < numn / 2 + 1;i++){
		if (numn % i == 0){
			Flag = 0;
			break;
		}	
	}
	return Flag;
}
int main(){
	char a[9]={'\0'};
	gets(a);
	int sum = 0,count = strlen(a),flag = 1;
	for (int i = 0;i < count;i++){
		sum += a[i] - '0';
	}
	if (sum <= 2){
		printf("sum <=2.");
		return 0;
	}
	else {
		for (int i = sum;i > 1;i--){
			if (sum % i == 0 && judge(i)){
				printf("%d",i);
				return 0;
			}
		}
	}
}

671.方差计算

#include <stdio.h>

int main() {
	int n, a[30], average = 0, p = 0;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
		average += a[i];
	}
	average /= n;
	for (int i = 0; i < n; i++) {
		p += (a[i] - average) * (a[i] - average);
	}
	p /= n;
	printf("%d", p);
}

672.计算正弦函数

#include <stdio.h>

double factorial(double n1, int n2) {
	double n3 = 1;
	for (int i = 0; i < n2; i++) {
		n3 *= n1;
	}
	for (int i = n2; i > 0; i--) {
		n3 /= i;
	}
	return n3;
}

int main() {
	int n, token = 1, timer = 0;
	double sin, x;
	scanf("%d %lf", &n, &x);
	for (int i = 1; timer != n; i += 2) {
		sin += factorial(x, i) * token;
		token *= -1;
		timer++;
	}
	printf("%.4f", sin);
}

673.标题:判断同构数

问题描述
正整数n若是它平方数的尾部，则称n为同构数。比如6是其平方数36的尾部，76是其平方
数5776的尾部，6与76都是同构数。输入正整数n，判断是否为同构数。如果是，那么输出
n 1；如果不是，那么输出n 0。
输入说明
输入数据为1个正整数。
输出说明
输出数据只有一行，包括两个整数。其中第一个就是输入的整数；第二个是1或者0，表示
是同构数或者不是同构数。
输入样例
25
输出样例
25 1

#include <stdio.h>

int main() {
	int n1, n2, count = 0, flag = 1;
	scanf("%d", &n1);
	int n3 = n1;
	while (n3 != 0) {
		n3 /= 10;
		count++;
	}
	n2 = n1 * n1;
	n3 = 1;
	for (int i = 0; i < count; i++) {
		n3 *= 10;
	}
	if (n1 != n2 % n3) {
		flag = 0;
	}
	printf("%d %d", n1, flag);
}

674.信号解调

#include <stdio.h>

int doublen(int n) {
	n *= n;
	return n;
}

int main() {
	int n, a[20], b[20];
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d %d", &a[i], &b[i]);
	}
	for (int i = 0; i < n; i++) {
		if ((doublen(a[i] - 4) + doublen(b[i] - 4)) > (doublen(a[i] + 4) + doublen(b[i] + 4))) {
			printf("2 ");
		} else {
			printf("1 ");
		}
	}
}

675.可构造三角形个数

题目描述：
对于长度为 n 的整数序列，从第一个元素开始检测，连续的三个整数是否能构成三角
形，统计能构造的三角形的个数。
输入说明：输入分两部分，第一部分是一个整数 n（0<n<30），指明序列长度；第二部
分是 n 个整数，整数之间以空格分隔，代表输入序列 x0、x1、……xn-1
输出说明：输出为一个整数，表示能构造的三角形个数。
输入样例：
5
1 2 3 4 5
输出样例：
2
样例说明：依次判断整数（1, 2, 3）、（2, 3, 4）、（3, 4, 5）是否能构成三角形。

#include <stdio.h>

int max(int a, int b, int c) {
	int temp = a;
	if (b > a)
		temp = b;
	if (temp < c)
		temp = c;
	return temp;
}

int main() {
	int a[30], n, count = 0;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
	}
	for (int i = 0; i < n - 2; i++) {
		if (2 * max(a[i], a[i + 1], a[i + 2]) < a[i] + a[i + 1] + a[i + 2]) {
			count++;
		}
	}
	printf("%d", count);
}

676.ROT13加密

问题描述
ROT13是一种古典加密方法，其加密原理是把一个字母用字母表位置相距13的字母来进行
替换，例如字母‘a’用字母‘n’来替换，字母‘z’用字母‘m’来替换。
输入一段字符串，然后把其中的大小写字母按照上述加密方法进行加密，其它字符保持不
变。
输入说明
输入数据只有一行，包含待加密的字符串，长度不超过60个字符。
输出说明
输出加密后的字符串。
输入样例
Abc# 2xyz
输出样例
Nop# 2klm

#include <stdio.h>
#include <cstring>
int main(){
	char str[61];
	gets(str);
	for (int i = 0;i < strlen(str);i++){
		if ((str[i] >= 'a' && str[i] <= 'm') || (str[i] >= 'A' && str[i] <= 'M')){
			str[i] += 13;
		}
		else if(str[i] >= 'n' && str[i] <= 'z'){
			str[i] += 12 - 'z' +'a';
		}
		else if(str[i] >= 'N' && str[i] <= 'Z'){
			str[i] += 12 - 'Z' +'A';
		}
	}
	for (int i = 0;i < strlen(str);i++){
		printf("%c", str[i]);
	}
	return 0;
}

677.勒让德多项式

#include <stdio.h>

double Px(int n,double x){//表示Pn(x) 
	switch (n){
		case 0: return 1;
		case 1: return x;
		default: return 1.0 * Px(n - 1, x) * x * (2 * n - 1) / n - 1.0 * Px(n - 2, x) * (n - 1) / n;
	}
} 
int main(){
	int n;
	double x,sum = 0;
	scanf("%d %lf", &n, &x);
	for (int i = 1;i <= n;i++){
		sum += Px(i, x);
	}
	printf("%.4f", sum);
}

681.模式匹配

题目描述：
接收信号中包含特定的信号模式，对接收信号进行检测，以统计特定模式出现的次数。
例如接收信号为 9 3 5 7 5 8 6 3 5 7 1 9 3 5 7，如果特定信号为 3 5 7，则接收信号中包含了
3 个特定模式。通过键盘输入接收信号整数序列，输出其中包含的模式 3 5 7 的出现次数。
输入说明：输入分三部分，第一部分是一个整数 n（0<n<30），指明接收信号长度；第
二部分是 n 个整数，整数之间以空格分隔，代表接收信号序列 x0、x1、……xn-1。
输出说明：输出其中模式 3 5 7 出现的次数；
输入样例：
15
9 3 5 7 5 8 6 3 5 7 1 9 3 5 7
输出样例：
3

#include <stdio.h>

int main() {
	int a[30], n, b[3] = {3, 5, 7}, sum = 0;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
	}
	for (int i = 0; i < n - 2; i++) {
		if (a[i] == b[0] && a[i + 1] == b[1] && a[i + 2] == b[2]) {
			sum++;
		}
	}
	printf("%d", sum);
}

682.判断梅森尼数

#include <stdio.h>
int judge(int numn){
	int Flag = 1;
	if (numn == 1){
		return 0;
	}
	//排除numn = 1的情况
	for (int i = 2;i < numn / 2 + 1;i++){
		if (numn % i == 0){
			Flag = 0;
			break;
		}
		
	}
	return Flag;
}
int main(){
	int n, m = 1;
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		m *= 2;
	}
	m--;
	printf("%d ", m);
	if (judge(m)){
		printf("1");
	}
	else {
		printf("0");
	}
	return 0;
}

683.平滑滤波

#include <stdio.h>
int a[30];
void opt(int i, int n){
	if (i != n - 1){
		switch (i){
			case 0:
				printf("%d ", (a[0] + a[1] + a[2]) / 3);
				break;
			default:
				printf("%d ", (a[i] + a[i + 1] + a[i - 1]) / 3);
				break;
		}
	}
	else {
		printf("%d ", (a[n - 1] + a[n - 3] + a[n - 2]) / 3);
	}
}
int main(){
	int n;
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		scanf("%d", &a[i]);
	}
	for (int i = 0;i < n;i++){
		opt(i, n);
	}
	return 0;
}

684.logistic方程

#include <stdio.h>
#include <cmath>
int main(){
	double x1, r, xn;
	scanf("%lf%lf", &x1, &r);
	int token = 0;
	xn = x1;
	for (int i = 2;i < 1001;i++){	
		xn = (1.0 - xn) * xn * r;
		if (fabs(xn - x1) < 0.00001){
			token = 1;
			break;
		}
		x1 = xn;
	}
		printf("%.4f %d", xn, token);
	return 0;
}

685.删除特定字符后排序输出

问题描述
输入字符串 s（长度不超过100），将字符串 s 中所有字符“”删除，并将修改后的字符串按照
ASCII 码从小到大的顺序输出。
输入说明
输入数据为一行包含空格的字符串。
输出说明
输出将原字符串中“”删除后再排序的新字符串。
输入样例
dgjk %&* df78dg 88*
输出样例
%&7888dddfggjk

#include<stdio.h>
#include <cstring>
int main()
{
	char s[101], temp;
	gets(s);
	int a = strlen(s);
	for (int i = 0;i < a;i++){
		if (s[i] == '*'){
			s[i] = '\0';
		}
	}
	for (int i = 0;i < a;i++){
		for (int j = 0;j < a;j++){
			char wd1[2], wd2[2];
			wd1[0] = s[i], wd2[0] = s[j];//将char转化为 const* char
			if (strcmp(wd1,wd2) < 0){//strcmp要求内部两变量均为const* char 
				temp = s[i];
				s[i] = s[j];
				s[j] = temp; 
			}
		}
	}
	for (int i = 0;i < a;i++){
		printf("%c", s[i]);
	}
	return 0;
}

686.校验和计算

题目描述：
通信过程中会为发送信息添加校验信息以利于接收端检测发送过程中出现的错误。添加
方法如下：
对于长度为n的整数序列x0、x1、……xn-1，计算所有整数的各位数字之和，并将结果模
10 运算后，结果即为所求校验信息。
输入说明：输入分两部分，第一部分是一个整数n（0<n<20），指明序列长度；第二部
分是n个整数，代表输入序列x0、x1、……xn-1，其中0≤xi<100000，0≤i<n。
输出说明：输出为一个整数，表示校验信息。
输入样例：
5
11 22 33 44 55
输出样例：
0
样例说明：各个整数的各位数字之和为：1+1+2+2+3+3+4+4+5+5=30，所以校验信息
为：30%10=0。

#include <stdio.h>
int opt(int i){
	int sum = 0;
	while (i != 0){
		sum += i % 10;
		i /= 10;
	}
	return sum;
}
int main(){
	int n, a[20], sum = 0;
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		scanf("%d", &a[i]);
		sum += opt(a[i]);
	}
	sum %= 10;
	printf("%d", sum);
	return 0;
}

687.试题名称 2-5 数值信息报表

问题描述
输入两行整数，第一行为一个整数n，表示将要统计的整数个数，第二行为n个整数，整数
之间用空格分隔开来，试编程求解该数列所有整数之和、最大值及其位置信息和最小值及其
所处的位置信息（数列排序从1开始）。
输入说明
输入第一行一个整数n（2<n<50），输入第二行n个非负整数，每个整数均不超过100000，
且n个整数都不相同。
输出说明
输出为5个整数，分别是数列中所有整数之和，最大数，最大数位置，最小数，最小数位置，
整数之间用空格分隔。
测试样例：
输入样例1
5
17 2 3 8 47
输出样例1
77 47 5 2 2
输入样例2
9
3 81 2 16 7 8 5 4 1
输出样例2
127 81 2 1 9

#include <stdio.h>
int main(){
	int n, a[20], sum = 0, max = 0, min = 100000, maxn, minn;
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		scanf("%d", &a[i]);
		sum += a[i];
		if (a[i] > max){
			max = a[i];
			maxn = i + 1;
		}
		if (a[i] < min){
			min = a[i];
			minn = i + 1;
		}
	}
	printf("%d %d %d %d %d", sum, max, maxn, min, minn);
	return 0;
}

688.出现次数最多的数

问题描述
给定n个正整数，找出它们中出现次数最多的数。如果这样的数有多个，请输出其中最小的一个。
输入说明
输入数据分为两行。
输入的第一行只有一个正整数n(1 ≤ n ≤ 1000)，表示数字的个数。
输入的第二行有n个整数s1 , s2 , …, sn (1 ≤ si ≤ 10000, 1 ≤ i ≤ n)。相邻的数用空
格分隔。
输出说明
输出这n个整数中出现次数最多的数。如果这样的数有多个，输出其中最小的一个。
输入样例1
6
10 1 10 20 30 20
输出样例1
10
输入样例2
8
52 4 20 70 30 70 40 98
输出样例2
70

#include<stdio.h>
int main()
{
	int n, a[1000], maxcount = 0, maxnum = a[0];
	scanf("%d",&n);
	for(int i = 0;i < n;i++){
		scanf("%d", &a[i]);
	}
	for(int i = 0;i < n;i++){
		int count = 0;
		for(int j = 0;j < n;j++){
			if(a[j] == a[i]){
				count++;	
			} 
		}
		if(count > maxcount){
			maxcount = count;
			maxnum = a[i];
		}
		if(count == maxcount){
			maxnum = a[i] > maxnum ? maxnum : a[i];
		}
	}
	printf("%d", maxnum);
	return 0;
}

689.寻找同数

问题描述
注意力训练有一种方法叫做“寻找同数”，它既是“眼力”的训练——快速的在一串一串的数字
中找到“指定”的数字出现的次数；同时也是观察力与专注力的训练——只有保持注意力的高度
集中，你才能快速准确的找到这些指定的数字。
输入说明
输入数据分为两行。
第一行为一个数字字符串m（长度不超过3），表示待寻找的数字；
第二行为一个数字字符串s（长度不超过50）。
要求在数字串s中查找数字串m出现的次数。
输出说明
输出一个整数，表示在第二行所给的数字串s中，可以找到几个m数字串。
输入样例1
13
5213415133
输出样例1
2
输入样例2
11
1111
输出样例2
3
提示:
数字串应按照字符数组处理

#include<stdio.h>
#include <cstring>
int main()
{
	char m[4] = {'\0'}, s[51] = {'\0'};
	gets(m);
	gets(s);
	int count = 0;
	for (int i = 0;i < strlen(s);i++){
		if (s[i] == m[0]){
			int flag = 1;
			for (int j = 0;j < strlen(m);j++){	
				if (s[i + j] != m[j]){
					flag = 0;
					break;
				}
			}
			if (flag){
				count++;
			}
		}
	}
	printf("%d", count);
	return 0;
}

690.数字个数统计2

题目描述：一个正整数n（1<n<1000），在区间[n,n2]（含端点）内统计奇数个数、
偶数个数、能被4整除且不能被3整除的数字个数，并求出各统计数字两两之和
的最大值。
输入说明：输入一行，包含一个正整数n，范围为1<<n <1000。
输出说明：输出两行，第一行包含统计数字结果，奇数个数、偶数个数、能被 4
整除且不能被3整除数字个数，各数字之间用一个空格分隔；第二行为各统计结
果两两之和的最大值。
输入样例1：
5
输出样例1：
11 10 3
21
输入样例2：
18
输出样例2：
153 154 51
307
输入样例3：
20
输出样例3：
190 191 64
381

#include <stdio.h>
#include <algorithm>
int main(){
	int n;
	scanf("%d", &n);
	int count1 = (n * n - n) / 2, count2 = (n * n - n) / 2, count3 = 0, max;
	if ((n * n - n) % 2 == 0 && n % 2 == 0 ){
		count2++;
	}
	else if((n * n - n) % 2 == 0 && n % 2 == 1){
		count1++;
	}
	for (int i = n;i <= n * n;i++){
		if (i % 4 == 0 && i % 3 != 0){
			count3++;
		}
	}
	max = std::max({count1 + count2,count1 + count3,count3 + count2});
	printf("%d %d %d\n%d", count1, count2, count3, max);
	return 0;
}

691.数列折半交换

问题描述
对一个整数数列进行折半交换：如果该数列有奇数个元素，则数列的中间元素不动，左半
边的元素整体移到右边，右半边的元素整体移到左边；如果该数列有偶数个元素，左、右
半边元素交换。
输入说明
输入数据分为两行。
第一行包含了一个整数n，表示数列元素数，1 ≤ n ≤ 30。
第二行是整数数列的n个元素，元素之间用空格隔开。
输出说明
输出折半交换后的整数序列。
输入样例1
5
1 2 1 4 3
输出样例1
4 3 1 1 2
输入样例2
4
5 7 6 8
输出样例2
6 8 5 7

#include <stdio.h>
int main(){
	int n, a[30], b[30];
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		scanf("%d", &a[i]);
	}
	if (n % 2 == 0){
		for (int i = 0;i < n / 2;i++){
			b[n / 2 + i] = a[i];
		}
		for (int i = 0;i < n / 2;i++){
			b[i] = a[n / 2 + i];
		}
	}
	else{
		b[n / 2] = a[n / 2];
		for (int i = 0;i < n / 2;i++){
			b[n / 2 + i + 1] = a[i];
		}
		for (int i = 0;i < n / 2;i++){
			b[i] = a[n / 2 + i + 1];
		}
	}
	for (int i = 0;i < n;i++){
		printf("%d ", b[i]);
	}
	return 0;
}

692.数字个数统计3

题目描述：输入两个三位正整数A和B，在区间[A,B]之间，或在区间[B,A]之间，
完成统计任务：3的倍数数字个数、4的倍数数字个数和5的倍数且不是2的倍数
的数字个数，并求出各统计数字两两之间余数的最大值（提示：注意求余时被除
数和除数的顺序）。
输入说明：输入一行，包含两个三位正整数A和B。
输出说明：输出两行，第一行包含统计数字结果，3 的倍数数字个数、4 的倍数
数字个数、5的倍数且不是2的倍数数字个数，各数字之间用一个空格分隔；第
二行为各统计结果两两之间余数的最大值。
输入样例1：
100 300
输出样例1：
67 51 20
51
输入样例2：
235 121
输出样例2：
38 28 12
28
输入样例3：
577 315
输出样例3：
88 66 27
66

#include <stdio.h>
#include <algorithm>
int main(){
	int A, B, a, b, max;
	scanf("%d%d", &A, &B);
	a = (A < B) ? A : B;
	b = (A > B) ? A : B;
	int count1 = 0, count2 = 0, count3 = 0;
	for (int i = a;i <= b;i++){
		if (i % 3 == 0){
			count1++;
		}
		if (i % 4 == 0){
			count2++;
		}
		if (i % 5 == 0 && i % 2 != 0){
			count3++;
		}
	}
	max = std::max({count1 % count2,count2 % count1,count1 % count3,count3 % count1,count3 % count2,count2 % count3});
	printf("%d %d %d\n%d", count1, count2, count3, max);
	return 0;
}

693.有序序列插值

问题描述
将输入的一系列整数保存在数组中，然后将数组中的元素按照从小到大的顺序排列，在将
一个给定的整数插入到排好序的数组中，使得数组中的元素仍然保持从小到大的顺序。

输入说明
输入数据分为三行。
第一行包含了一个整数n，表示整数系列的个数，1 ≤ n ≤ 20。
第二行包含n个整数，整数区间为[0,10000]。
第三行包含了一个整数m，表示即将插入数组的整数, 0 ≤ m ≤ 10000。

输出说明
将数组元素按从小到大的顺序输出，中间用空格分隔。

输入样例
6
5 8 2 6 1 4
7
输出样例
1 2 4 5 6 7 8

#include <stdio.h>
int main(){
	int a[21], n, temp;
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		scanf("%d", &a[i]);
	}
	scanf("%d", &a[n]);
	for (int i = 0;i < n + 1;i++){
		for (int j = 0;j < n + 1;j++){
			if (a[i] < a[j]){
				temp = a[i];
				a[i] = a[j];
				a[j] = temp; 
			}
		}
	}
	for (i = 0;i < n + 1;i++){
		printf("%d ", a[i]);
	}
	return 0;
}

694.数字统计

#include <stdio.h>
int a(int n){
	switch (n){
		case 1:
			return 2;
		case 2:
			return 3;
		default:
			return (n - 1) * (n - 1) + 3 * (n - 2) + 1;
	}
}
int main(){
	int k, m, count1 = 0, count2 = 0, count3 = 0;
	scanf("%d%d", &m, &k);
	for (int i = 1;i <= k;i++){
		if (a(i) % m == 0){
			count1++;
		}
		if (a(i) % m == 1){
			count2++;
		}
		if (a(i) % m > 1){
			count3++;
		}
	} 
	printf("%d %d %d", count1, count2, count3);
}

695.等差数列及位置指示

类别
数组
时间限制
2S
内存限制
1000Kb
问题描述
请写一个程序，判断给定整数序列能否构成一个等差数列。
输入说明
输入数据由两行构成，第一行只有一个整数 n（n<100），表示序列长度（该序列中整数的个数）；
第二行为n个整数，每个整数互不相同，且取值区间都为[-32768~32767]，整数之间以空格间隔。
输出说明
对输入数据进行判断，若不能构成等差数列，将数列递增排序，分别输出排序后数据间的最大差值和最小差值，数据间以空格分隔；
若能构成等差数列，将数列递增排序，并输出排序后各个数据在原数列中的对应位置(位置计数从1开始)。
输入样例1
6
21 15 4 18 35 11
输出样例1
14 3
样例2输入
5
2
6
8
4 10
样例2输出
1 4 2 3 5

#include <stdio.h>
int main() {
	int n, a[100], b[100], temp, dif1, dif2, maxdif = -100000, mindif = 100000;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
		b[i] = a[i];
	}
	for (int i = 0; i < n - 1; i++) {
		for (int j = i + 1; j < n; j++) {
			if (a[j] < a[i]) {
				temp = a[i];
				a[i] = a[j];
				a[j] = temp;
			}
		}
	}
	dif1 = a[1] - a[0];
	int flag = 1;
	for (int i = 0; i < n - 1 ; i++) {
		dif2 = a[i + 1] - a[i];
		if (dif1 != dif2) {
			flag = 0;
		}
		if (dif2 > maxdif){
			maxdif = dif2;
		}
		if (dif2 < mindif){
			mindif = dif2;
		}
	}
	if (flag){
		for (int i = 0;i < n;i++){
			for (int j = 0;j < n;j++){
				if (a[i] == b[j]){
					printf("%d ", j + 1);
					break;
				}
			}
		}
	}
	else{
		printf("%d %d", maxdif, mindif);
	}
	return 0;
}

696.交换最大值与最小值

问题描述
将输入的一系列整数保存在数组中，然后将输入的一系列整数中的最小值与第一个数交
换，然后将最大值与最后一个数交换，最后按照交换后的顺序输出数组中的元素。（注：
已知输入的系列整数最大值和最小值均唯一）
输入说明
输入数据分为两行。
第一行包含了一个整数n，表示整数系列的个数，2 ≤ n ≤ 20。
第二行包含n个整数，整数区间为[0,10000]。
输出说明
按照交换后的顺序输出数组中的元素，中间用空格分隔。
输入样例1
6
5 8 2 5 1 4
输出样例1
1 4 2 5 5 8
输入样例2
6
1 8 2 5 6 9
输出样例2
1 8 2 5 6 9

#include <stdio.h>
int main(){
	int a[20], n, temp;
	int max = 0, maxn, min = 10000, minn;
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		scanf("%d", &a[i]);
		if (a[i] < min){
			min = a[i];
			minn = i;
		}	
	}
	temp = a[0];
	a[0] = a[minn];
	a[minn] = temp; 
	for (int i = 0;i < n;i++){
		if (a[i] > max){
			max = a[i];
			maxn = i;
		}	
	}
	temp = a[n - 1];
	a[n - 1] = a[maxn];
	a[maxn] = temp;			 
	for (int i = 0;i < n;i++){
		printf("%d ", a[i]);
	}
	return 0;
}

697.出租车费

问题描述
某城市普通出租车计费标准如下：
起步里程为3公里，起步费10元；
超起步里程后10公里内，每公里2元；
超过10公里以上的部分，每公里加收50%的回空补贴费；
营运过程中，因路阻及乘客要求临时停车的，按每增加5分钟多计费2元
（增加不足5分钟则不收费）。
输入说明
在一行上输入一个浮点数和一个整数，分别表示运营里程和停车多少分钟，
并以空格相隔。
输出说明
输出所需费用（结果保留一位小数）。
输入样例
输入样例1：12.8 13

输入样例2：10.0 8
输出样例
输出样例1：36.4

输出样例2：26.0

本题和P113几乎相同

#include <stdio.h>
int main()
{	double X,Y=10.0;
	int T;
	scanf("%lf %d", &X, &T);
	if (X>3 ){
		Y+=2*(X-3);
	}
	if(X>10){
		Y+=(X-10);
	}
	Y+=2*(T/5);
	printf("%.1f",Y);
}

698.乘法口诀数列

问题描述
从任意给定的两个一位数字 a1 和 a2 开始，用乘法口诀生成一个n项数列 {a1,a2,…,an}，
规则为从 a1 开始顺次进行，每次用当前数字与后面一个数字相乘，将结果贴在数列末尾。
如果结果不是一位数，则其每一位都应成为数列的一项。
输入说明
在一行中读入 3 个整数，依次为 a1、a2 和 n，满足 0≤a1,a2≤9，1≤n≤100。
输出说明
输出数列的前 n 项，各数字间以1个空格分隔。
输入样例
2 3 10
输出样例
2 3 6 1 8 6 8 4 8 4
样例说明：
原始数列：2 3
更新数列：2 3 6
更新数列：2 3 6 1 8
更新数列：2 3 6 1 8 6
更新数列：2 3 6 1 8 6 8
更新数列：2 3 6 1 8 6 8 4 8
更新数列：2 3 6 1 8 6 8 4 8 4 8
输出数列前10项：2 3 6 1 8 6 8 4 8 4
23=6
36=18,18拆分为两项
61=6
18=8
86=48,48拆分为两项
68=48,48拆分为两项

#include <stdio.h>
int main(){
	int n, k = 2;
	int a[100];
	scanf("%d%d%d", &a[0], &a[1], &n);
	for (int i = 0;i < n;i++){
		if (a[i] * a[i + 1] <= 9){
			a[k] = a[i] * a[i + 1];
			k++;
		}
		else {
			a[k] = a[i] * a[i + 1] / 10;
			a[k + 1] = a[i] * a[i + 1] % 10;
			k += 2;
		}
		printf("%d ", a[i]);
	}
	return 0;
}

699.歌唱比赛评分

问题描述
西安市举办青年歌手比赛，有N个评委进行打分，评委中设组长1人。评委给
选手打分后，去掉所打分数中的一个最高分和一个最低分后计算该选手的平均分。
若组长打出的分数是所有分数中的最高分或最低分，则判定组长所打分数有效，
将参与选手平均分的计算。本题要求编写程序，输入评委人数和每位评委所打分
数，并指定组长是哪位评委，求出该选手的平均得分。（评委打分的范围为0分-20 分之间，且所打分数均为整数。）
输入说明
第一行输入两个正整数，以空格分隔。第一个数N是评委总人数（5≤N≤20），第
二个数M是指定第M个人为组长（0<M≤N）。 例如输入“5 2”，则表示评委总共
5 人，其中，第2人为组长。
第二行依次输入N个整数，表示评委的分数，相邻分数之间以空格分隔。
输出说明
输出选手的平均得分，是单精度数（以float类型存储），小数点后保留两位小数。
测试样例：
输入样例1
5 5
16 15 16 19 19
输出样例1
17.50
输入样例2
6 2
9 7 8 6 8 9
输出样例2
8.00

#include <stdio.h>
#include <algorithm>
int main(){
	int M, N, score[20];
	float final = 0;
	scanf("%d %d", &N, &M);
	for (int i = 0;i < N;i++){
		scanf("%d", &score[i]);
		final += score[i];
	}
	int maxn = 0, minn = 20;
	for (int i = 0;i < N;i++){
		maxn = std::max(maxn, score[i]);
		minn = std::min(minn, score[i]);
	}
	final -= (maxn + minn);
	N -= 2;
	if (maxn == score[M - 1]){
		final += maxn;
		N++;
	}
	else if (minn == score[M - 1]){
		final += minn;
		N++;
	}
	printf("%.2f", final / 1.0 / N);
}

700.分别计算奇数和偶数之和

问题描述
接受用户输入的正整数n，用程序实现1到正整数n之间的奇数和偶数之和。
输入说明
正整数n
输出说明
分别输出1到n之间的奇数和偶数之和（第一个数为奇数之和，第二个数为偶数之和，两个
数之间用空格间隔）。
测试样例1：
输入样例1：50
输出样例1：625 650
测试样例2
输入样例2：30
输出样例2：225 240
测试样例3
输入样例3：10
输出样例3：25 30
测试样例4
输入样例4：45
输出样例4：529 506
先传这么多，剩下的有时间在接着传上去。

#include <stdio.h>
int main(){
	int n, sum1 = 0, sum2 = 0;
	scanf("%d", &n);
	for (int i = 1;i <= n;i++){
		if (i % 2 == 0){
			sum2 += i;
		}
		else {
			sum1 += i;
		}
	}
	printf("%d %d", sum1, sum2);
} 

701.异常点检测

#include<stdio.h>
#include<cmath>
int main()
{
	int n;
	scanf("%d", &n);
	double a[100];
	for(int i = 0;i < n;i++){
		scanf("%lf", &a[i]);
	}
	double sum = 0, ave, s;
	for(int i = 0;i < n;i++){
		sum += a[i];
	}
	ave = sum / n;
	double sum2;
	for(int i = 0;i < n;i++){
		sum2 += (a[i] - ave) * (a[i] - ave);
	}
	s = sqrt(sum2 / (n-1));
	int count = 0;
	for(int i = 0;i < n;i++){
		if(a[i] > (ave + 3 * s) || a[i] < (ave - 3 * s)) count++;
	}
	printf("%.4f %d", s, count);
	return 0;
}

702.最长的整数序列

问题描述
给定一个整数数列，数列中连续相同的最长整数序列算成一段，问数列中最长的整数序列的长度是多少？
输入说明
输入数据分为两行。
输入的第一行只有一个整数n（1 ≤ n ≤ 1000），表示数列中整数的个数。
输入的第二行有n个整数a1 , a2 , …, an（0 ≤ ai ≤ 1000），表示给定的数列，相邻的整数之间用一个空格分隔。
输出说明
输出一个整数，表示给定的数列中最长的整数序列的长度。
输入样例1
8
8 8 8 0 12 12 8 0
输出样例1
3
输入样例2
11
1 1 1 2 2 3 3 3 3 0 5
输出样例2
4

#include <stdio.h>
int main(){
	int a[1000], n;
	scanf ("%d", &n);
	for (int i = 0;i < n;i++){
		scanf("%d", &a[i]);
	}
	int count = 1, out = 1;
	for (int i = 0;i < n - 1;i++){
		if (a[i] == a[i + 1]){
			count++;
		}
		else {
			if (count > out){
				out = count;
			}
			count = 1;
		}
	}
	if (count > out){
		out = count;
	}
	printf("%d", out);
} 

703.最小公倍数求和

问题描述
对于n个正整数，分别求两相邻整数的最公倍数，得到n-1个值，然后求这n-1个值的和。
如给定n=4个整数2 8 6 5，则相邻整数为（2,8），（ 8,6），（ 6,5），这三组数的最小公倍数分
别为8，24，30，所以最终输出62。
输入说明
输入分两行：
第一行为一个正整数n，1<n<100；
第二行为n个正整数，每个整数绝对值都小于210，整数之间以空格分隔.
输出说明
输出一行，为最小公倍数的和，输出后换行。
测试样例：
 输入样例1
4
2 8 6 5
输出样例1
62
输入样例2
6
5 1 2 8 4 1
 输出样例2
27

#include <stdio.h>
int LCM(int a, int b){
	int c, GCD;
	int store = a * b;
	do{
		c = a % b;
		if (c == 0){
			GCD = b;
		}
		a = b;
		b = c;
	}while(c != 0);
	return store / GCD;
}
int main(){
	int n, a[100], sum = 0;
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		scanf("%d", &a[i]);
	}
	for (int i = 0;i < n - 1;i++){
		sum += LCM(a[i],a[i + 1]);
	}
	printf("%d", sum);
}

704.字符串处理1

题目描述：输入由数字和字符构成的字符串（不包含空格），将字符串中符合十六进制数据
格式的数字和字符按照其对应的十进制数值进行累加，并输出累加结果，如果字符串中不含
有任何满足十六进制格式的字符，则输出结果NO。
输入格式
输入一行字符串，字符串c的长度不超过50。
输出说明
输出一个整数，表示十进制的累加值。
输入样例1
3A5cH5o
输出样例1
35
输入样例2
GjoniuJk
输出样例2
NO

#include <stdio.h>
#include <cstring>
int main(){
	char a[50] = {'\0'};
	gets(a);
	int sum = 0, flag = 0;
	for (int i = 0;i < strlen(a);i++){
		if (a[i] >= '0' && a[i] <= '9'){
			sum += a[i] - '0';
			flag = 1;
		}
		else if(a[i] >= 'A' && a[i] <= 'F'){
			sum += a[i] - 'A' + 10; 
			flag = 1;
		}
		else if(a[i] >= 'a' && a[i] <= 'f'){
			sum += a[i] - 'a' + 10; 
			flag = 1;
		}
	}
	if (flag){
		printf("%d", sum);
	}
	else{
		printf("NO");
	}
}

705.数组折叠

题目描述：从键盘任意输入两个数字n(0<n≤6)和m(0<m≤n)，n为输入数据长度参数，m为
折叠次数。然后任意输入长度为2^n(2的n次幂) 的一串数字，并对该串数字进行m次折叠，最终将折叠后的数据进行输出。数据串一次折叠规则为：
a[0]+a[(2^n) -1] ,a[1]+a[(2^n) 2], a[2]+a[(2^n) -3]…a[(2^{(n-1))-1]+a[2}(n-1)]，第二次折叠在第一次折叠后的数组基础上使用同样的规则进行折叠。
输入格式
第一行输入两个整数n和m，两数用空格间隔开。
第二行输入2^n个整数，数字间用空格间隔开。
输出格式
输出处理后的结果，数字间用空格间隔开。
输入样例1
3 1
5 9 3 7 6 12 8 2
输出样例1
7 17 15 13
输入样例2
3 2
5 9 3 7 6 12 8 2
输出样例2
20 32

#include <stdio.h>
int a[64], n;
void opt(int i,int k){
	int num1 = a[i], num2 = a[k - 1 - i];
	a[i] = num1 + num2;
}
int main(){
	int m;
	scanf("%d %d", &n, &m);
	int k = 1;
	for (int j = 0;j < n;j++){
		k *= 2;
	}
	for (int i = 0;i < k;i++){
		scanf("%d", &a[i]);
	}
	for (int j = 0;j < m;j++){
		for (int i = 0;i < k / 2;i++){
			opt(i, k);
		}
		k /= 2;
	}
	for (int i = 0;i < k;i++){
		printf("%d ", a[i]);
	}
	return 0;
}

706.字符串插入

问题描述
编写程序：将一个不大于20个字符的字符串插入到一个不大于20个字符的主字符串的指定
位置中，并打印插入后的字符串。
输入说明
输入分三行：
第一行为主字符串；
第二行为子字符串；
第三行为要插入位置开始的索引号（数组下标）n；
输出说明
输出一行，为最后的字符串。
测试样例：
输入样例1
qwertyuiop
qazsxdcfv
5
输出样例1
qwertqazsxdcfvyuiop
输入样例2
qwert
Asd
3
输出样例2
qweAsdrt
输入样例3
Thank
you
5
输出样例3
Thankyou

#include <stdio.h>
#include <cstring>
int main(){
	char str1[21] = {'\0'}, str2[21] = {'\0'}, str3[41] = {'\0'};
	gets(str1);
	gets(str2);
	int n;
	scanf("%d", &n);
	for (int i = 0;i < n;i++){
		str3[i] = str1[i];
	}
	for (int i = 0;i < strlen(str2);i++){
		str3[i + n] = str2[i];
	}
	for (int i = n;i < strlen(str1);i++){
		str3[strlen(str2) + i] = str1[i];
	}
	for (int i = 0;i < strlen(str3);i++){
		printf("%c", str3[i]);
	} 
	return 0;
}

707.判断字符串子串

问题描述
编写程序：判断一个不大于20个字符的字符串是否是另一个不大于20个字符的字符串的子
串，如果是，则输出子串在父串的起始位置, 如果不是子串，则输出 No!。
输入说明
输入分2行：
第一行为主字符串；
第二行为子字符串；
输出说明
是子串，输出输出子串在父串的起始位置。
不是子串， 输出 No!
测试样例：
输入样例1：
I am a young girl.
young
输出样例1：
8
输入样例2
It is a big city.
it
输出样例2
14
输入样例3
Just do it.
thank
输出样例3
No!
输入样例4：
qwertyuiop
qwer
输出样例4：
1

#include<stdio.h>
#include <cstring>
int main()
{
	char m[21] = {'\0'}, s[21] = {'\0'};
	gets(s);
	gets(m);
	for (int i = 0;i < strlen(s);i++){
		if (s[i] == m[0]){
			int flag = 1;
			for (int j = 0;j < strlen(m);j++){	
				if (s[i + j] != m[j]){
					flag = 0;
					break;
				}
			}
			if (flag){
				printf("%d", i + 1);
				return 0;
			}
		}
	}
	printf("No!");
	return 0;
}

708.奇偶求和

#include <stdio.h>
int a(int n){
	return 3 * (n - 1) * (n - 1) + 2 * (n - 1) + 1;
}
int main(){
	int m, sum_even = 0, sum_odd = 0, count_even = 0, count_odd = 0;
	scanf("%d", &m);
	for (int i = 7;count_even != m || count_odd != m - 1;i++){//a6 = 86,a7 = 121，故从7开始 
		if (a(i) % 2 == 0 && count_even != m){
			count_even++;
			sum_even += a(i);
		}
		else if (a(i) % 2 == 1 && count_odd != m - 1){
			count_odd++;
			sum_odd += a(i);
		}
	}
	printf("%d %d", sum_even, sum_odd);
}