东华大学2020考研计算机复试准备上机题解析答案_进阶篇(1-30)

前言

提交代码：
选择C++编程语言，因为有的时候会用到C++的一些方便的头文件什么的，还有我编写代码是有一部分是纯C的，因为做题来讲C的scanf和printf很方便。

发布文章安排：
我会抽时间发文章的，看时间安排了，现在时间有点紧吧。马上过年了。过完年要开始准备准备其他东西了
今天开始更新了。

解题解法质量：
题目没有测试数据 因为数据实在不好拷贝出来 就没弄 不过都能保证AC
关于我的解法和代码的精简程度，我是以当时做题的心态来解题的，由于当时急着刷完所有题目，所以难免会有一些题应该有其他更优的解法，我却用了比较暴力一点的，毕竟当时的劳动强度有点大，抓进度来着，如果有更好的解法，欢迎联系我，或者直接评论，共同学习，共同进步！

联系方式：

如果有问题交流咨询，可以加入QQ群：673852347

其他未尽事宜，还望海涵！

1 求长方形的面积和周长

作者: Hu Yongjian 时间限制: 1S 章节: 顺序结构

问题描述 :

求一个长方形的面积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

AC代码：

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

2 数列和

作者: Hu Yongjian 时间限制: 1S 章节: 顺序结构

问题描述 :

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

输入说明 :

你的程序需要从标准输入设备（通常为键盘）中读入一个整数N（1 ≤ N < 10,000）；在行首和行尾没有多余的空格。在所有数据的前后，以及两组数据之间都没有多余的空行。

输出说明 :

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

输入范例 :

10
输出范例 :

55

AC代码：

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

3 解方程

作者: 江宝钏 时间限制: 1S 章节: 顺序结构

问题描述 :

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

输入说明 :

整数a b

输出说明 :

x 保留1位小数

输入范例 :

1 2

输出范例 :

-0.5

AC代码：

#include<stdio.h>// 
int main()
{
    int a,b;
    scanf("%d%d",&a,&b);
    printf("%0.1f\n",(5-3*b)/2.0/a);
    return 0;
}

4 一个月的天数

作者: Turbo 时间限制: 1S 章节: 分支结构

问题描述 :

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

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

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

2000 2
输出范例 :

29

AC代码：

