前言：

本刷题记录几乎都是基础题，无需用到算法、数据结构，适合小白食用，但言归正传，算法和数据结构很重要，无论是面试还是工作都会用到。

头文件

我的常用头文件

1
2
3
4
5
6
#include <iostream>
#include <math.h>
#include <string.h>
#include <string>
#include <algorithm>
using namespace std;

头文件相关函数及用法

math.h（math 函数）

  1. fabs(double x)

    对 double 型变量取绝对值

    abs(int x)

    对 int 型变量取绝对值

    注意：该函数不会根本上改变变量的值，使用时注意保存该变量或直接输出它

  2. floor(double x)和 ceil(double x)

    对 double 型变量向下取整和向上取整，返回类型为 double 类型

  3. round(double x)

    四舍五入求整

  4. pow(double r,double p)

    返回 r 的 p 次方

  5. sqrt(double x)

    返回 double 型变量的算术平方根

  6. log(double x)

    返回 double 型变量的以 e 为底的对数

  7. sin(double x)、cos(double x)、tan(double x)

    返回 double 型变量的正弦值、余弦值和正切值，参数要求是弧度制

  8. asin(double x)、acos(double x)、atan(double x)

    返回 double 型变量的反正弦值、反余弦值、反正切值

algorithm

  1. sort (array+xnum, array+ynum)

对 [xnum, ynum) 之间的数组升序排序，数字和字母等都可以排序

例如：sort(a, a + sizeof(a));

  1. sort (array+xnum, array+ynum, compare)

    可以加条件判断 compare 函数

    1
    2
    3
    4
    // 例子：下面表示的是按照从大到小排序
    bool compare(int a, int b) {
    	return abs(a) > abs(b);
    }

  2. reverse (array+xnum, array+ynum)

    对 [xnum, ynum) 之间的数组翻转顺序，同上

    注意：只能反转字符串和数字数组，不能反转字符数组

    例子：

    1. reverse(str.begin(), str.end());

    2. reverse(array, array + length);

string.h

  1. memset (array, 0, sizeof(array))

    如果 array 是数字型，只能将全初始化为 0

    如果 array 是 char 型，可以初始化为任意字符

  2. strrev (array)

    即可实现字符数组的反转

  3. strcpy (charA, charB)

    把 charB 所指向的字符串复制到 charA

  4. memcpy (b, a, sizeof(a))

    将数组 a 赋值给 b

零碎知识点

  1. 不要写打印输出的提示信息

  2. 数组定义时，大小不能用变量

  3. 字符数组结束标志为'\0'

  4. %c 是单个字符，%s 是字符串

    巧记：c 指 char，s 指 string

  5. 判断奇偶最简方法：

    if (num & 1) 👉 true 为奇数，false 为偶数

  6. gets 函数用于输入字符串，还可以输入空格

  7. getchar 函数用于输入字符，也可以输入空格

    tips：getchar() 的一个功能是可将回车字符吸收掉

  8. 不同数据类型所占的字节/位数：

    类型字节位数
    char18
    short216
    int, long, float432
    long long, double864

  9. 获取数组长度：

    length = sizeof(array) / sizeof(array[0]);

  10. 将 char 型转化为 int 型：

    int a_int = a_char + 0;

  11. 循环输入（输多少数据，数组记录多少数据）：

    1
    2
    3
    4
    5
    6
    7
    int main() {
        int a[max],i=0;
    	while (scanf("%d", &x) == 1) { // while (cin>>x)
    		a[i++] = x;
    	}
        ...
    }

    此处的等于 1 作用是判断输入 1 个值是否成功，以此类推，输入 n 个值就将 1 换成 n。算法竞赛中，常常难以确定所需数组大小，一般数组得先声明得大一点（有些题目会提到范围），在空间够用前提下，再来写后续代码。如果要数组定义的很大，那么建议在 main 函数外定义。


HDU OJ 刷题记录

刷题通道：HDU OJ

题目分类：HDU OJ 题目分类

1000 A+B

Problem Description
计算 A + B。

Input
每一行包含两个整数 A 和 B，程序可一直进行下去

Output
对于每种情况，在一行中输出 A+B

Sample Input
1 1

Sample Output
2

1
2
3
4
5
6
7
8
9
10
#include <iostream>
using namespace std;

int main() {
	int a, b;
	while(scanf("%d%d", &a, &b) == 2) { //==2也可以换成 !=EOF
		cout<< a+b<< endl;
	}
	return 0;
}

scanf("%d%d", &a, &b) == 2这一判断是确保输入了俩数

1001 总和问题

Problem Description
在此问题中，您的任务是计算 SUM（n）= 1 + 2 + 3 + ... + n。

Input
输入将由一系列整数 n 组成，每行一个整数。

Output
对于每种情况，在一行中输出 SUM（n），然后输出空白行。您可以假设计算结果将在 32 位带符号整数的范围内。

Sample Input
1
100

Sample Output
1
5050

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

int main() {
	int n;
	while (scanf("%d", &n) == 1) {
		cout << (int)((1.0 + n) * n / 2 + 0.5) << endl
		     << endl; //计算(1+n)*n时可能会超出 int 的最大值，即造成上溢overflow
	}
	return 0;
}

1008 电梯

Problem Description
我们城市最高的建筑物只有一部电梯。请求列表由 N 个正数组成。数字按指定顺序指示电梯将停在的楼层。
将电梯上移一层需要 6 秒钟，而将一层下移则需要 4 秒钟。电梯将在每个站点停留 5 秒钟。
对于给定的请求列表，您将计算完成列表上的请求所花费的总时间。电梯在开始时位于 0 楼，并且在满足请求后不必返回 0 楼。

Input
有多个测试用例。每个案例包含一个正整数 N，后跟 N 个正数。输入中的所有数字均小于 100。N = 0 的测试用例表示输入结束。该测试用例将不被处理。

Output
将每个测试用例的总时间打印在一行上。

Sample Input
1 2
3 2 3 1
0

Sample Output
17
41

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include <string.h>
using namespace std;
int a[100], b[100];

int main() {
	int N;
	memset(b, 0, 100);
	while(scanf("%d", &N) == 1 && N) {
		int t = 0;
		for(int i = 0; i < N; i++) {
			cin>> a[i];
			if ((a[i]-b[i]) > 0) {
				t += (a[i]-b[i])*6 + 5;
			} else {
				t += (b[i]-a[i])*4 + 5;
			}
			b[i + 1] = a[i];
		}
		cout<< t<< endl;
	}
	return 0;
}

1021 斐波那契

Problem Description
还有另一种斐波那契数：F（0）= 7，F（1）= 11，F（n）= F（n-1）+ F（n-2）（n> = 2）。

Input
输入由一系列行组成，每行包含一个整数 n。（n <1,000,000）。

Output
如果 3 被 F（n）均分，则打印单词"yes"。

如果没有，则打印单词“ no”。

Sample Input
0
1
2
3
4
5

Sample Output
no
no
yes
no
no
no

技巧：本题需要自己找规律，因为到最后数字变得很大,long long 数组都会溢出，所以它是找规律题 f(2)、f(6)、f(10)、f(14)、f(18)、f(22)、f(26)、f(30)……都是 yes

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

int main() {
	int n;
	while (scanf("%d", &n) == 1)  {
		if((n+2) % 4 == 0) {
			cout<< "yes"<< endl;
		} else {
			cout<< "no"<< endl;
		}
	}
	return 0;
}

2000 字母 ASCII 大小排序

Problem Description
输入三个字符后，按各字符的 ASCII 码从小到大的顺序输出这三个字符。

Input
输入数据有多组，每组占一行，有三个字符组成，之间无空格。

Output
对于每组输入数据，输出一行，字符中间用一个空格分开。

Sample Input
qwe
asd
zxc

Sample Output
e q w
a d s
c x z

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


int main() {
	char a[3];
	while (cin>> a) {
		sort(a, a + sizeof(a));
		for (int i = 0; a[i] != '\0'; i++) {
			if(i) {cout<< " ";}
			cout<< a[i];
		}
		cout<< endl;
	}

	return 0;
}

2001 计算两点间距

Problem Description
输入两点坐标（X1,Y1）,（X2,Y2）,计算并输出两点间的距离。

