1.5编程基础之循环控制

最新推荐文章于 2023-08-03 20:13:29 发布

伶俐角少儿编程

最新推荐文章于 2023-08-03 20:13:29 发布

阅读量996

点赞数 1

分类专栏： C++入门篇文章标签： c++ 算法数据结构

本文链接：https://blog.youkuaiyun.com/qq_33897084/article/details/128249855

版权

C++入门篇专栏收录该内容

6 篇文章

订阅专栏

文章目录

01:求平均年龄

总时间限制: 1000ms 内存限制: 65536kB

描述
班上有学生若干名，给出每名学生的年龄（整数），求班上所有学生的平均年龄，保留到小数点后两位。

输入
第一行有一个整数n（1<= n <= 100），表示学生的人数。其后n行每行有1个整数，表示每个学生的年龄，取值为15到25。

输出
输出一行，该行包含一个浮点数，为要求的平均年龄，保留到小数点后两位。

样例输入

2
18
17

样例输出

17.50

参考代码

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
	int a,n,s=0; // 定义年龄和变量初始化为0 
	cin >> n;// 输入人数 
	for(int i=0;i<n;i++){
		cin >> a; // 输入每人年龄 
		s += a;
	} 
	cout << fixed << setprecision(2) << s*1.0/n; //计算平均年龄 ，保留两位小数 
}

02:财务管理

总时间限制: 1000ms 内存限制: 65536kB

描述
Larry今年毕业并找到了一份工作。他赚很多钱，但似乎总是不够。Larry认为他需要控制他的投资以解决自己的财务问题。Larry拿到了自己的银行账户详单，想看看自己有多少钱。请帮助Larry写一个程序，通过过去12个月中每月的月末结余，计算平均结余。

输入
输入包含12行，每行包含一个数，为某个月的结余。每个数都是不大于1,000,000的正数，保留两位小数，省略"$"符。

输出
输出一个数，为这12个月的平均月末结余，保留到小数点后第二位，并在最前面加一个"$"符。

样例输入

100.00
489.12
12454.12
1234.10
823.05
109.20
5.27
1542.25
839.18
83.99
1295.01
1.75

样例输出

$1581.42

参考代码

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
	double a, s=0; // 定义和变量初始化为0 
	for(int i=0;i<12;i++){
		cin >> a; // 输入每月金额 
		s += a;
	} 
	cout << fixed << setprecision(2) << '$' << s*1.0/12; //计算平均数 ，保留两位小数 
}

03:均值

总时间限制: 1000ms 内存限制: 65536kB

描述
给出一组样本数据，计算其均值。

输入
输入有两行，第一行包含一个整数n（n小于100），代表样本容量；第二行包含n个绝对值不超过1000的浮点数，代表各个样本数据。

输出
输出一行，包含一个浮点数，表示均值，精确到小数点后4位。

样例输入

2
1.0 3.0

样例输出

2.0000

参考代码

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
	double d, s=0; // 定义和变量初始化为0 
	int n;
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> d; // 输入数字 
		s += d;
	} 
	cout << fixed << setprecision(4) << s/n; //计算平均数 ，保留四位小数 
}

04:求整数的和与均值

总时间限制: 1000ms 内存限制: 65536kB

描述
读入n（1 <= n <= 10000）个整数，求它们的和与均值。

输入
输入第一行是一个整数n，表示有n个整数。第2~n+1行每行包含1个整数。每个整数的绝对值均不超过10000。

输出
输出一行，先输出和，再输出平均值（保留到小数点后5位），两个数间用单个空格分隔。

样例输入

4
344
222
343
222

样例输出

1131 282.75000

参考代码

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
	int n, d, s=0; // 定义和变量初始化为0 
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> d; // 输入数字 
		s += d;
	} 
	cout << s << ' ' << fixed << setprecision(5) << s*1.0/n; //计算平均数 ，保留四位小数 
}

05:最高的分数

总时间限制: 1000ms 内存限制: 65536kB

描述
孙老师讲授的《计算概论》这门课期中考试刚刚结束，他想知道考试中取得的最高分数。因为人数比较多，他觉得这件事情交给计算机来做比较方便。你能帮孙老师解决这个问题吗？

输入
输入两行，第一行为整数n（1 <= n < 100），表示参加这次考试的人数.第二行是这n个学生的成绩，相邻两个数之间用单个空格隔开。所有成绩均为0到100之间的整数。

输出
输出一个整数，即最高的成绩。

样例输入

5
85 78 90 99 60

样例输出

99

参考代码

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
	int n, d, m=0; // 定义最大数变量初始化为0 
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> d; // 输入数字 
		if(d>m)m=d; // 输入的数字如果大于最大值，将最大值设为这个数字 
	} 
	cout << m << endl;  
}

06:整数序列的元素最大跨度值

总时间限制: 1000ms 内存限制: 65536kB

描述
给定一个长度为n的非负整数序列，请计算序列的最大跨度值（最大跨度值 = 最大值减去最小值）。

输入
一共2行，第一行为序列的个数n（1 <= n <= 1000)，第二行为序列的n个不超过1000的非负整数，整数之间以一个空格分隔。

输出
输出一行，表示序列的最大跨度值。

样例输入

6
3 0 8 7 5 9

样例输出

9

参考代码

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
	int n, d, max=1, min=1000; // n的范围 1 <= n <= 1000， 将最小值设为1000，最大值设为1 
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> d; // 输入数字 
		if(d>max)max=d; // 输入的数字如果大于最大值，将最大值设为这个数字 
		if(d<min)min=d; // 输入的数字如果小于最小值，将最小值设为这个数字 
	} 
	cout << max-min << endl;  
}

07:奥运奖牌计数

总时间限制: 1000ms 内存限制: 65536kB

描述
2008年北京奥运会，A国的运动员参与了n天的决赛项目(1≤n≤17)。现在要统计一下A国所获得的金、银、铜牌数目及总奖牌数。

输入
输入n＋1行，第1行是A国参与决赛项目的天数n，其后n行，每一行是该国某一天获得的金、银、铜牌数目，以一个空格分开。

输出
输出1行，包括4个整数，为A国所获得的金、银、铜牌总数及总奖牌数，以一个空格分开。

样例输入

3
1 0 3
3 1 0
0 3 0