#include<stdio.h>// 判断瑞年先
int main()
{
    int a,b;
    int month[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
    scanf("%d%d",&a,&b);
    if( (a%100!=0 && a%4==0) || (a%400==0) )month[2]++;
    printf("%d\n",month[b]);
    return 0;
}

5 银行存款到期日

作者: Turbo 时间限制: 1S 章节: 分支结构

问题描述 :

银行存款有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

AC代码：
判断到几月份到期就行。如果到期那月明明没有31日，则要输出当前最大的日子。

#include<stdio.h>// 判断瑞年先
int main()
{
    int yy,mm,dd,time;
    int month[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
    scanf("%d%d%d%d",&yy,&mm,&dd,&time);
    mm+=time;
    while(mm>12)      //可能存在月数大于1年，所以用while比较稳妥
    {
        mm-=12;
        yy++;
    }
    if( (yy%100!=0 && yy%4==0) || (yy%400==0) )month[2]++;
    printf("%d %d %d\n",yy,mm,dd<month[mm]?dd:month[mm]);
    return 0;
}

（交流技术，分享经验：编程交流Q群：673852347）

6 实数运算

作者: Turbo 时间限制: 1S 章节: 分支结构

问题描述 :
输入两个实数，求它们的和，差，积，商。
输入说明 :
输入数据由两行组成：第一行为两个实数a、b，它们以空格分隔，在行首和行尾没有多余的空格；第二行为运算符号’+‘、’-‘、’*‘、’/‘之一，在行首和行尾没有多余的空格。
输出说明 :
输出运算结果(保留一位小数)，行首和行尾没有多余的空格，当除数为0时输出’Wrong!’。

#include<stdio.h>// 
int main()  //有一个case没有过，试一试double变量怎么样呢？
{
    double a,b;
    char c;
    scanf("%lf %lf\n%c",&a,&b,&c);
    switch(c)
    {
        case '+':printf("%0.1f\n",a+b);break;
        case '-':printf("%0.1f\n",a-b);break;
        case '*':printf("%0.1f\n",a*b);break;
        case '/':
            if(b==0) printf("Wrong!\n");
            else
                printf("%0.1f\n",a/b);break;
        default:break;
    }
    return 0;
}

7 解二次方程

作者: 江宝钏 时间限制: 1S 章节: 分支结构

问题描述 :
编写程序求方程ax2+bx+c=0的根，a、b、c的值由键盘输入，假设b2-4ac>0
输入说明 :
3个整数a b c，以一个空格分隔
输出说明 :
两个根，大数在前，小数在后
输出时保留两位小数。

#include<stdio.h>// 
#include<math.h>
int main()
{
    int a,b,c;
    scanf("%d %d %d",&a,&b,&c);
    printf("%0.2f %0.2f\n",(-b+sqrt(b*b-4.0*a*c))/2.0/a,(-b-sqrt(b*b-4.0*a*c))/2.0/a);
    return 0;
}

8 求第几天

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

问题描述 :

按年、月、日的顺序读入一个日期，输出该日期是这一年中的第几天。
输入说明 :
输入数据为三个正整数y 、m、d，分别表示年、月、日，整数之间以空格分隔，在行首和行尾没有多余的空格。
输出说明 :
输出一个整数，表示输入的日期是这一年中的第几天，在行首和行尾没有多余的空格。

 
#include<stdio.h>// 
int main()
{
    int y,m,d,sum=0,month[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
    scanf("%d %d %d",&y,&m,&d);
    if((y%400==0) || (y%100!=0 && y%4==0))month[2]++;
    for(int i=1;i<m;i++)sum+=month[i];
    printf("%d\n",sum+d);
    return 0;
}

9 求阶乘结果0的个数

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

问题描述 :
编写一个程序，求出N！的末尾含有多少个0。
提示：在乘积中，末尾有多少个0，主要看各乘数的素数因子中有多少个2和5，每一个2和5的结合将给末尾贡献一个0。而乘数中因子2的个数远多于因子5的个数，因此，就计算各乘数中因子5的个数即可。
输入说明 :
你的数据需要从标准输入设备（通常为键盘）中读入多组测试数据。每组输入数据由一行组成，每行由一个正整数N组成，N小于等于100000，在行首和行尾没有多余的空格。
输出说明 :
对每组测试数据，你的程序需要向标准输出文件（通常为启动该程序的文本终端）依次输出一组对应的答案。所有数据前后不要输出多余的空行，两组数据之间也不要输出多余的空行。每组输出数据由一行组成，每行由一个整数组成，在行首和行尾不要输出多余的空格。

Solution:
　　令n! = (5K) * (5(K-1)) * (5*(K-2)) * … * 5 * A，其中A就是不含5因子的数相乘结果，n = 5*K + r（0<= r <= 4）。假设f(n!)是计算阶乘n!尾数0的个数，而g(n!)是计算n!中5因子的个数，那么就会有如下公式：
　　f(n!) = g(n!) = g(5^K * K! * A) = K + g(K!) = K + f(K!)，其中K=n / 5（取整数）。

#include<stdio.h> 
//人家都给提示了，阶乘时候每个数的因子，必定偶数约占一半，因子2必定大于5的因子。数数5的个数呀
int main()
{
    long N,sum=0; //N可能很大哦
    while(scanf("%ld",&N)!=EOF)
    {
        sum=0;
        while(N>=5)
        {
            sum+=N/5;   //某个数是5的倍数，则就有几个5
            N=N/5;      //跳跃式前进可以降低时间复杂度
        }
        printf("%ld\n",sum);
    }
    return 0;
}

10 怪数

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

问题描述 :
寻找怪数：有一种奇怪的自然数，它的比其本身小的所有因子之和等于它本身，例如：6＝1＋2＋3，其中1、2、3都是6的因子，编程找出整数N之内的所有怪数。
输入说明 :
输入一个整数N(10<=N≤10000)，在行首和行尾没有多余的空格。
输出说明 :
输出N之内(<=N)的所有怪数，每一行输出一个整数。（注：若N中有3个怪数，你则需要输出三行，每行一个怪数。）所有数据前后没有多余的空格，中间也没有多余的空行。

#include<stdio.h>
//判断到N/2就OK了，因为N/2下面的因子就是自身了
int main()
{
    int N;
    scanf("%d",&N);
    for(int i=1;i<=N;i++)
    {
        int sum=0;
        for(int j=1;j<=i/2;j++)
        {
            if(i%j==0)sum+=j;       //求出各因子
        }
        if(sum==i)printf("%d\n",i);
    }
    return 0;
}

11 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的乘积和有几位相等，两个数之间用一个空格隔开。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。

#include<stdio.h>// 
int main()
{
    int a,b,c,sum;
    while(scanf("%d %d %d",&a,&b,&c)!=EOF)
    {
        int temp=sum=(100*a+10*b+c) * (100*c+10*b+a),count=0;
        while(temp)
        {
            if(temp%10==a || temp%10==b ||temp%10==c)count++;;
            temp/=10;
        }
        printf("%d %d\n",sum,count);
    }
    return 0;
}

（交流技术，分享经验：编程交流Q群：673852347）

12 奇妙的比值

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

问题描述 :
明明喜欢钻研各种各样的数学问题。一天，明明对数的因子产生了兴趣，他想把一个数的所有因子都找出来，然后把它们相加再去除以这个数，这样会得到一个比值。明明想看看不同的数的该比值会有什么不同，以便做研究。
例如6这个数，它一共有4个因子，分别是：1、2、3、6，把他们相加然后再除以6，即1+2+3+6=12，12/6=2，就可以得到2这个比值。
明明为了研究，需要得到大量的比值，但是如果通过手动计算比值的话需要花大量的时间，于是明明就想请你帮忙，帮他写一个程序，能够求数的比值。 明明的问题可以归结为：给你一个数，求所有因子和，把这些因子相加，然后再除以这个数，求得比值。
输入说明 :
你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行仅包括一个正整数n（1≤n≤120），代表所求比值的那个数。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个浮点数，就是所求的比值，保留2位小数。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。（注：最后求得的比值保留2位小数。） 注：通常，显示屏为标准输出设备。

#include<stdio.h>
#include<math.h>
int main()
{
    int N;
    while(scanf("%d",&N)!=EOF)
    {
        int sum=0,i;
        for(i=1;i<sqrt(1.0*N);i++)//用根值提前结束判定
        {
            if(N%i==0)sum=sum+i+N/i;
        }
        if(i==sqrt(1.0*N))sum+=i;;      //如果一个数的因子是X²那么就只能加一个
        printf("%0.2f\n",1.0*sum/N);
    }
    return 0;
}

（交流技术，分享经验：编程交流Q群：673852347）

13 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”，不包括双引号。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。

Solution:
由于本题的数据不大 完全可以暴力AC 个位是7 这个是定好的 所以 只遍历前其他的几位就行了

#include<stdio.h>
//其实可以列出等式  ***...***7乘以T=7***...*** 发现没？？
//左边的7乘T的个位数就是右边的个位数。而右边的个位数即是左边的十位数，可以递推得到
//但是直接循环也可以做
int weishu(long a)      //判断a有几位数
{
    int t=1;
    while(a/10)
    {
        t++;
        a/=10;
    }
    return t;
}
int main()
{
    int T;
    while(scanf("%d",&T)!=EOF)
    {
        long N,temp=1,i;
        if(T==1)   //1的时候要特判，因为下面的N计算位数是适用于2位及其以上的数
        {
            printf("7\n");
            continue;
        }
        for(N=0;N<100000;++N)//少一位循环，多一分时间
        {
            for(i=weishu(N),temp=1;i;i--)temp*=10; //没用math.h emm杀鸡焉用牛刀
            if(N+temp*7==(N*10+7)*T)
            {
                printf("%ld\n",N*10+7);
                break;
            }
        }
        if(N>=100000)printf("No\n");
    }
    return 0;
}

（交流技术，分享经验：编程交流Q群：673852347）

14 黑色星期五

作者: xxx 时间限制: 1S 章节: 一维数组

问题描述 :
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日是星期六,星期日,星期一…星期五的次数.

#include<stdio.h> 
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;
}

15 三角形

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

问题描述 :
“明明，你会用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表示三角形由几行数字组成。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为构建出来的三角形，三角形中的同一行的数字两两之间用一个空格隔开。每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。

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

#include<stdio.h>
int main()
{           //主要是有个啥吧，那个最后一次输出没有空格，我们可以设计个count
    int s,n,count=1;
    while(scanf("%d%d",&s,&n)!=EOF)
    {
        if(count!=1)printf("\n");
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=i;j++)
            {
                printf("%d",s++);
                if(s>=10)s=1;
                if(j!=i)printf(" ");
            }
                printf("\n");
        }
        count++;
    }
    return 0;
}