Input
输入数据有多组，每组占一行，由 4 个实数组成，分别表示 x1,y1,x2,y2,数据之间用空格隔开。

Output
对于每组输入数据，输出一行，结果保留两位小数。

Sample Input
0 0 0 1
0 1 1 0

Sample Output
1.00
1.41

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

int main() {
	double x1, y1, x2, y2;
	while (cin>> x1>> y1>> x2>> y2) {
		double ans = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
		printf("%.2lf\n", ans);
	}
	return 0;
}

2002 计算球体积

Problem Description
根据输入的半径值，计算球的体积。

Input
输入数据有多组，每组占一行，每行包括一个实数，表示球的半径。

Output
输出对应的球的体积，对于每组输入数据，输出一行，计算结果保留三位小数。

Sample Input
1
1.5

Sample Output
4.189
14.137

提示：#define PI 3.1415927

注意：球体积公式是 4/3PIR^3

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

int main() {
	double r;
	while (cin>> r) {
		printf("%.3lf\n", (pow(r, 3)*PI*4/3));
	}

	return 0;
}

2003 求绝对值

Problem Description
求实数的绝对值。

Input
输入数据有多组，每组占一行，每行包含一个实数。

Output
对于每组输入数据，输出它的绝对值，要求每组数据输出一行，结果保留两位小数。

Sample Input
123
-234.00

Sample Output
123.00
234.00

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

int main() {
	double x;
	while (cin>> x) {
		double ans = fabs(x);
		printf("%.2lf\n", ans);
	}
	return 0;
}

2004 成绩等级

Problem Description
输入一个百分制的成绩 t，将其转换成对应的等级，具体转换规则如下：
90~100 为 A;

80~89 为 B;

70~79 为 C;

60~69 为 D;

0~59 为 E;

Input
输入数据有多组，每组占一行，由一个整数组成。

Output
对于每组输入数据，输出一行。如果输入数据不在 0~100 范围内，请输出一行：“Score is error!”。

Sample Input
56
67
100
123

Sample Output
E
D
A
Score is error!

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

int main() {
	int t;
	while (cin>> t) {
		if (t > 100 || t < 0) {
			cout<< "Score is error!"<< endl;
		} else if (t >= 90) {
			cout<< "A"<< endl;
		} else if (t >= 80) {
			cout<< "B"<< endl;
		} else if (t >= 70) {
			cout<< "C"<< endl;
		} else if (t >= 60) {
			cout<< "D"<< endl;
		} else {
			cout<< "E"<< endl;
		}
	}

	return 0;
}

2005 第几天

Problem Description
给定一个日期，输出这个日期是该年的第几天。

Input
输入数据有多组，每组占一行，数据格式为 YYYY/MM/DD 组成，具体参见 sample input ,另外，可以向你确保所有的输入数据是合法的。

Output
对于每组输入数据，输出一行，表示该日期是该年的第几天。

Sample Input
1985/1/20
2006/3/12

Sample Output
20
71

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


int main() {
	int y, m, d;
	char c;
	while (cin>> y>> c>> m>> c>> d) {
		int ans = 0;
		for (int i = 1; i < m; i++) {
			if (i == 2 && (y % 400 == 0 || (y % 4 == 0 && y % 100 != 0))) { //是否是闰年
				ans += 29;
			} else if (i == 2) {
				ans += 28;
			} else if (i==4 || i==6 || i==9 || i==11) {
				ans += 30;
			} else {
				ans += 31;
			}
		}
		cout<< ans + d<< endl;
	}
	return 0;
}

2006 求奇数的乘积

Problem Description
给你 n 个整数，求他们中所有奇数的乘积。

Input
输入数据包含多个测试实例，每个测试实例占一行，每行的第一个数为 n，表示本组数据一共有 n 个，接着是 n 个整数，你可以假设每组数据必定至少存在一个奇数。

Output
输出每组数中的所有奇数的乘积，对于测试实例，输出一行。

Sample Input
3 1 2 3
4 2 3 4 5

Sample Output
3
15

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

int main() {
	int n;
	while (cin>> n) {
		long long ans = 1;
		for (int i = 0; i < n; i++) {
			int a;
			cin>> a;
			if (a % 2 == 1) {
				ans *= a;
			}
		}
		cout<< ans<< endl;
	}

	return 0;
}

2007 平方和与立方和

Problem Description
给定一段连续的整数，求出他们中所有偶数的平方和以及所有奇数的立方和。

Input
输入数据包含多组测试实例，每组测试实例包含一行，由两个整数 m 和 n 组成。

Output
对于每组输入数据，输出一行，应包括两个整数 x 和 y，分别表示该段连续的整数中所有偶数的平方和以及所有奇数的立方和。
你可以认为 32 位整数足以保存结果。

Sample Input
1 3
2 5

Sample Output
4 28
20 152

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

int main() {
	long long x, y, temp;
	while (cin>> x>> y) {
		long long evenSum = 0, oddSum = 0;
		if (x > y) {
			temp = x;
			x = y;
			y = temp;
		}  //注意当题目过不了的时候可以考虑加上这种方法
		for (; x <= y; x++) {
			if (x%2 == 0) {
				evenSum += x*x;
			} else {
				oddSum += x*x*x;
			}
		}
		cout<< evenSum << " "<< oddSum<< endl;
	}
	return 0;
}

2008 数值统计

Problem Description
统计给定的 n 个数中，负数、零和正数的个数。

Input
输入数据有多组，每组占一行，每行的第一个数是整数 n（n<100），表示需要统计的数值的个数，然后是 n 个实数；如果 n=0，则表示输入结束，该行不做处理。

Output
对于每组输入数据，输出一行 a,b 和 c，分别表示给定的数据中负数、零和正数的个数。

Sample Input
6 0 1 2 3 -1 0
5 1 2 3 4 0.5
0

Sample Output
1 2 3
0 0 5

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

int main() {
	int n;
	while (cin>> n && n) {
		double a[99];
		int z = 0, f = 0, l = 0;
		for (int i = 0; i < n; i++) {
			cin>> a[i];
		}
		for (int i = 0; i < n; i++) {
			if (a[i] < 0) {
				f++;
			} else if (a[i] > 0) {
				z++;
			} else {
				l++;
			}
		}
		cout<< f<< " "<< l<< " "<< z<< endl;
	}

	return 0;
}

2009 求数列的和

Problem Description
数列的定义如下：
数列的第一项为 n，以后各项为前一项的平方根，求数列的前 m 项的和。

Input
输入数据有多组，每组占一行，由两个整数 n（n<10000）和 m(m<1000)组成，n 和 m 的含义如前所述。

Output
对于每组输入数据，输出该数列的和，每个测试实例占一行，要求精度保留 2 位小数。

Sample Input
81 4
2 2

Sample Output
94.73
3.41

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

int main() {
	double n, m;
	while (cin>> n>> m) {
		double ans = 0;
		for (int i = 0; i < m; i++) {
			ans += n;
			n = sqrt(n);
		}
		printf("%.2lf\n", ans);
	}

	return 0;
}

2010 水仙花数

Problem Description
春天是鲜花的季节，水仙花就是其中最迷人的代表，数学上有个水仙花数，他是这样定义的：
“水仙花数”是指一个三位数，它的各位数字的立方和等于其本身，比如：153=1^3+5^3+3^3。
现在要求输出所有在 m 和 n 范围内的水仙花数。

Input
输入数据有多组，每组占一行，包括两个整数 m 和 n（100<=m<=n<=999）。

Output
对于每个测试实例，要求输出所有在给定范围内的水仙花数，就是说，输出的水仙花数必须大于等于 m,
并且小于等于 n，如果有多个，则要求从小到大排列在一行内输出，之间用一个空格隔开;
如果给定的范围内不存在水仙花数，则输出 no; 每个测试实例的输出占一行。

Sample Input
100 120
300 380

Sample Output
no
370 371

注意： 1.每行数据末尾没有空格 2.输出给定范围内的数据

方法一：

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

