【东华oj】基础进阶刷题

东华oj

• 前言
• 基础题
• • 【顺序结构】
  • 1 求长方形的面积和周长
  • 2 数列和
  • 3 解方程
  • 【分支结构】
  • 4 一个月的天数
  • 5 银行存款到期日
  • 6 实数运算
  • 7 解二次方程
  • 8 门票价格计算
  • 9 星期几问题
  • 10 时间相加
  • 11 成绩转换
  • 【循环】
  • 12 求第几天
  • 13 求阶乘结果0的个数
  • 14 怪数
  • 15 abc数字
  • 16 奇妙的比值
  • 17 T的倍数N
  • 18 三角形
  • 19 数字串处理❤
  • 20 公式求解
  • 21 累加式
  • 22 约瑟夫环2❤
  • 23 整除的尾数
  • 24 回文质数
  • 25 汽水瓶
  • 26 阶乘最后的非0位❤
  • 27 算菜价
  • 28 水果价格
  • 29 求奇数的乘积
  • 30 求最晚和最早日期
  • 31 素数
  • 32 计算e
  • 33 数字之和
  • 【一维数组】
  • 34 繁殖问题
  • 35 奇妙的数字
  • 36 整除的尾数
  • 37 黑色星期五
  • 38 树
  • 39 约瑟夫环❤
  • 40 最大与最小
  • 41 环
  • 42 求数列项
  • 43 最高频率
  • 44 三艘船
  • 45 回文数
  • 46 特殊四位数
  • 47 最大值
  • 48 数列1
  • 49 修理牛棚❤
  • 50 按要求输出序列
  • 50 按要求输出序列
  • 【函数】
  • 58 素数表
  • 【二维数组】
  • 69 杨辉三角
  • 【字符串】
  • 81 求小数位数个数

前言

本以为自己无多大希望，出成绩这一个月来一直忙于找工作与毕设，现在只剩不到一周了（事实上oj系统开启时间只剩三天了），这三天要好好刷题，之后准备面试的自我介绍、理论知识之类的，一定来得及，加油！
“悟已往之不谏，知来者之可追。

”

基础题 【顺序结构】 1 求长方形的面积和周长

问题描述 :
求一个长方形的面积S及周长P。

面积的公式为S = a × b，周长的公式P=2*(a+b)，其中a代表长方形的长，b代表长方形的宽。

输入说明 :
你的程序需要从标准输入设备（通常为键盘）中读入两个整数：一个整数a（0 ≤a < 10000），代表长方形的长；一个整数b（0 ≤ b < 10000），代表长方形的宽；在a和b之间有一个空格；在行首和行尾没有多余的空格。

输出说明 :
你的程序需要向标准输出文件（通常为启动该程序的终端）输出对应的答案。

答案占一行，其中包含两个整数，即长方行的面积和周长，中间以一个空格分隔。

在行首和行尾不要输出多余的空格。

#include
using namespace std;
int main(){
	int a,b,s,p;
	while(cin>>a>>b){
		s=a*b;
		p=2*(a+b);
		cout<<s<<" "<<p<<endl;
	}
	return 0;
}

2 数列和

问题描述 :

尝试求从1+2+…+N这N个自然数的和。

输入说明 :

你的程序需要从标准输入设备（通常为键盘）中读入一个整数N（1 ≤ N <
10,000）；在行首和行尾没有多余的空格。

在所有数据的前后，以及两组数据之间都没有多余的空行。

输出说明 :

对每组测试数据，你的程序需要向标准输出设备（通常为启动该程序的终端）输出对应的答案，其中仅有一个整数，即题目描述中的数列之和。

在行首和行尾不要输出多余的空格。

#include
using namespace std;
int main(){
	int sum=0,N;
	if(cin>>N){
		for(int i=0;i<=N;i++){
			sum+=i;
		}
	}
	cout<<sum<<endl;
	return 0;
}

3 解方程

问题描述 :

编写程序：输入a、b后，输出一元一次方程2ax+3*b-5=0的解。

输入说明 :

整数a b

输出说明 :

x 保留1位小数

关于输出保留一位小数：
①printf("%.1f",x);
②cout<

#include
using namespace std;
int main(){
	double a,b,x;
	cin>>a>>b;
	x=(5-3*b)/(2*a);
	printf("%.1f",x);
	return 0;
}

【分支结构】 4 一个月的天数

问题描述 :

输入年和月，输出该月有几天。

输入说明 :

输入两个整数，中间以空格分隔，第一个整数表示年，第二个整数表示月。

输出说明 :

输出该年该月的天数，输出时，行首与行尾均无空格，仅输出一个整数。

switch的使用。

注意，年数为整百时，仅当年数可以整除400才算做闰年。

例如1900年是平年，28天。

#include
using namespace std;
int main(){
	int year,month;
	int crl;
	cin>>year>>month;
	if(month==1||month==3||month==5||month==7
	||month==8||month==10||month==12) crl=1;
	if(month==4||month==6||month==9||month==11) crl=2;
	if(month==2){
		if(year%100==0){
			if(year%400==0) crl=3;
		}
		else{
			if(year%4==0) crl=3;
		}
	}
	switch(crl){
		case 1:{
			cout<<31<<endl;
			break;
		}
		case 2:{
			cout<<30<<endl;
			break;
		}	
		case 3:{
			cout<<29<<endl;
			break;
		}		
		default:{
			cout<<28<<endl;
			break;
		}
	}
	return 0;
}

5 银行存款到期日

问题描述 :

银行存款有3个月、6个月定期等。

从键盘输入一个日期（即为存款日期）以及定期的时间长度（单位为月，输入的时间长度可为小于等于60的任意正整数），请编程输出该定期存款的到期日期。

下面以3个月定期为例，说明定期的概念。

比如：

输入2014年4月30日，则到期日是2014年7月30日；

输入2014年3月31日，则到期日是2014年6月30日（6月没有31日，所以30日就到期）；

输入2014年11月30日，则到期日是2015年2月28日；

输入2015年11月30日，则到期日是2016年2月29日。

输入说明 :

共输入4个整数，中间以空格分隔，第一个整数表示年，第二个整数表示月，第三个整数表示日，第四个整数表示定期长度（单位为月）。

输出说明 :

输出到期日期，共输出三个整数，中间以一个空格分隔，行首与行尾均无空格。

也是要注意一个闰年的问题。

原年份year与新年份y（while循环++）
原月份month与新月份m（while循环-12）
原日期day与新日期d（原31新30的判断）

#include
using namespace std;
int main(){
	int year,month,day,num,y,m,d;
	int crl;
	cin>>year>>month>>day>>num;
	y=year;
	m=month+num;
	d=day;
	while(m>12){
		m-=12;
		y++;
	}
	
	if(m==2){
		if(y%100==0){
			if(y%400==0) d=29;
			else d=28;
		}
		else{
			if(y%4==0) d=29;
			else d=28;
		}
	}	
	if(d>30){
		if(m==4||m==6||m==9||m==11)
		d=30;
	}
	cout<<y<<" "<<m<<" "<<d<<endl;
	return 0;
}

6 实数运算

问题描述 :

输入两个实数，求它们的和，差，积，商。

输入说明 :

输入数据由两行组成：第一行为两个实数a、b，它们以空格分隔，在行首和行尾没有多余的空格；第二行为运算符号’+’、’-’、’*’、’/'之一，在行首和行尾没有多余的空格。

输出说明 :

输出运算结果(保留一位小数)，行首和行尾没有多余的空格，当除数为0时输出’Wrong!’。

最初用switch，不成功哈哈哈。

因为switch中的条件似乎只能用数字而不能字符，因此还要多赋一个crl的数字值。

