东华大学2021考研基本练习题46~90

46 特殊四位数

问题描述 :

数学一直是明明很喜欢的一门学科，不但上课认真听讲，而且还自己钻研。有一次，老师在课上讲了一种特殊的四位整数，这种整数有两个特性：

第一，它是某一个自然数的平方；

第二，它的千位数字与十位数字之和等于百位数字与个位数字之积。

然后老师就举了一个例子：1156，1156是34的平方，且1156的千位数字1加上十位数字5等于百位数字1乘以个数数字6，即1+5=1*6。

然后老师告诉同学，这是最小的一个符合以上两个特性的四位整数，接着老师就留下了作业，要让同学们回家后尽量多的找出符合这两个特性的特殊四位数。明明回家后，就开始找了起来，1157、1158、1159、……、3136，直到到了3136（3136=5656，3+3=16），明明才找到了第二个这样的特殊四位数。明明觉得这样找下去不是办法，后面还有好几千个数字要一个一个试下来，这样一定无法在睡觉前完成。于是明明就求助于你，帮他写一个程序，从小到大求出所有的这样的特殊四位数，然后当明明想要第几个这样的特殊四位数时，你就能够很快的告诉他。 如果把上述所有的特殊四位数按从小到大的顺序排列后记为S1，S2，…，Sn，…，即排在第1个位置上的特殊四位数记为S1，排在第2个位置上的特殊四位数记为S2，…，排在第n个位置上的特殊四位数记为Sn，那么明明的问题可以归结为：假如一个特殊四位数排在第n个位置上，那么这个特殊四位数Sn等于多少呢？

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行仅有一个正整数n（n不大于特殊四位数的个数），表示要求第n个特殊四位数Sn。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个正整数，表示与输入数据n相对应的那个特殊四位数Sn，每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

输入范例 :

1
2
输出范例 :

1156
3136

#include
int kaifang(int n)
{
    int i;
    for(i=1;i<100;i++)
    {
        if(i*i==n)
        {
            return 1;
        }
    }
    return 0;
}
int main()
{
    int n,i,qian,bai,shi,ge,a[20]={0},p=0;
    for(i=1000;i<10000;i++)
    {
        qian=i/1000;
        bai=(i-qian*1000)/100;
        shi=(i-qian*1000-bai*100)/10;
        ge=i%10;
        if(kaifang(i)&&qian+shi==bai*ge)
        {
            a[p++]=i;
        }
    }
    while((scanf("%d",&n))!=EOF)
    {
        printf("%d\n",a[n-1]);
    }
	return 0;
}

47 最大值

问题描述 :