int main() {
	int m, n;
	while (cin>> m>> n) {
		int b, s, g, flag = 0;
		int temp = n;
		if (100 <= m && n <= 999 && m < n) {
			for (;m <= n; m++) {  // 注意小于等于
				b = m / 100;
				s = m / 10 % 10;
				g = m % 100 % 10;
				if ((b*b*b + s*s*s + g*g*g) == m) {
					if (flag) {
						cout<< ' ';
					}
					cout<< m;
					flag = 1;
				}
			}
			if (!flag) {
				cout<< "no" << endl;
			} else {
				cout<< endl;
			}
		}
	}
	return 0;
}

方法二：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//方法2：通过已知答案来推敲
int main() {
	int m, n, flag = 0;
	while (cin>> m>> n) {
		for (; m < n; m++) {
			if (m==153||m==370||m==371||m==407) {
				cout<< m<< " ";
				flag = 1;
			}
		}
		if (!flag) {
			cout<< "no";
		}
		cout<< endl;
	}

	return 0;
}

2011 多项式求和

Problem Description
多项式的描述如下：
1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6 + ...
现在请你求出该多项式的前 n 项的和。

Input
输入数据由 2 行组成，首先是一个正整数 m（m<100），表示测试实例的个数，第二行包含 m 个正整数，对于每一个整数(不妨设为 n,n<1000），求该多项式的前 n 项的和。

Output
对于每个测试实例 n，要求输出多项式前 n 项的和。每个测试实例的输出占一行，结果保留 2 位小数。

Sample Input
2
1 2

Sample Output
1.00
0.50

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

int main() {
	int m, n;
	cin>> m;
	while (m--) {
		double ans = 0;
		cin>> n;
		for (int i = 1; i <= n; i++) {
			ans = (i % 2 == 0) ? (ans - 1.0/i) : (ans + 1.0/i);
		}
		printf("%.2lf\n", ans);
	}

	return 0;
}

2012 素数判定

Problem Description
对于表达式 n^2 + n + 41，当 n 在（x,y）范围内取整数值时（包括 x, y）(-39<=x<y<=50)，判定该表达式的值是否都为素数。

Input
输入数据有多组，每组占一行，由两个整数 x，y 组成，当 x=0,y=0 时，表示输入结束，该行不做处理。

Output
对于每个给定范围内的取值，如果表达式的值都为素数，则输出"OK",否则请输出“Sorry”,每组输出占一行。

Sample Input
0 1
0 0

Sample Output
OK

注意：素数判断只需看 2 ~ √m 之间是否能被整除，能则不是素数

By the way, 质数又称素数

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

int main() {
	int x, y;
	while (cin>> x>> y && (x || y)) {
		int ss;  //素数
		int flag = 1;   //标志素数
		for (int i = x; i <= y; i++) {
			ss = i*i + i + 41;
			for (int j = 2; j <= sqrt(ss); j++) {  //判断素数
				if (ss % j == 0) {
					cout<< "Sorry"<< endl;
					flag = 0;
					break;
				}
			}
			if (!flag) {
				break;
			}
		}
		if (flag) {
			cout<< "OK"<< endl;
		}
	}

	return 0;
}

2013 蟠桃记

Problem Description
喜欢西游记的同学肯定都知道悟空偷吃蟠桃的故事，其实你们是有所不知：悟空是在研究一个数学问题！他研究的问题是蟠桃一共有多少个！
当时的情况是这样的：
第一天悟空吃掉桃子总数一半多一个，第二天又将剩下的桃子吃掉一半多一个，以后每天吃掉前一天剩下的一半多一个，到第 n 天准备吃的时候只剩下一个桃子。聪明的你，请帮悟空算一下，他第一天开始吃的时候桃子一共有多少个呢？

Input
输入数据有多组，每组占一行，包含一个正整数 n（1<n<30），表示只剩下一个桃子的时候是在第 n 天发生的。

Output
对于每组输入数据，输出第一天开始吃的时候桃子的总数，每个测试实例占一行。

Sample Input
2
4

Sample Output
4
22

逆向思维(倒放)：猴子每天先吐出一个桃子，然后再吐出 2 倍的桃子

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

int main() {
	int n;
	while (cin>> n) {
		int pnum = 1;
		for (int i = 1; i < n; i++) {
			pnum = 2 * (pnum + 1);
		}
		cout<< pnum<< endl;
	}

	return 0;
}

2014 大赛评分

Problem Description
青年歌手大奖赛中，评委会给参赛选手打分。选手得分规则为去掉最高最低分，然后计算平均分，请编程输出某选手的得分。

Input
输入数据有多组，每组占一行，每行的第一个数是 n(2<n<=100)，表示评委的人数，然后是 n 个评委的打分。

Output
对于每组输入数据，输出选手的得分，结果保留 2 位小数，每组输出占一行。

Sample Input
3 99 98 97
4 100 99 98 97

Sample Output
98.00
98.50

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

int main() {
	int n;
	while (cin>> n) {
		double grades[100], avg = 0;
		for (int i = 0; i < n; i++) {
			cin>> grades[i];
		}
		sort(grades, grades+n);  //排序
		for (int i = 1; i < n - 1; i++) {
			avg += grades[i];
		}
		printf("%.2lf\n", avg/(n-2));
	}

	return 0;
}

2015 偶数数列平均值

Problem Description
有一个长度为 n(n<=100)的数列，该数列定义为从 2 开始的递增有序偶数，现在要求你按照顺序每 m 个数求出一个平均值，如果最后不足 m 个，则以实际数量求平均值。编程输出该平均值序列。

Input
输入数据有多组，每组占一行，包含两个正整数 n 和 m，n 和 m 的含义如上所述。

Output
对于每组输入数据，输出一个平均值序列，每组输出占一行。

Sample Input
3 2
4 2

Sample Output
3 6
3 7

注意：用数列的中位数来算均值方便些

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

int main() {
	int n, m, a[100];
	a[0] = 2;
	for (int i = 1; i < 100; i++) {
		a[i] = a[i-1] + 2;
	}
	while (cin>> n>> m) {
		int i;
		for (i = 0; i < n; i+=m) {
			if (n - i < m) {   	   //最后数列不足m个
				if (m % 2 == 0) {  //m为偶数
					if (i) {cout<< " ";}
					cout<< (a[i+(n-i)/2] + a[i])/2;
				} else { 		   //m为奇数
					if (i) {cout<< " ";}
					cout<< a[i-((n-i)-1)/2];
				}
			} else {
				if (m % 2 == 0) {  //m为偶数
					if (i) {cout<< " ";}
					cout<< (a[i+m/2] + a[i])/2;
				} else { 		   //m为奇数
					if (i) {cout<< " ";}
					cout<< a[i+(m-1)/2];
				}
			}
		}
		cout<< endl;
	}

	return 0;
}

2016 数据的交换输出

Problem Description
输入 n(n<100)个数，找出其中最小的数，将它与最前面的数交换后输出这些数。

Input
输入数据有多组，每组占一行，每行的开始是一个整数 n，表示这个测试实例的数值的个数，跟着就是 n 个整数。n=0 表示输入的结束，不做处理。

Output
对于每组输入数据，输出交换后的数列，每组输出占一行。

Sample Input
4 2 1 3 4
5 5 4 3 2 1
0

Sample Output
1 2 3 4
1 4 3 2 5

注意：一定要将 flag 初始化，否则 min 一开始就是最小的话，
那么 if 就不执行，从而 flag 至始至终没有值， 从而导致 temp 那儿的转化出错

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

int main() {
	int n;
	while(cin>> n && n && n < 100) {
		int flag = 0, min, a[100];
		for (int i = 0; i < n; i++) {
			cin>> a[i];
			if (!i) {min = a[i];}
			if (min > a[i]) {
				min = a[i];
				flag = i;
			}
		}

		int temp = a[0];
		a[0] = a[flag];
		a[flag] = temp;

		for (int i = 0; i < n; i++) {
			if (i) {cout<< " ";}
			cout<< a[i];
		}
		cout<< endl;
	}

	return 0;
}

2017 字符串统计

Problem Description
对于给定的一个字符串，统计其中数字字符出现的次数。

Input
输入数据有多行，第一行是一个整数 n，表示测试实例的个数，后面跟着 n 行，每行包括一个由字母和数字组成的字符串。

Output
对于每个测试实例，输出该串中数值的个数，每个输出占一行。

Sample Input
2
asdfasdf123123asdfasdf
asdf111111111asdfasdfasdf

Sample Output
6
9

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

int main() {
	int n;
	cin>> n;
	while (n--) {
		char a[1000];
		cin>> a;
		int sum = 0;
		for (int i = 0; a[i] != '\0'; i++) {
			if (a[i] <= '9' && a[i] >= '0') {
				sum++;
			}
		}
		cout<< sum<< endl;
	}

	return 0;
}

2018 母牛的数量

Problem Description
有一头母牛，它每年年初生一头小母牛。每头小母牛从第四个年头开始，每年年初也生一头小母牛。请编程实现在第 n 年的时候，共有多少头母牛？

Input
输入数据由多个测试实例组成，每个测试实例占一行，包括一个整数 n(0<n<55)，n 的含义如题目中描述。
n=0 表示输入数据的结束，不做处理。

Output
对于每个测试实例，输出在第 n 年的时候母牛的数量。
每个输出占一行。

Sample Input
2
4
5
0

Sample Output
2
4
6

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

int main() {
	int n;
	while (cin>> n && n) {
		// 各年龄牛数的初始化
		int num1 = 0; //1岁的母牛数
		int num2 = 0; //2岁的母牛数
		int num3 = 0; //3岁的母牛数
		int num4 = 1; //4岁及以上的母牛数，可生牛了
		int t1, t2, t3, t4; //temp
		for (int i = 2; i <= n; i++) {
			t1 = num1;
			t2 = num2;
			t3 = num3;
			t4 = num4;
			num1 += t4 - t1; //num1取决于num4有多少，又因为大了一岁，所以这个年龄区间牛数还要减去原来的
			num2 += t1 - t2; //num2取决于num1有多少，同样需要减去原来牛数
			num3 += t2 - t3; //以此类推
			num4 += t3;		 //4年及以上不用减去原来的牛数了，扎堆
			num1 += t3;      //3岁牛一到4岁就要生一岁的牛，再加t3
		}
		cout<< num1 + num2 + num3 + num4<< endl;
	}

	return 0;
}

2019 数列有序

Problem Description
有 n(n<=100)个整数，已经按照从小到大顺序排列好，现在另外给一个整数 m，
请将该数插入到序列中，并使新的序列仍然有序。

Input
输入数据包含多个测试实例，每组数据由两行组成，第一行是 n 和 m，
第二行是已经有序的 n 个数的数列。n 和 m 同时为 0 标示输入数据的结束，本行不做处理。

Output
对于每个测试实例，输出插入新的元素后的数列。

Sample Input
3 3
1 2 4
0 0

Sample Output
1 2 3 4

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


int main() {
	int n, m;
	while (cin>> n>> m && (n || m)) {
		int a[100];
		for (int i = 0; i < n; i++) {
			cin>> a[i];
		}
		a[n] = m;
		sort(a, a+n+1); //+1是因为又多了一个m数
		for (int i = 0; i <= n; i++) {
			if(i) {cout<< " ";}
			cout<< a[i];
		}
		cout<< endl;
	}

	return 0;
}

2020 绝对值排序

Problem Description
输入 n(n<=100)个整数，按照绝对值从大到小排序后输出。题目保证对于每一个测试实例，所有的数的绝对值都不相等。

Input
输入数据有多组，每组占一行，每行的第一个数字为 n,接着是 n 个整数，n=0 表示输入数据的结束，不做处理。

Output
对于每个测试实例，输出排序后的结果，两个数之间用一个空格隔开。每个测试实例占一行。

Sample Input
3 3 -4 2
4 0 1 2 -3
0

Sample Output
-4 3 2
-3 2 1 0

方法一：

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

int main() {
	int n;
	while (cin>> n && n) {
		int a[100], b[100];
		for (int i = 0; i < n; i++) {
			cin>> a[i];
			b[i] = a[i];
		}
		for (int i = 0; i < n; i++)	{
			b[i] = abs(b[i]);
		}
		sort(b, b+n);
		reverse(b, b+n);
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				if (b[i] == -a[j]) {
					b[i] = -b[i];
				}
			}
		}
		for (int i = 0; i < n; i++) {
			if (i) {
				cout<< " ";
			}
			cout<< b[i];
		}
		cout<<endl;
	}
	return 0;
}