#include
#include
using namespace std;
int main(){
	double a,b;
	char ch;
	cin>>a>>b;
	cin>>ch;
	if (ch == '+') {
		cout <<fixed << setprecision(1) << a + b <<endl;
	} else if (ch == '-') {
		cout <<fixed << setprecision(1) << a - b <<endl;
	} else if (ch == '*') {
		cout <<fixed << setprecision(1) << a * b <<endl;
	} else if (ch == '/') {
		if(b!=0)
			cout <<fixed << setprecision(1) << a / b <<endl;
		else
			cout << "Wrong!" <<endl;
	}
}

7 解二次方程

问题描述 :

编写程序求方程ax2+bx+c=0的根，a、b、c的值由键盘输入，假设b2-4ac>0

输入说明 :

3个整数a b c，以一个空格分隔

输出说明 :

两个根，大数在前，小数在后

输出时保留两位小数。

根公式：（-b±sqrt▲）/2，并if▲>0
保留两位print("%.2f",x);

#include
#include
#include
using namespace std;

int main() {
	int a,b, c;
	double x1, x2, d;
	while(cin>>a>>b>>c){
		d = b*b-4*a*c;
		x1= ((-b)+sqrt(d))/(2* a) ;
		x2 = ((-b)-sqrt(d))/(2* a) ;
		if(x1 > x2){
			cout << fixed <<setprecision(2) << x1 <<" "<< x2 <<endl;
		} else {
			cout << fixed <<setprecision(2) << x2 <<" "<< x1 <<endl;
		}
	}
	return 0;
}

8 门票价格计算

问题描述 :

某旅游景点门票价格为每人5元。

但团体可以优惠，分为以下情况：

人数超过20，则所有人优惠10%；

人数超过40，则所有人优惠15%；

人数超过80，则所有人优惠20%；

人数超过120，则所有人优惠30%。

请跟据团体的人数，求出该团体的总门票价格。

输入说明 :

输入一个整数i（0≤i≤1,000），表示一个团体的总人数。

在行首和行尾没有多余的空格。

输出说明 :

输出一个实数，即该团体需要支付的总票价，精确到小数点后2位。

在行首和行尾不要输出多余的空格。

switch语句分支即可

#include
#include
#include
using namespace std;

int main() {
	int n;
	double s;
	while(cin>>n){
		if (0 <= n && n <=20) {
			s=n * 5;
		} else if(n > 20 && n <= 40) {
			s = n * 5 * 0.9;
		} else if (n > 40 && n <= 80) {
			s = n * 5 * 0.85;
		} else if (n > 80 && n <= 120) {
			s = n * 5 * 0.8;
		} else if (n > 120) {
			s = n * 5 * 0.7;
		}
		cout<<fixed<<setprecision(2)<<s<<endl;
	}
		
	return 0;
}

9 星期几问题

问题描述 :
根据一个范围在0至6的整数，用英文输出它对应的是星期几。

（0对应Sunday，1对应Monday， 2对应Tuesday， 3对应Wednesday， 4对应Thursday， 5对应Friday， 6对应Saturday）
输入说明 :
输入一个整数n（0 ≤ n ≤ 6）。

在行首和行尾没有多余的空格。

输出说明 :
输出一个字符串，即输入n对应的星期几的英文名称，请注意大小写。

在行首和行尾不要输出多余的空格。

switch分支，很简单

#include
#include
#include
using namespace std;

int main() {
	int n;
	string ch;
	while(cin>>n){
		if (n == 0) {
			ch = "Sunday";
		} else if(n == 1) {
			ch = "Monday";
		} else if (n == 2) {
			ch = "Tuesday";
		} else if (n == 3) {
			ch = "Wednesday";
		} else if (n == 4) {
			ch = "Thursday";
		} else if (n == 5) {
			ch = "Friday";
		} else if (n == 6) {
			ch = "Saturday";
		}
		cout<<ch<<endl;
	}
		
	return 0;
}

10 时间相加

问题描述 :

输入两个时间A和B，分别都由3个整数组成，分别表示时分秒，比如，假设A为34 45 56，就表示A所表示的时间是34小时 45分钟 56秒。

输出A+B即两个时间相加后的结果。

输入说明 :

输入数据由6个整数AH,AM,AS,BH,BM,BS组成，分别表示时间A和B所对应的时分秒。

题目保证所有的数据合法。

输出说明 :

输出A+B，输出结果也由时分秒三部分组成，同时也要满足时间的规则（即：分和秒的取值范围在0~59），输出仅占一行，整数之间以一个空格分隔，行首与行尾无多余空格。

输出H,M,S
两次if，s-=60，则M++；M-=60,H++；

#include
#include
#include
using namespace std;

int main() {
	int a , b, c, d, e, f, s, i, m;
	while(cin>>a>>b>>c>>d>>e>>f){
		s = a + d;
		i = b + e;
		m = c + f;
		if(m >= 60) {
			m -= 60;
			i++;
		}
	    if(i >= 60) {
			i -= 60;
			s++;
		} 
		cout<<s<<" "<<i<<" "<<m<<endl;
	}
		
	return 0;
}

11 成绩转换

问题描述 :

输入一个百分制的成绩t，将其转换成对应的等级，具体转换规则如下：

90~100为A;

80~89为B;

70~79为C;

60~69为D;

0~59为E;

输入说明 :

输入一个整数。

输出说明 :

输出对应结果，占一行。

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

注意：无多余空格。

switch结构

#include
#include
#include
using namespace std;

int main() {
	int n;
	string ch;
	while(cin>>n){
		if (n <= 100 && n >= 90) {
			ch = "A";
		} else if(n <= 89 && n >= 80) {
			ch = "B";
		} else if (n <= 79 && n >= 70) {
			ch = "C";
		} else if (n <= 69 && n >= 60) {
			ch = "D";
		} else if (n <= 59 && n >= 0) {
			ch = "E";
		} else {
			ch = "Score is error!";
		}
		cout<<ch<<endl;
	}
		
	return 0;
}

【循环】 12 求第几天

问题描述 :

按年、月、日的顺序读入一个日期，输出该日期是这一年中的第几天。

输入说明 :

输入数据为三个正整数y 、m、d，分别表示年、月、日，整数之间以空格分隔，在行首和行尾没有多余的空格。

输出说明 :

输出一个整数，表示输入的日期是这一年中的第几天，在行首和行尾没有多余的空格。

数组存每个月的天数：int mon[12]={31,28…}
for循环：
sum +=mon[ i ]
分类if：
①闰年&&月份≥3：sum+day+1
②else：sum+day

    #include  
    using namespace std;  
    int main()  
        {  
        int y,m,d,total=0,i;  
        int db[12]={31,28,31,30,31,30,31,31,30,31,30,31}; 
        cin>>y>>m>>d;   
        for(i=0;i<m-1;i++)  
            {  
              total+=db[i];        
            }
        if((y%4==0&&y%100!=0)||(y%400==0))  
            cout<<total+d+1<<endl;
        else  
            cout<<total+d<<endl; 
        return 0;   
    }  

13 求阶乘结果0的个数

问题描述 :

编写一个程序，求出N！的末尾含有多少个0。

提示：在乘积中，末尾有多少个0，主要看各乘数的素数因子中有多少个2和5，每一个2和5的结合将给末尾贡献一个0。

而乘数中因子2的个数远多于因子5的个数，因此，就计算各乘数中因子5的个数即可。

输入说明 :

你的数据需要从标准输入设备（通常为键盘）中读入多组测试数据。

每组输入数据由一行组成，每行由一个正整数N组成，N小于等于100000，在行首和行尾没有多余的空格。

输出说明 :

对每组测试数据，你的程序需要向标准输出文件（通常为启动该程序的文本终端）依次输出一组对应的答案。

所有数据前后不要输出多余的空行，两组数据之间也不要输出多余的空行。

每组输出数据由一行组成，每行由一个整数组成，在行首和行尾不要输出多余的空格。

5出现次数：sum
for：
int j=i；
while（j是五倍数）
sum++；
j/=5

#include
#include
#include
using namespace std;

int fi(int l)
{
    int b=0;
    while(l>=5)
    {
        l/=5;
        b+=l;
    }
    return b;
}
int main()
{
    int n;   
    while(cin>>n)
    {
        int t=fi(n);
        cout<<t<<endl;
    }
    return 0;
}