样例输出

4 4 3 11

参考代码

#include<iostream>
using namespace std;
int main(){
	int n, j=0, y=0, t=0; // 务必初始化为0 
	int a, b, c;
	cin >> n;
	for(int i=0; i<n; i++){ // 循环n次，n是天数 
		cin >> a >> b >> c;
		j += a; // 累计金牌数量 
		y += b; // 累计银牌数量 
		t += c; // 累计铜牌数量 
	}
	cout << j << ' ' << y << ' ' << t << ' ' << j+y+t << endl;
	return 0;
}

08:多边形内角和

总时间限制: 1000ms 内存限制: 65536kB

描述
在欧几里德几何中，n边形的内角和是(n-2)*180°。已知其中(n-1)个内角的度数，就能计算出剩下的一个未知内角的度数。请编写一个程序，来解决这个问题。

输入
第1行只有一个整数n(2第2行有(n-1)个正整数，是每个已知内角的度数。相邻两个整数之间用单个空格隔开。数据保证给定多边形合法。

输出
一个正整数，为未知内角的度数。

样例输入

3
45 60

样例输出

75

参考代码

#include<iostream>
using namespace std;
int main(){
	int n, s=0, a;
	cin >> n;
	for(int i=0;i<n-1;i++){
		cin >> a;
		s += a;	// 使用累计求和的方式计算出已知角度和			
	} 
	cout << (n-2)*180 - s << endl; // 内角和- 知角度和，计算出未知内角角度 
}

09:奇数求和

总时间限制: 1000ms 内存限制: 65536kB

描述
计算非负整数 m 到 n（包括m 和 n ）之间的所有奇数的和，其中，m 不大于 n，且n 不大于300。例如 m=3, n=12, 其和则为：3+5+7+9+11=35。

输入
两个数 m 和 n，两个数以一个空格分开，其中 0 <= m <= n <= 300 。

输出
输出一行，包含一个整数，表示m 到 n（包括m 和 n ）之间的所有奇数的和

样例输入

7 15

样例输出

55

参考代码

#include<iostream>
using namespace std;
int main(){
	int m, n, s=0;
	cin >> m >> n; 
	for(int i=m; i<=n; i++){ // 循环获取m到n所有数字 
		if(i%2==1) s+=i; // 如果是奇数，累加求和 
	}
	cout << s << endl; 
}

10:满足条件的数累加

总时间限制: 1000ms 内存限制: 65536kB

描述
将正整数 m 和 n 之间（包括 m 和 n）能被 17 整除的数累加。其中，0 < m < n < 1000。

输入
一行，包含两个整数m和n，其间，以一个空格间隔。

输出
输出一行，包行一个整数，表示累加的结果。

样例输入

50 85

样例输出

204

参考代码

#include<iostream>
using namespace std;
int main(){
	int m, n, s=0;
	cin >> m >> n; 
	for(int i=m; i<=n; i++){ // 循环获取m到n所有数字 
		if(i%17==0) s+=i; // 如果能被17整除，累加求和 
	}
	cout << s << endl; 
}

11:整数的个数

总时间限制: 1000ms 内存限制: 65536kB

描述
给定k（1 < k < 100）个正整数，其中每个数都是大于等于1，小于等于10的数。写程序计算给定的k个正整数中，1，5和10出现的次数。

输入
输入有两行：第一行包含一个正整数k，第二行包含k个正整数，每两个正整数用一个空格分开。

输出
输出有三行，第一行为1出现的次数，，第二行为5出现的次数，第三行为10出现的次数。

样例输入

5
1 5 8 10 5

样例输出

1
2
1

参考代码

#include<iostream>
using namespace std;
int main(){
	int n, n1=0, n5=0, n10=0, m;
	cin >> n; 
	for(int i=0; i<n; i++){ // 循环n次，输入n个数字 
		cin >> m;
		switch(m){ // 判断数字，记录个数 
			case 1:
				n1 += 1;
				break;
			case 5:
				n5 += 1;
				break;
			case 10:
				n10 += 1;
				break; 
		}
	}
	cout << n1 << endl << n5 << endl << n10 << endl; 
}

12:与指定数字相同的数的个数

总时间限制: 1000ms 内存限制: 65536kB

描述
输出一个整数序列中与指定数字相同的数的个数。

输入
输入包含2行：第1行为N和m，表示整数序列的长度(N <= 100)和指定的数字，中间用一个空格分开；第2行为N个整数，整数之间以一个空格分开。

输出
输出为N个数中与m相同的数的个数。

样例输入

3 2
2 3 2

样例输出

2

参考代码

#include<iostream>
using namespace std;
int main(){
	int N,n,m,count=0;
	cin >> N >> m;
	for(int i=0;i<N;i++){
		cin >> n;
		if(n==m) count+=1; // 如果输入的数字等于m，计数		
	}
	cout << count;
}

13:乘方计算

总时间限制: 1000ms 内存限制: 65536kB

描述
$给出一个整数a和一个正整数n，求乘方a^n。$

输入
一行，包含两个整数a和n。-1000000 <= a <= 1000000，1 <= n <= 10000。

输出
一个整数，即乘方结果。题目保证最终结果的绝对值不超过1000000。

样例输入

2 3

样例输出

8

参考代码

#include<iostream>
using namespace std;
int main(){
	int a, n, c=1; //将结果编程初始化为1 
	cin >> a >> n;
	for(int i=0;i<n;i++){
		c*=a;	 // 将a累乘n次，计数a的n次方 
	}
	cout << c;
}

14:人口增长问题

总时间限制: 1000ms 内存限制: 65536kB

描述
我国现有x亿人口，按照每年0.1%的增长速度，n年后将有多少人？

输入
一行，包含两个整数x和n，分别是人口基数和年数，以单个空格分隔。

输出
输出最后的人口数，以亿为单位，保留到小数点后四位。1 <= x <= 100, 1 <= n <= 100。

样例输入

13 10

样例输出

13.1306

参考代码

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
	double x, n; 
	cin >> x >> n;
	for(int i=0;i<n;i++){
		x*=1.001; // 每年人数是上一年人数乘(1+0.1%) 
	}
	cout << fixed << setprecision(4) << x << endl;
	return 0;
}

15:银行利息

总时间限制: 1000ms 内存限制: 65536kB