方法二：

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

bool compare(int a, int b) {
	return abs(a) > abs(b);
}

int main() {
	int n;
	while (cin>> n && n) {
		int a[100];
		for (int i = 0; i < n; i++) {
			cin>> a[i];
		}
		sort(a, a+n, compare);
		for (int i = 0; i < n; i++) {
			if (i) {cout<< " ";}
			cout<< a[i];
		}
		cout<<endl;
	}
	return 0;
}

2021 发工资

Problem Description
作为杭电的老师，8 号这一天是发工资的日子，财务处的小胡老师最近就在考虑一个问题：
如果每个老师的工资额都知道，最少需要准备多少张人民币，才能在给每位老师发工资的时候都不用老师找零呢？
这里假设老师的工资都是正整数，单位元，人民币一共有 100 元、50 元、10 元、5 元、2 元和 1 元六种。

Input
输入数据包含多个测试实例，每个测试实例的第一行是一个整数 n（n<100），表示老师的人数，然后是 n 个老师的工资。
n=0 表示输入的结束，不做处理。

Output
对于每个测试实例输出一个整数 x,表示至少需要准备的人民币张数。每个输出占一行。

Sample Input
3
1 2 3
0

Sample Output
4

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

int main() {
    int n;
    while (cin >> n && n) {
        int num = 0;           //人民币张数
        int a[100];            //老师工资
        int b, ws, s, w, e, y; //六种面值的张数
        for (int i = 0; i < n; i++) {
            cin >> a[i];
            b = a[i] / 100;
            ws = a[i] % 100 / 50;
            s = a[i] % 100 % 50 / 10;
            w = a[i] % 100 % 50 % 10 / 5;
            e = a[i] % 100 % 50 % 10 % 5 / 2;
            y = a[i] % 100 % 50 % 10 % 5 % 2;
            num += b + ws + s + w + e + y;
        }
        cout << num << endl;
    }

    return 0;
}

2022 海选女主角

Problem Description
hss 开办了一个女友竞选面试，面试那天，来了 mn 个 MM，站成一个 mn 的队列，hss 的助理团为每个 MM 打了分数，分数都是 32 位有符号整数。如果 MM 不太优秀，分数有可能是负数哦! 奇怪的是，hss 的目的是要选一个面试分数绝对值（必须还是 32 位整数）最大的 MM，差到极点也是好。

Input
输入数据有多组，每组的第一行是两个整数 m 和 n，表示应聘 MM 的总共的行列数，然后是 m 行整数，每行有 n 个，m 和 n 的定义见题目的描述。

Output
对于每组输入数据，输出三个整数 x,y 和 s，分别表示选中的 MM 的行号、列号和分数。
note:行号和列号从一开始，如果有多个 MM 的分数绝对值一样，那么输出排在最前面的一个（即行号最小的那个，如果行号相同则取列号最小的那个）。

Sample Input
2 3
1 4 -3
-7 3 0

Sample Output
2 1 -7

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

int main() {
	int m, n;
	while (cin>> m>> n) {
		int mm[100][100];
		int max = 0, I, J;
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				cin>> mm[i][j];
			}
		}
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				if (abs(max) < abs(mm[i][j])) {
					max = mm[i][j];
					I = i;
					J = j;
				}
			}
		}
		cout<< I+1 << " "<< J+1 << " "<< max<< endl;

	}

	return 0;
}

2023 求平均成绩

Problem Description
假设一个班有 n(n<=50)个学生，每人考 m(m<=5)门课，求每个学生的平均成绩和每门课的平均成绩，并输出各科成绩均大于等于平均成绩的学生数量。

Inp
输入数据有多个测试实例，每个测试实例的第一行包括两个整数 n 和 m，分别表示学生数和课程数。然后是 n 行数据，每行包括 m 个整数（即：考试分数）。

Output
对于每个测试实例，输出 3 行数据，第一行包含 n 个数据，表示 n 个学生的平均成绩，结果保留两位小数；第二行包含 m 个数据，表示 m 门课的平均成绩，结果保留两位小数；第三行是一个整数，表示该班级中各科成绩均大于等于平均成绩的学生数量。
每个测试实例后面跟一个空行。