16 数字串处理

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

问题描述 :
明明的爸爸经常对明明进行数学启蒙教育。有一天他和明明做了一个游戏，对一串数字进行处理。明明的爸爸首先给明明一串数字，在这串数字中有很多数字会连续重复出现很多次，爸爸就要求明明把其中连续重复出现次数最多的那个数字找出来。如果有很多个数字连续出现的次数相同，即重复出现次数最多的数字不止一个，那就要明明找出第一次出现该重复次数的那个数字。 例如有一串数字：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），每个数字之间用一个空格隔开。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为两个整数：出现次数最多的那整数，以及它的出现次数。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

#include<stdio.h> //summershell
#include<string.h>//memset多香啊！本来想排序，但是万一多个最大值就难搞哦
int main()
{
    int n,num[101],s[101];
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<n;i++)
            scanf("%d",&s[i]);
        memset(num,0,sizeof(num));//初始化
        int i=0,count,maxlen=0,maxnum=-1;
        while(i<n)//注意题上的连续二字，开始理解错了，无情WA
        {
            count=1;
            for(int j=i+1;j<n;j++)//类似于字符串比较
            {
                if(s[i]==s[j])++count;
                else break;
            }
            if(count>maxlen){maxlen=count;maxnum=s[i];}
            i+=count;
        }
        printf("%d %d\n",maxnum,maxlen);
    }
    return 0;
}