描述
农夫约翰在去年赚了一大笔钱！他想要把这些钱用于投资，并对自己能得到多少收益感到好奇。已知投资的复合年利率为R（0到20之间的整数）。约翰现有总值为M的钱（100到1,000,000之间的整数）。他清楚地知道自己要投资Y年（范围0到400）。请帮助他计算最终他会有多少钱，并输出它的整数部分。数据保证输出结果在32位有符号整数范围内。

输入
一行包含三个整数R，M，Y，相邻两个整数之间用单个空格隔开。

输出
一个整数，即约翰最终拥有多少钱（整数部分）。

样例输入

5 5000 4

样例输出

6077

提示
在样例中，第一年后: 1.05 * 5000 = 5250第二年后: 1.05 * 5250 = 5512.5第三年后: 1.05 * 5512.50 = 5788.125第四年后: 1.05 * 5788.125 = 6077.531256077.53125的整数部分为6077。
在样例中，第一年后: 1.05 * 5000 = 5250第二年后: 1.05 * 5250 = 5512.5第三年后: 1.05 * 5512.50 = 5788.125第四年后: 1.05 * 5788.125 = 6077.531256077.53125的整数部分为6077。

参考代码

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
	double M, R;//计算过程中钱数是浮点型
	int Y; 
	cin >> R >> M >> Y;
	for(int i=0;i<Y;i++){
		M *= (1 + 0.01*R);
	}
	cout << int(M) << endl; // 保留整数部分
	return 0;
}

16:买房子

总时间限制: 1000ms 内存限制: 65536kB

描述
某程序员开始工作，年薪N万，他希望在中关村公馆买一套60平米的房子，现在价格是200万，假设房子价格以每年百分之K增长，并且该程序员未来年薪不变，且不吃不喝，不用交税，每年所得N万全都积攒起来，问第几年能够买下这套房子？（第一年年薪N万，房价200万）

输入
一行，包含两个正整数N（10 <= N <= 50）, K（1 <= K <= 20），中间用单个空格隔开。

输出
如果在第20年或者之前就能买下这套房子，则输出一个整数M，表示最早需要在第M年能买下，否则输出Impossible。

样例输入

50 10

样例输出

8

参考代码

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
	double n, k, f=200; // n：年薪 k：增长 f：房价 
	int y=1; // y：年数 
	cin >> n >> k;
	while(true){ // 无限循环 
		if(y*n >= f || y > 20)break; // 积攒钱数大于房价，能够买起，跳出循环 
		y++;// 不能买起，年数加1 
		f *= (1+0.01*k);// 房价增加
	}
	if(y>20) cout << "Impossible";//如果大于20年，输出 Impossible，否则输出年数 
	else cout << y; 
	return 0;
}

17:菲波那契数列

总时间限制: 1000ms 内存限制: 65536kB

描述
菲波那契数列是指这样的数列: 数列的第一个和第二个数都为1，接下来每个数都等于前面2个数之和。给出一个正整数k，要求菲波那契数列中第k个数是多少。
菲波那契数列是指这样的数列: 数列的第一个和第二个数都为1，接下来每个数都等于前面2个数之和。给出一个正整数k，要求菲波那契数列中第k个数是多少。

输入
输入一行，包含一个正整数k。（1 <= k <= 46）

输出
输出一行，包含一个正整数，表示菲波那契数列中第k个数的大小

样例输入

19

样例输出

4181

参考代码

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
	int n1=1, n2=1, n, k;
	cin >> k;
	if(k<3){ // 如果k<3,n就是1 
		n=1;
	}else{
		for(int i=2;i<k;i++){
			n = n1 + n2;    // n等于前两项的和 
			n1 = n2;		// 往后移，以便下次循环计算 
			n2 = n;			// 往后移，以便下次循环计算 
		}
	}
	cout << n;
}

18:鸡尾酒疗法

总时间限制: 1000ms 内存限制: 65536kB

描述
鸡尾酒疗法，原指“高效抗逆转录病毒治疗”（HAART），由美籍华裔科学家何大一于1996年提出，是通过三种或三种以上的抗病毒药物联合使用来治疗艾滋病。该疗法的应用可以减少单一用药产生的抗药性，最大限度地抑制病毒的复制，使被破坏的机体免疫功能部分甚至全部恢复，从而延缓病程进展，延长患者生命，提高生活质量。人们在鸡尾酒疗法的基础上又提出了很多种改进的疗法。为了验证这些治疗方法是否在疗效上比鸡尾酒疗法更好，可用通过临床对照实验的方式进行。假设鸡尾酒疗法的有效率为x，新疗法的有效率为y，如果y-x大于5%，则效果更好，如果x-y大于5%，则效果更差，否则称为效果差不多。下面给出n组临床对照实验，其中第一组采用鸡尾酒疗法，其他n-1组为各种不同的改进疗法。请写程序判定各种改进疗法效果如何。

输入
第一行为整数n（ 1 < n <= 20）；其余n行每行两个整数，第一个整数是临床实验的总病例数(小于等于10000)，第二个疗效有效的病例数。这n行数据中，第一行为鸡尾酒疗法的数据，其余各行为各种改进疗法的数据。

输出
有n-1行输出，分别表示对应改进疗法的效果：如果效果更好，输出better；如果效果更差，输出worse；否则输出same

样例输入

5
125 99
112 89
145 99
99 97
123 98

样例输出

same
worse
better
same

参考代码

#include<iostream>
using namespace std;

int main(){
	int n,a,b;
	double x, y;
	cin >> n;
	cin >> a >> b;
	x = b*1.0/a; // 需要转化为浮点型，乘1.0
	for(int i=0;i<n-1;i++){
		cin >> a >> b;
		y = b*1.0/a;
		if(y-x>0.05) cout << "better" << endl;
		else if(x-y>0.05) cout << "worse" << endl;
		else cout << "same" << endl; 
		
	}
	return 0;
}

19:救援

总时间限制: 1000ms 内存限制: 65536kB