Sample Input
2 2
5 10
10 20

Sample Output
7.50 15.00
7.50 15.00
1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <iostream>
#include <math.h>
#include <string.h>
using namespace std;

int main() {
	int n, m;
	while (cin>> n>> m) {
		double Savg[50], Cavg[5];  //数组大小要大于题目给定的极值
		int sc[50][5];
		int sum = 0;  //各科成绩均 >= 平均成绩的学生数量
		memset(Savg, 0, sizeof(Savg));
		memset(Cavg, 0, sizeof(Cavg));

		//输入每名学生成绩
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				cin>> sc[i][j];
			}
		}

		//求每位同学的平均成绩
		for (int i = 0; i < n; i++) { //学生
			for (int j = 0; j < m; j++) {  //课程
				Savg[i] += sc[i][j];  //把第i位同学所有课程成绩累加
				Cavg[j] += sc[i][j];  //把第j门课程所有同学成绩累加
			}
			if(i){
				cout<< " ";
			}
			Savg[i] /= (m*1.0);
			printf("%.2lf", Savg[i]);
		}
		cout<< endl;

		//求每们课的平均成绩
		for (int i = 0; i < m; i++) {
			if(i) {
				cout<< " ";
			}
			Cavg[i] /= (n*1.0);
			printf("%.2lf", Cavg[i]);
		}
		cout<< endl;

		//求各科成绩均 >= 平均成绩的学生数量
		for (int i = 0; i < n; i++) { //学生
			int flag = 1;  //1代表符合，0代表不符合
			for (int j = 0; j < m; j++) {  //课程
				if (sc[i][j] < Cavg[j]) {
					flag = 0;
					break;
				}
			}
			if (flag) {
				sum++;
			}
		}
		cout<< sum<< endl<< endl;  //注意题目要求：每个实例后跟一个空行
	}
	return 0;
}

2024 C 语言合法标识符判断

Problem Description
输入一个字符串，判断其是否是 C 的合法标识符。

Input
输入数据包含多个测试实例，数据的第一行是一个整数 n，表示测试实例的个数，
然后是 n 行输入数据，每行是一个长度不超过 50 的字符串。

Output
对于每组输入数据，输出一行。如果输入数据是 C 的合法标识符，则输出"yes"，否则，输出“no”。

Sample Input
3
12ajf
fi8x_a
ff ai_2

Sample Output
no
yes
no

提示：合法标识符由字母、下划线、数字这三个方面组成，但开头必须是字母或下划线

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

int main() {
    int n;
    cin >> n;
    getchar(); //把无用的回车字符吸收掉
    while (n--) {
        char s[50];
        int flag = 1; // 0不满足，1满足
        gets(s);
        if ((s[0] >= 'a' && s[0] <= 'z') || (s[0] >= 'A' && s[0] <= 'Z') ||
            s[0] == '_') {
            for (int i = 1; s[i] != '\0'; i++) {
                if (!((s[i] >= 'a' && s[i] <= 'z') ||
                      (s[i] >= 'A' && s[i] <= 'Z') || (s[i] == '_') ||
                      (s[i] >= '0' && s[i] <= '9'))) {
                    flag = 0;
                }
            }
        } else {
            flag = 0;
        }
        if (flag) {
            cout << "yes" << endl;
        } else {
            cout << "no" << endl;
        }
    }

    return 0;
}

2025 查找最大字母

Problem Description
对于输入的每个字符串，查找其中的最大字母，在该字母后面插入字符串“(max)”。

Input
输入数据包括多个测试实例，每个实例由一行长度不超过 100 的字符串组成，字符串仅由大小写字母构成。

Output
对于每个测试实例输出一行字符串，输出的结果是插入字符串“(max)”后的结果，
如果存在多个最大的字母，就在每一个最大字母后面都插入"(max)"。

Sample Input
abcdefgfedcba
xxxxx

Sample Output
abcdefg(max)fedcba
x(max)x(max)x(max)x(max)x(max)

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


int main() {
	char a[100];
	while (cin>> a) {
		char max = a[0];
		for (int i = 0; a[i] != '\0'; i++) {
			if (max < a[i]) {
				max = a[i];
			}
		}
		for (int i = 0; a[i] != '\0'; i++) {
			cout<< a[i];
			if (max == a[i]) {
				cout<< "(max)";
			}
		}
		cout<< endl;
	}

	return 0;
}

2026 首字母变大写

Problem Description
输入一个英文句子，将每个单词的第一个字母改成大写字母。

Input
输入数据包含多个测试实例，每个测试实例是一个长度不超过 100 的英文句子，占一行。

Output
请输出按照要求改写后的英文句子。

Sample Input
i like acm
i want to get an accepted

Sample Output
I Like Acm
I Want To Get An Accepted

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


int main() {
	char s[100];
	while(gets(s)) {
		s[0] -= 32;
		for (int i = 1; s[i] != '\0'; i++) {
			if (s[i] == ' ') {
				s[i+1] -= 32;
			}
		}
		cout<< s<< endl;
	}

	return 0;
}

2027 统计元音

Problem Description
统计每个元音字母在字符串中出现的次数。

Input
输入数据首先包括一个整数 n，表示测试实例的个数，
然后是 n 行长度不超过 100 的字符串。

Output
对于每个测试实例输出 5 行，格式如下：
a:num1
e:num2
i:num3
o:num4
u:num5
多个测试实例之间由一个空行隔开。

请特别注意：最后一块输出后面没有空行：）

Sample Input
2
aeiou
my name is ignatius

Sample Output
a:1
e:1
i:1
o:1
u:1

a:2
e:1
i:3
o:0
u:1

注意：定义变量时变量名不要搞重复了

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

int main() {
    int n, a, e, i, o, u;
    cin >> n;
    getchar();
    while (n--) {
        a = e = i = o = u = 0;
        char c[100];
        gets(c);
        for (int k = 0; c[k] != '\0'; k++) {
            if (c[k] == 'a') {
                a++;
            } else if (c[k] == 'e') {
                e++;
            } else if (c[k] == 'i') {
                i++;
            } else if (c[k] == 'o') {
                o++;
            } else if (c[k] == 'u') {
                u++;
            }
        }
        cout << "a:" << a << endl;
        cout << "e:" << e << endl;
        cout << "i:" << i << endl;
        cout << "o:" << o << endl;
        cout << "u:" << u << endl;
        if (n) {
            cout << endl;
        }
    }

    return 0;
}

2028 最小公倍数

Problem Description
求 n 个数的最小公倍数。

Input
输入包含多个测试实例，每个测试实例的开始是一个正整数 n，然后是 n 个正整数。

Output
为每组测试数据输出它们的最小公倍数，每个测试实例的输出占一行。你可以假设最后的输出是一个 32 位的整数。

Sample Input
2 4 6
3 2 5 7

Sample Output
12
70

提示：最小公倍数为俩数之积除它们的最大公约数，而最大公约数采用辗转相除法。

辗转相除法 思路：

有两整数 a 和 b

  1. a%b 得余数 c
  2. 若 c=0，则 b 即为两数的最大公约数
  3. 若 c≠0，则 a=b，b=c，再回去执行步骤 1

本题 a = a / divisor(a, b) * b 这个地方，OJ 只能让 b 在后面乘才能通过，终于想明白了，因为如果 b 先乘，可能数字会越界，所以先除，数变小了再乘，细节。。。

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

int divisor (int a, int b) {  //用来求最大公约数，运用到了递归
	if (b == 0) {
		return a;
	} else {
		return divisor(b, a % b);
	}
}

int main() {
	int n;
	while (cin>> n) {
		int a, b;
		cin>> a;
		for (int i = 1; i < n; i++) {
			cin>> b;
			a = a / divisor(a, b) * b; //每一次和新输入的数进行求最小公倍数
		}

		cout<< a<< endl;
	}

	return 0;
}

2029 回文数（简单版）

Problem Description
“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。
请写一个程序判断读入的字符串是否是“回文”。

Input
输入包含多个测试实例，输入数据的第一行是一个正整数 n,表示测试实例的个数，后面紧跟着是 n 个字符串。

Output
如果一个字符串是回文串，则输出"yes",否则输出"no".