17 公式求解

作者: 朱星垠 时间限制: 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的大小进行排序，从小到大输出。 每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。 注：通常，显示屏为标准输出设备。

#include<stdio.h>// :summershell
int main()//水题！
{
    int a,b,count=1;
    while(scanf("%d %d",&a,&b)!=EOF && (a || b))
    {
        if(count++!=1)printf("\n");
        for(int i=1;i<=100;i++)
            for(int j=1;j<=100;j++)
                if(a*a+i*i==b*b+j*j)printf("%d %d\n",i,j);
    }
    return 0;
}

18 累加式

作者: 朱星垠 时间限制: 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的累加式构成，累加式中不包含空格；每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

#include<stdio.h>// :summershell
int main()//水题！
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        int count=1,i;
        for(i=1;i<=n;i++)
        {
            if(count++!=1)printf("+");
            printf("%d",i);
        }
        for(i=n-1;i>=1;--i)
            printf("+%d",i);
        printf("\n");
    }
    return 0;
}

（交流技术，分享经验：编程交流Q群：673852347）

19 约瑟夫环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，即明明要选定的那个数。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

 
#include<stdio.h>// summershell
//由于之前方法很笨，这里我选择作弊的方法，反向推答案，因为10这个case很容易超时了
int main()
{
    int k,a[11]={0,2,7,5,30,169,441,1872,7632,1740,93313};
    while(scanf("%d",&k)!=EOF)printf("%d\n",a[k]);
    return 0;
}

（交流技术，分享经验：编程交流Q群：673852347）

//很容易超时的代码
#include<stdio.h>// summershell
#include<string.h>//约瑟夫环！扩展的循环队列喽
int main()//鄙人的代码很笨！没能研究规律，惭愧！有个case超时了
{
    int k,m,a[42];//且m值要尽量的小
    while(scanf("%d",&k)!=EOF)
    {
        for(m=1;m<=100000;++m)
        {
            int count=0,p=0;        //p指示当前出队位置
            memset(a,0,sizeof(a));//1代表出队
            while(count<k)
            {
                int i=1;
                while(i<m)
                {
                    do
                    {
                        p=(p+1)%(2*k);
                    }
                    while(a[p]==1 && count<k);//无人则调到下一个
                    i++;
                }
                if(p>=k && p<=2*k-1)
                {
                    count++;    //出队了
                    a[p]=1;
                    do
                    {
                        p=(p+1)%(2*k);
                    }
                    while(a[p]==1 && count<k);
                }
                else break;
            }
            if(count>=k)
            {
                printf("%d\n",m);
                break;
            }
        }

    }
    return 0;
}

20 整除的尾数

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

问题描述 :
一个整数，只知道前几位为a，不知道末二位，被另一个整数b除尽了，那么该数的末二位该是什么呢？
输入说明 :
第一行为T,以下T行，每行为一组测试数据,包含两个整数a，b（0<a<10000, 10<b<100）。
输出说明 :
对应每组数据，将满足条件的所有尾数在一行内输出，格式见范例。同组数据的输出，其每个尾数之间空一格，行首与行尾没有空格。

