目录
- 1 求长方形的面积和周长
- 2 数列和
- 3 解方程
- 4 一个月的天数
- 5 银行存款到期日
- 6 实数运算
- 7 解二次方程
- 8 门票价格计算
- 9 星期几问题
- 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 回文数
1 求长方形的面积和周长
问题描述 :
求一个长方形的面积S及周长P。面积的公式为S = a × b，周长的公式P=2*(a+b)，其中a代表长方形的长，b代表长方形的宽。
输入说明 :
你的程序需要从标准输入设备（通常为键盘）中读入两个整数：一个整数a（0 ≤a < 10000），代表长方形的长；一个整数b（0 ≤ b < 10000），代表长方形的宽；在a和b之间有一个空格；在行首和行尾没有多余的空格。
输出说明 :
你的程序需要向标准输出文件（通常为启动该程序的终端）输出对应的答案。答案占一行，其中包含两个整数，即长方行的面积和周长，中间以一个空格分隔。在行首和行尾不要输出多余的空格。
输入范例 :
40 5
输出范例 :
200 90
#include <stdio.h>
int main()
{
int a,b,c;
while(scanf("%d%d",&a,&b) != EOF)
{
printf("%d %d",a*b,2*(a+b));
}
return 0;
}
2 数列和
问题描述 :
尝试求从1+2+…+N这N个自然数的和。
输入说明 :
你的程序需要从标准输入设备（通常为键盘）中读入一个整数N（1 ≤ N < 10,000）；在行首和行尾没有多余的空格。在所有数据的前后，以及两组数据之间都没有多余的空行。
输出说明 :
对每组测试数据，你的程序需要向标准输出设备（通常为启动该程序的终端）输出对应的答案，其中仅有一个整数，即题目描述中的数列之和。在行首和行尾不要输出多余的空格。
输入范例 :
10
输出范例 :
55
#include <stdio.h>
int main()
{
int i,n,sum=0;
while(scanf("%d",&n) != EOF)
{
for(i=1;i<=n;i++)
{
sum+=i;
}
printf("%d",sum);
}
return 0;
}
3 解方程
问题描述 :
编写程序：输入a、b后，输出一元一次方程2ax+3*b-5=0的解。
输入说明 :
整数a b
输出说明 :
x 保留1位小数
输入范例 :
1 2
输出范例 :
-0.5
#include <stdio.h>
int main()
{
double x;
int a,b;
while(scanf("%d%d",&a,&b) != EOF)
{
x=(5.0-3*b)/2/a;
printf("%.1f",x);
}
return 0;
}
4 一个月的天数
问题描述 :
输入年和月，输出该月有几天。
输入说明 :
输入两个整数，中间以空格分隔，第一个整数表示年，第二个整数表示月。
输出说明 :
输出该年该月的天数，输出时，行首与行尾均无空格，仅输出一个整数。
输入范例 :
2000 2
输出范例 :
29
主要考察分支结构，其中闰年的判断方法需要着重记忆：
#include <stdio.h>
int main()
{
int year,month;
while((scanf("%d%d",&year,&month)) != EOF)
{
if(year%4==0&&year%100!=0||year%400==0 && month==2)
printf("29\n");
else if(month==2)
printf("28\n");
else if(month==1||month==3||month==5||
month==7||month==8||month==10||month==12)
printf("31\n");
else printf("30\n");
}
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个整数，中间以空格分隔，第一个整数表示年，第二个整数表示月，第三个整数表示日，第四个整数表示定期长度（单位为月）。
输出说明 :
输出到期日期，共输出三个整数，中间以一个空格分隔，行首与行尾均无空格。
输入范例 :
2014 4 30 3
输出范例 :
2014 7 30
前前后后提交了五次，坑有点多
1、闰年判断方法
2、存款日期可以不止12个月，故年份判断不能直接取余
3、月份对12取余后容易忽略12，注意单独讨论。或用month数组存储，把0的位置空出，对13取余
#include<stdio.h>
int runnian(int a)//闰年判断
{
if((a%4==0&&a%100!=0)||a%400==0)
return 1;
else
return 0;
}
int main()
{
int year,month,date,regular,year1,month1,date1;
while((scanf("%d%d%d%d",&year,&month,&date,®ular)) != EOF)
{
/**错误解法
if(month+regular>12)
year1=year+1;
else year1=year;
month1 = (month+regular)%12;*/
year1 = year;
while(month+regular>12)
{
year1++;
regular-=12;
}
month1 = (month+regular)%12;
if(month1==0) month1=12;//易错
if(month1==2&&date>=29)//考虑闰年2月情况
{
if(runnian(year1))date1=29;
else date1=28;
}
//考虑小月遇到31号
else if((month1==4||month1==6||month1==9||month1==11)&&date==31)
{
date1=30;
}
else
{
date1=date;
}
printf("%d %d %d\n",year1,month1,date1);
}
return 0;
}
6 实数运算
问题描述 :
输入两个实数，求它们的和，差，积，商。
输入说明 :
输入数据由两行组成：第一行为两个实数a、b，它们以空格分隔，在行首和行尾没有多余的空格；第二行为运算符号’+’、’-’、’*’、’/'之一，在行首和行尾没有多余的空格。
输出说明 :
输出运算结果(保留一位小数)，行首和行尾没有多余的空格，当除数为0时输出’Wrong!’。
输入范例 :
0.5 1.3
+
输出范例 :
1.8
#include<stdio.h>
int main()
{
int flag = 0;
double a,b,result;
char c;
while((scanf("%lf %lf %c",&a,&b,&c)) != EOF)
{
if(c == '+')
result = a+b;
else if(c == '-')
result = a-b;
else if(c == '*')
result = a*b;
else if(c == '/')
{
if(b == 0){
printf("Wrong!");
flag = 1;
}
else result = a/b;
}
if(flag == 0)
printf("%.1f",result);
}
return 0;
}
7 解二次方程
问题描述 :
编写程序求方程ax2+bx+c=0的根，a、b、c的值由键盘输入，假设b2-4ac>0
输入说明 :
3个整数a b c，以一个空格分隔
输出说明 :
两个根，大数在前，小数在后
输出时保留两位小数。
输入范例 :
2 -7 5
输出范例 :
2.50 1.00
#include<stdio.h>
#include<math.h>
int main()
{
double a,b,c,re1,re2;
while((scanf("%lf%lf%lf",&a,&b,&c)) != EOF)
{
re1 = (-b+sqrt(b*b-4*a*c))/(2*a);
re2 = (-b-sqrt(b*b-4*a*c))/(2*a);
printf("%.2f %.2f",re1,re2);
}
return 0;
}
8 门票价格计算
问题描述 :
某旅游景点门票价格为每人5元。但团体可以优惠，分为以下情况：
人数超过20，则所有人优惠10%；
人数超过40，则所有人优惠15%；
人数超过80，则所有人优惠20%；
人数超过120，则所有人优惠30%。
请跟据团体的人数，求出该团体的总门票价格。
输入说明 :
输入一个整数i（0≤i≤1,000），表示一个团体的总人数。在行首和行尾没有多余的空格。
输出说明 :
输出一个实数，即该团体需要支付的总票价，精确到小数点后2位。在行首和行尾不要输出多余的空格。
输入范例 :
80
输出范例 :
340.00
#include<stdio.h>
#include<math.h>
int main()
{
int n;
double price;
while((scanf("%d",&n)) != EOF)
{
if(n<=20){
price = n*5;
}
else if(n<=40&&n>20){
price = n*5*0.9;
}
else if(n<=80&&n>40){
price = n*5*0.85;
}
else if(n<=120&&n>80){
price = n*5*0.8;
}
else
price = n*5*0.7;
printf("%.2f",price);
}
return 0;
}
9 星期几问题
问题描述 :
根据一个范围在0至6的整数，用英文输出它对应的是星期几。（0对应Sunday，1对应Monday， 2对应Tuesday， 3对应Wednesday， 4对应Thursday， 5对应Friday， 6对应Saturday）
输入说明 :
输入一个整数n（0 ≤ n ≤ 6）。在行首和行尾没有多余的空格。
输出说明 :
输出一个字符串，即输入n对应的星期几的英文名称，请注意大小写。在行首和行尾不要输出多余的空格。
输入范例 :
0
输出范例 :
Sunday
#include<stdio.h>
int main()
{
char s[7][10]={"Sunday","Monday","Tuesday","Wednesday",
"Thursday","Friday","Saturday"};
int n;
while((scanf("%d",&n)) != EOF)
{
printf("%s\n",s[n]);
}
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），输出仅占一行，整数之间以一个空格分隔，行首与行尾无多余空格。
输入范例 :
50 59 30 30 1 40
输出范例 :
81
1
10
#include<stdio.h>
int main()
{
int AH,AM,AS,BH,BM,BS,h,m,s,hh,mm,ss;
int p1=0,p2=0;
while((scanf("%d%d%d%d%d%d",&AH,&AM,&AS,&BH,&BM,&BS))!=EOF)
{
ss=AS+BS;
while(ss>=60)
{
ss-=60;
p1++;
}
mm=AM+BM+p1;
while(mm>=60)
{
mm-=60;
p2++;
}
hh=AH+BH+p2;
printf("%d %d %d\n",hh,mm,ss);
}
return 0;
}
11 成绩转换
问题描述 :
输入一个百分制的成绩t，将其转换成对应的等级，具体转换规则如下：
90~100为A;
80~89为B;
70~79为C;
60~69为D;
0~59为E;
输入说明 :
输入一个整数。
输出说明 :
输出对应结果，占一行。如果输入数据不在0~100范围内，请输出一行：“Score is error!”。
注意：无多余空格。
输入范例 :
88
输出范例 :
B
#include<stdio.h>
int main()
{
int t,flag=0;
char a;
while((scanf("%d",&t))!=EOF)
{
if(t>=90&&t<=100) a='A';
else if(t>=80&&t<=89) a='B';
else if(t>=70&&t<=79) a='C';
else if(t>=60&&t<=69) a='D';
else if(t>=0&&t<=59) a='E';
else{
flag=1;
printf("Score is error!\n");
}
if(flag==0)
printf("%c\n",a);
flag=0;
}
return 0;
}
12 求第几天
问题描述 :
按年、月、日的顺序读入一个日期，输出该日期是这一年中的第几天。
输入说明 :
输入数据为三个正整数y 、m、d，分别表示年、月、日，整数之间以空格分隔，在行首和行尾没有多余的空格。
输出说明 :
输出一个整数，表示输入的日期是这一年中的第几天，在行首和行尾没有多余的空格。
输入范例 :
2000 12 31
输出范例 :
366
#include<stdio.h>
int runnian(int n)
{
if((n%4==0&&n%100!=0)||n%400==0) return 1;
else return 0;
}
int main()
{
int i,sum=0,a[12]={31,28,31,30,31,30,31,31,30,31,30,31};
int y,m,d;
while((scanf("%d%d%d",&y,&m,&d)) != EOF)
{
for(i=0;i<m-1;i++)
{
sum+=a[i];
}
sum=sum+d;
if(m>2) sum+=runnian(y);
printf("%d\n",sum);
i=0,sum=0;
}
return 0;
}
13 求阶乘结果0的个数
问题描述 :
编写一个程序，求出N！的末尾含有多少个0。
提示：在乘积中，末尾有多少个0，主要看各乘数的素数因子中有多少个2和5，每一个2和5的结合将给末尾贡献一个0。而乘数中因子2的个数远多于因子5的个数，因此，就计算各乘数中因子5的个数即可。
输入说明 :
你的数据需要从标准输入设备（通常为键盘）中读入多组测试数据。每组输入数据由一行组成，每行由一个正整数N组成，N小于等于100000，在行首和行尾没有多余的空格。
输出说明 :
对每组测试数据，你的程序需要向标准输出文件（通常为启动该程序的文本终端）依次输出一组对应的答案。所有数据前后不要输出多余的空行，两组数据之间也不要输出多余的空行。每组输出数据由一行组成，每行由一个整数组成，在行首和行尾不要输出多余的空格。
输入范例 :
5
100000
输出范例 :
1
24999
#include<stdio.h>
int main()
{
int n,i,count=0,k;
while((scanf("%d",&n)) != EOF)
{
for(i=1;i<=n;i++)
{
k=i;
while(k%5==0)
{
k/=5;
count++;
}
}
printf("%d\n",count);
count=0;
}
return 0;
}
14 怪数
问题描述 :
寻找怪数：有一种奇怪的自然数，它的比其本身小的所有因子之和等于它本身，例如：6＝1＋2＋3，其中1、2、3都是6的因子，编程找出整数N之内的所有怪数。
输入说明 :
输入一个整数N(10<=N≤10000)，在行首和行尾没有多余的空格。
输出说明 :
输出N之内(<=N)的所有怪数，每一行输出一个整数。（注：若N中有3个怪数，你则需要输出三行，每行一个怪数。）所有数据前后没有多余的空格，中间也没有多余的空行。
输入范例 :
28
输出范例 :
6
28
#include<stdio.h>
#include<math.h>
int main()
{
int n,i,j,k,num,sum=0;
while((scanf("%d",&n)) != EOF)
{
for(num=1;num<=n;num++)
{
for(i=1;i<num;i++)
{
if(num%i==0)
{
sum+=i;
}
}
if(sum==num) printf("%d\n",num);
sum=0;
}
}
return 0;
}
15 abc数字
问题描述 :
明明的爸爸是一位著名的数学家同时也是一位著名的数学启蒙老师。他经常出一些简单而有趣的数学题目来给刚刚接触数学的小朋友做，培养他们对数学的兴趣。一天，明明的爸爸想到了这样一个题目。如果有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的乘积和有几位相等，两个数之间用一个空格隔开。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。
输入范例 :
1 1 1
2 2 2
输出范例 :
12321 2
49284 1
#include<stdio.h>
int main()
{
int na,nb,nc,sum1,sum2,sum,i=0,j,p=0,t;
while(scanf("%d%d%d",&na,&nb,&nc)!=EOF)
{
printf("%d",(na*100+nb*10+nc)*(nc*100+nb*10+na));
sum=(na*100+nb*10+nc)*(nc*100+nb*10+na);
while(sum>=1)
{
if(sum%10==na||sum%10==nb||sum%10==nc) p++;
sum=sum/10;
}
printf(" %d\n",p);
p=0;
}
return 0;
}
16 奇妙的比值
问题描述 :
明明喜欢钻研各种各样的数学问题。一天，明明对数的因子产生了兴趣，他想把一个数的所有因子都找出来，然后把它们相加再去除以这个数，这样会得到一个比值。明明想看看不同的数的该比值会有什么不同，以便做研究。
例如6这个数，它一共有4个因子，分别是：1、2、3、6，把他们相加然后再除以6，即1+2+3+6=12，12/6=2，就可以得到2这个比值。
明明为了研究，需要得到大量的比值，但是如果通过手动计算比值的话需要花大量的时间，于是明明就想请你帮忙，帮他写一个程序，能够求数的比值。 明明的问题可以归结为：给你一个数，求所有因子和，把这些因子相加，然后再除以这个数，求得比值。
输入说明 :
你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行仅包括一个正整数n（1≤n≤120），代表所求比值的那个数。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个浮点数，就是所求的比值，保留2位小数。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。（注：最后求得的比值保留2位小数。） 注：通常，显示屏为标准输出设备。
输入范例 :
6
10
输出范例 :
2.00
1.80
#include<stdio.h>
int main()
{
int i,n,t,sum;
while(scanf("%d",&n)!=EOF)
{
sum=0;
for(i=1;i<=n;i++)
{
if(n%i==0)
sum+=i;
}
printf("%.2f\n",(double)sum/n);
}
return 0;
}
17 T的倍数N
问题描述 :
明明学习数学已经有很多年了，对各种各样的数学问题都有研究。有一天，明明的爸爸问明明说：“明明，你觉得你对数字敏感吗？”明明毫不犹豫地回答：“那当然，非常敏感。”于是明明的爸爸就说：“好，那我问你一个问题，如果有一个个位数为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”，不包括双引号。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。
输入范例 :
5
3
8
输出范例 :
142857
No
No
#include<stdio.h>
#include<math.h>
int weishu(int n)
{
int count=0;
while(n)
{
n/=10;
count++;
}
return count;
}
int main()
{
int T,n,num;
while(scanf("%d",&T)!=EOF)
{
for(n=1;n<1000001;n++)
{
if(n%10==7)
{
num=7*pow(10,(double)weishu(n)-1)+n/10;
//printf("num=%d\n",num);
if(num/n==T&&num%n==0)
{
printf("%d\n",n);
break;
}
}
}
if(n==1000001) printf("No\n");
}
return 0;
}
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表示三角形由几行数字组成。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为构建出来的三角形，三角形中的同一行的数字两两之间用一个空格隔开。每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。
注：通常，显示屏为标准输出设备。
输入范例 :
1 5
5 6
输出范例 :
1
2 3
4 5 6
7 8 9 1
2 3 4 5 6
5
6 7
8 9 1
2 3 4 5
6 7 8 9 1
2 3 4 5 6 7
#include<stdio.h>
int main()
{
int start,row,i,j,plus=0,tr;
while(scanf("%d%d",&start,&row)!=EOF)
{
plus=0;
for(i=1;i<=row;i++)
{
for(j=1;j<=i;j++)
{
tr=(start+plus)%9==0?9:(start+plus)%9;
printf("%d",tr);
plus++;
if(j<i)
printf(" ");
}
printf("\n");
}
printf("\n");
}
return 0;
}
19 数字串处理
问题描述 :
明明的爸爸经常对明明进行数学启蒙教育。有一天他和明明做了一个游戏，对一串数字进行处理。明明的爸爸首先给明明一串数字，在这串数字中有很多数字会连续重复出现很多次，爸爸就要求明明把其中连续重复出现次数最多的那个数字找出来。如果有很多个数字连续出现的次数相同，即重复出现次数最多的数字不止一个，那就要明明找出第一次出现该重复次数的那个数字。 例如有一串数字：2 2 2 1 1 1，其中2出现了3次，1也出现了3次，而明明要找出的那个数字是2，因为2是第一次重复出现3次的那个数字。 明明的爸爸现在已经设计好了很多组这样的数据，但是他不想自己来寻找，他想让你帮他写一个程序，找出出现次数最多的那个数字，然后他手中就有一份标准答案，可以用来检查明明到底做得对不对。 明明爸爸的问题可以归结为：给你一串数字，找出在这串数字中连续出现次数最多的那个数字；若有多个数字连续出现的次数相当，则找出第一次出现该次数的那个数字。
输入说明 :
你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据有2行，测试数据的第一行有1个整数n（1<n<100），表示数字串中有几个数；测试数据的第二行有n个数，数字串中的数字k，k（1 ≤k ≤100），每个数字之间用一个空格隔开。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为两个整数：出现次数最多的那整数，以及它的出现次数。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。
输入范例 :
2
1 2
9
2 2 2 1 1 1 1 2 2
输出范例 :
1 1
1 4
#include<stdio.h>
int main()
{
int n,k,i,j,count=1,maxcount=0,max,a[101];
while(scanf("%d",&n)!=EOF)
{
count=1;
maxcount=1;
for(i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
max=a[0];
for(j=0;j<n-1;j++)
{
if(a[j]==a[j+1])
{
count++;
if(maxcount<count)
{
maxcount=count;
max=a[j];
}
}
else count=1;
}
printf("%d %d\n",max,maxcount);
}
return 0;
}
20 公式求解
问题描述 :
明明刚上初中，数学课上老师教了平方的概念，即两个相同的数相乘可以表示为这个数的平方：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的大小进行排序，从小到大输出。 每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。 注：通常，显示屏为标准输出设备。
输入范例 :
2 5
3 4
0 0
输出范例 :
5 2
11 10
4 3
#include<stdio.h>
int main()
{
int i,j,a,b,x,y;
while(scanf("%d%d",&a,&b))
{
if(a==0||b==0) break;
for(x=1;x<101;x++)
{
for(y=1;y<101;y++)
{
if(a*a+x*x==b*b+y*y)
{
printf("%d %d\n",x,y);
}
}
}
printf("\n");
}
return 0;
}
21 累加式
问题描述 :
累加式对于明明来说是一个全新的概念，他在数学课上第一次听到了这个名词。可是明明在课堂上并没有完全明白，于是回家后明明就问他爸爸什么是累加式。明明的爸爸是一位数学家，自然对累加式非常熟悉，告诉明明：“累加式是一种表达式，这种表达式的构成方法是这样的：从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的累加式构成，累加式中不包含空格；每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。
输入范例 :
1
5
10
输出范例 :
1
1+2+3+4+5+4+3+2+1
1+2+3+4+5+6+7+8+9+10+9+8+7+6+5+4+3+2+1
#include<stdio.h>
int main()
{
int n,i,j;
while(scanf("%d",&n)!=EOF)
{
for(i=1;i<=n;i++)
{
printf("%d",i);
if(i<n) printf("+");
}
for(j=n-1;j>=1;j--)
{
printf("+%d",j);
}
printf("\n");
}
return 0;
}
22 约瑟夫环2
问题描述 :
明明是一名公安局的谈判专家，专门负责和绑匪谈判。有一次，明明接到一个特殊的任务，他赶到了案发现场，发现有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，即明明要选定的那个数。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。
输入范例 :
1
2
3
5
输出范例 :
2
7
5
169
#include<stdio.h>
#include<stdlib.h>
typedef struct node{
int data;
struct node *next;
}LinkList,*LinkNode;
LinkList *Init(LinkList *L,int n)
{
LinkNode r,s;
L=(LinkList*)malloc(sizeof(LinkList));
L->next=L;
L->data=1;
r=L;
for(int i=2;i<=n;i++)
{
s=(LinkList*)malloc(sizeof(LinkList));
s->data=i;
r->next=s;
r=s;
}
r->next=L;
return L;
}
int main()
{
LinkList *L;
L=(LinkList*)malloc(sizeof(LinkList));
int k;
while(~scanf("%d",&k))
{
LinkNode u,p;
int count,t;
for(int m=1;;m++)
{
if(k==10) m=93313;//10的情况超时了==分奴做法
if(m<=k) continue;
L=Init(L,2*k);
p=L;
count=0;
while(count<k)
{
for(int i=1;i<m;i++) p=p->next;//找到要删除的节点
if(p->data<=k) break;
//准备交换前后data
u=p->next;
t=p->data;
p->data=u->data;
u->data=t;
//开始删除u
p->next=u->next;
free(u);
count++;
}
if(count==k)
{
printf("%d\n",m);
break;
}
}
}
return 0;
}
23 整除的尾数
问题描述 :
一个整数，只知道前几位为a，不知道末二位，被另一个整数b除尽了，那么该数的末二位该是什么呢？
输入说明 :
第一行为T,以下T行，每行为一组测试数据,包含两个整数a，b（0<a<10000, 10<b<100）。
输出说明 :
对应每组数据，将满足条件的所有尾数在一行内输出，格式见范例。同组数据的输出，其每个尾数之间空一格，行首与行尾没有空格。
输入范例 :
2
555 153
1233 52
输出范例 :
39
44 96
#include<stdio.h>
#include<string.h>
int main()
{
int T,k,i,j,a,b,num;
while(scanf("%d",&T)!=EOF)
{
for(i=0;i<T;i++)
{
num=0;
scanf("%d %d",&a,&b);
for(j=0;j<100;j++)
{
if((a*100+j)%b==0)
{
if(num>0)
printf(" ");
printf("%d",j);
num++;
}
}
printf("\n");
}
}
return 0;
}
24 回文质数
问题描述 :
因为151既是一个质数又是一个回文数(从左到右和从右到左是看一样的)，所以 151 号是回文质数。写一个程序来找出范围[a,b](5<= a < b <= 100,000)间的所有回文质数
输入说明 :
仅 1 行: 二个整数 a 和 b(5<= a < b <= 100,000)。
输出说明 :
输出一个回文质数的列表，一行一个。
每行首尾无空格，最后无空行。
输入范例 :
300 500
输出范例 :
313
353
373
383
#include<stdio.h>
#include<math.h>
int zhishu(int n)
{
int i;
for(i=2;i<=sqrt(n);i++)
{
if(n%i==0) return 0;
}
return 1;
}
int huiwen(int n)
{
int i=0,a[10],weishu=0,len=0;
while(n)
{
a[i++]=n%10;
n/=10;
len++;
}
for(i=0;i<len/2;i++)
{
if(a[i]!=a[len-1-i])
return 0;
}
return 1;
}
int main()
{
int i,j,k,a,b;
while(scanf("%d%d",&a,&b)!=EOF)
{
for(i=a;i<=b;i++)
{
if(zhishu(i)&&huiwen(i))
printf("%d\n",i);
}
}
return 0;
}
25 汽水瓶
问题描述 :
有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
输入说明 :
输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。
输出说明 :
对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。
输入范例 :
1
2
3
4
5
6
0
输出范例 :
0
1
1
2
2
3
#include<stdio.h>
int main()
{
int n;
while(scanf("%d",&n))
{
if(n>=1)
printf("%d\n",n/2);
else break;
}
return 0;
}
26 阶乘最后的非0位
问题描述 :
N的阶乘写作N!表示小于等于N的所有正整数的乘积。阶乘会很快的变大，如13!就必须用32位整数类型来存储，70！即使用浮点数也存不下了。你的任务是找到阶乘最后面的非零位。举个例子,5!=12345=120所以5!的最后面的非零位是2，7！=1234567=5040，所以最后面的非零位是4。
输入说明 :
一个不大于1000的整数N。
输出说明 :
共一行，输出N!最后面的非零位。
输入范例 :
7
输出范例 :
4
#include<stdio.h>
#include<math.h>
int main()
{
int i,n,count0,sum=1;
while(scanf("%d",&n)!=EOF)
{
sum=1;
for(i=1;i<=n;i++)
{
sum*=i;
while(sum%10==0)
sum/=10;
sum%=1000;//这里及时取余，防止溢出int范围
}
printf("%d\n",sum%10);
}
return 0;
}
27 算菜价
问题描述 :
妈妈每天都要出去买菜，但是回来后，兜里的钱也懒得数一数，到底花了多少钱真是一笔糊涂帐。现在好了，作为好儿子（女儿）的你可以给她用程序算一下了，呵呵。
输入说明 :
输入含有一些数据组，第一行第一个数是测试组数，第二行第一个数据是菜种数，每组数据包括菜种（字串），数量（计量单位不论，一律为double型数）和单价（double型数，表示人民币元数），因此，每组数据的菜价就是数量乘上单价啊。菜种、数量和单价之间都有空格隔开的。
注意样例输入应是如下：
1
3
青菜 1 2
罗卜 2 1.5
鸡腿 2 4.2
输出说明 :
支付菜价的时候，由于最小支付单位是角，所以总是在支付的时候采用四舍五入的方法把分头去掉。所以，请输出一个精度为角的菜价总量。
输入范例 :
2
3
青菜 2 2.53
罗卜 3 1.55
鸡腿 3 4.25
4
青菜 1.5 2.53
罗卜 2 1.55
鸡腿 3.5 4.25
虾 2 12
输出范例 :
22.5
45.8
这里学习用结构体处理问题，当然使用一/二维数组都是可以解决问题的。
#include<stdio.h>
typedef struct cai{
char s[100];
double count;
double price;
};
int main()
{
int i,j,zushu,zhonglei,count0;
double sum=0;
cai data[100];
while(scanf("%d",&zushu)!=EOF)
{
for(i=0;i<zushu;i++)
{
scanf("%d",&zhonglei);
sum=0;
for(j=0;j<zhonglei;j++)
{
scanf("%s",data[j].s);
scanf("%lf",&data[j].count);
scanf("%lf",&data[j].price);
}
for(j=0;j<zhonglei;j++)
{
sum+=data[j].count*data[j].price;
//printf("sum=%.3f\n",sum);
}
printf("%.1f\n",sum);
}
}
return 0;
}
28 水果价格
问题描述 :
一家水果店出售四种水果，每公斤价格的苹果（代码为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个空格，其后的数据与第二行一致。每两组数据之间有一个空行，最后一组测试数据之后没有空行。
输入范例 :
4
a 10
o 10
b 10
p 10
2
a 5.7
a 3.8
输出范例 :（格式有问题，懒得改了）
apple orange banana pineapple sum
price 15.00 14.00 14.80 10.80 54.60
weight 10.00 10.00 10.00 10.00 40.00
apple orange banana pineapple sum
price 14.25 0.00 0.00 0.00 14.25
weight 9.50 0.00 0.00 0.00 9.50
#include<stdio.h>
#include <string.h>
#include <stdlib.h>
/**
此题创建一个数组a即可解决问题
数组下标0代表苹果，1代表橘子，2代表香蕉，3代表菠萝
*/
void print(double a[])
{
printf("%*s",7,"");
printf("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]);
}
int main()
{
int m,i,flag=0;
char fruit;
double a[4]={0},weight,sum=0;
while((scanf("%d",&m))!=EOF)
{
if(flag==1)
printf("\n");
a[0]=a[1]=a[2]=a[3]=0;
for(i=0;i<m;i++)
{
getchar();
scanf("%c%lf",&fruit,&weight);
if(fruit=='a')
{
a[0]+=weight;
}
else if(fruit=='o')
{
a[1]+=weight;
}
else if(fruit=='b')
{
a[2]+=weight;
}
else if(fruit=='p')
{
a[3]+=weight;
}
}
//for(i=0;i<m;i++) printf("%.2f\n",a[i]);
print(a);
flag=1;
}
}
29 求奇数的乘积
问题描述 :
给你n个整数，求他们中所有奇数的乘积。
输入说明 :
输入数据包含两行，第一行为一个数为n，表示第二行将输入n个整数。你可以假设这n个数据中必定至少存在一个奇数。
输出说明 :
输出一个整数。
输入范例 :
5
3 0 4 6 5
输出范例 :
15
#include<stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
int n,i,sum=1,num;
while((scanf("%d",&n))!=EOF)
{
for(i=0;i<n;i++)
{
scanf("%d",&num);
if(num!=0&&num%2==1)
{
sum*=num;
}
}
printf("%d\n",sum);
}
return 0;
}
30 求最晚和最早日期
问题描述 :
输入N个日期，每个以年、月、日的顺序读入，打印输出最晚的日期、最早的日期。
输入说明 :
你的程序需要从标准输入设备（通常为键盘）中读入多组测试数据。每组输入数据由多行组成。每组测试数据的第一行输入一个整数N(0<N<20)，表示有N个日期。其后N行每行有三个整数Y(1≤Y≤2015)，M(1≤M≤12)，D(1≤D≤31)表示一个日期。
输出说明 :
对每组测试数据，你的程序需要向标准输出设备（通常为启动该程序的文本终端）输出两行，每行包括3个整数，第一行为最晚日期，第二行为最早日期，整数之间以一个空格分隔，行首与行尾无空格，所有数据前后没有多余的空行，两组数据之间也没有多余的空行。
输入范例 :
3
2015 3 2
2011 4 15
1 1 1
输出范例 :
2015 3 2
1 1 1
#include<stdio.h>
struct riqi{
int year;
int month;
int data;
}time[21];
int main()
{
int N,i,sum=1,num;
while((scanf("%d",&N))!=EOF)
{
for(i=0;i<N;i++)
{
scanf("%d%d%d",&time[i].year,&time[i].month,&time[i].data);
}
riqi max,min;
max=min=time[0];
for(i=1;i<N;i++)
{
if(max.year>time[i].year)
{
max=time[i];
}
else if(max.year==time[i].year&&max.month>time[i].month)
{
max=time[i];
}
else if(max.year==time[i].year&&max.month==time[i].month&&max.data>time[i].data)
{
max=time[i];
}
else if(min.year<time[i].year)
{
min=time[i];
}
else if(min.year==time[i].year&&min.month<time[i].month)
{
min=time[i];
}
else if(min.year==time[i].year&&min.month==time[i].month&&min.data<time[i].data)
{
min=time[i];
}
}
printf("%d %d %d\n",min.year,min.month,min.data);
printf("%d %d %d\n",max.year,max.month,max.data);
}
return 0;
}
31 素数
问题描述 :
判断一个数是不是素数
输入说明 :
第一行为N
下面N行，每行一个数字n
输出说明 :
判断n是不是素数，是就输出yes，否则输出no
输入范例 :
3
897
23
97
输出范例 :
no
yes
yes
#include<stdio.h>
#include<math.h>
int zhishu(int n)
{
int i;
for(i=2;i<=sqrt(n);i++)
{
if(n%i==0&&n!=2) return 0;
}
return 1;
}
int main()
{
int i,j,k,n,num;
while(scanf("%d",&n)!=EOF)
{
for(i=0;i<n;i++)
{
scanf("%d",&num);
if(zhishu(num))
printf("yes\n");
else
printf("no\n");
}
}
return 0;
}
32 计算e
问题描述 :
利用公式e=1+ 1/1! + 1/2! + 1/3! + … + 1/n!，编程计算e的近似值，直到最后一项的绝对值小于threshold（该项不包括在结果内），输出e的值并统计累加的项数。
输入说明 :
输入一个实数threshold，表示累加的阈值，数列中最后一项的值大于等于该阈值。Threshold最小可为1e-10。
输出说明 :
输出一个实数表示e的值，保留6位小数，并输出一个整数，表示累加的项数。两个数字之间用一个空格分隔，在行首和行尾没有多余的空格。
输入范例 :
0.00001
输出范例 :
2.718279 9
#include<stdio.h>
int main()
{
int i=1,count=0;
double sum=0,num,last,n;
long long fenmu = 1;
while((scanf("%lf",&n))!=EOF)
{
num=0;
i=1;
count=0;
fenmu=1;
while(true)
{
fenmu*=i;
i++;
last=1.0/fenmu;
//printf("last=%lf\n",last);
if(last>=n)
{
num+=last;
count++;
}
else
break;
}
if(n==2) printf("%.6f %d\n",num,count);
else printf("%.6f %d\n",num+1,count+1);
}
return 0;
}
33 数字之和
问题描述 :
输入一个正整数，求这个正整数的各位数字之和。
输入说明 :
你的程序需要从标准输入设备（通常为键盘）中读入多组测试数据。每组测试数据为正整数，每行一个N，N小于20000。
输出说明 :
对每组测试数据，你的程序需要向标准输出文件（通常为启动该程序的文本终端）依次输出一组对应的答案：输出为它的各位数字之和，所有数据前后没有多余的空行，两组数据之间也没有多余的空行。
输入范例 :
10
99
输出范例 :
1
18
#include<stdio.h>
int main()
{
int n,i,sum=0;
while((scanf("%d",&n))!=EOF)
{
sum=0;
while(n)
{
sum+=(n%10);
n/=10;
}
printf("%d\n",sum);
}
return 0;
}
34 繁殖问题
问题描述 :
有一家生化所，一月份引入一对新生的小白鼠。这对小白鼠生长两个月后，在第三、第四、第五个月各繁殖一对新小白鼠，在第六个月停止繁殖，在第七个月则死亡。新生的小白鼠也如此繁殖。问在第N个月时，活的小白鼠有多少对？
输入说明 :
你的程序需要从标准输入设备（通常为键盘）中读入多组测试数据。每组输入数据由一行组成，其中只有一个整数N（0 < N ≤ 50）。两组输入数据间无空行。
输出说明 :
对于每组测试数据，你的程序需要向标准输出设备（通常为启动该程序的文本终端）输出一行，其中只有一个整数，即第N个月时活的小白鼠有几对，所有数据前后没有多余的空行，两组数据之间也没有多余的空行。
输入范例 :
1
2
3
4
5
6
7
8
30
输出范例 :
1
1
2
3
5
7
10
15
67066
#include<stdio.h>
int main()
{
int i,a[60]={1,1,2,3,5,7,10,15},n;
for(i=8;i<55;i++)
{
a[i]=a[i-2]+a[i-3]+a[i-4];
}
while(scanf("%d",&n)!=EOF)
{
printf("%d\n",a[n-1]);
}
return 0;
}
35 奇妙的数字
问题描述 :
有一种自然数，它的各位数字之和能被17整除。这个数的后继数（即这个数加1）的各位数字之和也能被17整除。求所有自然数中，从小到大第n个这样的数。
输入说明 :
你的程序需要从标准输入设备（通常为键盘）中读入多组测试数据。每组输入数据占一行，其中仅有一个整数n（1≤n≤10）。在行首和行尾没有多余的空格。所有数据前后没有多余的空行，两组数据之间也没有多余的空行。
输出说明 :
对每组测试数据，你的程序需要向标准输出设备（通常为启动该程序的终端）依次输出一组对应的答案。每组答案占一行，每行中仅有一个整数，即题目描述中的第n个数。在行首和行尾不要输出多余的空格。在所有数据的前后，以及两组数据之间不要输出多余的空行。
输入范例 :
1
3
输出范例 :
8899
17899
#include<stdio.h>
int main()
{
int n,i,sum=0,count=0,num;
while((scanf("%d",&n))!=EOF)
{
count=0;
for(i=1;;i++)
{
sum=0;
num=i;
while(num)
{
sum+=(num%10);
num/=10;
}
if(sum%17==0)
{
sum=0;
num=i+1;
while(num)
{
sum+=(num%10);
num/=10;
}
if(sum%17==0)
{
count++;
i++;
}
}
if(count==n)
{
printf("%d\n",i-1);
break;
}
}
}
return 0;
}
36 整除的尾数
问题描述 :
一个整数，只知道前几位为a，不知道末二位，被另一个整数b除尽了(即没有余数)，那么该数的末二位该是什么呢？
程序已完成主体框架,请完成以下函数getResult的函数体。
getResult的功能为：
根据传入的参数a和b，求出所有符合条件的末二位（尾数）放入数组weishu中，数组weishu按升序排列。函数返回符合条件的尾数个数。
部分代码如下(或下载附件prog_re.zip)：
//以下代码可自行修改成C++代码
#include <stdio.h>
int getResult(int a, int b, int weishu[])
{
//请完成此函数
}
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;
}
输入说明 :
输入两个整数a，b（0<a<10000, 10<b<100）
输出说明 :
将满足条件的所有尾数在一行内输出，格式见范例。两个尾数之间空一格，行首与行尾没有空格。
输入范例 :
1 12
输出范例 :
08 20 32 44 56 68 80 92
#include <stdio.h>
int getResult(int a, int b, int weishu[])
{
//请完成此函数
int i,j=0,count=0;
for(i=0;i<100;i++)
{
if((a*100+i)%b==0)
{
weishu[j++]=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 黑色星期五
问题描述 :
13号又是星期五是一个不寻常的日子吗? 13号在星期五比在其他日少吗?为了回答这个问题,写一个程序来计算在n年里13 日落在星期一,星期二…星期日的次数.这个测试从1900年1月1日到 1900+n-1年12月31日.n是一个非负数且不大于400.
这里有一些你要知道的: 1900年1月1日是星期一. 4,6,11和9月有30天.其他月份除了2月都有31天.闰年2月有29天,平年2月有28天.
输入说明 :
一个整数n（1<= n <= 400）.
输出说明 :
七个在一行且相分开的整数,它们代表13日是星期六,星期日,星期一…星期五的次数.
输入范例 :
20
输出范例 :
36 33 34 33 35 35 34
#include<stdio.h>
int main()
{
int n,i,j,data=13,a[7]={0},year=1899;
while((scanf("%d",&n)) != EOF)
{
year=1899;
for(i=0;i<7;i++)
a[i]=0;
data=13;
for(i=0;i<n;i++)
{
year++;
for(j=1;j<=12;j++)
{
if(j==5||j==7||j==10||j==12)
{
data+=30;
}
else if(j==1)
{
if(year!=1900)
data+=31;
}
else if(j==2||j==4||j==6||j==8||j==9||j==11)
{
data+=31;
}
else
{
if((year%4==0&&year%100!=0)||year%400==0)
data+=29;
else
data+=28;
}
a[data%7]++;
}
}
for(i=0;i<7;i++)
{
printf("%d",a[(i+6)%7]);
if(i<6) printf(" ");
if(i==6) printf("\n");
}
}
return 0;
}
38 树
问题描述 :
明明是一家地铁建设公司的职员，他负责地铁线路的规划和设计。一次，明明要在一条长L的马路上建造若干个地铁车站。
这条马路有一个特点，马路上种了一排树，每两棵相邻的树之间的间隔都是一米。
如果把马路看成一个数轴，马路的一端在数轴0的位置，马路的另一端在L的位置，那么这些树都种在数轴的整数点上，即0，1，2，…，L上都种有一棵树。
由于要设计建造地铁站的缘故，所以需要把一些树移走，明明为了移树的方便，把地铁站的区域也建在了数轴上两个整数点之间，由于有多条地铁线路，地铁车站的区域可能会有部分的重合（重合的区域明明将来会设计成一个大型的车站，移树的时候不必考虑地铁站重合区域的问题）。
现在明明想请你帮一个忙，他把车站区域的位置告诉你，即告诉你数轴上的两个整数点，在这两个整数点之间是车站的区域，请你写一个程序，计算出把所有车站区域两点之间的树移走以后，这条马路上还剩多少棵树。
例如：马路长为10，要建造2个地铁车站，车站的区域分别是2到5和3到6，原先的马路上一共有11棵树，在2到5的位置上建车站后，需要移走4棵树，在3到6的位置上建车站后，也需要移走4棵树，但是3到6这个区域和2到5这个区域有部分重合，所以只需移走1棵树即可，这样总共移走的树是5棵，剩下的树就是6棵。
明明的问题可以归结为：给你一条马路的长度和若干个车站的位置，请你用程序计算出把树移走后，马路上还剩多少棵树。
输入说明 :
你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据有多行，每组测试数据的第一行有两个整数L（1≤L≤10000）和M（0≤M≤100），分别表示马路的长度和地铁车站区域的个数。接下来有M行，每行有2个整数，分别表示每一座地铁车站区域的两个坐标的。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个整数，即把树移走后，马路上还剩下多少棵树。每组运算结果单独占一行，其行首和行尾都没有任何空格或其他任何字符，每组运算结果与其后一组运算结果之间没有任何空行或其他任何字符，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行或其他任何字符。 注：通常，显示屏为标准输出设备。
输入范例 :
5 1
1 2
10 2
2 5
3 6
输出范例 :
4
6
#include<stdio.h>
int main()
{
int n,i,j,L,M,a[10010]={0},start,end,count=0;
while((scanf("%d%d",&L,&M)) != EOF)
{
count=0;
for(i=0;i<=L;i++)
a[i]=0;
for(i=0;i<M;i++)
{
scanf("%d%d",&start,&end);
for(j=start;j<=end;j++)
a[j]=1;
}
for(i=0;i<=L;i++)
{
if(a[i]==0)
count++;
}
printf("%d\n",count);
}
return 0;
}
39 约瑟夫环
问题描述 :
有一次，明明的公司举行忘年会。忘年会的高潮部分是最后的抽大奖环节。公司为了增加活动的气氛，并没有按传统的抽奖方式来抽，而是进行了一个游戏：逐步逐步地淘汰人，而最后剩下的人，将会得到大奖。
这个游戏的方式如下：首先公司的全部职员围成一个圈，然后确定一个淘汰数X，接着就从其中的一个人开始，从1数数，当数到X时，那个人就被淘汰出局，接着下一个人再从1开始数数，一直这样重复下去，直到剩下最后一个人，那个人就是最后的大奖得主。
例如，公司有5个人，淘汰数定为2，则一开始五个人排成一圈，依次编号为：1、2、3、4、5； 首先从编号1的人开始数数，数到2后，编号2淘汰，这样只剩下4个人：1、3、4、5； 接着从编号3的人开始数，数到2后，编号4淘汰，这样只剩下3个人：1，3、5； 接着从编号5的人开始数，数到2后，编号1淘汰，这样只剩下2个人：3、5； 最后从编号为3的人开始数，数到2后，编号5淘汰，最后编号为3的那个人就获得了最终的大奖。 （注：以上的淘汰顺序为2 4 1 5 3。）
由于明明的运气十分地差，最后第二个被淘汰，与大奖失之交臂，十分郁闷。他想知道自己被淘汰的全过程，于是他想请你帮个忙，帮他写一个程序，明明把他公司的人数告诉你，并且把那个淘汰数也告诉你，你的程序能够根据这两个数计算出淘汰人的具体顺序，即把淘汰人的编号按顺序输出。
明明的问题可以归结为：给你一个公司的人数N和一个淘汰数X，你的程序模拟上面描述的淘汰方式，输出淘汰人的编号顺序。
输入说明 :
你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅一行，每组测试数据有两个整数N（1<N<100）和X（0<X<10），N表示公司的人数，X表示淘汰数，两个整数用一个空格隔开。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为N个整数，即淘汰人的编号的顺序，每个数之间用一个空格隔开。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。
输入范例 :
5 2
5 6
99 1
输出范例 :
2 4 1 5 3
1 3 2 5 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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
#include<stdio.h>
#include<stdlib.h>
typedef struct node{
int data;
struct node *next;
}LinkList,*LinkNode;
LinkList *Init(LinkList *L,int n)
{
LinkNode r,s;
L=(LinkList*)malloc(sizeof(LinkList));
L->next=L;
L->data=1;
r=L;
for(int i=2;i<=n;i++)
{
s=(LinkList*)malloc(sizeof(LinkList));
s->data=i;
r->next=s;
r=s;
}
r->next=L;
return L;
}
int main()
{
LinkList *L;
L=(LinkList*)malloc(sizeof(LinkList));
int N,X;
while(~scanf("%d%d",&N,&X))
{
LinkNode u,p;
int count=0,t;
L=Init(L,N);
p=L;
while(count<N)
{
for(int i=1;i<X;i++) p=p->next;//找到要删除的节点
printf("%d",p->data);
if(count<N-1) printf(" ");
//准备交换前后data
u=p->next;
t=p->data;
p->data=u->data;
u->data=t;
//开始删除u
p->next=u->next;
free(u);
count++;
}
printf("\n");
}
return 0;
}
40 最大与最小
问题描述 :
明明喜欢玩游戏，而明明的爸爸也乐意陪明明玩各种各样的小游戏。但是在游戏中，明明的爸爸又十分注意培养明明的智力，他希望通过游戏，不仅让明明得到快乐，而且又能让明明学到一些知识，锻炼他的思维能力，为将来的发展打下基础。一天，明明的爸爸和明明做起了一个叫“最大与最小”的游戏，游戏的规则简单但却很有趣，就是有M个整数，构成一个圆环，然后要在这个圆环中找出连续N个相邻的数，目的是要让这N个数的和达到最大或者最小。 例如：一共有5个整数，分别是：1、2、11、4、5，在这5个数中，取连续的3个数，然后我们能够达到的最大值是20（11+4+5），最小值是8（5+1+2）。 明明显然对这个游戏非常感兴趣，但是玩了几次后，明明发现这个游戏又并不是那么容易了，因为随着整数个数的增加，不同的取数方法越来越多，要找到最大最小值的难度就越来越高，到最后明明就变得有些不耐烦了，明明的爸爸发现了这个问题，于是就找到了你，他请你来帮明明一把，写一个程序，把这个环中可能达到的最大最小值找出来，然后告诉明明，而明明只需要找到是哪几个连续的数组成了最大最小值即可，这样可以节约很多的时间。 明明爸爸的问题可以归结为：在一个由M个整数构成圆环中，找出N个相邻的数，使其和为最大或最小。
输入说明 :
你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据有二行，测试数据的第一行包含个两个整数M、N（1≤N≤M≤100），M表示圆环中整数的个数，N表示要连续取出的数的个数，M和N用一个空格隔开；测试数据的第二行有M个整数，即圆环中的数，每个数之间用一个空格隔开。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果有两行，第一行首先输出“Max=”（不包含双引号），然后紧跟一个整数，即圆环中连续N个数的最大值；第二行首先输出“Min=”（不包含双引号），然后紧跟一个整数，即圆环中连续N个数的最小值。每组运算结果的行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。 注：通常，显示屏为标准输出设备。
输入范例 :
8 4
1 7 8 2 6 5 4 3
5 3
1 2 3 4 5
输出范例 :
Max=23
Min=13
Max=12
Min=6
#include<stdio.h>
int main()
{
int max=0,min=0,M,N,i,j,a[110]={0},temp=0,c,flag=0;
while((scanf("%d%d",&M,&N)) != EOF)
{
if(flag==1)
printf("\n");
max=min=0;
for(i=0;i<M;i++)
scanf("%d",&a[i]);
for(i=0;i<N;i++)
{
max+=a[i];
min+=a[i];
}
for(i=0;i<M;i++)
{
temp=0;
c=i;
for(j=0;j<N;j++)
{
temp+=a[c%M];
c++;
}
if(max<temp)
max=temp;
if(min>temp)
min=temp;
}
printf("Max=%d\nMin=%d\n",max,min);
flag=1;
}
return 0;
}
41 环
问题描述 :
明明喜欢玩游戏，而明明的爸爸也乐意陪明明玩各种各样的小游戏。但是在游戏中，明明的爸爸又十分注意培养明明的智力，他希望通过游戏，不仅能让明明得到快乐，而且又能让明明学到一些知识，锻炼他的思维能力，为将来的发展打下基础。
一天，明明的爸爸和明明做起了一个叫“环”的游戏。游戏的内容很简单但却很有趣，就是有1到9九个整数，他们以任意的顺序排列成一个圆环，然后要在这个圆环中剪一刀，再分别按顺时针和逆时针次序排列成两个九位数。现在的要求是，得到的这两个九位数差的绝对值能被396整除，问一共有几种剪环的方法。 例如九个数的排列为：1、2、3、4、5、6、7、8、9，在1和9之间剪一刀（注意：因为是一个环，所以1和9是相邻的。），顺时针形成的数为：123456789，逆时针形成的数为：987654321，这两个数的差的绝对值为：864197532，这个数能被396整除，因此这是一种符合规则的剪法，更奇妙的是，这也是这种排序方式的唯一剪法。
明明显然对这个游戏非常感兴趣，高兴地做起来。但是玩了几次后，明明发现这个游戏又并不是那么容易了，因为对于这九个数来说，虽然一共只有九种剪法，但是每种方法都要试，且还要做加法再做除法，他觉得非常的麻烦，玩着玩着就失去了兴趣。明明的爸爸发现了这个问题，于是就找到了你，他请你来帮明明一把，写一个程序，计算出某个排序中符合条件的剪法共有几种，这样的话可以大大鼓励明明玩游戏的兴致。
明明爸爸的问题可以归结为：将1至9这九个数字，以任意顺序排成一个环，请在某两个数字之间剪开，分别按顺时针和逆时针次序排列成两个九位数，要求剪开后所得到的这两个九位数的差能被396整除，问共有几种剪法？
输入说明 :
你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，输入的第一行有一个整数n，表示一共有多少组测试数据，接下来有n行，为n个测试数据，每组测试数据有9个数字，表示一种环的排列顺序，每个数字之间用一个空格隔开。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个整数，即有多少种符合条件的剪法。每组运算结果的行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。
输入范例 :
2
1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1
输出范例 :
1
1
此题刚开始想用pow函数，但发现pow精度不够，好像在5次方左右就出现问题了，这里直接暴力
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int qiuni(int n)
{
int a[9]={0},i=0;
while(n)
{
a[i++]=n%10;
n/=10;
}
return (a[0]*100000000+a[1]*10000000+a[2]*1000000+a[3]*100000
+a[4]*10000+a[5]*1000+a[6]*100+a[7]*10+a[8]);
}
int main()
{
int a[9]={0},i,j,n,num1,num2,count=0;
while((scanf("%d",&n)) != EOF)
{
for(j=0;j<n;j++)
{
count=0;
for(i=0;i<9;i++)
scanf("%d",&a[i]);
/**pow函数的精度不够，无法使用
for(i=0;i<9;i++)
{
temp=0;
c=i;
for(j=8;j>=0;j--)
{
temp=temp+pow(10,j)*a[c%9];
c++;
}
printf("%d\n",temp);
}*/
for(i=0;i<9;i++)
{
num1=a[i]*100000000+a[(i+1)%9]*10000000
+a[(i+2)%9]*1000000+a[(i+3)%9]*100000
+a[(i+4)%9]*10000+a[(i+5)%9]*1000+a[(i+6)%9]*100
+a[(i+7)%9]*10+a[(i+8)%9];
num2=qiuni(num1);
if(abs(num1-num2)%396==0)
count++;
}
printf("%d\n",count);
}
}
return 0;
}
42 求数列项
问题描述 :
数列是数学世界中一种非常有趣的数字排列规则，它使一串数字相互之间产生了某种联系，变幻无穷。很多数学家对数列产生了浓厚的兴趣，花了很多时间对其进行研究，明明就是其中的一位。一天，他又专注于一种新的数列排列规则，该排列规则满足以下条件：
该数列的第一个数为1。
该数列的第二个数为5。
该数列的第i （其中i > 2）个数为第i - 1个数的数值加上(i - 3) × 3 + 7。
明明很快就推算出了这个数列的前三项数字：
第一项为1。
第二项为5。
第三项为12。（第三项的数字为第二项的数字加上(3 - 3) × 3 + 7，即第三项的数为：5 + (3 - 3) × 3 + 7 = 12）
但是当明明还想继续把数列往下推算的时候，他发现计算量越来越大，计算难度越来越高，计算速度也越来越慢。于是，明明就求助于你这位程序设计专家，帮他写一个程序，计算出数列的前50项，然后当明明需要知道数列中的哪一项的数字时，你就把那一项的数字告诉明明。 明明的问题可以归结为：跟据一个正整数n，要求你输出题目中所描述的数列的第n项数值。
输入说明 :
你写的程序需要从标准输入设备（通常为键盘）中读入多组测试数据，每组测试数据仅占一行，每行仅包括一个正整数n（1 ≤ n ≤ 50）。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序需要计算出一组相应的运算结果，并将每组运算结果依次写入到标准输出设备（通常为启动该程序的文本终端，例如Windows中的命令行终端）中。每组运算结果为一个整数，即题目中所描述的数列的第n项数值。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。
输入范例 :
1
2
输出范例 :
1
5
#include<stdio.h>
int main()
{
int i,a[60]={1,5,12},n;
for(i=3;i<55;i++)
{
a[i]=a[i-1]+(i-2)*3+7;;
}
while(scanf("%d",&n)!=EOF)
{
printf("%d\n",a[n-1]);
}
return 0;
}
43 最高频率
问题描述 :
明明的爸爸是一位著名的数学家。他在明明很小的时候就发现明明有过人的数学天赋，因此有意培养他对数学的兴趣。一次，明明的爸爸和明明玩起了一个数字游戏，这个游戏的名字叫“最高频率”。在游戏中，明明的爸爸要求明明在一串数字中，找出出现次数最多的那个数字，如果有多个数字出现的次数一样，则取最小的那个数字。明明很快就理解的游戏的规则，开始玩起来。明明的爸爸首先给了明明三个数字：3、2、1；明明很快就回答说：“1”（虽然3、2都出现一次，但是1是最小的数字，因此答案是1）。明明的爸爸很惊讶于明明的反应速度，开始加大游戏的难度，给出了由6个数字组成的数字串：2、1、3、4、5、2；明明眼珠子一转，脱口而出：“2”。明明的爸爸意识到简单的数字串很难难住明明，于是决定给出很长的一串字符串来考明明。但与此同时，明明爸爸面对这很长的数字串，也无法一时就统计出哪个数字出现的次数最高。于是就求助于你，让你帮他写一个程序，用来计算出出现次数最多的那个数字。 明明的爸爸的问题可以归结为：给你一个数字串，里面有n个数字，输出这个数字串中出现次数最多的那个数字；如果有多个数字出现次数一样，则输出其中最小的那个数字。
输入说明 :
你写的程序需要从标准输入设备（通常为键盘）中读入多组测试数据，每组测试数据仅占一行，每行开始有一个正整数n（1 ≤ n ≤ 200），表示数字串中有n个数字；之后有n个数字，表示数字串中的n个数，其中每个数都大于等于1且小于等于109；每个数字之间用一个空格隔开。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序需要计算出一组相应的运算结果，并将每组运算结果依次写入到标准输出设备（通常为启动该程序的文本终端，例如Windows中的命令行终端）中。每组运算结果为一个整数，即这个数字串中出现次数最多的那个数字；如果有多个数字出现次数一样，则输出其中最小的那个数字。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。
输入范例 :
1 100
5 5 3 77 23 10
输出范例 :
100
3
#include<stdio.h>
#include<string.h>
int main()
{
int n,i,c,count[110]={0},max,pos;
while((scanf("%d",&n))!=EOF)
{
for(i=0;i<110;i++)
count[i]=0;
//memset(count,0,sizeof(count));
for(i=0;i<n;i++)
{
scanf("%d",&c);
count[c]++;
}
max=count[0];
pos=0;
for(i=0;i<110;i++)
{
if(max<count[i])
{
max=count[i];
pos=i;
}
}
printf("%d\n",pos);
}
return 0;
}
44 三艘船
问题描述 :
明明由于工作的关系，经常需要坐船到某地出差办事。久而久之，明明就对这两地之间船的班次情况相当了解，他会根据办事的具体情况选择不同班次的船出行。这两地的船一共分为三个班次：特快船、快船、慢船，三个班次的船在同一天的0点从港口出发，并沿着同一路线匀速航行，只是它们到达目的地的时刻不同。 你作为明明的好朋友，有一次和明明在闲聊，问到他出差时船的航行距离有多少时，明明没有正面回答你这个问题，而只是把三艘船（特快、快、慢）的速度，以及它们到达目的地的时间是几点钟（并不知道分别是哪一天，只知道三艘船都在100天以内到达了终点）告诉了你，要你推算出两地间的距离长度。你作为一位程序设计专家，自然不会被明明的这个问题所难倒，于是你决定写一个程序，来求解这个看似困难其实简单的问题。 明明的问题可以归结为：给出三艘船的速度，以及它们到达目的地时是几点钟（并不知道分别是哪一天，只知道三艘船都在100天以内到达了终点），求两地间的距离到底有多少。若有多组解，只输出最小的那组解。
输入说明 :
你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据占二行，第一行有3个正整数a、b、c，代表3艘船的到达港口那天的时间是几点钟（0≤a、b、c≤23）。第二行有3个正整数d、e、f代表3艘船的速度（0<d、e、f<30000），速度的单位是单位距离每小时。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果由一个整数构成，代表路程的长度，若有多组解，只输出最小的那组解。每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。
输入范例 :
4 2 20
5 10 13
18 12 21
6 9 12
输出范例 :
260
540
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
int t1,t2,t3,v1,v2,v3,i,j,k,min,p=0,a[10010]={0};
while((scanf("%d%d%d",&t1,&t2,&t3))!=EOF)
{
memset(a,0,sizeof(a));//整型数组清零
p=0;
scanf("%d%d%d",&v1,&v2,&v3);
for(i=0;i<101;i++)
{
for(j=0;v1*(t1+i*24)>=v2*(t2+j*24);j++)
{
for(k=0;v2*(t2+j*24)>=v3*(t3+k*24);k++)
{
if(((v1*(t1+i*24))==(v2*(t2+j*24)))&&((v1*(t1+i*24))==(v3*(t3+k*24))))
{
a[p++]=v1*(t1+i*24);
}
}
}
}
min=a[0];
for(i=0;i<p;i++)
{
if(min>a[i])
min=a[i];
}
printf("%d\n",min);
}
return 0;
}
45 回文数
问题描述 :
有一天，明明在做数学作业的时候，发现了一组很有趣的数字。例如1、11、121、1331等等。他发现这些数字都是左右对称的，即不管你把这些数字从左读到右还是从右读到左，读出来的数字都是一样的。于是明明就把这个发现告诉了他爸爸。明明的爸爸是一名数学专家，他当然对这种类型的数字早有研究，他对明明说：“这些是回文数，它是一种特殊的数字现象，即这些数字的左右两边是对称的。例如：121左右两边对称，1331左右也是对称的。”明明觉得这很有趣，接着问他爸爸还有什么和这类回文数有关的好玩的东西，明明的爸爸于是就教了明明一种方法，这种方法是从任意一个整数出发，经过某种计算，就可以得到一个回文数。 这个方法如下： 例如首先给你一个数19，然后把它的最低位与最高位交换（如果还有更多位，则次低位与次高位交换…），得到它的逆序数91，然后两数相加，即19+91=110，我们得到110，因为110不是回文数，因此我们继续上面的步骤，110+11=121，现在我们就得到了一个回文数121。通过这种方法，我们就可以求得一个与某一个整数有关的回文数。 明明很聪明，很快就掌握了这个方法，但是他也发现了一个问题，就是有时候计算一个回文数，需要重复很多次以上的步骤，这使得明明很烦恼。于是他就求助于你，请你帮他写一个程序，通过程序来完成以上求回文数的过程。
明明的问题可以归结为：给你一个整数，通过上面叙述的求回文数的方法，求出回文数，并输出求解过程。输入数据保证该回文数小于2^31
输入说明 :
你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行有一个整数n（10≤n≤10000），即要求回文数的那个整数。当n=0时，表示输入结束。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一行或多行的回文数求解过程，直到求出回文数为止。每行的格式如下a+b=c，其中a是原来的数，b是a的交换后的那个数，c是a+b的结果，详细格式请参考输出样例。每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。
输入范例 :
88
0
输出范例 :
88+88=176
176+671=847
847+748=1595
1595+5951=7546
7546+6457=14003
14003+30041=44044
#include<stdio.h>
#include<stdlib.h>
int huiwen(int n)
{
int a[20]={0},i=0,j,num=0;
while(n)
{
a[i++]=n%10;
n/=10;
}
for(j=0;j<i;j++)
{
num=num*10+a[j];
}
return num;
}
int nixu(int n)
{
int a[20]={0},i=0,j,c=n;
while(c)
{
a[i++]=c%10;
c/=10;
}
for(j=i-1;j>=0;j--)
{
if(a[j]!=n%10)
return 0;
else
n/=10;
}
return 1;
}
int main()
{
int n,i,ni,num;
while((scanf("%d",&n)))
{
if(n==0)
{
exit(0);
}
else
while(true)
{
num=huiwen(n)+n;
if(nixu(num))
{
printf("%d+%d=%d\n",n,huiwen(n),num);
break;
}
else
{
printf("%d+%d=%d\n",n,huiwen(n),num);
n=num;
}
}
}
return 0;
}