14 怪数

作者: Turbo时间限制: 1S章节: 循环

问题描述 :

寻找怪数：有一种奇怪的自然数，它的比其本身小的所有因子之和等于它本身，例如：6＝1＋2＋3，其中1、2、3都是6的因子，编程找出整数N之内的所有怪数。

输入说明 :

输入一个整数N(10<=N≤10000)，在行首和行尾没有多余的空格。

输出说明 :

输出N之内(<=N)的所有怪数，每一行输出一个整数。

（注：若N中有3个怪数，你则需要输出三行，每行一个怪数。

）所有数据前后没有多余的空格，中间也没有多余的空行。

for（i为2~n）：
int sum=0
for（j为1~i）：
if（j是i的因子）：sum+=j
if（sum=i）
输出

#include
#include
#include
using namespace std;

int fi(int a) {
	int sum = 0;
	for (int i = 1; i < a; i++) {
		if(a %  i == 0) {
			sum += i;
		}	
	}
	if (sum == a) {
		return 1;
	} else return 0;
}

int main() {
	int n, i = 2;
	while(cin>>n){
		while (i <= n) {
			i++;
			if(fi(i)){
				cout<<i<<endl;
			}
		}	
	}		
	return 0;
}

15 abc数字

作者: Turbo时间限制: 10S章节: 循环

问题描述 :

明明的爸爸是一位著名的数学家同时也是一位著名的数学启蒙老师。

他经常出一些简单而有趣的数学题目来给刚刚接触数学的小朋友做，培养他们对数学的兴趣。

一天，明明的爸爸想到了这样一个题目。

如果有a、b、c三个1位的正整数，那么按以下的方法构成2个三位数：第一种方法是a为百位，b为十位，c为个位，构成的数就是abc；第二种方法是c为百位，b为十位，a为个位，构成的数就是cba；然后将这两个三位数相乘，会得到另一个数。

现在就要数一下这个相乘后所得到的数中，有几个数字是与a、b、c相同的。

例如：a=1，b=2，c=3，这样构成的两个三位数分别是123和321，两数相乘得到39483，在这个数中有2个“3”与c所表示的“3”是一样的，因此有2个数字是与a、b、c其中之一相同的。

明明的爸爸决定明天把这道题目给小朋友做，他手头有很多组这样的a、b、c，但是要把所有的a、b、c都通过上述的方法计算出结果来需要很多的时间，明明的爸爸没有那么多的时间，于是他求助于你，请你帮他写一个程序，用来计算出相应的结果。

明明爸爸的问题可以归结为：输入a，b，c三个一位数字，要求abc这样的一个三位数与cba这样的一个三位数相乘，输出其结果，再判断相乘后的结果中的数字中有多少位是与a、b、c相同的，并输出有几位相等。

输入说明 :

你写的程序要求从标准输入设备（通常，键盘为标准输入设备）中读入测试数据作为你所写程序的输入数据。

标准输入设备中有多组测试数据，每组测试数据仅占一行，每行有三个正整数a、b、c，且a、b、c都为正整数，a、b、c中间用一个空格隔开。

每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备（通常，显示屏为标准输出设备）中。

每组运算结果为两个整数，即abc和cba的乘积和有几位相等，两个数之间用一个空格隔开。

每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。

sum=（a100+b10+c）（c100+b*10+a）
int flag，count
while（sum/=10）：
flag=sum%10
if（flag==a或b或c）：count++

#include
#include
#include
using namespace std;

int main() {
	int a,b,c,l,r,s;
	while(cin>>a>>b>>c){
                int count = 0;
		l = a * 100 + b * 10 + c;
		r = c * 100 + b * 10 + a;
		s = l * r;
		for (int i = s;i > 0;i /=10) {
			int j = i / 10;
			int k = i - j*10; 
			if (k == a || k == b || k == c){
				count++;
			}
		}
		cout << s << " "<<count<<endl;
	}		
	return 0;
}

16 奇妙的比值

作者: 孙辞海 时间限制: 10S章节: 循环

问题描述 :

明明喜欢钻研各种各样的数学问题。

一天，明明对数的因子产生了兴趣，他想把一个数的所有因子都找出来，然后把它们相加再去除以这个数，这样会得到一个比值。

明明想看看不同的数的该比值会有什么不同，以便做研究。

例如6这个数，它一共有4个因子，分别是：1、2、3、6，把他们相加然后再除以6，即1+2+3+6=12，12/6=2，就可以得到2这个比值。

明明为了研究，需要得到大量的比值，但是如果通过手动计算比值的话需要花大量的时间，于是明明就想请你帮忙，帮他写一个程序，能够求数的比值。

明明的问题可以归结为：给你一个数，求所有因子和，把这些因子相加，然后再除以这个数，求得比值。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。

标准输入设备中有多组测试数据，每组测试数据仅占一行，每行仅包括一个正整数n（1≤n≤120），代表所求比值的那个数。

每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。

每组运算结果为一个浮点数，就是所求的比值，保留2位小数。

每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。

（注：最后求得的比值保留2位小数。

）
注：通常，显示屏为标准输出设备。

for（i为2~n）：
double sum=0，dev=0；
for（j为1~i）：
if（j是i的因子）：sum+=j
dev=sum/n
两位小数输出dev

#include
#include
#include
using namespace std;

int main() {
	int n;
	double sum = 0;
	while(cin>>n){
		sum = 0;
		for (int i = 1; i <= n; i++) {
			if (n % i == 0) {
				sum += i;
			}
		}
		sum /=n;
		cout << fixed <<setprecision(2) << sum <<endl;
	}		
	return 0;
}

17 T的倍数N

作者: 程裕强 时间限制: 10S章节: 循环

问题描述 :

明明学习数学已经有很多年了，对各种各样的数学问题都有研究。

有一天，明明的爸爸问明明说：“明明，你觉得你对数字敏感吗？”明明毫不犹豫地回答：“那当然，非常敏感。

”于是明明的爸爸就说：“好，那我问你一个问题，如果有一个个位数为7的自然数N，把它的个位数移到最高位，其余各位均右移一位（如127变成712），要求这样得到的一个新的数是原数的T倍。

若我现在把自然数T告诉你，你能求出最小的符合条件的自然数N吗？”
明明觉得这个问题很简单，只要按从小到大的顺序把所有是7结尾的自然数找出来，然后交换位置，再除一下，看看倍数是不是T倍就可以了。

明明回答爸爸说：“这个问题很简单，来考我吧。

”于是明明的爸爸就给了明明一个数字2，让他开始动手寻找。

但是，使明明意想不到的是，他找了很久很久，始终没有找到想要的那个数，而当他到查到1000007时，需要的那个数还是没有出现，于是就放弃了。

他觉得靠手工查找的话，是无法快速找到的。

因此，明明求助于你，请你帮他写一个程序，来解决这个相当棘手的问题。

但是他也给了你另外一个条件，如果找到超过1000000时还是没有找到需要的那个数的话，就停止寻找。

明明的问题可以归结为：对于一个个位数为7的自然数N，把它的个位数移到最高位，其余各位均右移一位，要求这样得到的一个新的数是原数的T倍。

现给出这个自然数T，求满足这个要求的最小的自然数N。

若在[1,
1000000] 的范围内没有找到N，则输出“No”。

输入说明 :

你写的程序要求从标准输入设备（通常，键盘为标准输入设备）中读入测试数据作为你所写程序的输入数据。

标准输入设备中有多组测试数据，每组测试数据仅占一行，每行仅有一个自然数T（1≤T≤9）。

每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备（通常，显示屏为标准输出设备）中。

每组运算结果输出一个自然数N或“No”，不包括双引号。

每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。

因为有多组测试数据，cin>>T这个部分可以放在while里面。


int num=7；
for（i为1~1000000）：
	if（i%10==7）
		old=i；
		while（i/10！= 0）{
			num*=10；
		}
		new=old/10+num
		if（new==old）
			输出
			break；