描述
救生船从大本营出发，营救若干屋顶上的人回到大本营，屋顶数目以及每个屋顶的坐标
和人数都将由输入决定，求出所有人都到达大本营并登陆所用的时间。
在直角坐标系的原点是大本营，救生船每次从大本营出发，救了人之后将人送回大本营。坐标系中的点代表屋顶，每个屋顶由其位置坐标和其上的人数表
示。救生船每次从大本营出发，以速度50 米/分钟驶向下一个屋顶，达到一个屋顶后，救下其上的所有人，每人上船1
分钟，船原路返回，达到大本营，每人下船0.5 分钟。假设原点与任意一个屋顶的连线不穿过其它屋顶。

输入
第一行，一个整数，表示屋顶数n。接下来依次有n 行输入，每一行上包含两个表示屋顶相对于大本营的平面坐标位置的实数（单位是米）、一个表示人数的整数，数之间以一个空格分开。

输出
一行，救援需要的总时间，精确到分钟 (向上取整)。

样例输入

1
30 40 3

样例输出

7

参考代码

#include<iostream>
#include<cmath>
using namespace std;

int main(){
	int n, c;//屋顶数, 人数
	double x, y, d;//x,y坐标, 距离
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> x >> y >> c;
		d += sqrt(x*x+y*y)/50*2+c*1.5;	// 距离/50*2 + 人数*1.5
	}	
    d = ceil(d);//最后再向上取整
	cout << d << endl;
	return 0;
}

20:球弹跳高度的计算

总时间限制: 1000ms 内存限制: 65536kB

描述
一球从某一高度落下（整数，单位米），每次落地后反跳回原来高度的一半，再落下。编程计算气球在第10次落地时，共经过多少米? 第10次反弹多高？

输入
输入一个整数h，表示球的初始高度。

输出
输出包含两行：第1行：到球第10次落地时，一共经过的米数。第2行：第10次弹跳的高度。注意：结果可能是实数，结果用double类型保存。提示：输出时不需要对精度特殊控制，用cout << ANSWER，或者printf(“%g”, ANSWER)即可。

样例输入

20

样例输出

59.9219
0.0195313

参考代码

#include<iostream>
using namespace std;

int main(){
	int n,a,b;
	double x, y;
	cin >> n;
	cin >> a >> b;
	x = b*1.0/a;
	for(int i=0;i<n-1;i++){
		cin >> a >> b;
		y = b*1.0/a;
		if(y-x>0.05) cout << "better" << endl;
		else if(x-y>0.05) cout << "worse" << endl;
		else cout << "same" << endl; 
		
	}
	return 0;
	
}

21:角谷猜想

总时间限制: 1000ms 内存限制: 65536kB

描述
所谓角谷猜想，是指对于任意一个正整数，如果是奇数，则乘3加1，如果是偶数，则除以2，得到的结果再按照上述规则重复处理，最终总能够得到1。如，假定初始整数为5，计算过程分别为16、8、4、2、1。程序要求输入一个整数，将经过处理得到1的过程输出来。

输入
一个正整数N(N <= 2,000,000)

输出
从输入整数到1的步骤，每一步为一行，每一部中描述计算过程。最后一行输出"End"。如果输入为1，直接输出"End"。

样例输入

5

样例输出

5*3+1=16
16/2=8
8/2=4
4/2=2
2/2=1
End

提示
注意计算过程中中间值可能会超过int范围。

参考代码

#include<iostream>

int main(){
	long int n;//结果有可能超出int范围，所以选择使用long int
	scanf("%d", &n);
	while(n!=1){
		if(n%2==1){
			printf("%ld*3+1=%ld\n", n, n*3+1); // 是奇数，打印n*3+1 注意类型，长整型 ld
			n = n*3+1;
		}else{
			printf("%ld/2=%ld\n", n, n/2); // 是奇数，打印n/2 注意类型，长整型 ld
			n = n/2;
		}
	}
	printf("%s\n", "End");
	return 0;
}

22:津津的储蓄计划

总时间限制: 1000ms 内存限制: 65536kB

描述
津津的零花钱一直都是自己管理。每个月的月初妈妈给津津300元钱，津津会预算这个月的花销，并且总能做到实际花销和预算的相同。为了让津津学习如何储蓄，妈妈提出，津津可以随时把整百的钱存在她那里，到了年末她会加上20％还给津津。因此津津制定了一个储蓄计划：每个月的月初，在得到妈妈给的零花钱后，如果她预计到这个月的月末手中还会有多于100元或恰好100元，她就会把整百的钱存在妈妈那里，剩余的钱留在自己手中。例如11月初津津手中还有83元，妈妈给了津津300元。津津预计11月的花销是180元，那么她就会在妈妈那里存200元，自己留下183元。到了11月月末，津津手中会剩下3元钱。津津发现这个储蓄计划的主要风险是，存在妈妈那里的钱在年末之前不能取出。有可能在某个月的月初，津津手中的钱加上这个月妈妈给的钱，不够这个月的原定预算。如果出现这种情况，津津将不得不在这个月省吃俭用，压缩预算。现在请你根据2004年1月到12月每个月津津的预算，判断会不会出现这种情况。如果不会，计算到2004年年末，妈妈将津津平常存的钱加上20％还给津津之后，津津手中会有多少钱。

输入
包括12行数据，每行包含一个小于350的非负整数，分别表示1月到12月津津的预算。

输出
包括一行，这一行只包含一个整数。如果储蓄计划实施过程中出现某个月钱不够用的情况，输出-X，X表示出现这种情况的第一个月；否则输出到2004年年末津津手中会有多少钱。

样例输入

样例 #1：
290
230
280
200
300
170
340
50
90
80
200
60

样例 #2：
290
230
280
200
300
170
330
50
90
80
200
60

样例输出

样例 #1：
-7

样例 #2：
1580

参考代码

#include<iostream>
using namespace std;

int main(){
	int save=0, m=0, spend, n;// 妈妈存的钱, 每月的有的钱, 每月预计开销，不够开销的月份
	bool flag=true;
	for(int i=1;i<=12;i++){
		m+=300;
		cin >> spend;
		if(spend>m){ // 如果开销大于钱数
			n=i; // 记录下月数
			flag=false; // 记录下存在钱不够花的状态
		}else{
			m -= spend; // 减掉每月的开销
			save += m/100 * 100; // 将整百的钱交给妈妈保存
			m -= m/100 *100;// 减去整百的钱
		}
	}
	if(flag){
		save *= 1.2;// 交给妈妈的钱*1.2
		cout << save + m << endl; // 加上自己手里剩下的钱打印输出
	}
	else cout << '-' << n << endl;
	return 0;
}