#include<stdio.h>// summershell
int main()//格式控制还是需要练呀！
{
    int T,a,b;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d %d",&a,&b);
        int count=1;
        for(int i=0;i<100;++i)
            if((a*100+i)%b==0)printf(count++==1?"%02d":" %02d",i);
        printf("\n");
    }
    return 0;
}

21 回文质数

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

问题描述 :
因为151既是一个质数又是一个回文数(从左到右和从右到左是看一样的)，所以 151 号是回文质数。写一个程序来找出范围[a,b](5<= a < b <= 100,000)间的所有回文质数
输入说明 :
仅 1 行: 二个整数 a 和 b(5<= a < b <= 100,000)。
输出说明 :
输出一个回文质数的列表，一行一个。
每行首尾无空格，最后无空行。

#include<stdio.h>// summershell
#include<string.h>
int prime[100001];//质数 我偏爱打表
void find_prime()
{
    memset(prime,0,sizeof(prime));//1代表不是质数
    for(int i=2,j;i<100001;i++)
        if(prime[i]==0)
            for(j=2*i;j<100001;j+=i)
                prime[j]=1;
}
int huiwen(int a)
{
    int temp=a,stack[10],top=-1;
    while(temp)
    {
        stack[++top]=temp%10;
        temp/=10;
    }
    while(top!=-1)
    {
        if(stack[top--]!=a%10)return 0;
        a/=10;
    }
    return 1;
}
int main()
{
    int a,b;
    find_prime();
    scanf("%d %d",&a,&b);
    while(a<=b)
        if(!prime[a++] && huiwen(a-1))printf("%d\n",a-1);//严格控制输出呀
    return 0;
}

22 汽水瓶

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

问题描述 :
有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
输入说明 :
输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。
输出说明 :
对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。

#include<stdio.h>// summershell
int drink(int n)//递归--QAQ--
{
    return n<3?n-1:1+drink(n-3+1);//不是很严谨，仅对本题来讲无bug
}
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF && n)
        printf("%d\n",drink(n));
    return 0;
}

另解法

#include<stdio.h>// summershell
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF && n)
        printf("%d\n",n/2);
    return 0;
}

23 阶乘最后的非0位

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

问题描述 :
N的阶乘写作N!表示小于等于N的所有正整数的乘积。阶乘会很快的变大，如13!就必须用32位整数类型来存储，70！即使用浮点数也存不下了。你的任务是找到阶乘最后面的非零位。举个例子,5!=12345=120所以5!的最后面的非零位是2，7！=1234567=5040，所以最后面的非零位是4。
输入说明 :
一个不大于1000的整数N。
输出说明 :
共一行，输出N!最后面的非零位。

Solution:
举个例子 525=125，我们不能单纯的取5 而是至少25.因为1254=500 最后一位是5我们就不能鲁莽的取5*4=20的2了。所以我的算法使用了a%100尽量减少错误的出现

#include<stdio.h>// summershell
int last(int a)//因为乘法的规则告诉我们，取末位非0的部分即可
{
    while(a%100==0)a/=10;
    return a%1000;
}
int main()
{
    int N,temp=1;
    scanf("%d",&N);
    while(N)
    {
        temp=last(temp)*N;
        N--;
    }
    while(temp%10==0)temp/=10;
    printf("%d\n",temp%10);
    return 0;
}

24 算菜价

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

问题描述 :
妈妈每天都要出去买菜，但是回来后，兜里的钱也懒得数一数，到底花了多少钱真是一笔糊涂帐。现在好了，作为好儿子（女儿）的你可以给她用程序算一下了，呵呵。

输入说明 :
输入含有一些数据组，第一行第一个数是测试组数，第二行第一个数据是菜种数，每组数据包括菜种（字串），数量（计量单位不论，一律为double型数）和单价（double型数，表示人民币元数），因此，每组数据的菜价就是数量乘上单价啊。菜种、数量和单价之间都有空格隔开的。
注意样例输入应是如下：
1
3
青菜 1 2
罗卜 2 1.5
鸡腿 2 4.2

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