else
	输出no

18 三角形

“明明，你会用1到9这九个数字组成一个三角形吗？”明明的爸爸问明明。

明明被问的很莫名其妙，不明白他爸爸在说什么，于是就问道：“用1到9组成三角形？？？”“是的，我的要求很简单，给你2个数，一个数作为这个三角形的开始，另一个数决定这个三角形的大小。

例如我给你5和6这两个数，你就要组成如下的一个三角形：

5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7

明白了吗？”
明明观察了许久，终于看出了门道来，说道：“就是说给我2个数，例如5和6，那我就要从5这个数开始构建一个三角形。

第一行为一个数字，第二行为2个数字，以此类推，直到第六行的六个数字，且三角形中的数字都是1到9在循环重复，是这样吗？”“明明真聪明，就是这样。

”明明爸爸高兴的说道。

于是明明的爸爸给了明明很多组这样的数字，明明也构建出了很多个不同的三角形。

你能像明明那样，写一个程序来构建上面的三角形吗？

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。

标准输入设备中有多组测试数据，每组测试数据仅有一行，每行有两个整数s和n（1≤s≤9，1≤n≤80），其中s表示位于三角形的最顶端的数字，n表示三角形由几行数字组成。

每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。

每组运算结果为构建出来的三角形，三角形中的同一行的数字两两之间用一个空格隔开。

每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。

注：通常，显示屏为标准输出设备。

两层嵌套for，外层为每行个数，内层为1~9循环
1~9循环：若a为9则输出且再令为1，else使a++

#include
#include
#include
using namespace std;

int main() {
 int a, b;
 while(cin>>a>>b) {
  for (int i = 0; i < b; i++) {
   for (int j = 0; j < i; j++) {
    if (a == 9) {
     cout<<a<<" ";
     a = 1;
    } else {
     cout<<a<<" ";
     a++;
    }
   }
   if(a == 9) {
    cout<<a;
    a = 1;
   } else {
    cout<<a;
    a++;
   }
   cout<<endl;
  }    
 }  
 return 0;
}

19 数字串处理❤

作者: ZhouMingLiang时间限制: 10S章节: 循环

问题描述 :

明明的爸爸经常对明明进行数学启蒙教育。

有一天他和明明做了一个游戏，对一串数字进行处理。

明明的爸爸首先给明明一串数字，在这串数字中有很多数字会连续重复出现很多次，爸爸就要求明明把其中连续重复出现次数最多的那个数字找出来。

如果有很多个数字连续出现的次数相同，即重复出现次数最多的数字不止一个，那就要明明找出第一次出现该重复次数的那个数字。

例如有一串数字：2 2 2 1 1 1，其中2出现了3次，1也出现了3次，而明明要找出的那个数字是2，因为2是第一次重复出现3次的那个数字。

明明的爸爸现在已经设计好了很多组这样的数据，但是他不想自己来寻找，他想让你帮他写一个程序，找出出现次数最多的那个数字，然后他手中就有一份标准答案，可以用来检查明明到底做得对不对。

明明爸爸的问题可以归结为：给你一串数字，找出在这串数字中连续出现次数最多的那个数字；若有多个数字连续出现的次数相当，则找出第一次出现该次数的那个数字。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。

标准输入设备中有多组测试数据，每组测试数据有2行，测试数据的第一行有1个整数n（1

每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。

每组运算结果为两个整数：出现次数最多的那整数，以及它的出现次数。

每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。

注：通常，显示屏为标准输出设备。

#include
#include
#include
using namespace std;

int main() {
	int a[100], b, n, key,count,temp,i;
	while(cin>>n) {
		count = 1;
		for (i = 0;i < n;i++) {
			cin>>a[i];
		}
		key = a[0];	
		temp = 1;
		for (i = 1; i < n; i++) {
			//重复了
			if (a[i] == a[i - 1]) temp++;
			//没重复
			else{
				//出现次数更多的
				if(temp > count) {
					count = temp;
					//退一个开始查找，对比后面的
					key = a[i - 1];
					temp = 1;
				} else {
					temp = 1;
				}
			}
		}
		//重复次数相同，算先出现的
		if(temp > count) {
			count = temp;
			key = a[i - 1];
		}
		cout<<key<<" "<<count<<endl;			
	}		
	return 0;
}

20 公式求解

作者: 朱星垠时间限制: 10S章节: 循环

问题描述 :

明明刚上初中，数学课上老师教了平方的概念，即两个相同的数相乘可以表示为这个数的平方：a×a = a
2。

明明觉得这很有趣，就开始研究起来，很快掌握了这个知识点。

但是在一次考试中，明明遇到了一个难题，题目的要求是有四个正整数a、b、x、y，他们各自的平方数组成了一个等式a2

• x2 = b2 + y2，现在已知a和b，请求出所有小于等于100的x、y，来满足这个等式。
  

  
  

  例如给你a=2、b=5，我们可求出的解是x=5、y=2和x=11、y=10。
  

  
  

  
  明明虽然明白了题目的意思，但是要自己求解却显得相当困难。
  

  
  

  他想了很久也没有能够解出这道题目。
  

  
  

  放学回家就开始问他的爸爸，他爸爸虽然对数学很精通，但是也无法一时给出正确的答案，于是他就求助于你，帮他解决这个问题。
  

  
  

  
  明明的问题可以归结为：给定两个正整数a、b，求所有的正整数x和y，使a2 + x2 = b2 +
  y2，其中a、b、x、y都不大于100。
  

  
  

  在所有的有效解中，按x的大小进行排序，从小到大输出。
  

  
  

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。

标准输入设备中有多组测试数据：每组测试数据由一个不大于100的正整数a后跟一个不大于100的正整数b组成，a和b之间由一个空格分开，形成一行数据，其行首和行尾都没有任何空格，当a和b同时为0时，表示输入结束；每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组或者多组相应的运算结果，并将这一组或者多组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。

每组运算结果由一个不大于100的正整数x后跟一个不大于100的正整数y组成，x和y之间由一个空格分开，形成一行数据，其行首和行尾都没有任何空格；如果有多组相应的运算结果，则按x的大小进行排序，从小到大输出。

每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。

注：通常，显示屏为标准输出设备。

for循环即可

#include
#include
#include
using namespace std;

int main() {
	int a,b;
	while(cin>>a>>b) {
		if(a==0&b==0){
			break;
		}
	for (int x = 1;x <= 100; x++) {
		for (int y = 1; y <= 100; y++) {
			if(a * a + x * x == b * b + y * y) {
				cout<<x<<" "<<y<<endl;
				break;
			}
		}
	}
	cout<<endl;			
	}		
	return 0;
}

21 累加式

作者: 朱星垠时间限制: 10S章节: 循环

问题描述 :

累加式对于明明来说是一个全新的概念，他在数学课上第一次听到了这个名词。

可是明明在课堂上并没有完全明白，于是回家后明明就问他爸爸什么是累加式。

明明的爸爸是一位数学家，自然对累加式非常熟悉，告诉明明：“累加式是一种表达式，这种表达式的构成方法是这样的：从1开始加，其后的每一个数都比前一个数大1，然后加到某一个数后停止递增，之后每加的一个数都比前一个数小1，一直加到1为止，这样构成的一个表达式称为累加式。

例如1+2+3+4+3+2+1就是一个累加式，它从1开始加到4，然后再加到1，完成累加的过程。

”明明对他爸爸的回答相当满意，于是想构造更多的累加式出来，可是明明又不想过于辛苦，他来求助于你，帮他写一个程序，完成累加式的构造。

明明的问题可以归结为：给你一个正整数n，完成从1到n再到1的累加式的构造。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。

标准输入设备中有多组测试数据，每组测试数据仅占一行，每行仅包含一个正整数n（1≤n≤10）。

每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。

每组运算结果由一个1到n再到1的累加式构成，累加式中不包含空格；每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。

注：通常，显示屏为标准输出设备。