23:药房管理

总时间限制: 1000ms 内存限制: 65536kB

描述
随着信息技术的蓬勃发展，医疗信息化已经成为医院建设中必不可少的一部分。计算机可以很好地辅助医院管理医生信息、病人信息、药品信息等海量数据，使工作人员能够从这些机械的工作中解放出来，将更多精力投入真正的医疗过程中，从而极大地提高了医院整体的工作效率。
对药品的管理是其中的一项重要内容。现在药房的管理员希望使用计算机来帮助他管理。假设对于任意一种药品，每天开始工作时的库存总量已知，并且一天之内不会通过进货的方式增加。每天会有很多病人前来取药，每个病人希望取走不同数量的药品。如果病人需要的数量超过了当时的库存量，药房会拒绝该病人的请求。管理员希望知道每天会有多少病人没有取上药。

输入
共3行第一行是每天开始时的药品总量m第二行是这一天取药的人数n（0 < n <= 100）第三行共有n个数，分别记录了每个病人希望取走的药品数量（按照时间先后的顺序），两数之间以空格分隔

输出
只有1行，为这一天没有取上药品的人数。

样例输入

30
6
10 5 20 6 7 8

样例输出

2

参考代码

#include<iostream>
using namespace std;

int main(){
	int m, n, a, count=0;//库存, 人数, 需要的药数量,未取到药的人数初始化为0（存在没有人能取到药的情况）。 
	cin >> m >> n;
	for(int i=0;i<n;i++){
		cin >> a; 
		if(a>m){ //如果需求大于库存，拒绝
			count++; // 计数 
		}else{
			m-=a;	//取药，减库存		
		}	
	}
	cout << count << endl; 
	return 0;
}

24:正常血压

总时间限制: 1000ms 内存限制: 65536kB

描述
监护室每小时测量一次病人的血压，若收缩压在90 - 140之间并且舒张压在60 - 90之间（包含端点值）则称之为正常，现给出某病人若干次测量的血压值，计算病人保持正常血压的最长小时数。

输入
第一行为一个正整数n，n < 100其后有n行，每行2个正整数，分别为一次测量的收缩压和舒张压，中间以一个空格分隔。

输出
输出仅一行，血压连续正常的最长小时数。

样例输入

4
100 80
90 50
120 60
140 90

样例输出

2

参考代码

#include<iostream>
using namespace std;

int main(){
	int n, ss, sz, temp=0, count=0;//总小时数，收缩压，舒张压，再次持续小时，最长持续小时
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> ss >> sz;
		if(ss>=90&&ss<=140&&sz>=60&&sz<=90){
			temp+=1;//如果正常，正常持续小时数+1
		}else{
			temp=0;//不正常，小时数清零，下次重计数
		}
		count = temp>count?temp:count;//每次比较temp和count的值，获得最大持续时长。
	} 
	cout << count << endl;
	return 0;
}

25:求特殊自然数

总时间限制: 1000ms 内存限制: 65536kB

描述
一个十进制自然数,它的七进制与九进制表示都是三位数，且七进制与九进制的三位数码表示顺序正好相反。编程求此自然数,并输出显示。

输入
无。

输出
三行：第一行是此自然数的十进制表示；第二行是此自然数的七进制表示；第三行是此自然数的九进制表示。

样例输入

（无）

样例输出

（不提供）

参考代码

#include<iostream>
using namespace std;

int main(){
	// 七进制三位最大：342 最小：49
	// 九进制三位最大：728 最小：81
	// 范围三位七进制、九进制：81-342
	for(int i=81;i<343;i++){
		if(i%7==i/81&&i%9==i/49&&i%7/7==i%9/9){
			cout << i << endl;
			cout << i/49 << i%49/7 << i%7 << endl; //打印七进制数
			cout << i/81 << i%81/9 << i%9 << endl; //打印九进制数
			break; // 找到后跳出循环
		}
	}
	return 0;
}

26:统计满足条件的4位数个数

总时间限制: 1000ms 内存限制: 65536kB

描述
给定若干个四位数，求出其中满足以下条件的数的个数：
个位数上的数字减去千位数上的数字，再减去百位数上的数字，再减去十位数上的数字的结果大于零。

输入
输入为两行，第一行为四位数的个数n，第二行为n个的四位数，数与数之间以一个空格分开。(n <= 100)

输出
输出为一行，包含一个整数，表示满足条件的四位数的个数。

样例输入

5
1234 1349 6119 2123 5017

样例输出

3

参考代码

#include<iostream>
using namespace std;

int main(){
	int n, num, count=0;
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> num;
		// 个位: num%10
		// 十位: num%100/10
		// 百位: num%1000/100
		// 千位: num/1000
		if(num%10-num/1000-num%1000/100-num%100/10>0){
			count++; // 满足条件计数
		}
	}
	cout << count;
}

27:级数求和

总时间限制: 1000ms 内存限制: 65536kB

描述
已知：Sn= 1＋1／2＋1／3＋…＋1／n。显然对于任意一个整数K，当n足够大的时候，Sn大于K。现给出一个整数K（1<=k<=15），要求计算出一个最小的n；使得Sn＞K。

输入
一个整数K。

输出
一个整数n。

样例输入

1

样例输出

2

参考代码

#include<iostream>
using namespace std;

int main(){
	int k, n=1;
	double s=0;
	cin >> k;
	while(s<=k){ // Sn <= k 就一直累加
		s += 1.0/n; // Sn累加
		n++; // n累加
	}
	cout << --n; // n累加多次，所以输出前需要减1
	return 0;
}

28:分离整数的各个数位

总时间限制: 1000ms 内存限制: 65536kB

描述
给定一个整数，要求从个位开始分离出它的每一位数字。

输入
输入一个整数，整数在1到100000000之间。

输出
从个位开始按照从低位到高位的顺序依次输出每一位数字。数字之间以一个空格分开。

样例输入

123

样例输出

3 2 1

参考代码

#include<iostream>
using namespace std;

int main(){
	int n;
	cin >> n;
	while(n!=0){
		cout << n%10 << " ";
		n/=10;
	}
	return 0;
}

29:数字反转