#include<stdio.h>// summershell
int main()//水题
{
    int T,n;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        double sum=0,a,b;
        char s[128];
        for(int i=0;i<n;i++)
        {
            scanf("%s %lf %lf",s,&a,&b);
            sum+=a*b;
        }
        printf("%.1f\n",sum);

    }
    return 0;
}

（交流技术，分享经验：编程交流Q群：673852347）

25 繁殖问题

作者: 孙辞海 时间限制: 1S 章节: 一维数组

问题描述 :
有一家生化所，一月份引入一对新生的小白鼠。这对小白鼠生长两个月后，在第三、第四、第五个月各繁殖一对新小白鼠，在第六个月停止繁殖，在第七个月则死亡。新生的小白鼠也如此繁殖。问在第N个月时，活的小白鼠有多少对？
输入说明 :
你的程序需要从标准输入设备（通常为键盘）中读入多组测试数据。每组输入数据由一行组成，其中只有一个整数N（0 < N ≤ 50）。两组输入数据间无空行。
输出说明 :
对于每组测试数据，你的程序需要向标准输出设备（通常为启动该程序的文本终端）输出一行，其中只有一个整数，即第N个月时活的小白鼠有几对，所有数据前后没有多余的空行，两组数据之间也没有多余的空行。:

#include<stdio.h>// summershell
int main()//搞清题目让求当前的老鼠数，当当前老鼠数=新生+上个月的-死亡
{
    int N,newborn[55]={0,1,0,1,1,1},present[55]={0,1,1,2,3,5,7,10};
    for(int i=5;i<=52;i++)//新生的只能来自于上上,上上上,上上上上个月新生的
        newborn[i]=newborn[i-2]+newborn[i-3]+newborn[i-4];
    for(int i=8;i<=52;i++)//死亡是往前第七个月生的
        present[i]=present[i-1]+newborn[i]-newborn[i-6];
    while(scanf("%d",&N)!=EOF)
        printf("%d\n",present[N]);
    return 0;
}

26 树

作者: ZhuKai 时间限制: 10S 章节: 一维数组

问题描述 :
明明是一家地铁建设公司的职员，他负责地铁线路的规划和设计。一次，明明要在一条长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个整数，分别表示每一座地铁车站区域的两个坐标的。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个整数，即把树移走后，马路上还剩下多少棵树。每组运算结果单独占一行，其行首和行尾都没有任何空格或其他任何字符，每组运算结果与其后一组运算结果之间没有任何空行或其他任何字符，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行或其他任何字符。 注：通常，显示屏为标准输出设备。

Idea:
鉴于本题的数据不大 所以我选择循环处理

#include<stdio.h>// summershell
int main()//循环，车站内赋值为0
{
    int L,M,counter[10001],a,b;
    while(scanf("%d %d",&L,&M)!=EOF)
    {
        for(int i=0;i<10001;i++)counter[i]=1;
        while(M--)
        {
            scanf("%d %d",&a,&b);
            for(int j=a;j<=b;j++)counter[j]=0;
        }
        int sum=0;
        for(int j=0;j<=L;j++)if(counter[j])++sum;
        printf("%d\n",sum);
    }

    return 0;
}

（交流技术，分享经验：编程交流Q群：673852347）

27 约瑟夫环

作者: ZhouMingLiang 时间限制: 10S 章节: 一维数组

问题描述 :
有一次，明明的公司举行忘年会。忘年会的高潮部分是最后的抽大奖环节。公司为了增加活动的气氛，并没有按传统的抽奖方式来抽，而是进行了一个游戏：逐步逐步地淘汰人，而最后剩下的人，将会得到大奖。
这个游戏的方式如下：首先公司的全部职员围成一个圈，然后确定一个淘汰数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个整数，即淘汰人的编号的顺序，每个数之间用一个空格隔开。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

#include<stdio.h>// summershell
#include<string.h>//经典问题约瑟夫环
int main()
{
    int N,X,visit[101];//visit的0代表在环内，1不在
    while(scanf("%d %d",&N,&X)!=EOF)
    {
        memset(visit,0,sizeof(visit));
        int stays=N,number=0,pos=0;//number是第几个人
        while(stays>0)
        {
            number+=1-visit[pos];//若该位置有人则向前数数
            if(number==X)
            {
                if(stays!=N)printf(" ");
                printf("%d",pos+1);
                visit[pos]=1;//出列
                number=0;//重置
                stays--;
            }
            pos=(pos+1)%N;
        }
        printf("\n");
    }
    return 0;
}