很简单，if语句里面套两个for循环

#include
#include
#include
using namespace std;

int main() {
	int n;
	while(cin>>n) {
		if (n == 1) {
			cout<<"1"<<endl;
		}else{
			for (int i = 1; i<=n;i++){
			cout<<i<<"+";
		}
		for (int j = n-1; j > 1; j--) {
			cout<<j<<"+";
		}
		cout<<"1"<<endl;
		}
		
	}		
	return 0;
}

22 约瑟夫环2❤

作者: SunCiHai时间限制: 10S章节: 循环

问题描述 :

明明是一名公安局的谈判专家，专门负责和绑匪谈判。

有一次，明明接到一个特殊的任务，他赶到了案发现场，发现有k个绑匪绑架了k个人质，于是明明就开始和绑匪进行谈判。

绑匪提出了一个非常特殊的要求，如果明明能够回答出这个问题，那绑匪将释放所有的人质；否则，绑匪就要撕票。

绑匪的问题是这样：绑匪把人质和自己围成一个圈，把人质从1开始编号，一直编到k，然后绑匪自己从k+1开始编号，一直编到2k。

现在从编号1开始，每次从其中选出第m个人（隔m-1选出一个人）出列，然后绑匪要求明明选定这个m值，且m值要尽量的小，使得最先出列的k个人都是绑匪。

例如：有3个坏人和3个人质，他们排成一圈，其中编号1到3的为人质，编号4到6的为坏人，如下： 1、2、3、4、5、6；
明明要选定m=5时，能够满足绑匪的要求。

因为： 第一轮，从1开始数，编号5出列，剩下的人为： 1、2、3、4、6；
第二轮，从6开始数，编号4出列，剩下的人为： 1、2、3、6； 第三轮，从6开始数，编号6出列，剩下的人为： 1、2、3；
这样所有的绑匪都先出列，明明可以成功地救出所有的人质。

如果明明能够找到这个m值，那么所有的人质都想获救，否则的话，后果不堪设想。

明明意识到了问题的严重，这个问题对他来说十分地棘手。

于是明明想到了你，你是一名程序设计专家，明明想让你用程序来解这个问题，救出所有的人质。

明明的问题可以归结为：假设有k个人质和k个绑匪围成一圈。

人质的编号从1到k，绑匪的编号从k+1到2k。

从编号1开始，每次从其中选出第m个人(隔m-1选出一人)出列。

希望求出m的最小值，使得最先出列的k个人都是绑匪，即都是编号从k+1到2k的人。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。

标准输入设备中有多组测试数据，每组测试数据仅一行，每组测试数据有一个整数k（1≤k≤10），表示人质的人数和绑匪的人数。

每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。

每组运算结果为一个整数m，即明明要选定的那个数。

每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。

注：通常，显示屏为标准输出设备。

（没有想出来，看别人的）
算法概述：m从1开始测试，若当前出环人员编号满足要求，
则将当前出环人员从环中删除，若不满足要求，则重置数据
然后测试下一个m，直到找到合适的m

#include
#define MAX_SIZE 25

int main() {
	int k = 0, m = 0;
	int i = 0, j = 0;
	int nums[MAX_SIZE] = {0};// 环内人员编号
	int copyNums[MAX_SIZE] = {0}; 
	int left = 0;// 环内剩余人数 
	int start = 0;// 开始计数序号 
	
	while (scanf("%d", &k) != EOF) {
		for (i = 1; i <= 2 * k; i++) {
			nums[i] = i;
			copyNums[i] = nums[i];
		}
		
		m = 1;
		start = 1; 
		left = 2 * k;
		while (1) {
			for (i = k + 1; i <= 2 * k; i++) {
				start = (start + m - 1) % left;
				if (start == 0)// 特殊情况，回到起始点 
					start = left;
				if (copyNums[start] >= k + 1 && copyNums[start] <= 2 * k) {// 出环编号满足要求 
					for (j = start; j < left; j++)// 在环内删除当前出环人员 
						copyNums[j] = copyNums[j + 1];
					left--;
				} 
				else {// 不满足要求 
					m++;// 重置数据
					start = 1;
					left = 2 * k;
					for (j = 1; j <= 2 * k; j++)
						copyNums[j] = nums[j];
					break; 
				}
			}
			if (i == 2 * k + 1) {// 出环人员均满足要求 
				break; 
			}
		}
		printf("%d\n", m);
	} 
	
	return 0;
}

23 整除的尾数

作者: XXX时间限制: 1S章节: 循环

问题描述 :

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

输入说明 :

第一行为T,以下T行，每行为一组测试数据,包含两个整数a，b（0

输出说明 :

对应每组数据，将满足条件的所有尾数在一行内输出，格式见范例。

同组数据的输出，其每个尾数之间空一格，行首与行尾没有空格。

有点问题，题中要求输入多组数据，最后出结果。

但我写的程序输一行就出一行结果。

经过询问得知得使用数组，下次注意。

#include
using namespace std;

int main() {
	int T,a,b; 
	cin>>T;
	while(T!=0){
		cin>>a>>b;
		int num=a*100;
		for(int i=0;i<100;i++){
			if((num+i)%b==0)
				cout<<i<<" ";
		}
		T--;
		cout<<endl; 
	}
	return 0;
}

24 回文质数

作者: xxx时间限制: 1S章节: 循环

问题描述 :

因为151既是一个质数又是一个回文数(从左到右和从右到左是看一样的)，所以 151 号是回文质数。

写一个程序来找出范围[a,b](5<= a
< b <= 100,000)间的所有回文质数

输入说明 :

仅 1 行: 二个整数 a 和 b(5<= a < b <= 100,000)。

输出说明 :

输出一个回文质数的列表，一行一个。

每行首尾无空格，最后无空行。

质数：for循环找因子，若%=0则break找下一个
回文数：while循环%和/混用

参考：使用isSys（）和isPrime（）两个函数，可以更直观

#include
#include
using namespace std;

bool isPrime(int n) {
	int q;
	for(q = 2; q <= sqrt(n); q++) {
		if (n % q == 0) {
			return false;
		}
	}
	if (q > sqrt(n)) {
		return true;
	}
}

bool isSys(int n) {
	int a[6];
	int i = 0;
	int j = 0;
	int k = n;
	while(true) {
		j = j * 10 + k % 10;
		k = k / 10;
		if (k < 1) {
			break;
		}
	}
	if (j == n) {
		return true;
	} else {
		return false;
	}
}

int main() {
	int a, b;
	cin >> a >> b;
	for (int i = a; i < b; i++) {
		if(isSys(i)) {
			if(isPrime(i)) {
				cout<< i <<endl;
			}
		}
	}
	return 0;
}

25 汽水瓶

作者: xxx时间限制: 1S章节: 循环

问题描述 :

有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。

小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。

然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。

如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？

输入说明 :

输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。

n=0表示输入结束，你的程序不应当处理这一行。

输出说明 :

对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。

如果一瓶也喝不到，输出0。

while（a大于3时：
a=a/3+a%3
count+=a/3
以及if判断最后余数如果为2，则可以count+1（因为可以借一瓶再还，喝到了3瓶）

#include
#include
using namespace std;

int main()
{
	int a;
	int count = 0;
	while (cin >> a && a != 0)
	{
		int x, y;
		count = 0;
		while (a >= 3)
		{
			x = a / 3;
			y = a % 3;
			a = x + y;
			count += x;
		}
		if (a == 2)
			cout << count + 1 << endl;
		else
			cout << count << endl;
	} 
	return 0;
}

26 阶乘最后的非0位❤

作者: XXX时间限制: 1S章节: 循环

问题描述 :

N的阶乘写作N!表示小于等于N的所有正整数的乘积。

阶乘会很快的变大，如13!就必须用32位整数类型来存储，70！即使用浮点数也存不下了。

你的任务是找到阶乘最后面的非零位。

举个例子,5!=12345=120所以5!的最后面的非零位是2，7！=1234567=5040，所以最后面的非零位是4。