总时间限制: 1000ms 内存限制: 65536kB

描述
给定一个整数，请将该数各个位上数字反转得到一个新数。新数也应满足整数的常见形式，即除非给定的原数为零，否则反转后得到的新数的最高位数字不应为零（参见样例2）。

输入
输入共 1 行，一个整数N。-1,000,000,000 ≤ N≤ 1,000,000,000。

输出
输出共 1 行，一个整数，表示反转后的新数。

样例输入

样例 #1：
123

样例 #2：
-380

样例输出

样例 #1：
321

样例 #2：
-83

参考代码

#include<iostream>
using namespace std;

int main(){
	int n, num;
	bool flag=false;//标志位，如果不是0再开始输出。
	cin >> n;
	if(n<0){ //如果是负数，先打印负号，再取反变为整数处理。
		cout << "-";
		n=-n;		
	}
	while(n!=0){
		num = n%10;
		if(num!=0)flag=true;// 不是0，赋值为true
		if(flag)cout << num;// 如果是true，代表不是0，开始输出
		n/=10;
	}
	return 0;
}

30:含k个3的数

总时间限制: 1000ms 内存限制: 65536kB

描述
输入两个正整数 m 和 k，其中1 < m < 100000，1 < k < 5 ，判断 m 能否被19整除，且恰好含有k个3，如果满足条件，则输出YES，否则，输出NO。
例如，输入：
43833 3
满足条件，输出YES。如果输入：39331 3
尽管有3个3，但不能被19整除，也不满足条件，应输出NO。

输入
m 和 k 的值，中间用单个空格间隔。

输出
满足条件时输出 YES，不满足时输出 NO。

样例输入

43833 3

样例输出

YES

参考代码

#include<iostream>
using namespace std;

int main(){
	int m, k, num, count=0;
	cin >> m >> k;
	if(m%19!=0){ // 不能被19整除，输出NO，返回。不再继续执行
		cout << "NO" << endl;
		return 0;
	}
	while(m!=0){
		num = m%10;
		if(num==3){
			count++;// 累计计算3的数量
		}
		m/=10;
	}
	if(count==k) cout << "YES" << endl; 
	else cout << "NO" << endl;
	return 0;
}

31:开关灯

总时间限制: 1000ms 内存限制: 65536kB

描述
假设有N盏灯(N为不大于5000的正整数)，从1到N按顺序依次编号，初始时全部处于开启状态；有M个人(M为不大于N的正整数)也从1到M依次编号。第一个人（1号）将灯全部关闭，第二个人（2号）将编号为2的倍数的灯打开，第三个人（3号）将编号为3的倍数的灯做相反处理（即，将打开的灯关闭，将关闭的灯打开）。依照编号递增顺序，以后的人都和3号一样，将凡是自己编号倍数的灯做相反处理。请问：当第M个人操作之后，哪几盏灯是关闭的，按从小到大输出其编号，其间用逗号间隔。

输入
输入正整数N和M，以单个空格隔开。

输出
顺次输出关闭的灯的编号，其间用逗号间隔。

样例输入

10 10

样例输出

1,4,9

参考代码

#include<iostream>
using namespace std;

int main(){
	int n, m; 
	cin >> n >> m;
	cout << 1;
	for(int i=2;i<=n;i++){
		bool flag=false;// false代表是关灯状态，初始默认为关闭状态。
		if(i%2==0)flag=true;//如果是2的倍数。开灯
		for(int j=3;j<=m;j++){ // 2之后，
			if(i%j==0){ //是这个数字的倍数，状态取反
				flag=!flag;
			}		
		}
		if(!flag) cout << ',' << i;//输出关灯状态的编号
	}
	return 0;
}

32:求分数序列和

总时间限制: 1000ms 内存限制: 65536kB

描述
有一个分数序列 q₁/p₁,q₂/p₂,q₃/p₃,q₄/p₄,q₅/p₅,… ,其中q_i+1= q_i+ p_i, p_i+1=q_i, p₁= 1, q₁= 2。比如这个序列前6项分别是2/1,3/2,5/3,8/5,13/8,21/13。求这个分数序列的前n项之和。

输入
输入有一行，包含一个正整数n(n <= 30)。

输出
输出有一行，包含一个浮点数，表示分数序列前n项的和，精确到小数点后4位。

样例输入

2

样例输出

3.5000

参考代码

#include<iostream>
#include<iomanip>
using namespace std;

int main(){
	int n, q=2, p1=1, p2=2, temp; 
	double s=q/p1;
	cin >> n;
	for(int i=1;i<n;i++){
		q = q+p1;
		s += 1.0*q/p2;
		temp = p1;
		p1 = p2;
		p2 = temp;
		p2 = p1 + p2;
	}
	cout << fixed << setprecision(4) <<s;
	return 0;
}

33:计算分数加减表达式的值

总时间限制: 1000ms 内存限制: 65536kB

描述
编写程序，输入n的值，求 1/1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6 + 1/7 - 1/8 + … + (-1)n-1·1/n 的值。

输入
输入一个正整数n。1 <= n <= 1000。

输出
输出一个实数，为表达式的值，保留到小数点后四位。

样例输入

2

样例输出

0.5000

参考代码

#include<iostream>
#include<iomanip>
using namespace std;

int main(){
	int n;
	double s=0;
	cin >> n;
	for(int i=1;i<=n;i++){
		if(i%2==0){ // 如果是偶数项，减
			s -= 1.0/i;
		}else{ //奇数项，加
			s += 1.0/i;
		}		
	} 
	cout << fixed << setprecision(4) << s << endl;
	return 0;
}

34:求阶乘的和

总时间限制: 1000ms 内存限制: 65536kB

描述
给定正整数n，求不大于n的正整数的阶乘的和（即求1!+2!+3!+…+n!）

输入
输入有一行，包含一个正整数n（1 < n < 12）。

输出
输出有一行：阶乘的和。

样例输入

5

样例输出

153

参考代码

#include<iostream>
#include<iomanip>
using namespace std;

int main(){
	int n, j=1, s=1;// 项数，每个数的阶乘，和
	cin >> n;
	for(int i=2;i<=n;i++){// 从第二项开始计算
		j*=i;// 计算i的阶乘j
		s+=j;// 将j累加到和变量
	} 
	cout << s << endl;
	return 0;
}