28 最大与最小

作者: ZhouMingLiang 时间限制: 10S 章节: 一维数组

问题描述 :
明明喜欢玩游戏，而明明的爸爸也乐意陪明明玩各种各样的小游戏。但是在游戏中，明明的爸爸又十分注意培养明明的智力，他希望通过游戏，不仅让明明得到快乐，而且又能让明明学到一些知识，锻炼他的思维能力，为将来的发展打下基础。一天，明明的爸爸和明明做起了一个叫“最大与最小”的游戏，游戏的规则简单但却很有趣，就是有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个数的最小值。每组运算结果的行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。 注：通常，显示屏为标准输出设备。

#include<stdio.h>// summershell
int main()//循环，遍历！
{
    int M,N,a[101],max,min,count=1;
    while(scanf("%d %d",&M,&N)!=EOF)
    {
        for(int i=0;i<M;i++)scanf("%d",&a[i]);
        max=-100,min=1000000;
        for(int i=0;i<M;i++)
        {
            int temp=0;
            for(int j=0;j<N;j++)
            {
                temp+=a[(j+i)%M];
            }
            if(max<temp)max=temp;
            if(min>temp)min=temp;
        }
        if(count++!=1)printf("\n");
        printf("Max=%d\nMin=%d\n",max,min);
    }
    return 0;
}

29 环

作者: ZhouMingLiang 时间限制: 10S 章节: 一维数组

问题描述 :
明明喜欢玩游戏，而明明的爸爸也乐意陪明明玩各种各样的小游戏。但是在游戏中，明明的爸爸又十分注意培养明明的智力，他希望通过游戏，不仅能让明明得到快乐，而且又能让明明学到一些知识，锻炼他的思维能力，为将来的发展打下基础。
一天，明明的爸爸和明明做起了一个叫“环”的游戏。游戏的内容很简单但却很有趣，就是有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个数字，表示一种环的排列顺序，每个数字之间用一个空格隔开。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
输出说明 :
对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个整数，即有多少种符合条件的剪法。每组运算结果的行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

思路:
就是把他们切开后正序和逆序各自组成两个数

#include<stdio.h>// summershell
int main()
{
    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++)
        {
            for(int j=0;j<9;j++)
            {
                temp=(cut+j)%9;
                b[j]=a[temp];
            }
            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;
}

（交流技术，分享经验：编程交流Q群：673852347）

30 求数列项

作者: 朱凯 时间限制: 10S 章节: 一维数组

问题描述 :
数列是数学世界中一种非常有趣的数字排列规则，它使一串数字相互之间产生了某种联系，变幻无穷。很多数学家对数列产生了浓厚的兴趣，花了很多时间对其进行研究，明明就是其中的一位。一天，他又专注于一种新的数列排列规则，该排列规则满足以下条件：

1. 该数列的第一个数为1。
2. 该数列的第二个数为5。
3. 该数列的第i （其中i > 2）个数为第i - 1个数的数值加上(i - 3) × 3 + 7。
   明明很快就推算出了这个数列的前三项数字：
4. 第一项为1。
5. 第二项为5。
6. 第三项为12。（第三项的数字为第二项的数字加上(3 - 3) × 3 + 7，即第三项的数为：5 + (3 - 3) × 3 + 7 = 12）
   但是当明明还想继续把数列往下推算的时候，他发现计算量越来越大，计算难度越来越高，计算速度也越来越慢。于是，明明就求助于你这位程序设计专家，帮他写一个程序，计算出数列的前50项，然后当明明需要知道数列中的哪一项的数字时，你就把那一项的数字告诉明明。 明明的问题可以归结为：跟据一个正整数n，要求你输出题目中所描述的数列的第n项数值。
   输入说明 :
   你写的程序需要从标准输入设备（通常为键盘）中读入多组测试数据，每组测试数据仅占一行，每行仅包括一个正整数n（1 ≤ n ≤ 50）。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。
   输出说明 :
   对于每一组测试数据，你写的程序需要计算出一组相应的运算结果，并将每组运算结果依次写入到标准输出设备（通常为启动该程序的文本终端，例如Windows中的命令行终端）中。每组运算结果为一个整数，即题目中所描述的数列的第n项数值。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。

#include<stdio.h>// 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;
}

（交流技术，分享经验：编程交流Q群：673852347）