Sample Input
4
level
abcde
noon
haha

Sample Output
yes
no
yes
no

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

int main() {
    int n;
    cin >> n;

    string str, s;
    getchar();
    while (n--) {
        cin >> str;
        s = str;
        reverse(str.begin(), str.end());
        if (str == s) {
            cout << "yes" << endl;
        } else {
            cout << "no" << endl;
        }
    }

    return 0;
}

2030 汉字统计

Problem Description
统计给定文本文件中汉字的个数。

Input
输入文件首先包含一个整数 n，表示测试实例的个数，然后是 n 段文本。

Output
对于每一段文本，输出其中的汉字的个数，每个测试实例的输出占一行。

[提示:]从汉字机内码的特点考虑~

Sample Input
2
WaHaHa! WaHaHa! 今年过节不说话要说只说普通话 WaHaHa! WaHaHa!
马上就要期末考试了 Are you ready?

Sample Output
14
9

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

int main() {
	int n, count;
	cin>> n;
	getchar();
	while (n--) {
		char c;
		count = 0;
		while ((c = getchar()) != '\n') {
			if (c < 0) {  //汉字ASCii码小于0
				count++;
			}
		}
		cout<< count / 2 << endl; //因为汉字有2个字节，所以除以2
	}

	return 0;
}

2032 杨辉三角打印

Problem Description
还记得中学时候学过的杨辉三角吗？具体的定义这里不再描述，你可以参考以下的图形：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

Input
输入数据包含多个测试实例，每个测试实例的输入只包含一个正整数 n（1<=n<=30），表示将要输出的杨辉三角的层数。

Output
对应于每一个输入，请输出相应层数的杨辉三角，每一层的整数之间用一个空格隔开，每一个杨辉三角后面加一个空行。

Sample Input
2 3

Sample Output
1
1 1

1
1 1
1 2 1

注意：

  1. 不要用阶乘的方式，因为容易超出字节长度。
  2. 每行结尾不要有空格
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <iostream>
using namespace std;


int main() {
	int n, i, j;
	int yhsj[30][30];
	yhsj[0][0] = 1;
	yhsj[1][0] = 1;
	yhsj[1][1] = 1;
	for (i = 2; i < 30; i++) {
		for (j = 0; j <= i; j++) {
			if (j == 0 || j == i) {
				yhsj[i][j] = 1;
			} else {
				yhsj[i][j] = yhsj[i-1][j] + yhsj[i-1][j-1];
			}
		}
	}

	while (cin>> n) {
		for (i = 0; i < n; i++) {
			for (j = 0; j < i; j++) {
				cout<< yhsj[i][j]<< " ";
			}
			cout<< yhsj[i][j]<<endl;
		}
		cout<< endl;
	}
	return 0;
}

2035 A^B

Problem Description
求 A^B 的最后三位数表示的整数。
说明：A^B 的含义是“A 的 B 次方”

Input
输入数据包含多个测试实例，每个实例占一行，由两个正整数 A 和 B 组成（1<=A,B<=10000），
如果 A=0, B=0，则表示输入数据的结束，不做处理。

Output
对于每个测试实例，请输出 A^B 的最后三位表示的整数，每个输出占一行。

Sample Input
2 3
12 6
6789 10000
0 0

Sample Output
8
984
1

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

int main() {
	int A, B;
	while (cin>> A>> B && A && B) {
		int ans = A;
		for (int i = 0; i < B - 1; i++) {
			ans = (ans * A) % 1000;
		}
		cout<< ans<< endl;
	}

	return 0;
}

2039 三角形

Problem Description
给定三条边，请你判断一下能不能组成一个三角形。

Input
输入数据第一行包含一个数 M，接下有 M 行，每行一个实例，包含三个正数 A,B,C。其中 A,B,C <1000;

Output
对于每个测试实例，如果三条边长 A,B,C 能组成三角形的话，输出 YES，否则 NO。

Sample Input
2
1 2 3
2 2 2

Sample Output
NO
YES

注意：ABC 的描述是正数(用 double)，别理解成整数了(不用 int)

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

int main() {
	int M;
	cin>> M;
	while (M--) {
		double A, B, C;
		cin>> A>> B>> C;
		if ((A+B)>C && (A+C)>B && (B+C)>A
		&& A<1000 && B<1000 && C<1000
		&& A>0 && B>0 && C>0) {
			cout<< "YES"<< endl;
		} else {
			cout<< "NO"<< endl;
		}
	}
	return 0;
}

2040 亲和数

Problem Description
古希腊数学家毕达哥拉斯在自然数研究中发现，220 的所有真约数(即不是自身的约数)之和为：
1+2+4+5+10+11+20+22+44+55+110 ＝ 284。
而 284 的所有真约数为 1、2、4、71、 142，加起来恰好为 220。人们对这样的数感到很惊奇，并称之为亲和数。
一般地讲，如果两个数中任何一个数都是另一个数的真约数之和，则这两个数就是亲和数。
你的任务就编写一个程序，判断给定的两个数是否是亲和数

Input
输入数据第一行包含一个数 M，接下有 M 行，每行一个实例,包含两个整数 A,B； 其中 0 <= A,B <= 600000 ;

Output
对于每个测试实例，如果 A 和 B 是亲和数的话输出 YES，否则输出 NO。

Sample Input
2
220 284
100 200

Sample Output
YES
NO

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

int main() {
	int n;
	cin>> n;
	while (n--) {
		int a[2], sum0, sum1;
		sum0 = sum1 = 0;
		cin>> a[0]>> a[1];
		for (int i = 1; i <= a[0] / 2; i++) {
			if (a[0] % i == 0) {
				sum0 += i;
			}
		}
		for (int i = 1; i <= a[1] / 2; i++) {
			if (a[1] % i == 0) {
				sum1 += i;
			}
		}
		if (sum1==a[0] && sum0==a[1]) {
			cout<< "YES" << endl;
		} else {
			cout<< "NO" << endl;
		}
	}

	return 0;
}

2042 老汉付过路费

Problem Description
徐老汉带着一群羊准备到另一个地方卖掉，路途有很多路口收费站，由于徐老汉没钱，收费员就将他的羊拿走一半，
看到老汉泪水涟涟，心疼又还给老汉一只。巧的是，后面每过一个收费站，都是拿走当时羊的一半，
然后退还一只，等到老汉到达市场，就只剩下 3 只羊了，你能帮忙算一下老汉最初有多少只羊吗？

Input
输入数据第一行是一个整数 N，下面由 N 行组成，每行包含一个整数 a(0<a<=30),表示收费站的数量。

Output
对于每个测试实例，请输出最初的羊的数量,每个测试实例的输出占一行。

Sample Input
2
1
2

Sample Output
4
6

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

int station(int sheep, int a) {
    for (int i = 1; i <= a; i++) {
        sheep = 2 * (sheep - 1);
    }

    return sheep;
}

int main() {
    int N, a, sheep = 3;
    cin >> N;
    while (N--) {
        cin >> a;
        cout << station(sheep, a) << endl;
    }

    return 0;
}

2043 判断安全密码

Problem Description
首先，我们要设一个安全的密码。那什么样的密码才叫安全的呢？
一般来说一个比较安全的密码至少应该满足下面两个条件：
(1)密码长度大于等于 8，且不要超过 16。
(2)密码中的字符应该来自下面“字符类别”中四组中的至少三组。
这四个字符类别分别为： 1.大写字母：A,B,C...Z; 2.小写字母：a,b,c...z; 3.数字：0,1,2...9; 4.特殊符号：~,!,@,#,$,%,^;

给你一个密码，你的任务就是判断它是不是一个安全的密码。

Input
输入数据第一行包含一个数 M，接下有 M 行，每行一个密码（长度最大可能为 50），密码仅包括上面的四类字符。

Output
对于每个测试实例，判断这个密码是不是一个安全的密码，是的话输出 YES，否则输出 NO。

Sample Input
3
a1b2c3d4
Linle@ACM
^~^@^@!%

Sample Output
NO
YES
NO

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