35:求出e的值

总时间限制: 1000ms 内存限制: 65536kB

描述
利用公式e = 1 + 1/1! + 1/2! + 1/3! + … + 1/n! 求e 。

输入
输入只有一行，该行包含一个整数n（2<=n<=15），表示计算e时累加到1/n！。

输出
输出只有一行，该行包含计算出来的e的值，要求打印小数点后10位。

样例输入

10

样例输出

2.7182818011

提示
1、e以及n!用double表示2、要输出浮点数、双精度数小数点后10位数字，可以用下面这种形式：printf(“%.10f”, num);

参考代码

#include<iostream>
#include<iomanip>
using namespace std;

int main(){
	int n;
	double e=1.0, j=1;// 注意j的阶乘定义为double，因为j可能保存15的阶乘，超出了int的范围。
	cin >> n;
	for(int i=1;i<=n;i++){
		j*=i;
		e += 1.0/j;	
	} 
	cout << fixed << setprecision(10) << e << endl;
	return 0;
}

36:计算多项式的值

总时间限制: 1000ms 内存限制: 65536kB

描述
假定多项式的形式为xn+xn-1+…+x2+x+1，请计算给定单精度浮点数x和正整数n值的情况下这个多项式的值。

输入
输入仅一行，包括x和n，用单个空格隔开。x在float范围内，n <= 1000000。

输出
输出一个实数，即多项式的值，精确到小数点后两位。保证最终结果在float范围内。

样例输入

2.0 4

样例输出

31.00

参考代码

#include<iostream>
#include<cmath>
#include<iomanip>
using namespace std;

int main(){
	float x, s=1;
	int n;
	cin >> x >> n;
	for(int i=1;i<=n;i++){
		s += pow(x, i);	//计算x的i次方	
	}
	cout << fixed << setprecision(2) << s << endl;
	return 0;
}

37:雇佣兵

总时间限制: 1000ms 内存限制: 65536kB

描述
雇佣兵的体力最大值为M，初始体力值为0、战斗力为N、拥有X个能量元素。当雇佣兵的体力值恰好为M时，才可以参加一个为期M天的战斗期，战斗期结束体力值将为0。在同一个战斗期内，雇佣兵每连续战斗n天，战斗力就会上升1点，n为当前战斗期开始时的战斗力。一个战斗期结束后，雇佣兵需要用若干个能量元素使其体力恢复到最大值M，从而参加下一个战斗期。每个能量元素恢复的体力值不超过当前的战斗力。每个能量元素只能使用一次。请问：雇佣兵的战斗力最大可以到达多少。

输入
一行包括三个整数M、N、X，相邻两个整数之间用单个空格隔开。M、N、X均为不超过10000的正整数。

输出
输出一个整数，为雇佣兵的最大战斗力。

样例输入

5 2 10

样例输出

6

参考代码

#include<iostream>
#include<cmath>
using namespace std;

int main(){
	int M, N, X, x; //x: 每期填满体力需要的能量
	cin >> M >> N >> X;
	x = M%N==0?M/N:M/N+1;// 计算第一期需要的能量，不能整除需要+1
	while(X>=x){// 所剩能量足够填满体力进行循环
		X-=x; // 能量减少 
		N+=M/N;	// 计算战力
		x = M%N==0?M/N:M/N+1; // 计算下期需要的能量，不能整除需要+1
	}
	cout << N << endl;
	return 0;
}

38:计算多项式的导函数

总时间限制: 1000ms 内存限制: 65536kB

描述
计算多项式的导函数是一件非常容易的任务。给定一个函数f(x)，我们用f’(x)来表示其导函数。我们用x^n来表示x的n次幂。为了计算多项式的导函数，你必须知道三条规则：
(1)、©’ = 0 如果C是常量
(2)、(Cx^n)’ = Cn*x^(n-1) 如果n >= 1且C是常量
(3)、(f1(x)+f2(2))’ = f1’(x)+f2’(x)容易证明，多项式的导函数也是多项式。现在，请你编写一个程序，给定一个不包含负系数且已合并好同幂次项的多项式f(x)，计算出它的导函数。

输入
输入有两行。第一行是一个整数n（0 <= n <= 100）表明多项式的最高次幂为n。第二行包含n+1个非负整数，C_n ，C_n-1 ，C_n-2 ，C_n-3 ，C_n-4 ，… ，C₁，C₀（0 <= C_i<= 1000）且C_n != 0。C_i是幂次为i的项的系数。

输出
在一行内输出f’(x)的结果。
（1）如果g(x) = 0那么直接输出0
（2）如果g(x)形如C_m(x^m)+C_m-1(x^(m-1))+…+C₀(C_m!=0)$那么输出C_m…C₀
（3）相邻整数之间有单个空格。

样例输入

3
0
10
2
3 2 1
3
10 0 1 2

样例输出

0
6 2
30 0 1

参考代码

#include<iostream>
#include<cmath>
using namespace std;

int main(){
	int n, c;
	cin >> n;
	if(n==0){
		cout << 0;
	}
	for(int i=n;i>0;i--){
		cin >> c;
		if(n==1){
			cout << 0;
		}else{
			cout << c*i << ' ';	
		}
	} 
	return 0;
}

39:与7无关的数

总时间限制: 1000ms 内存限制: 65536kB

描述
一个正整数,如果它能被7整除,或者它的十进制表示法中某一位上的数字为7,则称其为与7相关的数.现求所有小于等于n(n < 100)的与7无关的正整数的平方和.

输入
输入为一行,正整数n(n < 100)

输出
输出一行，包含一个整数，即小于等于n的所有与7无关的正整数的平方和。

样例输入

21

样例输出

2336

参考代码

#include<iostream>
#include<cmath>
using namespace std;

int main(){
	int n, s=0;
	cin >> n;
	for(int i=1;i<=n;i++){
		if(i%7!=0&&i%10!=7&&i%100/10!=7){// 不能被7整除，且个位和十位不是7
			s+=i*i; //计算平方和
		}
	}
	cout << s << endl;
	return 0;
}

40:数1的个数

总时间限制: 1000ms 内存限制: 65536kB