输入说明 :

一个不大于1000的整数N。

输出说明 :

共一行，输出N!最后面的非零位。

可以先乘出结果，然后对结果%10不为0，则输出当前余数
(是不是暴力破解了）

#include
#include
using namespace std;

int main()
{
	int n;
	long sum = 1, i;
	while (cin >> n)
	{
		for (i = 1; i <= n; i++) {
			sum *= i;
			while(sum % 10 == 0)
				sum = sum / 10;
			sum = sum % 1000;
			
		}
		cout << sum % 10<<endl;
	}
		
	return 0;
}

27 算菜价

作者: xxx时间限制: 1S章节: 循环

问题描述 :

妈妈每天都要出去买菜，但是回来后，兜里的钱也懒得数一数，到底花了多少钱真是一笔糊涂帐。

现在好了，作为好儿子（女儿）的你可以给她用程序算一下了，呵呵。

输入说明 :

输入含有一些数据组，第一行第一个数是测试组数，第二行第一个数据是菜种数，每组数据包括菜种（字串），数量（计量单位不论，一律为double型数）和单价（double型数，表示人民币元数），因此，每组数据的菜价就是数量乘上单价啊。

菜种、数量和单价之间都有空格隔开的。

注意样例输入应是如下：

1

3

青菜 1 2

罗卜 2 1.5

鸡腿 2 4.2

输出说明 :

支付菜价的时候，由于最小支付单位是角，所以总是在支付的时候采用四舍五入的方法把分头去掉。

所以，请输出一个精度为角的菜价总量。

#include
#include
#include
#include
using namespace std;

int main()
{
	int n, m, i, j;
	double num, price, sum;
	char ch;
	while(cin>>n) {
		for	(i = 0; i < n; i++) {
		int x;
		scanf("%d",&x);
		double sum=0;
		while(x--)
		{
			//中文菜名用数组输入。


			char a[10];
			double b,c;
			//数组用%s，double用%lf
			scanf("%s %lf %lf",a,&b,&c);
			sum+=(b*c);
		}
		printf("%.1f\n",sum);		
		}
	}
	return 0;
}

28 水果价格

作者: 朱星垠 时间限制: 1S章节: 循环

问题描述 :

一家水果店出售四种水果，每公斤价格的苹果（代码为a）1.5元，橘子（代码为o）1.4元，香蕉（代码为b）1.48元，菠萝（代码为p）1.08元。

编一个程序，使售货员只要在键盘上打入货品的代码及重量，计算机将显示货品名、单价、重量及总价。

输入说明 :

你的程序需要从标准输入设备（通常为键盘）中读入多组测试数据。

每组测试数据的第一行为一个整数m，表示有m件货品要被购买。

在接下来的m行中，每行输入两个值d，g。

d表示货品的代码，g表示重量。

两组数据之间没有多余的空行。

输出说明 :

对每组测试数据，你的程序需要向标准输出设备（通常为启动该程序的终端）依次输出一组对应的答案。

对应每组输入，输出货品名、单个总价及全部总价。

具体格式参照样例输出:第一行apple前为7个空格，之后为2个空格，其他水果名后都是1个空格，sum后没有空格；第二行price后有2个空格，其后关于价格的表示多为占7格2位小数且左对齐，但其中pineapple为占10格2位小数且左对齐，注意sum的价格仍然占7格，如第一组样例中的54.60后还有2个空格；第三行weight后有1个空格，其后的数据与第二行一致。

每两组数据之间有一个空行，最后一组测试数据之后没有空行。

#include
using namespace std;
int main()
{
	//a数组代表四种水果的总价格内容 
    double a[5],temp;
    int m,counter=1;
    //c为水果种类 
    char c,t;
    while(cin>>m)
    {
        for(int i=0;i<5;i++)a[i]=0.0;
        for(int i=0;i<m;i++)
        {
            cin>>c>>t>>temp;
            if(c=='a')a[0]+=temp;
            if(c=='o')a[1]+=temp;
            if(c=='b')a[2]+=temp;
            if(c=='p')a[3]+=temp;
        }
        if(counter++!=1) cout<<endl;
        cout<<"       apple  orange banana pineapple sum\n";
        printf("price  %-7.2f%-7.2f%-7.2f%-10.2f%-7.2f\n",a[0]*1.5,a[1]*1.4,a[2]*1.48,a[3]*1.08,a[0]*1.5+a[1]*1.4+a[2]*1.48+a[3]*1.08);
        printf("weight %-7.2f%-7.2f%-7.2f%-10.2f%-7.2f\n",a[0],a[1],a[2],a[3],a[0]+a[1]+a[2]+a[3]);
    }
    return 0;
}

29 求奇数的乘积

作者: xxx时间限制: 1S章节: 循环

问题描述 :

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

输入说明 :

输入数据包含两行，第一行为一个数为n，表示第二行将输入n个整数。

你可以假设这n个数据中必定至少存在一个奇数。

输出说明 :

输出一个整数。

很简单

#include
#include
#include
#include
using namespace std;

int main()
{
	int n, sum, c;
	while(cin>>n) {
		sum = 1;
		for(int i = 0; i < n; i++) {
			cin>>c;
			if(c%2 != 0) {
				sum *= c;
			}
		}
		cout <<sum<<endl;
	}
	return 0;
}

30 求最晚和最早日期

作者: Fu时间限制: 1S章节: 循环

问题描述 :

输入N个日期，每个以年、月、日的顺序读入，打印输出最晚的日期、最早的日期。

输入说明 :

你的程序需要从标准输入设备（通常为键盘）中读入多组测试数据。

每组输入数据由多行组成。

每组测试数据的第一行输入一个整数N(0

其后N行每行有三个整数Y(1≤Y≤2015)，M(1≤M≤12)，D(1≤D≤31)表示一个日期。

输出说明 :

对每组测试数据，你的程序需要向标准输出设备（通常为启动该程序的文本终端）输出两行，每行包括3个整数，第一行为最晚日期，第二行为最早日期，整数之间以一个空格分隔，行首与行尾无空格，所有数据前后没有多余的空行，两组数据之间也没有多余的空行。

if和for嵌套，找最大最小

#include
int main(){
  int N,i,Y[20],M[20],D[20],zao,wan,z,w;
  scanf("%d",&N);
  for(i=0;i<N;i++)
	  scanf("%d%d%d",&Y[i],&M[i],&D[i]);
   wan=Y[0];w=0;zao=Y[0];z=0;
   for(i=1;i<N;i++){
	   if(wan<Y[i]){wan=Y[i];w=i;}
	   else if(wan==Y[i]){
		   if(M[w]<M[i]) w=i;
		   else if(M[w]==M[i]){
			   if(D[w]<D[i]) w=i;
			   
		   }
	   }
	 
   }
   for(i=1;i<N;i++){
	   if(zao>Y[i]){zao=Y[i];z=i;}
	   else if(zao==Y[i]){
		   if(M[z]>M[i]) z=i;
		   else if(M[z]==M[i]){
			   if(D[z]>D[i]) z=i;
			   
		   }
	   }
	 
   }
	 printf("%d %d %d\n",Y[w],M[w],D[w]);  
	 printf("%d %d %d\n",Y[z],M[z],D[z]);  
	return 0;
}

31 素数

for (int i = 2;i<a;i ++)
{
	if (a%i==0) {
		b = 1;
		break;
	}
	else continue;
}

32 计算e

#include
using namespace std;

int main()
{
	double t,e=0,m=1.0;
	int n=0;
	cin>>t;
	while(m>=t){
		n++;
		e+=m;
		m*=1.0/n;
	}
	printf("%.6f %d",e,n);
	return 0;
}

33 数字之和

基本上是%、/、+=的while循环使用

#include
using namespace std;

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

【一维数组】 34 繁殖问题

用到递归啦。

类似猴子爬楼梯
m[i] = m[i - 2] + m[i - 3] + m[i - 4];
当前 长了2月的鼠生的 长了3月鼠生的 长了4月鼠生的

#include
#include
using namespace std;

int main()
{
	int n,result ;
	int m[50] = {1,1,2,3,5,7,10};
	while(cin>>n ) {
		for(int i = 7; i < 50; i++) {
			m[i] = m[i - 2] + m[i - 3] + m[i - 4];
		}
		cout<<m[n - 1]<<endl;
	}
}

35 奇妙的数字

while(scanf("%d",&count)!=EOF)
printf("%ld\n",a[count]);
这两行至关重要，&才能取到输入的位置

#include//东华我来喽.QAQ.2020考研:summershell
int weihe(long a)//暴力输出，省事简单
{
    int t=0;
    while(a)
    {
        t=t+a%10;
        a/=10;
    }
    return t;
}
int main()
{
    long a[51],i=8899;
    int count=1;
    while(count<20)
    {
        if(weihe(i)%17==0 && weihe(i+1)%17==0)a[count++]=i;
        ++i;
    }
    while(scanf("%d",&count)!=EOF)
        printf("%ld\n",a[count]);
    return 0;
}

36 整除的尾数

#include 

int getResult(int a, int b, int weishu[])

{
	//以下为填补的函数代码 
	int count=0;
    for(int i=0;i<100;i++){
 		if((a*100+i)%b==0){
 			weishu[count]=i;
 			count++;
		 }   	
	}
	return count;
}

int main()

{

    int a, b, weishu[100],count,i;

    scanf("%d%d", &a, &b);

    count=getResult(a,b,weishu);

    for(i=0; i<count; i++)

    {

        if (i>0)

            printf(" ");

        printf("%02d", weishu[i]);

    }

    printf("\n");

    return 0;

}

37 黑色星期五

#include//东华我来喽.QAQ.2020考研
int main()
{           //这题也不想研究规律啥的了，直接循环吧
    int n,yy;
    long long int dd=0;//可能很大
    int week[7]={0,0,0,0,0,0,0},month[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
    scanf("%d",&n);
    for(yy=1900;yy<=1900+n-1;yy++)
    {
        if( (yy%100!=0 && yy%4==0) || (yy%400==0) )month[2]=29;
        else month[2]=28;
        for(int i=1;i<=12;i++)      //12个月鸭！
        {
            for(int j=1;j<=month[i];j++)//每天都要判断一下
            {
                ++dd;
                if(j==13)
                week[dd%7]++;
            }
        }
    }
    printf("%d %d %d %d %d %d %d",week[6],week[0],week[1],week[2],week[3],week[4],week[5]);
    return 0;
}

38 树

a数组作为某坐标是否建地铁的判断。

初值为0，只要覆盖了地铁位置便加1，因此经过判断最后仍为0的坐标就是没有建地铁（可以保留下来的树个数）

#include
using namespace std;
 
int main(void) 
{
	//长度为l，地铁个数n 
	int l, n;
	while(cin>>l>>n) {
		int a[10000] = {0};
		while(n--) {
			//坐标xy 
			int x,y;
			cin>>x>>y;
			for (int i = x; i <= y; i++) {
				a[i]++;
			}
		}
		int count = 0;
		for (int j = 0; j <= l; j++) {
			if(a[j] == 0) {
				count++;
			}
		}
		cout<<count<<endl;
	}
}

39 约瑟夫环❤

#include
using namespace std;
 
int main(void) 
{
	//初试环个数n，每次输出第x个
	int n, x;
	while(cin>>n>>x) {
		int a[100];
		int i, k = 1;
		for(i = 1; i <= n; i++)
			a[i] = i;//初始约瑟夫环
		for (i = n; i >= 1; i--) {
			k = (k + x - 1) % i; //原始坐标=（新坐标+x-1）%总个数
			if(k == 0) k =i;
			if (i > 1) cout<<a[k]<<" ";
			else cout<<a[k]<<endl;//全部输出完毕，换行
			for (int j = k; j < i; j++)
			a[j] = a[j + 1];
			
		}
	}
	return 0;
}

40 最大与最小

数组输入，a[ ]存原数组，b[ ]存第i位开始的N位和，求b中最大最小即可

#include
using namespace std;
 
int main(void) 
{
	int n, x, t;
	int a[105], b[105];
	while(cin>>n>>x) {
		for(int i = 0; i < n; i++) {
			//数组输入，a存原数组
			//b存i开始的连续N个和
			cin>>a[i];
			b[i] = 0;
		}
		for (int i = 0; i < n; i++) {
			for (int j = i; j < i + x; j++) {
				if(j >= n) {
					b[i] += a[j % n];
				} else b[i] += a[j];
			}
		}
			//找b的最大/小元素
			for(int i = 0; i < n; i++) {
				for (int j = 1; j < n - i; j++) {
					if (b[j] < b[j - 1]) {
						t = b[j];
						b[j] = b[j - 1];
						b[j - 1] = t;
					}
				}
			}
			cout<<"Max="<<b[n - 1]<<endl;
			cout<<"Min="<<b[0]<<endl<<endl;
		}
	return 0;
}

41 环

#include//:Q+_+Q:东华我来喽 2020考研:summershell
int main()
{
	//N为测试组数，a[]为输入的数组顺序
    int N,a[9],b[9],temp;
    scanf("%d",&N);
    while(N--)
    {
        int cou=0;
        for(int i=0;i<9;i++)scanf("%d",&a[i]);
        for(int i=0,cut=0;i<9;i++,cut++)
        {
        	//切开后顺序b[]
            for(int j=0;j<9;j++)
            {
                temp=(cut+j)%9;
                b[j]=a[temp];
            }
            //x为顺序数，y为逆序数
            int x=0,y=0;
            for(int j=0;j<9;j++)x=x*10+b[j];
            for(int j=8;j>=0;j--)y=y*10+b[j];
            if(x<y){temp=x;x=y;y=temp;}
            if((x-y)%396==0)cou++;
        }
        printf("%d\n",cou);
    }
    return 0;
}

42 求数列项

#include//:Q+_+Q:东华我来喽 2020考研:summershell
int main()//水题
{
	//初始几项的数组
    int N,a[55]={0,1,5,12};
    for(int i=4;i<55;i++)
    	//根据递推公式
    	a[i]=a[i-1]+(i-3)*3+7;
    while(scanf("%d",&N)!=EOF)
    	printf("%d\n",a[N]);
    return 0;
}

43 最高频率

数组下标转换成新数组，新数组值最大的就是重复次数最多的.
比如3重复了两次，则a[3]=2，为最大
若有多个数字出现次数一样，比如{1，0，2，1，2}，a[3]=a[5]=2
则从数组最前面开始遍历，找最大的赋给maxp，且赋当前i值即为3；除非a[5]>2，否则不会成功赋值的

#include//:Q+_+Q:东华我来喽 2020考研:summershell
int main()//水题
{
    int N,a[2020],temp;
    while(scanf("%d",&N)!=EOF)
    {
        for(int i=0;i<2020;i++)
        	a[i]=0;
        for(int i=0;i<N;i++){
        	scanf("%d",&temp);
        	a[temp]++;
       	}
        int maxp=-10,min=0;
        for(int i=0;i<2020;i++){
        	if(maxp<a[i]){
        		maxp=a[i];
        		min=i;
       		}
       	}
        printf("%d\n",min);
    }
    return 0;
}

44 三艘船

三个数组，分别是经过i天后三个船走的距离，再循环判断怎样使三个距离相等

#include 
#include 
#include 
#include 
#include 
using namespace std;

int a, b, c, d, e, f;
int lista[101], listb[101], listc[101];
int fun();


int main() {
    
    while(cin >> a >> b >> c) {
        cin >> d >> e >> f;
        fun();
        
        int n = 0;
        //在100天内，暴力循环。

总之a船最慢用时最久，就是最内层循环
        for (int i = 0; i < 101; i++) {
            for (int j = i; j < 101; j++) {
                if (listc[i] == listb[j]) {
                    for (int l = j; l < 101; l++) {
                        if (listb[j] == lista[l]) {
                            cout << lista[l] << endl;
                            n = lista[l];
                            break;
                        }
                    }
                }
                if (n != 0) {
                    break;
                }
            }
            if (n != 0) {
                break;
            }
        }
    }
    return 0;

}

int fun() {
	
	for (int i = 0; i < 101; i++) {
            lista[i] = (i * 24 + a) * d;
            listb[i] = (i * 24 + b) * e;
            listc[i] = (i * 24 + c) * f;
        }
}

45 回文数

fun()函数求逆序数：%和/混用
a[0]=输入的n
a[1]=a[0]+fun(a[0])
依次循环，再来一个for循环判断a[i]==fun(a[i])

#include//东华我来喽.QAQ.2020考研:summershell
int huiwen(int a)//利用栈判断回文，判断回文的方法有多种，栈比较方便吧
{
    int stack[100],top=-1,temp=a;
    while(temp)
    {
        stack[++top]=temp%10;
        temp/=10;
    }
    while(top!=-1)
    {
        if(stack[top--]!=a%10)return 0;
        a/=10;
    }
    return 1;
}
int rever(int a)//利用队列逆转
{
    int queue[100],front=0,rear=0,temp=a,i;
    while(temp)
    {
        queue[rear++]=temp%10;
        temp/=10;
    }
    while(front!=rear)
        temp=temp*10+queue[front++];
    return temp;
}
int main()
{
    int N,a,b,c;
    while(scanf("%d",&N)!=EOF && N)
    {
        c=N;
        do
        {
            a=c;b=rever(a);c=a+b;
            printf("%d+%d=%d\n",a,b,c);
        }while(!huiwen(c));
    }
    return 0;
}

46 特殊四位数

judge（）函数判断是否符合
再在main函数里直接judge（i*i）就可以做到是平方数

#include//东华我来喽.QAQ.2020考研:summershell
int judge(int x)//千十和==百个积
{
    return x/1000+(x/10)%10==(x%10)*((x/100)%10)?1:0;
}
int main()//如果从1156找到9999，那么开方很麻烦，不妨从34*34到99*99入手
{
    int N,a[1000],counter=1;
    for(int i=34;i<100;i++)
        if(judge(i*i))
        	a[counter++]=i*i;
    while(scanf("%d",&N)!=EOF)
        printf("%d\n",a[N]);
    return 0;
}

47 最大值

类似前面那个环相加的题（a[ ]存原数组，b[ ]存第i个开始的N项和）
不过有点区别，首先是数组，其次可以选择x个和更大还是y个和更大，用到判断语句

#include
using namespace std;


int main() {
	int n, x, y, i, j;
	while(cin>>n>>x>>y) {
		int a[20] = {0};
		for (i = 0; i < n; i++) {
			cin>>a[i];
		}
		int max = -999;
		for (i = 0; i < n - x + 1; i++) {
			int sum = 0;
			for (int j = 0; j < x; j++) {
				sum += a[i + j];
			}
			int t = sum;
			for (j = x; j < y; j++) {
				sum += a[i+j];
				if (sum > t) {
					t = sum;
				}
			}
			if (t > max) {
				max = t;
			}
		} cout << max << endl;
	}	
	return 0;
} 

48 数列1

fun（）函数从i位逐个加到最后
main（）函数将i的开始位循环

#include//:Q+_+Q:东华我来喽 2020考研:summershell
int counter=0;
void fun(int a[],int N,int start)
{
    int temp;
    for(int len=1;start+len<=N;len++)//增加长度，逐个尝试
    {
        temp=0;
        for(int j=0;j<len;j++)temp+=a[j+start];
        if(temp%11==0)++counter;
    }
}
int main()//这道题，在基础篇里面做过，当时是循环遍历
{
    int N,a[2020];
    while(scanf("%d",&N)!=EOF)
    {
        for(int i=0;i<N;i++)scanf("%d",&a[i]);
        counter=0;
        for(int i=0,j,len;i<N;i++)//每次的起点都不同
            fun(a,N,i);
        printf("%d\n",counter);
    }
    return 0;
}

49 修理牛棚❤

这题的实质是计算间隔然后排序,先计算出所有的间隔数目,然后按大小排序,用牛棚头尾长度,减去间隔大的(不补这部分),就得到了需要求的长度.

先假设用一块很长的板子，一次性堵住所有的门。

则很容易计算出需要木板的长度。

然后我们发现有些牛棚之间有很大的间隔，十分浪费木板。

将这些间隔统计出来，根据题目要求（限定最多使用m个木板，即最多可以删去m-1个间隔），利用贪心规则，首先将间隔从大到小排序，每次先减去大的间隔，就可以求得全局最优解了。

#include 

int sort(int *num, int n)
{
    int i, j, temp;
    for (i = 1; i <=n; i++)
    {
        for (j = i + 1; j < n; j++)
        {
            if (num[i] > num[j])
            {
                temp = num[i];
                num[i] = num[j];
                num[j] = temp;
            }
        }
    }
}

int main()
{

    int m, c;
    int i = 0, j = 0, k = 0;
    int cowgap[200]={0};
    int cow[200]={0};
    while (scanf("%d %d", &m, &c) != EOF)
    {
        int door = 0;
        int sum = 0;
        for (i = 1; i <= c; i++)
        {
            scanf("%d", &cow[i]);
        }
        sort(cow, c+1);
        for (i = 1; i <= c; i++)
        {
            cowgap[i] = cow[i + 1] - cow[i] - 1;
        }
        sort(cowgap, c);

        for (i = 1; i < m; i++)
        {
            door += cowgap[c - i];
        }
        sum = cow[c] - cow[1] - door + 1;  //单个的门是修补长度是1
        printf("%d\n", sum);
    }
    return 0;
}

50 按要求输出序列

50 按要求输出序列

#include
using namespace std;

int sum = 0;
int main() {
	int n, m, a[200];
	while (cin>>n) {
		for (int i = 0; i < 110; i++) {
			a[i] = 0;
		}
		//重复个数数组
		for (int i = 0; i < n; i++) {
			cin>>m;
			a[m]++;
		}
		int f = 0;
		for (int i = 0; i < 110; i++) {
			//意思是只输出第一次出现的数字
			if (a[i] != 0) {
				if (f==0) {
					cout<<i;
					f = 1;
				} else {
					cout<<" "<<i;
				}
			}
		}
		cout<<endl;
	}	
	return 0;
} 

【函数】 58 素数表

#include
using namespace std;
 
int prime(int a){
	if(a<2) return 0;
	for(int i=2;i<=a/2;i++){
		if(a%i==0){
			return 0;
		}
	}
	return 1;
}
int main() 
{
	int m,n;
	cin>>m>>n;
	int count=0;
	for(int j=m;j<=n;j++){
		if(prime(j)==1){
			cout<<j<<" ";
			count++;
			if(count%10==0){
				cout<<endl;
			}	
		}
	}
	return 0;
}

【二维数组】 69 杨辉三角

#include
using namespace std;
 
int main() 
{
	int a[100][100],T,n;
	cin>>T;
	for(T;T>0;T--){
		cin>>n;
		a[0][0]=1;
		for(int i=0;i<n;i++){
			a[i][0]=1;
			a[i][i]=1;
			for(int j=0;j<=i;j++){
				if(j==0||j==i)
					a[i][j]=1;
				else
					a[i][j]=a[i-1][j-1]+a[i-1][j];
				cout<<a[i][j]<<" ";
			}
			cout<<endl;
		}
		cout<<endl;
	}
	return 0;
}

【字符串】 81 求小数位数个数

#include 
#include 
#include 
#include 
using namespace std;

int main(){
	char n[100];
	int i=0,count=0;
	while(gets(n)){
		while(n[i]!='.')
			i++;
		i++;
		while(n[i]!=')'++
			count,++i;printf
		("%d\n",)count;=
		i0,=count0;}
	return
	0 ;}