int main() {
	int M;
	cin>> M;
	getchar();
	while (M--) {
		char pwd;
		int a, b, c, d, num, flag;
		a = b = c = d = num = 0;
		flag = 1;
		while ((pwd = getchar()) != '\n') {
			if (pwd >= 'A' && pwd <= 'Z') {
				a = 1;
			} else if (pwd >= 'a' && pwd <= 'z') {
				b = 1;
			} else if (pwd >= '0' && pwd <= '9') {
				c = 1;
			} else if (pwd == '~' || pwd == '!' || pwd == '@'
			|| pwd == '#' || pwd == '$' || pwd == '%' || pwd == '^') {
				d = 1;
			} else {
				cout<< "NO"<< endl;
				flag = 0;
			}
			num++; // 统计密码长度
		}
		if (flag) { // flag为0则说明之前已经打印了NO，无需在判断了
			if (a + b + c + d >= 3 && num >= 8 && num <= 16) {
				cout<< "YES"<< endl;
			} else {
				cout<< "NO"<< endl;
			}
		}
	}

	return 0;
}

2055 一个简单的问题

问题描述
我们定义 f（A）= 1，f（a）= -1，f（B）= 2，f（b）= -2，... f（Z）= 26，f（z）= -26;
给您一个字母 x 和一个数字 y，您应该输出 y + f（x）的结果。

输入项
第一行包含一个数字 T，然后是 T 行，每行是一个 case。每个 case 包含一个字母和一个数字。

输出量
对于每种情况，您应将 y + f（x）的结果放在一行上。

样本输入
6
R 1
P 2
G 3
r 1
p 2
g 3

样本输出
19
18
10
-17
-14
-4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <iostream>
#include <math.h>
#include <string.h>
#define length 1000
using namespace std;

int f(int a) {
	a += 0;
	if (a >= 97) {
		a = 96 - a;
	} else {
		a -= 64;
	}
	return a;
}

int main() {
	int T;
	cin>> T;
	char ltr[length];
	int num[length];
	for (int i = 0; i < T; i++) {
		cin>> ltr[i]>> num[i];  //字母和数字都输入进去
	}

	for (int i = 0; i < T; i++) {
		cout<< num[i] + f(ltr[i])<< endl;  //计算结果
	}

	return 0;
}

2070 斐波那契数

问题描述
您对此问题的目标是开发一个程序，该程序将生成一个斐波纳契数。fibbonacci 函数的定义如下：
f（0）= 0
f（1）= 1
f（n）= f（n-1）+ f（n-2）
您的程序应该能够处理 n 中的 n 值。范围从 0 到 50。

输入项
每个测试用例在一行中由一个整数 n 组成，其中 0≤n≤50。输入以-1 终止。

输出量
针对每个测试用例，在一行中打印出答案。

样本输入
3
4
5
-1

样本输出
2
3
5

注意：函数返回值也要是 long long 型

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

int main() {
	int n;
	long long a[51];
	a[0] = 0;
	a[1] = 1;

	for (int i = 2; i <= 50; i++) {  //斐波那契数组
		a[i] = a[i-1] + a[i-2];
	}

	while (cin>> n && n != -1) {
		cout<< a[n]<< endl;
	}

	return 0;
}

2071 最大身高

问题描述
班上有一些学生，你能帮助老师找到最高的学生吗？

输入项
有一些情况。第一行包含一个整数 t，表示情况；每个案例的整数 n（1≤n≤100），后跟 n 个学生的身高。

输出量
对于每种情况，输出的最高高度均为两个十进制小数点的高度；

样本输入
2
3 170.00 165.00 180.00
4 165.00 182.00 172.00 160.00

样本输出
180.00
182.00

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

int main() {
	int t, n;
	cin>> t;
	while (t-- && cin>> n) {
		double a[100], max;
		for (int i = 0; i < n; i++) {
			cin>> a[i];
		}
		max = a[0];
		for (int i = 0; i < n; i++) {
			if (max < a[i]) {
				max = a[i];
			}
		}
		printf("%.2lf\n", max);
	}

	return 0;
}

2073 无限的路

甜甜从小就喜欢画图画，最近他买了一支智能画笔，由于刚刚接触，
所以甜甜只会用它来画直线，于是他就在平面直角坐标系中画出如下的图形：
如图（2073 无限的路.jpg）
甜甜的好朋友蜜蜜发现上面的图还是有点规则的，于是他问甜甜：
在你画的图中，我给你两个点，请你算一算连接两点的折线长度（即沿折线走的路线长度）吧。

Input
第一个数是正整数 N（≤100）。代表数据的组数。
每组数据由四个非负整数组成 x1，y1，x2，y2；所有的数都不会大于 100。

Output
对于每组数据，输出两点(x1,y1),(x2,y2)之间的折线距离。注意输出结果精确到小数点后 3 位。

Sample Input
5
0 0 0 1
0 0 1 0
2 3 3 1
99 99 9 9
5 5 5 5

Sample Output
1.000
2.414
10.646
54985.047
0.000

思路：先算出每个点到原点的距离，然后再相减。在算点到原点距离时，要将斜率为-1 的线和非-1 的线分开算，最后加在一起。

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

double fun(double a, double b) {
	int n;
	double len = 0;
	n = a + b;  //可称为截距
	// 斜率为-1的线的长度
	len = n * (n - 1) / 2 * sqrt(2);
	len += a * sqrt(2);
	// 斜率为非-1的线的长度
	for (int i = 1; i <= n; i++) {
		len += sqrt(i*i + (i - 1)*(i - 1));
	}
	return len;
}

int main() {
	int N;
	cin>> N;
	while (N--) {
		int x1, y1, x2, y2;
		cin>> x1>> y1>> x2>> y2;

		printf("%.3lf\n", fabs(fun(x1, y1) - fun(x2, y2)));
	}

	return 0;
}

2075 A%B

Problem Description
正整数 A 是否能被正整数 B 整除?

Input
输入数据的第一行是一个数据 T，表示有 T 组数据。
每组数据有两个正整数 A 和 B(A,B<10^9)。

Output
对于每组输入数据，输出"YES"表示可以被整除，"NO"表示不能被整除。

Sample Input
2
4 2
5 3

Sample Output
YES
NO

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

int main() {
	int T, a, b;
	cin>> T;
	while (T--) {
		cin>> a>> b;
		if (a % b == 0) {
			cout<< "YES"<< endl;
		} else {
			cout<< "NO" << endl;
		}
	}

	return 0;
}

2076 时针夹角大小

Problem Description
时间过的好快，一个学期就这么的过去了，xhd 在傻傻的看着表，出于对数据的渴望，突然他想知道这个表的时针和分针的夹角是多少。现在 xhd 知道的只有时间，请你帮他算出这个夹角。

注：夹角的范围[0，180]，时针和分针的转动是连续而不是离散的。

Input
输入数据的第一行是一个数据 T，表示有 T 组数据。
每组数据有三个整数 h(0 <= h < 24)，m(0 <= m < 60)，s(0 <= s < 60)分别表示时、分、秒。

Output
对于每组输入数据，输出夹角的大小的整数部分。

Sample Input
2
8 3 17
5 13 30

Sample Output
138
75

注意：h 赋值时，要知道 m 已经值变了，所以要用 temp 获取最初的值

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

int main() {
	int T;
	cin>> T;
	while (T--) {
		double h, m, s, temp;
		int angle;
		cin>> h>> m>> s;
		if (h >= 12) {
			h -= 12;
		}
		temp = m;
		m = m*6 + s/10;
		h = h*30 + temp/2 + s/120;
		angle = fabs(m - h) > 180 ? fabs(360 - fabs(m - h)) : fabs(m - h);
		cout<< angle<< endl;
	}

	return 0;
}

2078 复习时间

Problem Description
hss 复习有个习惯，在复习完一门课后，他总是挑一门更简单的课进行复习，而他复习这门课的效率为两门课的难度差的平方，
而复习第一门课的效率为 100 和这门课的难度差的平方。hss 这学期选了 n 门课，但是一晚上他最多只能复习 m 门课，
请问他一晚上复习的最高效率值是多少？

Input
输入数据的第一行是一个数据 T，表示有 T 组数据。
每组数据的第一行是两个整数 n(1 <= n <= 40)，m(1 <= m <= n)。
接着有 n 行，每行有一个正整数 a(1 <= a <= 100)，表示这门课的难度值。

Output
对于每组输入数据，输出一个整数，表示最高效率值。