为了培养明明对数学的热爱，明明的爸爸经常想出一些简单有趣且富有数学思想的游戏给明明玩。有一次，明明的爸爸在纸上写了N个数字，有正整数、负整数和0。明明的爸爸给明明一个范围，他可以选大于等于L1个且小于等于L2个的数字（L1≤L2），且这些数字必须是连续的。但是要求明明选出的数的和最大，这样说明明可能不太明白，于是明明爸爸就举了一个简单的例子。 例如有5个数字为“1”、“2”、“3”、“4”、“5”，明明可以选择大于等于1个且小于等于2个的数字，也就是说明明可以选择1个数字，或者连续的2个数字。通过观察数字串，最后我们会选2个数字，4和5，他们的和最大，为9。 明明明白爸爸的意思后，就开始玩起游戏来。但是他发现，这个游戏看似简单，其实还是有相当的难度，因为数字越多，选择数字个数范围越大，则题目越难，到后面明明有些不想玩了。于是明明就求助于你，请你帮他写一个程序，来求出和的最大值。 明明的问题可以归结为：有N个数字，从中选择出连续的M(L1≤M≤L2)个数，求出它们之和的最大值。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据有两行，每组测试数据的第一行有三个整数N(0

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个整数，即所求的最大值。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

输入范例 :

4 1 2
-1 0 1 2
5 1 2
-1 -2 -3 -4 -5
输出范例 :

3
-1

#include
int sum(int a[],int L,int length)//连续L个数，数组有效大小为length
{
    int i,num=0,j,max=-1000000;
    for(i=0;i<length;i++)
    {
        num=0;
        for(j=0;j<L;j++)
        {
            num+=a[(i+j)%length];
            if(max<num)
                max=num;
        }
    }
    return max;
}
int main()
{
    int n,i,L1,L2,a[30]={0},max;
    while((scanf("%d%d%d",&n,&L1,&L2))!=EOF)
    {
        for(i=0;i<n;i++)
        {
            scanf("%d",&a[i]);
        }
        max=sum(a,L1,n);
        for(i=L1;i<=L2;i++)
        {
            if(max<sum(a,i,n))
                max=sum(a,i,n);
        }
        printf("%d\n",max);
    }
	return 0;
}

48 数列1

问题描述 :

思维的严密性是相当重要的，尤其是在程序设计中，一个小小的错误，就可能导致无法想象的后果。明明的爸爸是一名富有经验的程序设计专家，深知思维严密的重要性。于是在明明很小的时候，就通过游戏的方式训练明明的思维严密性。今天，明明的爸爸和明明做了一个数列的游戏。

这个游戏很简单，就是有一数列，现在需要在数列中选出一个或者连续若干个数，要求这些数的和能被11整除。明明的爸爸想锻炼明明思维的严密性，因此要求明明尽可能多的找出符合条件的数列来，最好一个也不要漏掉。 例如有一数列为“11 22 33”，其中11可以被11整除，22可以被11整除，33可以被11整除，11+22=33能被11整除，22+33=55能被11整除，11+22+33=66能被11整除。所以以上一数列能被11整除的情况一共有六种。（注：虽然11+33也能被11整除，但是11和33在数列中没有连续出现，因此不算一种合理的情况。） 明明对这个游戏很感兴趣，高兴地玩了起来。由于粗心，明明总是无法一次就把所有的情况都找出来，这使得他爸爸不是很满意。于是明明爸爸决定先降低游戏的难度，事先告诉明明某一数列总共有多少种符合条件的选择数的方法，然后再让明明去选。明明的爸爸请你帮一个忙，他不想自己找出所有的情况，因此请你写一个程序，用程序来找出一共有多少种符合选数的情况，并把结果告诉他。 明明爸爸的问题可以归结为：给你一个数列，从中选出1个或连续若干个数，要求这些数的和能被11整除，问这样的选数方法一共有多少种。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据有两行，每组测试数据的第一行有一个整数n(0

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个整数，即表示一共有多少种选数方法。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

输入范例 :

10
1 1 1 1 1 1 1 1 1 1
2
11 22
输出范例 :

0
3

#include
int main()
{
    int n,i,j,k,a[60]={0},count=0,num=0;
    while((scanf("%d",&n))!=EOF)
    {
        count=0;
        for(i=0;i<n;i++)
            scanf("%d",&a[i]);
        for(i=0;i<n;i++)//循环更换每个起点
        {
            for(j=1;i+j<=n;j++)//循环更换每次选数个数s
            {
                num=0;
                for(k=0;k<j;k++)//遍历相加
                {
                        num+=a[i+k];
                }
                if(num%11==0)
                {
                   // printf("i=%d,j=%d,k=%d,num=%d\n",i,j,k,num);
                    count++;
                }
            }
        }
        printf("%d\n",count);
    }
	return 0;
}

49 修理牛棚

问题描述 :

在一个暴风雨的夜晚，农民约翰的牛棚的屋顶、门被吹飞了。 好在许多牛正在度假，所以牛棚（牛棚的总数S:1<= S<=200）没有住满。 剩下的牛一个紧挨着另一个被排成一行安置在有屋顶的牛棚来过夜。 所以有些牛棚里有牛，有些没有。

所有的牛棚有相同的宽度，且宽度设为1。 因为有些门遗失，农民约翰需要架起新的木板作为门。 他的新木材供应者将会供应他任何他想要的长度,但是供应者只能提供有限数目的木板。 农民约翰想将他购买的木板总长度减到最少。

计算拦住所有有牛的牛棚所需木板的最小总长度。

输出所需木板的最小总长度作为的答案。

说明：拦住一个牛棚需要的木板长度为1，拦住相邻的三个牛棚则需要木板长度为3。

比如有牛的牛棚编号为：

3 5 8 10 11

并且只能使用两块木板，

则第一块木板从3到5，长度为3，

第二块木板从8到11，长度为4，

因此，需要木板的总长度为7。

输入说明 :

第 1 行: M 和 C(用空格分开)

第 2 到 C+1行: 每行包含一个整数，表示牛所占的牛棚的编号。

其中：

可能买到的木板最大的数目：M(1<= M<=50);

需要安置的牛的数目C(1<= C <=S)

安置后牛所在的牛棚的编号stall_number(1<= stall_number <= S)。

输出说明 :

单独的一行包含一个整数表示所需木板的最小总长度

输入范例 :

3 5
2
4
6
8
7
输出范例 :

5

#include
#include
void qsort(int a[],int n)
{
    int i,j,t;
    for(i=0;i<n-1;i++)
        for(j=0;j<n-1-i;j++)
        {
            if(a[j]>a[j+1])
            {
                t=a[j];
                a[j]=a[j+1];
                a[j+1]=t;
            }
        }
}
int main()
{
    int i,j,a[210],b[210],m,c,len;
    //a存储牛位置，b存储两相邻牛的距离
    //显然b长度比a少1
    while(~scanf("%d%d",&m,&c))
    {
        len=0;
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        for(i=0;i<c;i++) scanf("%d",&a[i]);
        qsort(a,c);
        for(i=0;i<c-1;i++) b[i]=a[i+1]-a[i];
        qsort(b,c-1);
        for(i=0;i<c-m;i++) len+=b[i];
        if(m>c) m=c;
        printf("%d\n",len+m);
    }
}

50 按要求输出序列

问题描述 :

明明的爸爸是一位著名的数学家。他在明明很小的时候就发现明明有过人的数学天赋，因此有意培养他对数学的兴趣。一次，明明的爸爸为了培养明明对数字的敏感，和明明玩起了一个数字游戏，这个游戏的名称叫“按要求输出序列”。在游戏中，明明的爸爸给了明明一串数字，要求明明首先把这串数字中重复出现的数字删除到仅剩一个，即相同的数字只保留一个，然后将这串数字从小到大进行排序。明明很快就理解了游戏的规则，开始玩起来。明明的爸爸首先给了明明三个数字：3、2、1；明明很快就回答说：“1、2、3”。明明的爸爸惊讶于明明的反应能力，开始加大游戏的难度，给出了由6个数字组成的数字串：2、1、4、3、5、2；明明眼珠子一转，脱口而出：“1、2、3、4、5”（由于“2”出现了两次，因此要删除一个，然后再排序输出。）。明明的爸爸意识到简单的数字串难不住明明，于是决定给出很长的一串数字串来考明明。但与此同时，明明爸爸面对这很长的数字串也无法一时计算出最后的结果，于是就求助于你，让你帮他写一个程序，用来计算出数字串最后的结果。

明明的爸爸的问题可以归结为：给你一个数字串，里面有n个数字，首先对数字串中的数字进行处理，删除重复出现的数字（重复出现的数字只保留一个），然后对数字串从小到大进行排序，最后输出排序后的字符串。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据占两行：

第一行是一个正整数n（1≤n≤200），表示数字串中有n个数字，

第二行是n个数字，n个数字都大于等于0且小于等于109，每两个数字用一个空格隔开。

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

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个排序后的数字串，数字串中的数字用一个空格隔开。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

输入范例 :

5
4 2 2 6 6
9
76 19 1 2 55 37 38 55 76
输出范例 :

2 4 6
1 2 19 37 38 55 76

#include
#include
void qsort(int a[],int n)
{
    int i,j,t;
    for(i=0;i<n-1;i++)
    {
        for(j=0;j<n-i-1;j++)
        {
            if(a[j]>a[j+1])
            {
                t=a[j];
                a[j]=a[j+1];
                a[j+1]=t;
            }
        }
    }
}
int main()
{
    int i,j,n,a[210],b[210],c=0,flag=0;
    while((scanf("%d",&n))!=EOF)
    {
        flag=0;
        memset(b,-1,sizeof(b));
        for(i=0;i<n;i++)
            scanf("%d",&a[i]);
        qsort(a,n);
        for(i=0;i<n-1;i++)
            if(a[i]!=a[i+1])
                b[c++]=a[i];
            b[c]=a[n-1];
        for(i=0;i<c+1;i++)
        {
            if(b[i]!=-1)
            {
                if(flag==0) printf("%d",b[i]);
                else printf(" %d",b[i]);
                flag++;
            }
        }
        printf("\n");
    }
	return 0;
}

51 部落人乘法

问题描述 :

明明热爱数学，他的爸爸也有意培养明明对数学的兴趣。

一次，为了拓展明明的知识面，爸爸给明明讲了一个原始部落人计算乘法的方法：

据说原始部落人以小石子作为计算工具，并用减半和加倍两种运算就能求得任何两个整数的乘积。

其规则是：

左边不断除2，写下商，舍去余数；

右边不断加倍，直到左边变成1为止。

取结果的方法是：

如果某行左边是偶数，就划去整个这一行；

如果某行左边是奇数，右边剩下的数相加即可。

例如求13与15的乘积的过程是：

计算过程：

13--------15 ：13除以2等于6，舍去余数1，15乘以2等于30；

6---------30 ：6除以2等于3，30乘以2等于60；

3---------60 ：3除以2等于1，舍去余数1，60乘以2等于120；

1---------120 ：左边数字为1，停止计算。

取结果过程：

13--------15 ：左边是奇数，取15；

6---------30 ：左边是偶数，划去；

3---------60 ：取60；

1---------120 ：取120；

其结果就是： 13*15=15+60+120=195。

明明对爸爸讲的这个故事相当感兴趣，也自己动手开始模拟上面的过程计算起来。刚开始的时候，明明感觉这样计算很有趣，但是时间一长，明明就觉得这样的计算过程很麻烦。他想让你帮他写一个程序，快速的计算出上述乘法最后相加的式子和结果。

明明的问题可以归结为：给你两个整数，使用上面描述的乘法过程，输出最后的相加的式子。

输入说明 :

你的程序需要从标准输入设备（通常为键盘）中读入多组测试数据。每组测试数据占一行，其中包含两个整数a和b（1 <= a, b <= 100）。

输出说明 :

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

输入范例 :

13 15
2 4
输出范例 :

1315=15+60+120=195
24=8=8

#include
#include
int main()
{
    int a1,b1,i=0,j,k=0,left[15]={0},right[15]={0},c[15]={0},a,b,sum;
    while((scanf("%d%d",&a,&b))!=EOF)
    {
        memset(left,0,sizeof(a));
        memset(right,0,sizeof(b));
        memset(c,0,sizeof(c));
        sum=0;
        i=0;
        k=0;
        a1=a;
        b1=b;
        while(a1)
        {
            left[i]=a1;
            a1/=2;
            right[i]=b1;
            b1*=2;
            i++;
        }
        for(j=0;j<i;j++)
        {
            if(left[j]%2==1)
            {
                c[k++]=right[j];
                sum+=right[j];
            }
        }
        printf("%d*%d=%d",a,b,c[0]);
        for(i=1;i<k;i++)
            printf("+%d",c[i]);

        printf("=%d\n",sum);
    }
	return 0;
}

52 序列

问题描述 :

明明的爸爸经常用做游戏的方法启发明明对数学的兴趣。有一次，明明爸爸准备了许多盒子和球，他要和明明做一个放球的游戏。

游戏如下：要将k个小球依次装入到若干个盒子中去（可以使用的盒子数不限）。

小球装入盒子的规则如下：

1）第一个盒子不能为空。

2）依次装入各个盒子的球数必须严格递增。例如：当k=8时，装入方法有1，2，5或1，3，4。

3）装入的盒子数尽可能多。

4）所有相邻盒子的球数之差的绝对值之和最小。

如上例中：装入法1，2，5，则差的绝对值之和为(2-1)+(5-2)=4。装入法1，3，4，则差的绝对值之和为(3-1)+(4-3)=3。因此应该采用后一种装法。

明明明白了规则以后，就兴致盎然地玩起了游戏。起先明明玩得很有劲，每次都能顺利的找出最佳的装小球的方法。但是随着小球数量的增多，装小球的方法也就变得越来越多，明明就需要花更多的时间才能找到最佳的装球方法，这使得明明有些犯难了。于是明明想到了你，他想请你帮他写一个程序，他把小球的数量告诉你，而你的程序用来计算装小球的方法。

明明的问题可以归结为：告诉你小球的数量k，然后通过程序计算出盒子装小球的最佳方法。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行有一个整数k（1 ≤k ≤10000），即小球的个数。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一串整数，即表示依次放入各个盒子里的小球的个数，每两个数字之间用一个‘,’分隔。每组运算结果单独占一行，其行首和行尾都没有任何空格或其他任何字符，每组运算结果与其后一组运算结果之间没有任何空行或其他任何字符，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行或其他任何字符。 注：通常，显示屏为标准输出设备。

输入范例 :

1
8
10
输出范例 :

1
1,3,4
1,2,3,4

#include
#include
int main()
{
    int a[5000]={0},k,i,j,sum=0,allo,p;
    while((scanf("%d",&k))!=EOF)
    {
        memset(a,0,sizeof(a));
        sum=0;
        for(i=1;;i++)
        {
            sum+=i;
            if(sum<=k)
            {
                a[i]=i;
            }
            else break;
        }
        allo=k-sum+i;
        j=i-1;
        while(allo--)
        {
            a[j--]++;
        }
        for(p=1;p<i;p++)
            if(p<i-1)
                printf("%d,",a[p]);
            else printf("%d",a[p]);
        printf("\n");
    }
	return 0;
}

53 双重回文数

问题描述 :

如果一个数从左往右读和从右往左读都是一样，那么这个数就叫做回文数。例如，12321就是一个回文数，而77778就不是。当然，回文数的首和尾都应是非零的，因此0220就不是回文数。事实上，有一些数（如21），在十进制时不是回文数，但在其它进制（如二进制时为10101）时就是回文数。 编一个程序，从文件读入两个十进制数 N (1<= N <= 15) S (0

输入说明 :

只有一行，用空格隔开的两个数N和S。

输出说明 :

N行, 每行一个满足上述要求的数，并按从小到大的顺序输出。

输入范例 :

3 25
输出范例 :

26
27
28

#include
#include
int judge(int n)
{
    int i=0,j,jinzhi,a[50]={0},temp,count=0,flag=1,weishu;
    for(jinzhi=2;jinzhi<11;jinzhi++)
    {
        i=0;
        memset(a,0,sizeof(a));
        flag=1;
        temp=n;
        while(temp)
        {
            a[i++]=temp%jinzhi;
            temp/=jinzhi;
        }
        i--;
        weishu=i;
        if(a[i]==0)//开头是0直接淘汰
            break;
        for(j=0;j<=weishu/2;j++)
        {
            if(a[j]==a[i])
                i--;
            else
            {
                flag=0;
                break;
            }
        }
        if(flag)
        {
            count++;
            //printf("%d在%d进制中回文，此时count=%d,",n,jinzhi,count);
            //for(j=0;j<=weishu;j++)
                //printf("%d",a[j]);
            //printf("\n");
        }
    }
    if(count>=2)
        return n;
    else
        return 0;
}
int main()
{
    int N,S,i,j,count=0;
    while((scanf("%d%d",&N,&S))!=EOF)
    {
        count=0;
        for(i=S+1;;i++)
        {
            if(judge(i))
            {
                printf("%d\n",judge(i));
                count++;
            }
            if(count==N)
                break;
        }
    }
	return 0;
}

54 等差数列

问题描述 :

一个等差数列是一个能表示成a, a+b, a+2b,…, a+nb (n=0,1,2,3,…) 在这个问题中a是一个非负的整数，b是正整数。

写一个程序来找出在双平方数集合S中长度为n的等差数列。双平方数集合是所有能表示成p2＋q2的数的集合。

输入说明 :

第一行: N(3<= N<=25),要找的等差数列的长度。 第二行: M(1<= M<=250),搜索双平方数的上界0 <= p,q <= M。

输出说明 :

如果没有找到数列,输出`NONE’。

如果找到了，输出一行或多行, 每行由两个整数组成:a,b 这些行应该先按b排序再按a排序(均为升序)。

将不会有多于10,000个等差数列。

输入范例 :

5 7
输出范例 :

1 4
37 4
2 8
29 8
1 12
5 12
13 12
17 12
5 20
2 24

#include
#include
int main()
{
	int m,n,i,j,k,c[200000],a,b,flag;
	while((scanf("%d%d",&n,&m))!=EOF)
	{
	    flag=0;
	    memset(c,0,sizeof(c));
        for(i=0;i<=m;i++)
            for(j=0;j<=m;j++)
                c[i*i+j*j]=1;
        for(b=1;b<=2*m*m;b++)//懒得搞范围，所以在循环第一句加了if判断，更精确不会出错，也不会超时了
            for(a=0;a<=2*m*m-1;a++)
            {
                if(a+(n-1)*b>2*m*m) break;
                for(k=0;k<n;k++)
                {
                    if(c[a+b*k]!=1)
                        break;
                }
                if(k==n)
                {
                    printf("%d %d\n",a,b);
                    flag=1;
                }
            }
        if(!flag) printf("NONE\n");
	}
    return 0;
}

55 人见人爱A-B

问题描述 :

A和B是两个集合，A-B求的是两个集合的差，就是做集合的减法运算。（当然，大家都知道集合的定义，就是同一个集合中不会有两个相同的元素，这里还是提醒大家一下）呵呵，很简单吧？

输入说明 :

输入数据包含T个测试实例。

首先输入数字T，然后输入T组测试数据，每组输入数据占1行,每行数据的开始是2个整数n(0<=n<=100)和m(0<=m<=100),分别表示集合A和集合B的元素个数，然后紧跟着n+m个元素，前面n个元素属于集合A，其余的属于集合B. 每个元素为不超出int范围的整数,元素之间由一个空格隔开.

输出说明 :

针对每组数据输出一行数据,表示A-B的结果,如果结果为空集合，则输出“NULL”,否则从小到大输出结果,为了简化问题，每个元素后面跟一个空格.

输入范例 :

2
3 3 1 2 3 1 4 7
3 7 2 5 8 2 3 4 5 6 7 8
输出范例 :

2 3
NULL

#include
#include
void qsort(int a[],int n)
{
    int i,j,t;
    for(i=0;i<n-1;i++)
    {
        for(j=0;j<n-i-1;j++)
        {
            if(a[j]>a[j+1])
            {
                t=a[j];
                a[j]=a[j+1];
                a[j+1]=t;
            }
        }
    }
}
int main()
{
    int T,i,j,k,n,m,a[110]={0},b[110]={0},c[110]={0},count;
    while((scanf("%d",&T))!=EOF)
    {
        for(i=0;i<T;i++)
        {
            memset(a,0,sizeof(a));
            memset(b,0,sizeof(b));
            memset(c,0,sizeof(c));
            count=0;
            scanf("%d%d",&n,&m);
            for(j=0;j<n;j++)
                scanf("%d",&a[j]);
            for(j=0;j<m;j++)
                scanf("%d",&b[j]);
            for(j=0;j<n;j++)
            {
                for(k=0;k<m;k++)
                {
                    if(a[j]==b[k])
                    {
                        a[j]=-1;
                    }
                }
            }
            for(j=0;j<n;j++)
                if(a[j]!=-1)
                    c[count++]=a[j];
            qsort(c,count);
            if(count==0)
                printf("NULL");
            else
                for(j=0;j<count;j++)
                    printf("%d ",c[j]);
            printf("\n");
        }
    }
	return 0;
}

56 最少拦截系统

问题描述 :

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能达到前一发的高度。

某天，雷达捕捉到敌国的导弹来袭，如果系统数量太少，将导致有可能不能拦截所有的导弹。所以，根据雷达捕捉到的导弹高度，需要预先准备相应数量的拦截系统。

比如导弹的高度依次为：

5 3 4 2 4 1

则一个拦截系统的第一发炮弹必须打到高度5的地方，第二发炮弹打到高度3的地方。

但第三发炮弹打不到高度4的地方（因为每一发炮弹不能达到前一发的高度），所以要使用第二套拦截系统。

第二套拦截系统发射的炮弹高度打到4和2的高度(实际上,要拦截高度为2的炮弹,使用第一套拦截系统或者第二套都可以)，

第三套拦截系统发射的炮弹高度打到4和1的高度(实际上,要拦截高度为1的炮弹,三套拦截系统都可以)。

因此，总共需要三套拦截系统。

再比如导弹的高度依次为：

5 3 4 2 3 1

则一个拦截系统的第一发炮弹必须打到高度5的地方，第二发炮弹打到高度3的地方。

但第三发炮弹打不到高度4的地方（因为每一发炮弹不能达到前一发的高度），所以要使用第二套拦截系统。

第二套拦截系统发射的炮弹高度打到4的高度。

再要拦截高度为2的炮弹,使用第一套拦截系统或者第二套都可以，但考虑到后面还需要拦截炮弹，我们这里使用第一套拦截系统（为什么不能用第二套，自己想啦）。

再要拦截高度为3的炮弹,我们使用第二套拦截系统。

再拦截高度为1的炮弹，第一套和第二套系统都可以，我们就使用第二套吧。

因此，总共仅需要两套拦截系统，第一套拦截的是5 3 2，第二套拦截的是4 3 1。

请根据给定的高度数据，帮助计算一下最少需要多少套拦截系统。

输入说明 :

输入数据首先包括一个整数T (1<=T<= 100)，,表示测试数据的组数。

每组测试数据的第一行是一个整数N(1<= N <= 1000)，代表着导弹总个数(正整数), 接下来用N个数字代表着导弹依次飞来的高度，其中雷达给出的高度数据是不大于10000的正整数，用空格分隔。

输出说明 :

对应每组数据输出拦截所有导弹最少要配备多少套这种导弹拦截系统。

每组输出占一行，行首与行尾无空格。

输入范例 :

2
8
389 207 155 300 299 170 158 65
5
100 50 200 300 400
输出范例 :

2
4

#include
#include
int main()
{
    int T,i,j,N,daodan[1100],leida[1100],sum;
    scanf("%d",&T);
    while(T--)
    {
        sum=0;
        scanf("%d",&N);
        memset(daodan,0,sizeof(daodan));
        memset(leida,0,sizeof(leida));
        for(i=0;i<N;i++) scanf("%d",&daodan[i]);
        for(i=0;i<N;i++)
        {
            for(j=0;j<N;j++)
            {
                if(daodan[i]<leida[j])
                {
                    leida[j]=daodan[i];
                    break;
                }
                if(!leida[j])
                {
                    leida[j]=daodan[i];
                    sum++;
                    break;
                }
            }
        }
        printf("%d\n",sum);
    }
}

57 求N!

问题描述 :

给你一个整数N(0 ≤ N ≤ 10000)，你的任务是计算并输出 N!

输入说明 :

输入多行，每行一个N。

输出说明 :

对于每个输入N，在一行中输出N！

行首与行尾为空格，两组输出之间无空行。

输入范例 :

2
1
100

输出范例 :

2
1
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

#include
void print(int n)
{
    int i,j,temp,a[10001]={0},jinwei=0,max=0,length=1;
    a[0]=1;
    for(i=1;i<=n;i++)
    {
        for(j=0;j<length;j++)
        {
            temp=a[j]*i+jinwei;
            a[j]=temp%10;
            jinwei=temp/10;
            if(jinwei&&j==length-1)
                length++;
        }
    }
    //printf("max=%d\n",max);
    for(i=length-1;i>=0;i--)
        printf("%d",a[i]);
    printf("\n");
}
int main()
{
    int n;
    while((scanf("%d",&n))!=EOF)
    {
        print(n);
    }
	return 0;
}

58 素数表

问题描述 :

从键盘输入m,n

在屏幕上按每行10个的格式输出m~n之间的全部素数。

请用函数判断一个数是否素数。

输入说明 :

两个整数m n

输出说明 :

[m,n]之间(包含m和n)的素数，每行10个，每个数后跟一个空格。

输入范例 :

2 33
输出范例 :

2 3 5 7 11 13 17 19 23 29
31

#include
#include
int sushu(int n)
{
    int i;
    for(i=2;i<=sqrt(n);i++)
    {
        if(n%i==0)
            return 0;
    }
    if(n==0||n==1)
        return 0;
    return 1;
}
int main()
{
    int m,n,i,j,count=0;
    while((scanf("%d%d",&m,&n))!=EOF)
    {
        count=0;
        for(i=m;i<=n;i++)
        {
            if(sushu(i))
            {
                count++;
                printf("%d ",i);
                if(count%10==0)
                    printf("\n");
            }
        }
    }
	return 0;
}

59 倒数数列

问题描述 :

编写程序计算并输出

s=sumk=1n (1/k) = 1+1/2+1/3+…+1/n 的值。

要求定义并调用函数total(n)计算1+1/2+1/3+…+1/n

注意：此题的main函数如下所示：

int main(){

int n;

scanf("%d",&n);

printf("%.3f\n",total(n));

return 0;

}

或者：

int main(){

int n;

cin>>n;

cout<

return 0;

}

输入说明 :

正整数n，表示前n项求和

输出说明 :

s，表示前n项的和

首尾无空格

输入范例 :

2
输出范例 :

1.500

#include
double total(int n)
{
    int i;
    double sum=0;
    for(i=1;i<=n;i++)
        sum+=1.0/i;
    return sum;
}
int main(){

 int n;

 scanf("%d",&n);

 printf("%.3f\n",total(n));

 return 0;

}

60 排列数

问题描述 :

编写程序计算排列数

Pmn =m! / (m-n)!

要求定义函数fact(n)计算n的阶乘。

main函数中可使用如下形式调用：fact(m)/fact(m-n));

输入说明 :

两个数m、n

输出说明 :

Pmn

输入范例 :

3 2
输出范例 :

6

#include
int fact(int n)
{
    int i,sum=1;
    for(i=1;i<=n;i++)
        sum*=i;
    return sum;
}
int main(){

 int m,n;

 scanf("%d%d",&m,&n);

 printf("%d\n",fact(m)/fact(m-n));

 return 0;

}

61 亲和数

问题描述 :

古希腊数学家毕达哥拉斯在自然数研究中发现，

220的所有真约数(即不是自身的约数)之和为：

1+2+4+5+10+11+20+22+44+55+110＝284。

而284的所有真约数为1、2、4、71、 142，加起来恰好为220。

人们对这样的数感到很惊奇，并称之为亲和数。

一般地讲，如果两个数中任何一个数都是另一个数的真约数之和，则这两个数就是亲和数。

你的任务就编写一个程序，判断给定的两个数是否是亲和数。

请定义一个函数，传入一个数n，返回n的所有真约数之和。

输入说明 :

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

输出说明 :

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

输入范例 :

2
31604 28115
284 220
输出范例 :

NO
YES

#include
int qinhe(int a,int b)
{
    int i,sum=0;
    for(i=1;i<a;i++)
    {
        if(a%i==0)
            sum+=i;
    }
    if(sum==b)
        return 1;
    else
        return 0;
}
int main(){
    int i,M,a,b;
    while((scanf("%d",&M))!=EOF)
    {
        for(i=0;i<M;i++)
        {
            scanf("%d%d",&a,&b);
            if(qinhe(a,b)&&qinhe(b,a))
                printf("YES\n");
            else
                printf("NO\n");
        }
    }
    return 0;
}

62 分拆素数和

问题描述 :

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

说明：

比如10，可以拆成3+7和5+5以及7+3，

但是3+7与7+3相同，只算一种，5+5由于两个素数相同，不计算在内。

因此，10的拆法只有一种。

输入说明 :

首先输入一个T（不超过500），然后输入T个正的偶数，其值不会超过10000。

输出说明 :

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

输入范例 :

4
4
6
8
10

输出范例 :

0
0
1
1

#include
#include
int sushu(int n)
{
    int i;
    if(n==1||n==0)
        return 0;
    for(i=2;i<=sqrt(n);i++)
    {
        if(n%i==0)
            return 0;
    }
    return 1;
}
void fuction(int n)
{
    int i,count=0;
    for(i=2;i<n/2;i++)
    {
        if(sushu(i)&&sushu(n-i))
        {
            count++;
            //printf("%d拆为%d和%d\n",n,i,n-i);
        }
    }
    printf("%d\n",count);
}
int main(){
    int i,n,T;
    while((scanf("%d",&T))!=EOF)
    {
        for(i=0;i<T;i++)
        {
            scanf("%d",&n);
            fuction(n);
        }
    }
    return 0;
}

63 歌德巴赫猜想

问题描述 :

歌德巴赫猜想指出：任何一个大于2的偶数，都可以表示成两个素数的和。例如：8 = 3+5， 44 = 13+31等。试编程在6至100范围内验证歌德巴赫猜想。

输入说明 :

先输入一个正整数n，表示有n组测试数据。所有数据前后没有多余的空行，两组数据之间也没有多余的空行。每组输入数据由一行组成，在接下来的n行中，每行有1个偶数a（6≤a≤100），在行首和行尾没有多余的空格。

输出说明 :

对于每组输入，输出满足歌德巴赫猜想两个素数，小的素数的在前，在行首和行尾没有多余的空格。如果有多组结果，输出的第一个素数要求最小。所有数据前后没有多余的空行，两组数据之间也没有多余的空行。

输入范例 :

2
8
44
输出范例 :

3 5
3 41

#include
#include
int sushu(int n)
{
    int i;
    if(n==1||n==0)
        return 0;
    for(i=2;i<=sqrt(n);i++)
    {
        if(n%i==0)
            return 0;
    }
    return 1;
}
void fuction(int n)
{
    int i;
    for(i=2;i<=n/2;i++)
    {
        if(sushu(i)&&sushu(n-i))
        {
            printf("%d %d\n",i,n-i);
            break;
        }
    }
}
int main(){
    int i,n,T;
    while((scanf("%d",&T))!=EOF)
    {
        for(i=0;i<T;i++)
        {
            scanf("%d",&n);
            fuction(n);
        }
    }
    return 0;
}

64 N的倍数

问题描述 :

明明的爸爸在研究一个复杂的数学问题，研究了很长时间都没有结果。明明看见后就问爸爸在研究什么。明明的爸爸回答说：“我在研究一个整数的倍数问题，想找到某个数的倍数……”明明还没有等他爸爸说完，就抢着说：“这不是很简单嘛，你把这个整数乘以1，乘以2，……，就能得到很多的倍数呀。”明明的爸爸当然知道这种方法，但是他接着说：“这样的方法找倍数当然容易，但是我找的倍数有一个特点，那个倍数只能由0或1组成，且应该尽量的小。例如一个自然数2，它符合要求的那个倍数就是10。”这下明明明白为什么爸爸研究了那么多时间都还没有研究出结果了，因为随着数字的增大，找到它的符合要求的倍数越来越难。明明想帮他爸爸解决这个问题，于是他来求助于你，能否帮他爸爸写一个程序，来求一个整数的倍数，倍数仅有0或1组成，且要尽可能小。 明明的问题可以归结为：任意给定一个自然数N，寻找一个M，要求M是N的倍数，且它的所有各位数字都是由0或1组成，并要求M尽可能小。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行仅包括一个正整数N（1≤N≤100），代表要求倍数的那个整数。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个整数，即N的倍数M。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

输入范例 :

1
2
输出范例 :

1
10

#include
int judge(long long n)
{
    while(n)
    {
        if(n%10==0||n%10==1)
        {
            n/=10;
        }
        else
            return 0;
    }
    return 1;
}
int main(){
    int n;
    long long i;
    while((scanf("%d",&n))!=EOF)
    {
        for(i=1;;i++)
        {
            if(i%n==0&&judge(i))
            {
                printf("%lld\n",i);
                break;
            }
        }
    }
    return 0;
}

65 求n天后的日期

问题描述 :

写一个函数，传入年月日，计算它的第二天，并返回该日期。由用户输入年月日和一个n值，使用前述函数，计算该日期加n天的日期为多少。
输入说明 :

输入year,month,day和n共4个正整数，以空格分隔。n的值不超过2000。
输出说明 :

输出计算得到的结果年月日共3个正整数，整数之间以一个空格分隔，行首与行尾无多余空格。
输入范例 :

2000 1 1 366
输出范例 :

2001 1 1

#include
int runnian(int n)
{
    if((n%4==0&&n%100!=0)||n%400==0)
        return 1;
    else
        return 0;
}
void nextdate(int &year,int &month,int &day)
{
    if(month==1||month==3||month==5||month==7||month==8||month==10||month==12)
    {
        if(day==31)
        {
            if(month!=12)
            {
                month++;
                day=1;
            }
            else
            {
                year++;
                month=1;
                day=1;
            }
        }
        else
            day++;
    }
    else
    {
        if(month!=2)
        {
            if(day==30)
            {
                month++;
                day=1;
            }
            else
                day++;
        }
        else
        {
            if(day<28)
                day++;
            else if(day==28&&runnian(year))
                day++;
            else
            {
                month=3;
                day=1;
            }
        }
    }
}
int main(){
    int year,month,day,n,i;
    while((scanf("%d%d%d%d",&year,&month,&day,&n))!=EOF)
    {
        for(i=0;i<n;i++)
        {
            nextdate(year,month,day);
        }
        printf("%d %d %d\n",year,month,day);
    }
    return 0;
}

66 菱形输出

问题描述 :

明明这次又碰到问题了：

给定一个正整数N，明明的爸爸让他输出一个以Z开始的菱形，以后依次为Y，X…，

比如当N等于1的时候输出图形：

Z

当N等于2的时候，输出图形：（Y前没有空格，Z、X和W前一个空格）

Z

Y X

W

当N等于3的时候，输出图形（Z前两个空格，Y、X前一个空格，W前没有空格…）：

Z

Y X

W V

U T

S

明明发现当N很大的时候就不是很容易了，所以找到了你，希望你编写一个程序帮助他

明明的问题可以归结为：输入一个正整数N，输出一个以Z开始的菱形，以后依次为Y，X…。

请尝试定义函数，该函数的功能是输出以上图形的一行。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行仅包括一个正整数n（1≤n≤7）。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组输出一个以Z开始的菱形，具体格式参照样例输出。每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果之后没有空行。 注：通常，显示屏为标准输出设备。

输入范例 :

1
3
输出范例 :

Z

Z
Y X
W V
U T
S

#include
int main(){
    int i,j,n;
    char a;
    while((scanf("%d",&n))!=EOF)
    {
        if(n<1||n>7)
        {
            printf("\n");
            continue;
        }
        a='Z';
        if(n==1)
            printf("Z\n");
        else
        {
            for(i=1;i<n;i++)//上半部分
            {
                for(j=0;j<n-i;j++)
                    printf(" ");
                printf("%c",a--);
                if(i!=1)
                {
                    for(j=0;j<2*(i-2)+1;j++)
                        printf(" ");
                    printf("%c",a--);
                }
                printf("\n");
            }
            printf("%c",a--);//中间一行
            for(i=0;i<2*(n-2)+1;i++)
                printf(" ");
            printf("%c\n",a--);
            for(i=1;i<n;i++)
            {
                for(j=0;j<i;j++)
                    printf(" ");
                printf("%c",a--);
                if(i!=n-1)
                {
                    for(j=0;j<2*(n-i-2)+1;j++)
                        printf(" ");
                    printf("%c",a--);
                }
                printf("\n");
            }
        }
        printf("\n");
    }
    return 0;
}

67 三角形的个数

问题描述 :

明明的爸爸常用玩游戏的方法来激发明明对几何学的兴趣。这天明明的爸爸和明明又玩起了有关三角形的游戏。

明明爸爸对明明说：“我们能不能构造一个周长为15的三角形？” “太简单了，”明明说道：“三条边长都是5的三角形，它的周长不就是15吗？” “明明真聪明，算得真快。”明明爸爸接着说：“可是，我不想要三条边都相等的三角形哪！” 明明大眼睛一转，说道：“那也好办啊，我只要对这个等边三角形的一条边减去一个数，再把这个数加到另一条边上就可以得到一个新的周长为15的三角形。例如，在第一条边上减去1，在第二条边上加上1，这样不就可以得到一个周长为15的新的三角形了吗？” “哇，明明太聪明了”爸爸称赞道。“对，如果把第一条边上减去的1加到第三条边上去不就又可以得到周长为15的另外一个新三角形了吗？”爸爸模仿着明明的方法和语气。 “不对呀，爸爸。你构造的三角形和我构造的三角形是同样的三角形。爸爸你看，我的三角形三条边分别长为4、6、5，而你的三角形三条边分别长为4、5、6，将三条边按其边长排序后都得到4、5、6，所以它们是同一个三角形，不是两个不同的三角形。” “啊，还是明明聪明。那还有没有其他周长为15的三角形吗？” “当然有啦。三条边边长分别为4、4、7的三角形，它的周长就是15，不过你可能不喜欢它，因为它有两条边的边长相等。” 明明和爸爸玩了一下午这样的三角形游戏，明明一共又构造了另外两个他认为他爸爸喜欢的三角形，即边长分别为2、6、7的三角形和边长分别为3、5、7的三角形。

晚上，明明躺在床上还在思考：如果周长不是15，而是90，那么爸爸喜欢的三角形有多少个呢？

明明的问题可以归结为：根据一个正整数n（3 ≤ n ≤ 100），要求统计出同时满足下列条件的三角形的个数：

边长都是整数。

周长为n。

边长两两不相等。

之所以有上述第一个条件，那是因为明明只知道正整数，没有学过分数和实数，因此他构造出的三角形的边长均为正整数。 请你写一个程序来帮助明明计算出他认为他爸爸喜欢的三角形的个数。

输入说明 :

你写的程序需要从标准输入设备（通常为键盘）中读入多组测试数据，每组测试数据仅占一行，每行仅包括一个正整数n（3 ≤ n ≤ 100），代表需要被统计的三角形的周长，n的前后都没有任何空格。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果依次写入到标准输出设备（通常为启动该程序的文本终端，例如Windows中的命令行终端）中。每组运算结果为一个大于等于0的整数构成，即满足条件的三角形的个数。例如：测试数据n为15时，运算结果应为3。输出时，每组运算结果占一行，其行首和行尾都没有任何空格或其他字符，每组运算结果与其后一组运算结果之间没有任何空行或其他字符，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行或其他字符。

输入范例 :

15
30
输出范例 :

3
12

#include
int judge(int a,int b,int c)
{
    if((a+b>c)&&(a+c>b)&&(b+c>a)) return 1;
    else return 0;
}
int main(){
    int i,j,k,n,count;
    while((scanf("%d",&n))!=EOF)
    {
        count=0;
        for(i=1;i<n/2;i++)//第一条边
        {
            for(j=i+1;j>i;j++)//第二条边
            {
                k=n-i-j;
                if(k<=j) break;
                else
                {
                    if(judge(i,j,k))
                    {
                        //printf("%d %d %d\n",i,j,k);
                        count++;
                    }
                }
            }
        }
        printf("%d\n",count);
    }
    return 0;
}

68 素数

问题描述 :

明明的爸爸是一位数学家，明明受他爸爸的影响从小就喜欢数学，经常向他爸爸学习或请教数学问题。一天，明明问他爸爸什么是素数，明明的爸爸回答说：“首先，素数都是大于1的自然数；其次，素数是只能被1和其本身整除的数。例如‘3’这个数，它只能被1和3这两个整数整除，因此‘3’就是素数；但是‘4’就不是素数，因为4除了能被1和4整除外，还能被2整除，因此‘4’就不是一个素数。”明明对于爸爸的回答很满意，也很快明白了素数的定义。于是明明的爸爸就问明明：“明明，你现在知道了什么是素数，那我现在给你一个整数区间，你能告诉我在这个区间里，一共有多少个素数吗？” 例如：一个区间为[1，10]，则在这个区间里一共有2、3、5、7，总共4个素数。 明明想了想，觉得这很简单，就说：“没问题。”于是明明爸爸就给了明明一个很大的区间，这下明明有点犯难了，由于区间太大，一个一个算过了会很花时间。聪明的明明想到了你，你总是乐于助人。明明想让你帮他写一个程序，用来计算在某一个整数区间内一共有多少个素数。 明明的问题可以归结为：给你一个整数区间，求出在这个区间里共有多少个素数。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅有一行，每组测试数据有两个正整数M，N(0 < M ≤ N ≤ 1000000)，表示一个整数区间。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个整数，即区间[M, N]内一共有多少个素数。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

输入范例 :

1 10
10 30
输出范例 :

4
6

#include
#include
int judge(int n)
{
    int i;
    for(i=2;i<=sqrt(n);i++)
        if(n%i==0) return 0;
    if(n==1)return 0;
    return 1;
}
int main(){
    int i,m,n,count;
    while((scanf("%d%d",&m,&n))!=EOF)
    {
        count=0;
        for(i=m;i<=n;i++)
            if(judge(i)) count++;
        printf("%d\n",count);
    }
    return 0;
}

69 杨辉三角

问题描述 :

还记得中学时候学过的杨辉三角吗？

基本的特征是：

前提：端点的数为1.

每个数等于它上方两数之和。

每行数字左右对称，由1开始逐渐变大。

第n行的数字有n项。

你可以参考以下的图形：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
　 1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1
…

输入说明 :

输入数据首先包含一个正整数T ( T < 10 )，表示有 T 组测试数据, 每组测试数据只包含一个正整数n（1 <= n <= 20），表示将要输出的杨辉三角的层数。

输出说明 :

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

输出时，每一行的开头的“1”前面不需要空格，结尾的“1”后面也没有空格。

输入范例 :

2
5
8
输出范例 :

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1

#include
#include
int main(){
    int i,j,k,T,n,a[30][30];
    while((scanf("%d",&T))!=EOF)
    {
        for(i=0;i<T;i++)
        {
            memset(a,0,sizeof(a));
            scanf("%d",&n);
                a[0][0]=1;
            for(j=1;j<=n;j++)
                for(k=1;k<=j;k++)
                    a[j][k]=a[j-1][k-1]+a[j-1][k];
            for(j=1;j<=n;j++)
            {
                 for(k=1;k<=j;k++)
                 {
                     printf("%d",a[j][k]);
                     if(k<j) printf(" ");
                 }
                 printf("\n");
            }
            printf("\n");
        }
    }
    return 0;
}

70 矩阵问题

问题描述 :

从键盘上输入一个整数N，按以下规律输出一个(2N+1)*(2N+1)的矩阵：

对角线的值为1，

上半三角区域值为2，

下半三角区域值为3，

左半三角区域的值为4，

右半三角区域的值为5。

输入说明 :

你的程序需要从标准输入设备（通常为键盘）中读入多组测试数据。每组测试数据数据占一行，大于零，小于等于8。

输出说明 :

对每组测试数据，你的程序需要向标准输出文件（通常为启动该程序的终端）依次输出符合要求的矩阵，每行数据与数据之间以空格分隔，在行首和行尾不要输出多余的空格。在所有数据前后，以及两组数据之间不要输出多余的空行。

输入范例 :

1
8
输出范例 :

1 2 1
4 1 5
1 3 1
1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1
4 1 2 2 2 2 2 2 2 2 2 2 2 2 2 1 5
4 4 1 2 2 2 2 2 2 2 2 2 2 2 1 5 5
4 4 4 1 2 2 2 2 2 2 2 2 2 1 5 5 5
4 4 4 4 1 2 2 2 2 2 2 2 1 5 5 5 5
4 4 4 4 4 1 2 2 2 2 2 1 5 5 5 5 5
4 4 4 4 4 4 1 2 2 2 1 5 5 5 5 5 5
4 4 4 4 4 4 4 1 2 1 5 5 5 5 5 5 5
4 4 4 4 4 4 4 4 1 5 5 5 5 5 5 5 5
4 4 4 4 4 4 4 1 3 1 5 5 5 5 5 5 5
4 4 4 4 4 4 1 3 3 3 1 5 5 5 5 5 5
4 4 4 4 4 1 3 3 3 3 3 1 5 5 5 5 5
4 4 4 4 1 3 3 3 3 3 3 3 1 5 5 5 5
4 4 4 1 3 3 3 3 3 3 3 3 3 1 5 5 5
4 4 1 3 3 3 3 3 3 3 3 3 3 3 1 5 5
4 1 3 3 3 3 3 3 3 3 3 3 3 3 3 1 5
1 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 1

#include
#include
int main(){
    int i,j,k,n,a[20][20],startrow,startcol;
    while((scanf("%d",&n))!=EOF)
    {
        memset(a,0,sizeof(a));
        startrow=1;
        for(i=0;i<n;i++)//上半部分
        {
            for(j=i+1;j<2*(n-i)+i;j++)
                a[i][j]=2;
        }
        for(i=2*n;i>=n+1;i--)//下半部分
        {
            for(j=2*n-i+1;j<2*(n-2*n+i)+2*n-i;j++)
                a[i][j]=3;
        }
        for(j=0;j<n;j++)//左半部分
        {
            for(i=j+1;i<2*(n-j)+j;i++)
                a[i][j]=4;
        }
        for(j=2*n;j>=n+1;j--)//右半部分
        {
            for(i=2*n-j+1;i<2*(n-2*n+j)+2*n-j;i++)
                a[i][j]=5;
        }
        for(i=0;i<2*n+1;i++)
            a[i][i]=1;
        i=0;
        for(j=2*n;j>=0;j--)
            a[i++][j]=1;
        for(i=0;i<2*n+1;i++)
        {
            for(j=0;j<2*n+1;j++)
            {
                printf("%d",a[i][j]);
                if(j<2*n) printf(" ");
            }
            printf("\n");
        }
    }
    return 0;
}

71 发牌

问题描述 :

编制一个模拟发牌的程序。有编号为1，2，3，4四个人，将一付去掉大小怪的扑克按照如下顺序排列梅花c0-c12，方块d0-d12，红桃h0–h12，黑桃s0-s12，然后按照1，2，3，4四个人的顺序发牌，问最后每个人手上的牌有哪些。

输入说明 :

你的程序需要从标准输入设备（通常为键盘）中读入多组测试数据。每组输入数据由一行组成。每组数据包含一个在1到4之间的整数，代表四个人中的一个，在行首和行尾没有多余的空格。

输出说明 :

对每组测试数据，你的程序需要向标准输出设备（通常为启动该程序的终端）依次输出一组对应的答案。对于每组输入，输出那个人手上的牌。每组一行。每行包括13张牌，每张牌由牌的花色和牌的大小组成。牌的花色和牌的大小之间有一个空格，前后两张牌之间也有一个空格。其余数据前后没有多余的空格，两组数据之间也没有多余的空行。

输入范例 :

1
2

输出范例 :

c 0 c 4 c 8 c 12 d 3 d 7 d 11 h 2 h 6 h 10 s 1 s 5 s 9
c 1 c 5 c 9 d 0 d 4 d 8 d 12 h 3 h 7 h 11 s 2 s 6 s 10

#include
#include
int main(){
    int i,j,n,num[52]={0};
    char s[52][5]={0},zifu[4][2]={"c","d","h","s"};
    for(i=0;i<52;i++)
        num[i]=i%13;
    for(j=0;j<52;j++)
    {
        strcpy(s[j],zifu[j/13]);
    }
    while((scanf("%d",&n))!=EOF)
    {
        for(i=n;i<=52;i+=4)
        {
            printf("%s ",s[i-1]);
            printf("%d",num[i-1]);
            if(i+4<=52)
                printf(" ");
        }
        printf("\n");
    }
    return 0;
}

72 数字金字塔

问题描述 :

考虑在下面被显示的数字金字塔（第n行有n列）。写一个程序来计算从最高点开始在底部任意处结束的路径经过数字的和的最大。每前进一步可以走到它的正下方或者右下方（往下一行、往右一列）的位置。

7

3 8

8 1 0

2 7 4 4

4 5 2 6 5

在上面的样例中,从7 到 3 到 8 到 7 到 5 的路径产生了最大和:30

输入说明 :

第一个行包含 R(1<= R<=1000) ,表示行的数目。后面每行为这个数字金字塔特定行包含的整数。所有的被供应的整数是非负的且不大于100。

输出说明 :

输出仅一行，包含那个可能得到的最大的和。

输入范例 :

6
7
3 8
8 1 0
2 7 4 100
4 5 2 6 5
3 2 5 8 7 6
输出范例 :

129

#include
#include
int main(){
    int i,j,k,a[110][110]={0},n;
    while((scanf("%d",&n))!=EOF)
    {
        memset(a,0,sizeof(a));
        for(i=0;i<n;i++)
            for(j=0;j<=i;j++)
                scanf("%d",&a[i][j]);
        for(i=n-2;i>=0;i--)
            for(j=0;j<=i;j++)
                if(a[i+1][j]>a[i+1][j+1])
                    a[i][j]+=a[i+1][j];
                else a[i][j]+=a[i+1][j+1];
        printf("%d\n",a[0][0]);
    }
    return 0;
}

73 稀疏矩阵

问题描述 :

今天明明学到了什么叫做矩阵，但他发现要将一个矩阵输入进电脑是一件很麻烦的事。特别是有些矩阵很大，且大部分元素都是0，我们称这类矩阵为稀疏矩阵。 于是，明明发明了一种简单的表示方法，只指出矩阵中非零元素来表示该矩阵。

例如一个矩阵：

0 0 0 5

2 0 0 0

0 1 0 0

0 0 4 0

可以表示成：

1 4 5

2 1 2

3 2 1

4 3 4

但明明又开始力不从心了，于是再一次想到了你…

明明的问题可以归结为：试编程将一个稀疏矩阵a转换成只存放非零元素的矩阵b，即找出每个不是0的元素，按从左到右从上到下的顺序，输出其所在的行和列以及它的值。

输入说明 :

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

每组数据的第一行包括两个整数，M和N，用空格隔开，表示矩阵大小为M * N（1 ≤ M, N ≤ 20），之后的M行每行有N个整数，也用空格隔开，整数的大小不会超出int型，且必有一个数非零。行首行尾没有空格，每组测试数据之间也没有多余空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。对应每组输入数据，用明明的矩阵表示法输出该矩阵，即找出每个不是0的元素，按从左到右从上到下的顺序，输出其所在的行和列(行、列下标从1开始)以及它的值。其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。 注：通常，显示屏为标准输出设备。

输入范例 :

4 4
0 0 0 5
2 0 0 0
0 1 0 0
0 0 4 0
2 1
1
1
输出范例 :

1 4 5
2 1 2
3 2 1
4 3 4

1 1 1
2 1 1

#include
#include
int main(){
    int i,j,k,a[30][30]={0},m,n,flag=0;
    while((scanf("%d%d",&m,&n))!=EOF)
    {
        if(flag)
            printf("\n");
        memset(a,0,sizeof(a));
        for(i=0;i<m;i++)
            for(j=0;j<n;j++)
                scanf("%d",&a[i][j]);
        for(i=0;i<m;i++)
            for(j=0;j<n;j++)
                if(a[i][j])
                    printf("%d %d %d\n",i+1,j+1,a[i][j]);
        flag++;
    }
    return 0;
}

74 矩阵转换

问题描述 :

明明是一个很聪明的孩子，学什么东西都很快。但是他也有个缺点，就是不愿意做重复的劳动，往往学会一样东西以后，就不太愿意再去碰它。有一天，明明在数学课上学了矩阵的转换，即有一个r×r的矩阵，把矩阵中的数以左上到右下的对角线的方式进行交换，然后形成一个新的矩阵。

例如：有个3×3的矩阵如下：

1 2 3

4 5 6

7 8 9

通过以左上到右下的对角线交换后，形成了一个新的矩阵：

1 4 7

2 5 8

3 6 9

明明很快就学会了，然后自己动手做了几个类似的转换。但是，课后老师布置了很多矩阵转换的作业，让同学回家练习，这就使明明很厌烦了，觉得自己已经学会了，就没有再练习的必要了。于是明明就请你帮个忙，帮他写一个程序，来计算矩阵的交换，帮他完成老师布置的作业。

明明的问题可以归结为：有一个r×r的矩阵，把矩阵中的数以左上到右下的对角线的方式进行转换，然后输出转换后的矩阵。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据有多行，每组测试数据的第一行有一个整数r（1≤r≤10），表示一个r×r的矩阵，接下来有r行，每行有r个整数，表示要转换的矩阵中的数，每个数用一个空格隔开。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个转换后的矩阵。每组运算结果形成r行数据，每一行的数字之间以一个空格分隔，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。 注：通常，显示屏为标准输出设备。

输入范例 :

4
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
2
1 3
2 4
输出范例 :

1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16

1 2
3 4

#include
#include
int main(){
    int i,j,k,a[20][20]={0},n,flag=0,temp;
    while((scanf("%d",&n))!=EOF)
    {
        if(flag) printf("\n");
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                scanf("%d",&a[i][j]);
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                if(i>j)
                {
                    temp=a[i][j];
                    a[i][j]=a[j][i];
                    a[j][i]=temp;
                }
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                printf("%d",a[i][j]);
                if(j<n-1) printf(" ");
            }
            printf("\n");
        }
        flag++;
    }
    return 0;
}

75 魔方阵

问题描述 :

在一次数学课上，明明的老师讲了一种非常有趣的方阵，称之为三阶魔方阵。

它是一个三行三列，由1、2、3、……8、9，九个数字共同构成，且它每行、每列、两对角线之和均相等，于是一个合法的三阶魔方阵就形成了以下的方阵：

8 1 6

3 5 7

4 9 2

富有钻研精神的明明回家后，马上就对三阶魔方阵进行研究。

他总结出了5条n阶魔方阵的规律(n为奇数)，如下：

（1） 将“1”放在第一行（最上面一行）中间一列；

（2） 从“2”开始直到n*n为止各数依次按下列规则存放：每一个数存放的行的行数比前一个数的行数减1，每一个数存放的列的列数比前一个数的列数加1，即前一个数的右上方。

（3） 如果上一数的行数为1，则下一个数的行数为n（指最下面一行）；

（4） 当上一个数的列数为n时，下一个数的列数应为1（指最左一列）；

（5） 如果按上面规则确定的位置上已有数，或上一个数是第一行第n列时，则把下一个数放在上一个数的下面。

有了以上的方法，明明就可以轻易地构造出任意的n阶魔方阵。

例如构造3阶魔方阵的过程如下：

先将1放在第一行的中间一列：

放1：（参考规则1）

• 1 *

---

---

放2：（参考规则3）

• 1 *

---

• • 2

放3：（参考规则4）

• 1 *

3 * *

• • 2

放4：（参考规则5）

• 1 *

3 * *

4 * 2

放5：（参考规则2）

• 1 *

3 5 *

4 * 2

放6：（参考规则2）

• 1 6

3 5 *

4 * 2

放7：（参考规则5）

• 1 6

3 5 7

4 * 2

放8：（参考规则4）

8 1 6

3 5 7

4 * 2

放9：（参考规则3）

8 1 6

3 5 7

4 9 2

但是随着n的不断增大，构建一个n阶魔方阵所花的精力就越多。于是明明就请你帮忙，帮助他用程序来构建n阶魔方阵。

明明的问题可以归结为：给你一个阶数n，请你按照题目中描述的方法，构造出n阶魔方阵。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行仅包括一个正整数n（1≤n≤19，且n是奇数），表示要构造的魔方阵阶数。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。输出时，每组运算结果为n阶魔方阵。每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。 注：通常，显示屏为标准输出设备。

输入范例 :

5
3
输出范例 :

17 24 1 8 15
23 5 7 14 16
4 6 13 20 22
10 12 19 21 3
11 18 25 2 9

8 1 6
3 5 7
4 9 2

#include
#include
int main(){
    int i,j,n,a[30][30]={0},row,col,rowl,coll,flag=0;
    while((scanf("%d",&n))!=EOF)
    {
        if(flag) printf("\n");
        memset(a,0,sizeof(a));
        row=0;
        col=n/2;
        for(i=1;i<=n*n;i++)
        {
            a[row][col]=i;
            rowl=(row-1+n)%n;
            coll=(col+1)%n;
            if(a[rowl][coll]||(row==0&&col==n-1))
                row++;
            else
            {
                row=rowl;
                col=coll;
            }

        }

        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                printf("%d",a[i][j]);
                if(j<n-1) printf(" ");
            }
            printf("\n");
        }
        flag++;
    }
    return 0;
}

76 最大效益

问题描述 :

明明的爸爸开了一家小公司，公司里有5名职员。今天，公司接待了5位客户。明明的爸爸知道，和任何一位客户谈判并签下合同都要花一整天的时间，而他又希望在一天之内，和这5位客户都签好合同。因此，明明的爸爸要求公司里的5名职员分别与1位客户谈判。

明明的爸爸也知道，这5名职员和5位客户的性格各不相同。因此，不同的职员与不同的客户谈判，会给公司带来不同的经济效益。他现在要做出一个决策，让5名职员分别与哪位客户谈判，才能让公司今天的总经济效益最大。

明明的爸爸首先做了一张5行5列的效益表，如下所示：

1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1

在这张效益表中，每行代表一名公司职员，每列代表一个客户，每行中的5个数字就表示了当该行所代表的公司职员和每位客户谈判时所能产生的效益。明明的爸爸就要通过这张效益表来决定哪位职员与哪位顾客谈判，然后能够使公司的效益最大。就拿上面这张表来看，由于无论哪位职员与哪位客户谈判，所产生的效益都是1，因此最大的效益就是5。这是最简单的一种情况，但是当效益表里的数字变得复杂，就很难进行选择，到底哪种组合方式才是最优的。因此明明的爸爸求助于你，帮助他解决这个问题。

明明的爸爸的问题可以归结为：给你一张5行5列的效益表，表中的数字均为大于等于0的整数，要求在这张表中选出5个数字，使这5个数字的和最大。（注：这5个数字分别来自表中的不同行不同列，即同一行只能选择一个数字，同一列也只能选择一个数字。）

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据。每组测试数据占5行；每行包含5个正整数；第i行的第j个正整数Aij代表第i名职员与第j位客户谈判能为公司带来的经济效益（0≤Aij≤100, 1≤i,j≤5）。每组测试数据与其后一组测试数据之间没有任何空行；第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个整数s，即这一天中公司的最大可能总经济效益。例如：当测试数据中的所有Aij（1≤i,j≤5）均为1时，运算结果s应为5。输出时，每组运算结果s单独占一行，其行首和行尾都没有任何空格或其他任何字符；每组运算结果与其后一组运算结果之间没有任何空行或其他任何字符，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行或其他任何字符。

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

输入范例 :

98 97 96 95 94
1 2 3 4 5
11 22 33 44 55
66 77 88 99 1
13 32 64 7 86
输出范例 :

318

#include
int main(){
    int i,j,k,a[5][5]={0},max=-1,maxi,maxj,sum;
    while((scanf("%d",&a[0][0]))!=EOF)
    {
        sum=0;
        for(i=1;i<5;i++)
            scanf("%d",&a[0][i]);
        for(i=1;i<5;i++)
            for(j=0;j<5;j++)
                scanf("%d",&a[i][j]);
        for(k=0;k<5;k++)
        {
            max=-1;
            for(i=0;i<5;i++)
                for(j=0;j<5;j++)
                    if(max<a[i][j])
                    {
                        max=a[i][j];
                        maxi=i;
                        maxj=j;
                    }
            for(i=0;i<5;i++)
                a[maxi][i]=-1;
            for(i=0;i<5;i++)
                a[i][maxj]=-1;
            sum+=max;
        }
        printf("%d\n",sum);
    }
    return 0;
}

77 螺旋方阵

问题描述 :

明明在上学的时候，参加数学兴趣班。在班上，老师介绍了一种非常有趣的方阵，称之为螺旋方阵。该方阵一共由n×n个正整数构成（我们称之为n阶螺旋方阵），即共有n行n列。

方阵中的数字从1开始递增，数字的排序规则是从左上角出发由1开始排序，并按顺时针方向旋进，即先排最外面的一圈，然后排里面的一圈，以此类推，直到排到最后一个数为止。

例如一个4阶的螺旋方阵，一共有4×4=16个正整数构成，数字从1递增到16，最后排出来的方阵如下：

1 2 3 4

12 13 14 5

11 16 15 6

10 9 8 7

明明回家后想自己动手构造这样的螺旋方阵。他从n=1开始构造，但是他发现当n越来越大时，螺旋方阵的复杂性就越高，然后构造出来的方阵就越容易出错。为了降低构造方阵的出错率，提高构造速度，明明就求助于你，请你帮他写一个程序，来构造螺旋方阵。 明明的问题可以归结为：给你一个正整数n，请你按题目描述中所述的方法，构造出n阶的螺旋方阵。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行仅有一个正整数n（1≤n≤10），即所要构造的螺旋方阵的阶数。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个n阶的螺旋方阵，方阵中的数字用一个空格隔开，具体形式请参考输出样例。每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果之后没有空行。 注：通常，显示屏为标准输出设备。

输入范例 :

9
4

输出范例 :

1 2 3 4 5 6 7 8 9
32 33 34 35 36 37 38 39 10
31 56 57 58 59 60 61 40 11
30 55 72 73 74 75 62 41 12
29 54 71 80 81 76 63 42 13
28 53 70 79 78 77 64 43 14
27 52 69 68 67 66 65 44 15
26 51 50 49 48 47 46 45 16
25 24 23 22 21 20 19 18 17

1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7

#include
#include
int main(){
    int i,j,n,num,a[11][11],count;
    while((scanf("%d",&n))!=EOF)
    {
        memset(a,0,sizeof(a));
        i=j=count=0;
        num=1;
        while(true)
        {
            for(;j<n-count;j++)
                if(!a[i][j])
                    a[i][j]=num++;
            j--;i++;
            for(;i<n-count;i++)
                if(!a[i][j])
                    a[i][j]=num++;
            i--;j--;
            for(;j>=0+count;j--)
                if(!a[i][j])
                    a[i][j]=num++;
            i--;j++;
            for(;i>=0+count;i--)
                if(!a[i][j])
                    a[i][j]=num++;
            i+=2;j++;
            count++;
            if(num==n*n+1)
                break;
        }
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                printf("%d",a[i][j]);
                if(j<n-1) printf(" ");
            }
            printf("\n");
        }
    }
    return 0;
}

78 方块转换

问题描述 :

一块N x N（1=

写一个程序来找出将原始图案按照以下列转换方法转换成新图案的最小方式：

#1：转90度：图案按顺时针转90度。

#2：转180度：图案按顺时针转180度。

#3：转270度：图案按顺时针转270度。

#4：反射：图案在水平方向翻转（形成原图案的镜像）。

#5：组合：图案在水平方向翻转，然后按照#1-#3之一转换。

#6：不改变：原图案不改变。

#7：无效转换：无法用以上方法得到新图案。

如果有多种可用的转换方法，请选择序号最小的那个。

比如：

转换前：

 @-@
 ---
 @@-

转换后：
 @-@
 @--
 --@

这种转换采取#1（按顺时针转90度）即可。

注意：图案中的字符“@”和“-”在转90度后，还是“@”和“-”。不要认为“-”转90度后变成“|”。

输入说明 :

第一行： 单独的一个整数N。

第二行到第N+1行： N行,每行N个字符（不是’@‘就是’-’）；这是转换前的正方形。

第N+2行到第2*N+1行： N行,每行N个字符（不是’@‘就是’-’）；这是转换后的正方形。

输出说明 :

单独的一行包括1到7之间的一个数字（在上文已描述）表明需要将转换前的正方形变为转换后的正方形的转换方法。

输入范例 :

3
 --@
 --@
 ---
 @@-
 ---
 ---

输出范例 :

3

#include
#include
int turn90(char a[][20],char b[][20],int n)
{
    int i,j;
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            if(a[i][j]!=b[j][n+1-i])
                return 0;
    return 1;
}
int turn180(char a[][20],char b[][20],int n)
{
    int i,j;
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            if(a[i][j]!=b[n+1-i][n+1-j])
                return 0;
    return 1;
}
int turn270(char a[][20],char b[][20],int n)
{
    int i,j;
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            if(a[i][j]!=b[n+1-j][i])
                return 0;
    return 1;
}
int mirror(char a[][20],char b[][20],int n)
{
    int i,j;
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            if(a[i][j]!=b[i][n+1-j])
                return 0;
    return 1;
}
int assemble(char a[][20],char b[][20],int n)
{
    int i,j;
    char c[20][20];
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            c[i][j]=a[i][n+1-j];
    if(turn90(c,b,n)||turn180(c,b,n)||turn270(c,b,n))
        return 1;
    return 0;
}
int nochange(char a[][20],char b[][20],int n)
{
    int i,j;
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            if(a[i][j]!=b[i][j])
                return 0;
    return 1;
}
int main(){
    int i,j,n;
    char a[20][20],b[20][20];
    while((scanf("%d",&n))!=EOF)
    {
        for(i=1;i<=n;i++)
        {
            getchar();
            getchar();
            for(j=1;j<=n;j++)
                scanf("%c",&a[i][j]);
        }
        for(i=1;i<=n;i++)
        {
            getchar();
            getchar();
            for(j=1;j<=n;j++)
                scanf("%c",&b[i][j]);
        }
        /**
        printf("--------------------------\n");
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
                printf("%c ",a[i][j]);
            printf("\n");
        }
        printf("--------------------------\n");
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
                printf("%c ",b[i][j]);
            printf("\n");
        }
        printf("--------------------------\n");*/
        if(turn90(a,b,n))
            printf("1\n");
        else if(turn180(a,b,n))
            printf("2\n");
        else if(turn270(a,b,n))
            printf("3\n");
        else if(mirror(a,b,n))
            printf("4\n");
        else if(assemble(a,b,n))
            printf("5\n");
        else if(nochange(a,b,n))
            printf("6\n");
        else printf("7\n");
    }
    return 0;
}

79 阵列（待解决）

问题描述 :

明明在上学的时候，参加数学兴趣班。在班上，老师介绍了一种非常有趣的阵列。

该阵列由n个正整数构成，阵列中的数字从1开始递增，数字的排序规则是从1开始由中间逆时针向外转出，2出现在1的下面，然后直至输出n为止。

例如当n=5的时候，阵列如下：

5

1 4

2 3

当n=9时，阵列如下：

7 6 5

8 1 4

9 2 3

当n=10时，阵列如下：

7 6 5

8 1 4

9 2 3

10

明明回家后想自己动手构造这样的阵列。他从n=1开始构造，但是他发现当n越来越大时，阵列的复杂性就越高，然后构造出来的阵列就越容易出错。为了降低构造阵列的出错率，提高构造速度，明明就求助于你，请你帮他写一个程序，来构造这样的阵列。

明明的问题可以归结为：给你一个正整数n，请你按题目描述中所述的方法，构造出阵列。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行仅有一个正整数n（1≤n≤99），即所要构造的阵列的大小。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个大小为n的阵列，阵列中的数字用一个空格隔开，具体形式请参考输出样例： 当n为个位数时，输出的每个数占1位，当n为两位数时，两位数所在的列输出的每个数占2位(不足2位的左边补空格)。 每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果之后没有任何空行。 注：通常，显示屏为标准输出设备。

输入范例 :

5
45
10

输出范例 :

5
1 4
2 3

43 42 41 40 39 38 37
44 21 20 19 18 17 36
45 22 7 6 5 16 35
23 8 1 4 15 34
24 9 2 3 14 33
25 10 11 12 13 32
26 27 28 29 30 31

7 6 5
8 1 4
9 2 3
10

80 饲料调配

问题描述 :

农夫约翰从来只用调配得最好的饲料来为他的奶牛。

饲料用三种原料调配成：大麦，燕麦和小麦。他知道自己的饲料精确的配比，在市场上是买不到这样的饲料的。他只好购买其他三种混合饲料（同样都由三种麦子组成），然后将它们混合，来调配他的完美饲料。

给出三组整数，表示 大麦：燕麦：小麦 的比例，找出用这三种饲料调配 x：y：z 的饲料的方法。

例如，给出目标饲料 3：4：5 和三种饲料的比例：

1:2:3

3:7:1

2:1:2

你必须编程找出使这三种饲料用量最少的方案，要是不能用这三种饲料调配目标饲料，输出’NONE’。'用量最少’意味着三种饲料的用量（整数）的和必须最小。

对于上面的例子，你可以用8份饲料1，2份饲料2，和5份饲料3，来得到7份目标饲料： 8*(1:2:3) + 1*(3:7:1) + 5*(2:1:2) = (21:28:35) = 7*(3:4:5)

以上数字中，表示饲料比例的整数都是小于100（数量级）的非负整数，表示各种饲料的份数的整数都小于100。一种混合物的比例不会由其他混合物的比例直接相加得到。

输入说明 :

Line 1: 三个用空格分开的整数，表示目标饲料

Line 2…4: 每行包括三个用空格分开的整数，表示农夫约翰买进的饲料的比例

输出说明 :

输出文件要包括一行，这一行要么有四个整数，要么是’NONE’。前三个整数表示三种饲料的份数，用这样的配比可以得到目标饲料。第四个整数表示混合前三种饲料后得到的目标饲料的份数。

输入范例 :

3 4 5
1 2 3
3 7 1
2 1 2
输出范例 :

8 1 5 7

#include
int main(){
    int i,j,k,a[20][20],t1,t2,t3,flag=1,p;
    while((scanf("%d%d%d",&a[0][0],&a[0][1],&a[0][2]))!=EOF)
    {
        flag=1;
        for(i=1;i<=3;i++)
            for(j=0;j<3;j++)
                scanf("%d",&a[i][j]);
        for(i=0;i<101&&flag;i++)
        {
            for(j=0;j<101&&flag;j++)
            {
                for(k=0;k<101&&flag;k++)
                {
                    t1=i*a[1][0]+j*a[2][0]+k*a[3][0];
                    t2=i*a[1][1]+j*a[2][1]+k*a[3][1];
                    t3=i*a[1][2]+j*a[2][2]+k*a[3][2];
                    if(t1&&a[0][0]&&t1%a[0][0]==0)
                        p=t1/a[0][0];
                    else if(t2&&a[0][1]&&t2%a[0][1]==0)
                        p=t2/a[0][1];
                    else if(t3&&a[0][2]&&t3%a[0][2]==0)
                        p=t3/a[0][2];
                    if(p*a[0][0]==t1&&p*a[0][1]==t2&&p*a[0][2]==t3)
                    {
                        printf("%d %d %d %d\n",i,j,k,t2/a[0][1]);
                        flag=0;
                    }

                }
            }
        }
        if(flag) printf("NONE\n");
    }
    return 0;
}

81 求小数位数个数

问题描述 :

明明最近在一家软件公司实习，公司分配给他一个任务，要他写一个小程序，这个程序的功能是求出一个浮点数的小数部分的长度。例如程序输入1.1，则输出1，程序输入1.11，则输出2，明明觉得这个非常简单，花了不到5分钟的时间就把程序给写出来了，然后就把程序交给了测试员测试。但是没有想到的是，经过测试员的测试，发现了一大堆的错误，返回的结果很多都是不对的，这个令明明相当的不解，始终想不通自己的程序错在哪里。你是一名经验丰富的程序员，明明把这个问题来求助于你，明明和你说了他的想法，你一听就明白明明错在了哪里，原来明明使用double型来存放浮点数，但是由于double型的精度问题，不可能把所有的小数都精确的保存好，如果小数位数很长，就会出错。你发现了问题。现在请你写出正确的程序。 明明的问题可以归结为：给你一个浮点数，请你求出这个浮点数的小数位数。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行仅包括一个浮点数数n，n的长度不超过100。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个整数，即n的小数部分的位数。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

输入范例 :

1.11
1.00000000000000001
输出范例 :

17

#include
#include
int main(){
    int i,flag=1;
    char a[200];
    while((scanf("%s",a))!=EOF)
    {
        flag=1;
        for(i=0;i<strlen(a);i++)
            if(a[i]=='.')
            {
                printf("%d\n",strlen(a)-1-i);
                flag=0;
            }
        if(flag) printf("0\n");
    }
    return 0;
}

82 进制转换

问题描述 :

输入一个十进制数，将其化成N进制数输出（2≤N≤16)。 输出结果时，大于等于10的数字用字母代替，A代表10，B代表11以此类推。

输入说明 :

你的程序需要从标准输入设备（通常为键盘）中读入多组测试数据。每组输入数据由一行组成，每行有2个数，分别代表十进制数m（0≤ m < 2^31）和进制N（2≤N≤16)，它们以空格分隔，在行首和行尾没有多余的空格。

输出说明 :

对每组测试数据，你的程序需要向标准输出设备（通常为启动该程序的终端）依次输出一组对应的答案：输出10进制数转换后的N进制数。所有数据前后没有多余的空格，两组数据之间也没有多余的空行。

输入范例 :

100 10
100 15
输出范例 :

100
6A

#include
void convert(int num,int jinzhi)
{
    int i=0,j,t,temp;
    char a[100];
    t=num;
    if(t==0) printf("0");
    while(t)
    {
        temp=t%jinzhi;
        if(temp>=10)
            a[i++]=temp-10+'A';
        else a[i++]=temp+'0';
        t/=jinzhi;
    }
    for(j=i-1;j>=0;j--)
        printf("%c",a[j]);
    printf("\n");
}
int main(){
    int m,n;
    while((scanf("%d%d",&m,&n))!=EOF)
    {
        convert(m,n);
    }
    return 0;
}

83 表达式求值

问题描述 :

以字符串形式输入仅有整数和加减（正负）号构成的表达式，输出该表达式的值。

输入说明 :

标准输入设备中有多组测试数据，每组输入数据由一行组成，输入仅有整数和加减（正负）号构成的表达式（但是表达式可以插入空格）。

输出说明 :

依次输出从标准输入设备中读入的每一组测试数据对应的结果，输出一行，输出该表达式的值。所有数据前后没有多余的空格，两组数据之间也没有多余的空行。

输入范例 :

3+ 4+ 5+6
0+1
输出范例 :

18
1

#include
#include
int main(){
    int i,j=1,result=0,temp=0;
    char a[1010],b[1010]={0};
    while(gets(a))
    {
        result=0;
        j=1;
        memset(b,0,sizeof(b));
        b[0]='+';
        for(i=0;i<strlen(a);i++)
            if(a[i]!=' ') b[j++]=a[i];
        //printf("a长度为：%d\na为：%s\nb长度为：%d\nb为：%s\nj=%d\n",strlen(a),a,strlen(b),b,j);
        for(i=0;i<strlen(b);i++)
        {
            if(b[i]=='+'||b[i]=='-')
            {
                j=i+1;
                temp=0;
                while(b[j]!='+'&&b[j]!='-'&&b[j]!='\0')
                    temp=temp*10+(b[j++]-'0');
                if(b[i]=='+')
                    result+=temp;
                else result-=temp;
                i=j-1;
            }
        }
        printf("%d\n",result);
    }
    return 0;
}

84 删除字符

问题描述 :

从键盘输入一个字符串和一个字符，将输入字符从字符串中删除，输出新的字符串。如果字符串中没有此字符，则原样输出字符串。

输入说明 :

输入两行，第一行输入一个字符串，第二行输入一个字符。

字符串最多允许输入20个任意字符。

输出说明 :

输出删除字符后的字符串。

输入范例 :

ab ccdc
c
输出范例 :

ab d

#include
#include
int main(){
    int i,j;
    char a[30],c;
    while(gets(a))
    {
        scanf("%c",&c);
        for(i=0;i<strlen(a);i++)
        {
            if(a[i]!=c)
            {
                printf("%c",a[i]);
            }
        }
        printf("\n");
        getchar();
    }
    return 0;
}

85 手机短号

问题描述 :

大家都知道，手机号是一个11位长的数字串，同时，作为学生，还可以申请加入校园网，如果加入成功，你将另外拥有一个短号。假设所有的短号都是“6”+手机号的后5位，比如号码为13512345678的手机，对应的短号就是645678。

现在，如果给你一个11位长的手机号码，你能找出对应的短号吗？

输入说明 :

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

输出说明 :

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

输入范例 :

2
70711457490
47810534444

输出范例 :

657490
634444

#include
#include
int main(){
    int i,j,n;
    char a[30];
    while(~scanf("%d",&n))
    {
        getchar();
        for(i=0;i<n;i++)
        {
            gets(a);
            printf("6");
            for(j=6;j<11;j++)
                printf("%c",a[j]);
            printf("\n");
        }
        getchar();
    }
    return 0;
}

86 字符串统计

问题描述 :

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

输入说明 :

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

输出说明 :

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

输入范例 :

2
abadvbsbasdfWRWEFASDFASDFwefsadfasdfadef934577&%^&*(
adfasdferdasd233dsf234radfassdfasdf**HHIKKK

输出范例 :

27
29

#include
#include
int main(){
    int i,j,n,count=0;
    char a[3000];
    scanf("%d",&n);
    getchar();
    for(i=0;i<n;i++)
    {
        memset(a,0,sizeof(a));
        count=0;
        gets(a);
        for(j=0;j<strlen(a);j++)
            if(a[j]>='a'&&a[j]<='z')
                count++;
        printf("%d\n",count);
    }
    return 0;
}

87 弟弟的作业

问题描述 :

你的弟弟刚做完了“100以内数的加减法”这部分的作业，请你帮他检查一下。每道题目（包括弟弟的答案）的格式为a+b=c或者a-b=c，其中a和b是作业中给出的，均为不超过100的非负整数；c是弟弟算出的答案，可能是不超过200的非负整数，也可能是单个字符"?"，表示他不会算。

输入说明 :

输入文件包含不超过100行，以文件结束符结尾。每行包含一道题目，格式保证符合上述规定，且不包含任何空白字符。输入的所有整数均不含前导0。

输出说明 :

输出仅一行，包含一个非负整数，即弟弟答对的题目数量。

输入范例 :

55+12=67
15-8=7
100-35=?
83-50=33
4-3=6
81+5=21
输出范例 :

3

#include
#include
int main(){
    int i,j,k,n,count=0,temp1=0,temp2=0,result;
    char a[1010];
    while(gets(a))
    {
        temp1=temp2=result=0;
        if(a[strlen(a)-1]!='?')
        {
            for(i=0;;i++)
                if(a[i]!='+'&&a[i]!='-')
                    temp1=temp1*10+(a[i]-'0');
                else break;
            for(j=i+1;;j++)
                if(a[j]!='=')
                    temp2=temp2*10+(a[j]-'0');
                    else break;
            for(k=j+1;k<strlen(a);k++)
                result=result*10+(a[k]-'0');
            if((a[i]=='+'&&temp1+temp2==result)||(a[i]=='-'&&temp1-temp2==result))
                count++;
        }
        //printf("%d%c%d=%d\n",temp1,a[i],temp2,result);
    }
    printf("%d\n",count);
    return 0;
}

88 字符串排序

问题描述 :

明明刚刚开始学英文，对于26个英文字母的顺序总是记不住，每次默写英文字母的时候，顺序总是前后颠倒。明明的爸爸对此相当着急，想有没有很好的办法来帮助明明记住字母的顺序。一天，明明的爸爸突然想到了一个游戏，能够帮助明明记住英文字母。这个游戏如下，给明明一个任意长度的英文字串，其中只包含小写字母，然后让明明对字符串中的字母排序，然后再把排完序的字符串写出来，如果连续写对10次的话，明明的爸爸就会奖励他，带他出去吃KFC。 例如：有一个字符串为asdf，经过排序后的字符串就是adfs。 明明显然对这个游戏非常感兴趣（其实明明更感兴趣的是那顿KFC），接受了他爸爸的提议，玩起了这个游戏。但是明明的爸爸在出题目考明明的时候，自己却犯了难，用英文随便写出一个无序的英文字符串是很简单的，但是排序的话却要费一些功夫，而且还不能出错，否则就无法知道明明做的对不对了。于是明明的爸爸请你帮忙，帮他写一个排序程序，来输出排序后的字符串。

明明爸爸的问题可以归结为：输入一行字符串，全部由小写字母构成，对字符串按26个英文字母的先后顺序进行排序，然后输出。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行由一个字符串组成，字符串中只包含小写字母，字符串的长度不超过100个字符。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个排序后的字符串。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。

输入范例 :

asdf
shflsahfslfdjsldfsjd
输出范例 :

adfs
adddffffhhjjlllsssss

#include
#include
void qsort(char a[])
{
    int i,j,t;
    for(i=0;i<strlen(a)-1;i++)
    {
        for(j=0;j<strlen(a)-1-i;j++)
        {
            if(a[j]>a[j+1])
            {
                t=a[j];
                a[j]=a[j+1];
                a[j+1]=t;
            }
        }
    }
}
int main(){
    char a[1010];
    while(gets(a))
    {
        qsort(a);
        printf("%s\n",a);
    }
    return 0;
}

89 回文问题

问题描述 :

输入一串字符，其长度小于200，判断该串字符是否构成回文。 所谓回文是指从左到右和从右到左读一串字符的值是一样的，如：ABCBA。

输入说明 :

你的程序需要从标准输入设备（通常为键盘）中读入多组测试数据。每组输入数据由一行字符组成，它们之间没有空格，在行首和行尾没有多余的空格。

输出说明 :

对每组测试数据，你的程序需要向标准输出设备（通常为启动该程序的终端）依次输出一组对应的答案：构成回文的输出Yes ，反之输出 No。所有数据前后没有多余的空格，两组数据之间也没有多余的空行。

输入范例 :

abcba
abcbb
输出范例 :

Yes
No

#include
#include
int judge(char a[])
{
    int i,j;
    for(i=0;i<=(strlen(a)-1)/2;i++)
        if(a[i]!=a[strlen(a)-1-i]) return 0;
    return 1;
}
int main(){
    char a[1010];
    while(gets(a))
    {
        if(a[0]==NULL)
            printf("Yes\n");
        else if(judge(a))
            printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}

90 字符串中找整数

问题描述 :

对于一个字符串，编程找出其中的所有整数。例如，字符串“a12bc34d05”，其中有整数12、34、5。

输入说明 :

程序输入包括多行，每一行都是一串字符，字符串长度不超过500。字符串中的字符只有字母与数字。

输出说明 :

程序输出为多行，每行第一个数代表所对应的字符串中整数的总个数。紧跟其后的依次是每个整数，数和数之间有一个空格。行与行之间没有多余空行，行首行尾没有多余空格。

输入范例 :

a12bc034d5
12886668&78711
abcdefghijklmn
输出范例 :

3 12 34 5
2 12886668 78711
0

#include
#include
int main(){
    int i,j,u,v,flag;
    char a[1010],b[1010][1010],temp[1010];
    while(gets(a))
    {
        u=0;
        memset(b,'\0',sizeof(b));
        for(i=0;i<strlen(a);i++)
        {
            if(a[i]>='0'&&a[i]<='9')
            {
                v=0;
                for(j=i;j<strlen(a);j++)
                {
                    if(a[j]>='0'&&a[j]<='9')
                        b[u][v++]=a[j];
                    else if(v>0)
                        break;
                }
                u++;
                i=j;
            }
        }
        printf("%d",u);
        for(i=0;i<u;i++)
        {
            if(b[i][0]=='0')
            {
                flag=0;
                for(j=0;j<strlen(b[i]);j++)
                {
                    if(b[i][j]!='0') flag=1;
                    if(!flag) b[i][j]='*';
                }
            }
        }
        for(i=0;i<u;i++)
        {
            printf(" ");
            if(b[i][strlen(b[i])-1]=='*')
                printf("0");
            else
                for(j=0;j<strlen(b[i]);j++)
                {
                    if(b[i][j]!='*')
                        printf("%c",b[i][j]);
                }
        }
        printf("\n");
    }
    return 0;
}