描述
给定一个十进制正整数n，写下从1到n的所有整数，然后数一下其中出现的数字“1”的个数。例如当n=2时，写下1,2。这样只出现了1个“1”；当n=12时，写下1，2，3，4，5，6，7，8，9，10，11，12。这样出现了5个“1”。

输入
正整数n。1 <= n <= 10000。

输出
一个正整数，即“1”的个数。

样例输入

12

样例输出

5

参考代码

#include<iostream>
#include<cmath>
using namespace std;

int main(){
	int n, num, s=0;
	cin >> n;
	for(int i=1;i<=n;i++){
		num = i;
		while(num>0){ // 循环判断所有位数上的数字
			if(num%10==1){ // 判断个位是不是1
				s+=1; // 是1计数
			}
			num/=10; // 将个位去掉
		}
	}
	cout << s << endl;
	return 0;
}

41:数字统计

总时间限制: 1000ms 内存限制: 65536kB

描述
请统计某个给定范围[L, R]的所有整数中，数字2出现的次数。比如给定范围[2, 22]，数字2在数2中出现了1次，在数12中出现1次，在数20中出现1次，在数21中出现1次，在数22中出现2次，所以数字2在该范围内一共出现了6次。

输入
输入共 1 行，为两个正整数 L 和 R，之间用一个空格隔开。

输出
输出共 1 行，表示数字 2 出现的次数。

样例输入

样例 #1：
2 22

样例 #2：
2 100

样例输出

样例 #1：
6

样例 #2：
20

参考代码

#include<iostream>
#include<cmath>
using namespace std;

int main(){
	int l, r, num, s=0;
	cin >> l >> r;
	for(int i=l;i<=r;i++){ //循环取值，从l到r
		num = i;
		while(num>0){ //循环判断num每一位上的数字
			if(num%10==2){ // 数字是2就计数
				s+=1;
			}
			num/=10;//去除个位
		}
	}
	cout << s << endl;
	return 0;
}

42:画矩形

总时间限制: 1000ms 内存限制: 65536kB

描述
根据参数，画出矩形。

输入
输入一行，包括四个参数：前两个参数为整数，依次代表矩形的高和宽（高不少于3行不多于10行，宽不少于5列不多于10列）；第三个参数是一个字符，表示用来画图的矩形符号；第四个参数为1或0，0代表空心，1代表实心。

输出
输出画出的图形。

样例输入

7 7 @ 0

样例输出

@@@@@@@
@                @
@                @
@                 @
@                 @
@                @
@@@@@@@

参考代码

#include<iostream>
#include<cmath>
using namespace std;

int main(){
	int w, h, f;
	char s;
	cin >> h >> w >> s >> f;//注意高和宽不要搞反了
	for(int i=0;i<h;i++){
		for(int j=0;j<w;j++){
			if(f==1){//如果是1就是实心，直接打印
				cout << s;
			}else{
				if((i>0&&i<h-1)&&(j>0&&j<w-1)){//空心处理
					cout << ' ';
					
				}else{
					cout << s;	
				}
			}
		}
		if(i<h-1) cout << endl;//不要忘记打印一行后换行。
	} 
	return 0;
}

43:质因数分解

总时间限制: 1000ms 内存限制: 65536kB

描述
已知正整数 n 是两个不同的质数的乘积，试求出较大的那个质数。

输入
输入只有一行，包含一个正整数 n。对于60%的数据，6 ≤ n ≤ 1000。对于100%的数据，6 ≤ n ≤ 2*10^9。

输出
输出只有一行，包含一个正整数 p，即较大的那个质数。

样例输入

21

样例输出

7

参考代码

#include<iostream>
#include<cmath>
using namespace std;

int main(){
	int n;
	cin >> n;
	for(int i=2;i<n/2;i++){//注意范围，从2开始，到n/2-1结束。
		if(n%i==0){ //能够整除即找到了，比如21%3等于0.那么7就是较大的质数
			cout << n/i << endl;//计算较大质数并输出
			break;
		}
	}
	return 0;
}

44:第n小的质数

总时间限制: 1000ms 内存限制: 65536kB

描述
输入一个正整数n，求第n小的质数。

输入
一个不超过10000的正整数n。

输出
第n小的质数。

样例输入

10

样例输出

29

参考代码

#include<iostream>
#include<cmath>
using namespace std;

int main(){
	int n, count=0;
	bool flag;
	cin >> n;
	for(int j=2;;j++){//注意不需要加j<10000
		flag=true;
		for(int i=2;i<=sqrt(j);i++){
 			if(j%i==0){//是否能整除
				flag=false;//不是质数
				break;//不是质数，无需再继续判断，跳出本循环。继续判断下一个数
			}
		}
		if(flag){//如果是质数
			count++;//计数
			if(count==n){//是否是第n小的质数
				cout << j;
				break;//找到跳出循环
			}
		}
	}
		
	return 0;
}

45:金币

总时间限制: 1000ms 内存限制: 65536kB

描述
国王将金币作为工资，发放给忠诚的骑士。第一天，骑士收到一枚金币；之后两天（第二天和第三天）里，每天收到两枚金币；之后三天（第四、五、六天）里，每天收到三枚金币；之后四天（第七、八、九、十天）里，每天收到四枚金币……这种工资发放模式会一直这样延续下去：当连续N天每天收到N枚金币后，骑士会在之后的连续N+1天里，每天收到N+1枚金币（N为任意正整数）。你需要编写一个程序，确定从第一天开始的给定天数内，骑士一共获得了多少金币。

输入
一个整数（范围1到10000），表示天数。

输出
骑士获得的金币数。

样例输入

6

样例输出

14

参考代码

#include<iostream>
#include<cmath>
using namespace std;

int main(){
	int coins=0, day, n=0, i=1;//金币数量，天数，计算的天数，每天发的金币数
	cin >> day;
	while(n<day){
		n+=i;//天数，如果要一天发5个金币，则会发5天，累计加5即可
		coins+=i*i-(n>day?(n-day)*i:0);// 每次金币增加i*i,比如每天发5枚金币，发5天，就是25枚金币。存在算多的情况，比如第5天，发3枚金币，i*i会计算发3天3枚金币，但是没有到第六天，所以需要i*i-(n-day)*i，即3*3-（6-5）*3,就只计算第4、5天的金币。
		i++;// 发的金币数增加
	}
	cout << coins;	
	return 0;
}