Sample Input
2
2 2
52
25
12 5
89
64
6
43
56
72
92
23
20
22
37
31

Sample Output
5625
8836

提示：其实只要是找出难度系数最低的那个跟 100 的差平方一下就是答案了，这道题看似难，其实题目没有出好，很多条件/变量都是和答案的解出没关系

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

int min(int d[], int n) {  //找出最小值
	int min = 100;
	for (int i = 0; i < n; i++) {
		if (min > d[i]) {
			min = d[i];
		}
	}
	return min;
}

int main() {
	int T, j = 0;
	cin>> T;
	while(j<T) {
		int n, m, d[40];
		cin>> n>> m;
		for (int i = 0; i < n; i++) {
			cin>> d[i];
		}
		cout<<(100-min(d, n))*(100-min(d, n))<< endl;

		j++;
	}

	return 0;
}

2081 手机短号

Problem Description
手机号是一个 11 位长的数字串，同时作为学生，可以申请加入校园网，如果加入成功，你将另外拥有一个短号。
假设所有的短号都是是 6 + 手机号的后 5 位，比如号码为 13512345678 的手机，对应的短号就是 645678。
现在，如果给你一个 11 位长的手机号码，你能找出对应的短号吗？

Input
输入数据的第一行是一个 N(N <= 200)，表示有 N 个数据，接下来的 N 行每一行为一个 11 位的手机号码。

Output
输出应包括 N 行，每行包括一个对应的短号，输出应与输入的顺序一致。

Sample Input
2
13512345678
13787654321

Sample Output
645678
654321

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


int main() {
	int N;
	cin>> N;
	char pnum[200][11], lnum[200][6]; //放手机号和放短号的二位数组
	memset(lnum, '6', sizeof(lnum));  //将短号数组初始化为6，只有char型数组才可以初始化为某字符
	for (int i = 0; i < N; i++) {     //输入电话号码
		for (int j = 0; j < 11; j++) {
			cin>> pnum[i][j];
		}
	}
	for (int i = 0; i < N; i++) {     //获取短号
		for (int j = 6; j < 11; j++) {
			lnum[i][j-5] = pnum[i][j];
		}
	}
	for (int i = 0; i < N; i++) {     //输出短号
		for (int j = 0; j < 6; j++) {
			cout<< lnum[i][j];
		}
		cout<< endl;
	}
	return 0;
}

方法二：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
#include <string>
using namespace std;
int main(){
    string str;
    string newstr;
    int lines;
    cin>>lines;
    while(lines--){
        cin>>str;
        cout<<'6'<< &str[6]<<endl;
    }
    return 0;
}

2090 算菜价

Problem Description
妈妈每天都要出去买菜，但是回来后，兜里的钱也懒得数一数，到底花了多少钱真是一笔糊涂帐。现在你可以给她写程序算一下。

Input
输入含有一些数据组，每组数据包括菜种（字串），数量（计量单位不论，一律为 double 型数）和单价（double 型数，表示人民币元数），
因此，每组数据的菜价就是数量乘上单价啊。菜种、数量和单价之间都有空格隔开的。

Output
支付菜价的时候，由于最小支付单位是角，所以总是在支付的时候采用四舍五入的方法把分头去掉。最后，请输出一个精度为角的菜价总量。

Sample Input
青菜 1 2
罗卜 2 1.5
鸡腿 2 4.2

Sample Output
13.4

注意：本题有缺陷，就是没有说明输入终止条件，本人试出来终止条件是输入 EOF，不过和我们没关系，OJ 系统自己会输入判断的

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

int main() {
	char cname[1000];
	double num, price, sum = 0;
	while(cin>> cname>> num>> price) {
		sum += num*price;
	}
	printf("%.1lf\n", sum);
	return 0;
}

2092 整数解

Problem Description
有二个整数，它们加起来等于某个整数，乘起来又等于另一个整数，它们到底是真还是假，
也就是这种整数到底存不存在，实在有点说不准，你能快速回答吗？看来只能通过编程。
例如：
x + y = 9，x * y = 15 ? 找不到这样的整数 x 和 y
1+4=5，14=4，所以，加起来等于 5，乘起来等于 4 的二个整数为 1 和 4
7+(-8)=-1，7\（-8）=-56，所以，加起来等于-1，乘起来等于-56 的二个整数为 7 和-8

Input
输入数据为成对出现的整数 n，m（-10000<n,m<10000），它们分别表示整数的和与积，如果两者都为 0，则输入结束。

Output
只需要对于每个 n 和 m，输出“Yes”或者“No”，明确有还是没有这种整数就行了。

Sample Input
9 15
5 4
1 -56
0 0

Sample Output
No
Yes
Yes

关键：▲>=0 表示方程有解，sqrt_t*sqrt_t == t 表示解都为整数

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

int main() {
	double n, m;
	while (cin>> n>> m && (n || m)) {
		double t = n*n - 4*m;
		int sqrt_t = sqrt(t);
		if (t >= 0 && sqrt_t*sqrt_t == t) {
			cout<< "Yes\n";
		} else {
			cout<< "No\n";
		}
	}

	return 0;
}

2096 小明 A+B

Problem Description
小明今年 3 岁了, 现在他已经能够认识 100 以内的非负整数, 并且能够进行 100 以内的非负整数的加法计算.
对于大于等于 100 的整数, 小明仅保留该数的最后两位进行计算, 如果计算结果大于等于 100, 那么小明也仅保留计算结果的最后两位.
例如, 对于小明来说:

  1. 1234 和 34 是相等的
  2. 35+80=15

给定非负整数 A 和 B, 你的任务是代表小明计算出 A+B 的值.

Input
输入数据的第一行为一个正整数 T, 表示测试数据的组数. 然后是 T 组测试数据. 每组测试数据包含两个非负整数 A 和 B(A 和 B 均在 int 型可表示的范围内).

Output
对于每组测试数据, 输出小明 A+B 的结果.

Sample Input
2
35 80
15 1152

Sample Output
15
67

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


int main() {
	int T;
	cin>> T;
	while (T--) {
		int a, b;
		cin>> a>> b;
		cout<< (a%100 + b%100) % 100<< endl;
	}

	return 0;
}

2098 分拆素数和

Problem Description
把一个偶数拆成两个不同素数的和，有几种拆法呢？

Input
输入包含一些正的偶数，其值不会超过 10000，个数不会超过 500，若遇 0，则结束。

Output
对应每个偶数，输出其拆成不同素数的个数，每个结果占一行。

Sample Input
30
26
0

Sample Output
3
2

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

int sushu(int a) {
	int flag = 0; //0素数，1非素数
	for (int i = 2; i <= sqrt(a); i++) {  //判断i素数
		if (a % i == 0) {  //不是素数
			flag = 1;
			break;
		}
	}
	return flag;
}

int main() {
	int a;
	while (cin>> a && a) {
		int sum = 0;  	//拆法数量
		for (int i = 3; i < a/2; i++) {
			if (sushu(i) + sushu(a-i) == 0) {  //若i和a-i都为为素数
				sum++;  //拆法加1
			}
		}
		cout<< sum<< endl;
	}

	return 0;
}

2099 整除的尾数

Problem Description
一个整数，只知道前几位，不知道末二位，被另一个整数除尽了，那么该数的末二位该是什么呢？

Input
输入数据有若干组，每组数据包含二个整数 a，b（0<a<10000, 10<b<100），若遇到 0 0 则处理结束。

Output
对应每组数据，将满足条件的所有尾数在一行内输出，格式见样本输出。同组数据的输出，其每个尾数之间空一格，行末没有空格。

Sample Input
200 40
1992 95
0 0

Sample Output
00 40 80
15

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


int main() {
	int a, b;
	while (cin>> a>> b && (a || b)) {
		int flag = 0;
		a *= 100;
		for (int i = 0; i < 100; i++) {
			if (a % b == 0) {
				if(flag) {cout<< " ";}
				if (i<10)  //个位数前面要加0
					cout<< "0"<<i;
				else {
					cout<< i;
				}
				flag = 1;
			}
			a++;
		}
		cout<< endl;
	}

	return 0;
}

结束语：

各路好汉们若是有疑问或建议欢迎留言噢！祝各位好运！