东华大学2021考研基本练习题91~120

91 乒乓球

问题描述 :

国际乒联主席沙拉拉自从上任以来就立志于推行一系列改革，以推动乒乓球运动在全球的普及。其中11分制改革引起了很大的争议，有一部分球员因为无法适应新规则只能选择退役。明明就是其中一位，他退役之后走上了乒乓球研究工作，意图弄明白11分制和21分制对选手的不同影响。在开展他的研究之前，明明首先需要对他多年比赛的统计数据进行一些分析，所以需要你的帮忙。 （注：11（21）分制，在一局比赛中，选手A先得到11（21）分且此时领先选手B 2分或2分以上时，则选手A赢得此局；若当双方打成10（20）平后，则先多得2分的一方为胜方，赢得此局。）

明明通过以下方式进行分析，首先将比赛每个球的胜负列成一张表，然后分别计算在11分制和21分制下，双方的比赛结果（截至记录末尾）。一局比赛的开始比分为0比0。 比如现在有这么一份记录，（其中W表示明明获得一分，L表示明明的对手获得一分）：

WWWWWWWWWWWWWWWWWWWWWWLW

在11分制下，此时比赛的结果是明明第一局11比0获胜，第二局11比0获胜，正在进行第三局，当前比分1比1。

在21分制下，此时比赛结果是明明第一局21比0获胜，正在进行第二局，当前比分2比1。

再如有这么一份记录，（其中W表示明明获得一分，L表示明明的对手获得一分）：

WLWLWLWLWLWLWLWLWLWLWLWLWL

在11分制下，此时比赛的结果是明明和对手打成13比13，这局比赛仍没有分出胜负，因为任何一方都没有领先其对手2分。

在21分制下，此时比赛的结果是明明和对手打成13比13，这局比赛仍在进行中。

由于明明参加过多年的比赛，比赛的数据量相当庞大，如果仅仅使用手工统计，在短时间内统计出结果对于明明来说是相当困难的。因此明明求助于你，希望你能写一个程序，帮助他快速地统计出结果来。

明明的问题可以归结为：给你一系列的比赛数据（WL形式），分别按照11分制和21分制的比赛规则进行统计，然后输出统计结果。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每行包括一串有W、L和E组成比赛结果，其中W表示明明得一分，L表示明明的对手得一分，E表示该组测试数据的结束，也就是说E后面的W、L应该忽略，无需处理。每行的长度不会超过30个字符。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

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

每组运算结果由两部分组成，其中第一部分是11分制下的结果，第二部分是21分制下的结果，两部分之间由一个空行分隔。

每部分由若干行组成，每一行对应一局比赛的比分（按比赛信息输入顺序），每局的比分按如下形式表示：m:n，其中m表示明明的得分，n表示明明的对手的得分，m、n之间用一个冒号隔开。

输出时，每组运算结果与其后一组运算结果之间有一个空行，第一组运算结果前面以及最后一组运算结果后面没有任何空行或其他任何字符。 注：通常，显示屏为标准输出设备。

输入范例 :

WWWWWWWWWWLLLLLLLLLLL
WWWWWWWWWLLLLLLLLLE
LLLLLLLLLLLLLLLLLE
输出范例 :

13:11
6:9

19:20

0:11
0:6

0:17

#include
#include
#include
int main(){
    int i=-1,j,k,left1=0,right1=0,left2=0,right2=0,c1=0,c2=0;
    int result1[1010],result2[1010];
    char a[1010];
    while(scanf("%c",&a[++i])!=EOF)
    {
        if(a[i]!='E')
        {
            if(abs(left1-right1)>=2&&(left1>=11||right1>=11))
            {
                result1[c1++]=left1;
                result1[c1++]=right1;
                left1=right1=0;
                if(a[i]=='W') left1++;
                else if(a[i]=='L') right1++;
            }
            else if(a[i]=='W') left1++;
            else if(a[i]=='L') right1++;
            if(abs(left2-right2)>=2&&(left2>=21||right2>=21))
            {
                result2[c2++]=left2;
                result2[c2++]=right2;
                left2=right2=0;
                if(a[i]=='W') left2++;
                else if(a[i]=='L') right2++;
            }
            else if(a[i]=='W') left2++;
            else if(a[i]=='L') right2++;
        }
        else
        {
            memset(a,'\0',sizeof(a));
            for(j=0;j<c1;j+=2)
                printf("%d:%d\n",result1[j],result1[j+1]);
            if(left1||right1)
                printf("%d:%d\n",left1,right1);
            printf("\n");
            for(j=0;j<c2;j+=2)
                printf("%d:%d\n",result2[j],result2[j+1]);
            if(left2||right2)
                printf("%d:%d\n",left2,right2);
            printf("\n");
            left1=right1=left2=right2=c1=c2=0;
            memset(result1,0,sizeof(result1));
            memset(result2,0,sizeof(result2));
            i=-1;

        }
    }
    return 0;
}

92 字符串统计

问题描述 :

明明最近在做一个有关字符串的统计工作。两个由小写字母组成的字符串s1和s2，明明需要统计出以下四种关系：

（1）在s1或s2中存在的字母（包括在s1和s2中都存在的字母）；

（2）在s1中且在s2中的字母；

（3）在s1中但不在s2中的字母，在s2中但不在s1中的字母；

（4）不在s1中且也不在s2中的字母；

例如两个字符串s1为“lkjsvoahs”，s2为“qglhskjdfg”：

（1）在s1或者在s2或者s1、s2中都存在的字母：adfghjkloqsv；

（2）在s1中且在s2中的字母：hjkls；

（3）在s1中但不在s2中的字母，在s2中但不在s1中的字母：adfgoqv；

（4）不在s1中且也不在s2中的字母：bceimnprtuwxyz；

明明统计了很久，但是由于统计过程十分繁琐，且很容易出错，导致明明的进度非常慢，很有可能因为统计不完而错过了晚上的约会。因此明明想请你帮个忙，帮他写一个程序，用程序来统计出以上几项内容。

明明的问题可以归结为：

输入两串由小写字母组成的字符串s1和s2，比较其中的字母，输出以下四项，输出的字母以字典顺序排列：

（1）在s1或s2中存在的字母（包括在s1和s2中都存在的字母）；

（2）在s1中且在s2中的字母；

（3）在s1中但不在s2中的字母，在s2中但不在s1中的字母；

（4）不在s1中且也不在s2中的字母；

例如字符串s1为sadf，s2为asdf，则需输出以下四行（注意输出的格式）：

in s1 or s2:adfs

in s1 and s2:adfs

in s1 but not in s2 ,or in s2 but not in s1:

not in s1 and s2:bceghijklmnopqrtuvwxyz

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据两行，每组测试数据的第一行为字符串s1，每组测试数据的第二行为字符串s2；s1和s2都由小写英文字母组成，且长度不超过26个字符。测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

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

每组运算结果由四行组成：

第一行为在s1或者在s2或者s1、s2中都存在的字母；

第二行为在s1中且在s2中的字母；

第三行为在s1中但不在s2中的字母，在s2中但不在s1中的字母；

第四行为不在s1中且也不在s2中的字母；

具体格式请参考样例输出。

每组运算结果其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。

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

输入范例 :

sadf
asdf
lkjsvoahs
qglhskjdfg
输出范例 :

in s1 or s2:adfs
in s1 and s2:adfs
in s1 but not in s2 ,or in s2 but not in s1:
not in s1 and s2:bceghijklmnopqrtuvwxyz

in s1 or s2:adfghjkloqsv
in s1 and s2:hjkls
in s1 but not in s2 ,or in s2 but not in s1:adfgoqv
not in s1 and s2:bceimnprtuwxyz

#include
#include
int main(){
    int i,j,c[50];
    char a[50],b[50];
    while(gets(a))
    {
        gets(b);
        memset(c,0,sizeof(c));
        for(i=0;i<strlen(a);i++)
            if(!c[a[i]-'a']) c[a[i]-'a']++;
        for(i=0;i<strlen(b);i++)
            if(c[b[i]-'a']==1) c[b[i]-'a']++;
            else if(c[b[i]-'a']==0) c[b[i]-'a']--;
        printf("in s1 or s2:");
        for(i=0;i<26;i++)
            if(c[i]!=0) printf("%c",i+'a');
        printf("\nin s1 and s2:");
        for(i=0;i<26;i++)
            if(c[i]==2) printf("%c",i+'a');
        printf("\nin s1 but not in s2 ,or in s2 but not in s1:");
        for(i=0;i<26;i++)
            if(c[i]==1||c[i]==-1) printf("%c",i+'a');
        printf("\nnot in s1 and s2:");
        for(i=0;i<26;i++)
            if(c[i]==0) printf("%c",i+'a');
        printf("\n\n");
    }
    return 0;
}

93 隐藏口令

问题描述 :

有时候程序员有很奇怪的方法来隐藏他们的口令。

Billy"Hacker"Geits会选择一个字符串S（由L个小写字母组成，5<=L<=100,000），然后他把S顺时针绕成一个圈。

如字符串cbadfa，绕成一个圈后，我们认为字符串首尾相连。

每次取其中一个字母作为起始字母，并顺时针依次取字母而组成一个字符串。这样将得到一些字符串。

比如字符串cbadfa，按照以上规则取出的字符串有：

cbadfa badfac adfacb dfacba facbad acbadf

我们找到最小的那个字符串，可知为acbadf，也可知道它的第一个字符’a’在原字符串cbadfa中为第6个字符（位置从1开始），

将得到的结果6减1得到5，这就是我们需要的口令。

再比如字符串alabala，绕成一个圈后，每次取其中一个字母作为起始字母，并顺时针依次取字母而组成一个字符串。这样将得到一些字符串：

alabala labalaa abalaal balaala alaalab laalaba aalabal

我们找到最小的那个字符串，可知为aalabal，它的第一个字母’a’在原字符串中位置为7，7-1=6，则6为口令。

注：如果按照规则有两个字符串都是最小的，则取前面那一个。

输入说明 :

第一行：一个数L

第二行及之后：字符串S。

注意：字符串S可跨多行，但其中的’\n’不算成S中的字符

输出说明 :

一行，为得到的口令。

无多余空格或空行。

输入范例 :

6
cbadfa
输出范例 :

5

#include
#include
int main(){
    int i,j,n,p=0,tab,count;
    char a[100100],b[10010],max[10010],t;
    while((scanf("%d",&n))!=EOF)
    {
        count=tab=0;
        memset(a,'\0',sizeof(a));
        memset(b,'\0',sizeof(b));
        getchar();
        while(count<n)
        {
            scanf("%c",&t);
            if(t!='\n') a[count++]=t;
        }
        strcpy(max,a);
        for(i=0;i<n;i++)
        {
            p=0;
            for(j=0;j<n;j++)
                b[p++]=a[(i+j)%n];
            if(strcmp(max,b)>0)
            {
                tab=i;
                strcpy(max,b);
            }

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

94 求字符串的起始位置

问题描述 :

在程序设计中，对字符串的处理是经常遇到的一个问题。

例如，将字符串中所有的英文字母变成大写，或者将一个字符串与另一个字符串连接构成一个新的字符串。

由于此类的操作非常普遍，因此，在设计程序语言的时候，设计者就已经把这类操作的代码写好了，如果编程人员要使用这些代码，只需把该类代码的头文件包含到自己的程序中，编程人员就可以很简单的调用，这样使编程节省了不少时间。

明明是一名项目经理，他现在负责一种新的程序设计语言的开发，现在需要预先实现大量的和处理字符串有关的功能方法，以后这些方法会包含到程序设计语言中，方便程序语言使用者的开发。你是明明手下的一名软件工程师，明明分配给你一个任务，在两个字符串中，找到一个字符串在另一个字符串中的起始位置。 例如，有两个字符串，一个字符串s= “abc”，另一个字符串subs=“bc”，现在就要找出“bc”在“abc”中的其实位置，在这个例子中，“bc”的起始位置为2。

明明的问题可以归结为：输入两串字符串s和subs，求s中subs的起始位置。

输入说明 :

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

输出说明 :

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

输入范例 :

abc
bc
aaa
bbb
输出范例 :

2
0

#include
#include
int main(){
    int i,j,c;
    char a[110],b[110];
    while(gets(a))
    {
        gets(b);
        for(i=0;i<strlen(a);i++)
        {
            if(a[i]==b[0])
            {
                c=i;
                for(j=0;j<strlen(b);j++)
                    if(a[c]==b[j]) c++;
                    else break;
                if(j==strlen(b))
                {
                    printf("%d\n",i+1);
                    break;
                }
            }
        }
        if(i==strlen(a))
            printf("0\n");
    }
    return 0;
}

95 最长的单词

问题描述 :

明明刚开始学习英语的时候，对英语有浓厚的兴趣，但是随着时间的推移，英语单词量的增加，明明越来越觉得背单词是一件相当痛苦的事情。于是他想出各种各样的方法来增加背单词的乐趣。

这次他想出的方法是把所有要背的英语单词排成一行，找出其中最长的一个单词来先背，然后划去这个单词，在剩下的单词中再找出一个最长的单词来背，以此类推，直到把所有单词都背完。如果有多个长度相同的单词，则先背一行中靠前的那个单词。这样做的好处是：背到越后面，单词越短，越容易背，越能增加背单词的信心。

例如有这么一行单词： one two three four five 明明会首先挑出three来背，因为它是最长的一个单词，由5个字母组成；然后明明会选择four这个单词，虽然five这个单词的长度和four这个单词的长度一样，但是four在five的前面，所以明明会先背four这个单词，然后再背five，等明明把five这个单词背完以后，接着背one这个单词，最后背的是two这个单词。

但是在这样背单词之中，明明又发现了另一个问题，当要背非常多的单词时，寻找最长的单词会花很多时间，他想让你帮助他写一个程序，找出一行单词中最长的那个，节约明明背单词所花的时间，与此同时，明明希望你能告诉他这个英文单词有多少个字母组成，那他可以做到心里有数。

明明的问题可以归结为：在一行英文单词中，找出其中最长的单词（若有多个最长，找出第一个出现的），并输出这个单词的长度。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行包括许多个英语单词和空格，单词和单词之间可能有多个空格，每行的长度不会超过1000个字符。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

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

输入范例 :

a bc def ghijk lmn
abc def ghi
输出范例 :

5 ghijk
3 abc

#include
#include
int main(){
    int i,j,c;
    char a[1010],max[1010],temp[1010];
    while(gets(a))
    {
        c=0;
        memset(max,'\0',sizeof(max));
        memset(temp,'\0',sizeof(temp));
        for(i=0;i<=strlen(a);i++)//<=是为了方便判断结束符
        {
            if(a[i]!=' '&&a[i]!='\0')
            {
                temp[c++]=a[i];
            }
            else
            {
                //printf("()%s\n",temp);
                c=0;
                if(strlen(max)<strlen(temp))
                    strcpy(max,temp);
                memset(temp,'\0',sizeof(temp));
            }
        }
        printf("%d %s\n",strlen(max),max);
    }
    return 0;
}

96 奖学金

问题描述 :

明明所在学校的惯例是在每学期的期末考试之后发放奖学金。

发放的奖学金共有五种，获取的条件各不相同：

1. 院士奖学金：每人8000元，期末平均成绩高于80分，并且在本学期内发表1篇或1篇以上论文的学生均可获得。

2. 五四奖学金：每人4000元，期末平均成绩高于85分，并且班级评议成绩高于80分的学生均可获得。

3. 成绩优秀奖：每人2000元，期末平均成绩高于90分的学生均可获得。

4. 西部奖学金：每人1000元，期末平均成绩高于85分的西部省份学生均可获得。

5. 班级贡献奖：每人850元，班级评议成绩高于80分的学生干部均可获得。

只要符合条件就可以得奖。 每项奖学金的获奖人数没有限制，每名学生也可以同时获得多项奖学金。

例如明明的期末平均成绩是87分，班级评议成绩82分，同时他还是一位学生干部，那么他可以同时获得五四奖学金和班级贡献奖，奖金总数是4850元。

由于老师在学期末的时候很忙，所以，他把奖学金统计的事情交给明明做。老师把考试的相关数据给了明明，让他统计出以下数据：

1） 哪位同学获得的奖学金最多；

2） 获得最多奖学金的同学一共获得了多少奖学金；

3） 所有获得奖学金的同学一共获得了多少奖学金；

明明虽然很愿意帮老师这个忙，但是他发现，同学的数量很多，统计起来很麻烦，经常有统计出错的情况发生。于是明明就想请你帮一个忙，帮他写一个统计程序，统计出以上三项内容。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据有多行，每组测试数据的第一行有一个整数N（1≤N≤100），表示学生的总数。接下来的N行，每行是一位学生的数据，一行中从左向右依次是姓名，期末平均成绩，班级评议成绩，是否是学生干部，是否是西部省份学生，以及发表的论文数。姓名是由大小写英文字母组成的长度不超过20的字符串（不含空格），期末平均成绩和班级评议成绩都是0到100之间的整数（包括0和100），是否是学生干部和是否是西部省份学生分别用一个字符表示，Y表示是，N表示不是，发表的论文数是0到10的一个整数（包括0和10），每两个相邻数据项之间用一个空格分隔。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

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

每组运算结果有三行，第一行是获得最多奖金的学生的姓名，第二行是这名学生获得的奖金总数。 如果有不止一名学生获得的奖学金最多，输出他们之中出现最早的学生姓名，第三行是这N个学生获得的奖学金的总数。输出时，每组运算结果其行首和行尾都没有任何空格或其他任何字符，每组运算结果与其后一组运算结果之间有一个空行，最后一组运算结果后面没有空行。 注：通常，显示屏为标准输出设备。

输入范例 :

1
Peter 87 82 Y N 0
2
Peter 85 85 Y Y 1
Mary 90 90 N N 0
输出范例 :

Peter
4850
4850

Peter
8850
12850

#include
#include
struct student{
    char name[30];
    int qimo;
    int pingyi;
    char ganbu;
    char xibu;
    int lunwen;
    int price;
}a[110],max;
int main(){
    int i,j,n,sum;
    while((scanf("%d",&n))!=EOF)
    {
        for(i=0;i<n;i++)
        {
            scanf("%s %d %d %c %c %d",a[i].name,&a[i].qimo,&a[i].pingyi,
                  &a[i].ganbu,&a[i].xibu,&a[i].lunwen);
            a[i].price=0;
            if(a[i].qimo>80&&a[i].lunwen)
                a[i].price+=8000;
            if(a[i].qimo>85&&a[i].pingyi>80)
                a[i].price+=4000;
            if(a[i].qimo>90)
                a[i].price+=2000;
            if(a[i].qimo>85&&a[i].xibu=='Y')
                a[i].price+=1000;
            if(a[i].pingyi>80&&a[i].ganbu=='Y')
                a[i].price+=850;
        }
        max=a[0];
        for(i=0;i<n;i++)
            if(max.price<a[i].price)
                max=a[i];
        sum=0;
        for(i=0;i<n;i++)
            sum+=a[i].price;
        printf("%s\n%d\n%d\n\n",max.name,max.price,sum);
        flag++;
    }
    return 0;
}

97 回文数2

问题描述 :

有一天，明明正在做作业，发现了一组很有趣的数字，例如1、11、313等等。他发现这些数字都是左右对称的，即不论你把这些数字从左读到右还是从右读到左，读出来的数字都是一样的。于是明明就把这个发现告诉了他爸爸。明明的爸爸是一名数学家，对此类型数字早有研究。他对明明说：“这些是回文数，是一种特殊的数字，即这些数字的左右两边是对称的。例如：11左右两边对称，313左右也是对称的。” 明明觉得这很有趣，接着问他爸爸还有什么和这类回文数有关的有趣的东西。明明的爸爸就说：“你把这些回文数转换成二进制数，看看是不是也符合回文数的规则。”明明发现1的二进制数也是1，符合回文数的规则；11的二进制数是1011，不符合回文数的规则；33的回文数是100001，符合回文数的规则。明明就回答爸爸说：“1和33的二进制数符合回文数的规则，11的二进制数则不符合回文数的规则。” 明明爸爸很满意明明的回答，又给了明明很多十进制数，让他判断在这些数中哪些数既是十进制回文数又是二进制回文数。明明起先做起来很有意思，但是时间一长就失去了兴趣。他想请你帮个忙，帮他写一个程序，用来判断一个数，它的十进制数是回文数，且它的二进制数也是回文数。

明明的问题可以归结为：给你一个整数（十进制），判断该整数的十进制数和它的二进制数是否全为回文数。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅有一行，每行有一个整数N（0 <= N <= 1000），表示要判断回文数的那个数。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为“Yes”或“No”，如果该数的十进制数和二进制数都是回文数，则输出“Yes”（不含双引号），否则输出“No”（不含双引号）。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

输入范例 :

1
10
33
输出范例 :

Yes
No
Yes

#include
#include
int judge(int n)
{
    int i=0,j=0,k,a[110],b[110],c,d,flag=1;
    c=d=n;
    while(c)
    {
        a[i++]=c%10;
        c/=10;
    }
    while(d)
    {
        b[j++]=d%2;
        d/=2;
    }
    for(k=0;k<i/2;k++)
        if(a[k]!=a[i-k-1]) flag=0;
    for(k=0;k<j/2;k++)
        if(b[k]!=b[j-k-1]) flag=0;
    return flag;
}
int main(){
    int n;
    while((scanf("%d",&n))!=EOF)
    {
        if(judge(n)) printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}

98 加法器

问题描述 :

明明读小学的时候，不喜欢数学，尤其是不喜欢做加法，一做加法就头疼，这样导致明明长大后数学依然不好，而且对数字产生了抵触心理。可是不巧的是，明明进了一家会计公司，每天都要计算很多数据，在这些计算中加法运算居多，而且这些加法不只是是两个数之间的加法，更有多个数的连加。 例如：1+2+3的正确答案是6。 这给明明造成了很大的麻烦。你是明明的好朋友，看到明明如此痛苦，就产生了帮助明明的想法。你想帮明明写一个程序，这个程序能计算一串正整数的连加，从而帮助明明摆脱数字的困扰。 明明的问题可以归结为：给你一串正整数的连加表达式，完成这个表达式的计算。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅有一行，每行有一个表达式，表达式由正整数和加号（“+”）组成，不含其他任何符号，表达式中的数字小于等于30000,表达式的长度不超过1000，具体格式见输入样例。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

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

输入范例 :

1+2+3
5+111
输出范例 :

6
116

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

99 构造序列

问题描述 :

序列是在数学世界中一种非常有趣的数字现象，它通过某一规则来产生数字，使数字变得有趣、变幻无穷。很多数学家对序列这种事物产生了浓厚的兴趣，花了很多时间对其进行研究，明明就是其中的一位。一天，他又在研究一种新的序列产生规则，该序列的规则如下：

1） 第1轮，写出两个1，即11；

2） 第2轮，在它们中间插入2，成为121；

3） 第3轮，在上面数中每两个相邻的和为3的数之间插入3，成为13231；

4） 以此类推下去，第n轮，在第n-1轮的数字的基础上，每两个相邻的和为n的数之间插入n。

明明根据这个规则开始构造序列。开始还觉得容易，但是越到后面，明明发现构造序列的计算量越来越大，计算难度也越来越高，计算速度也越来越慢。于是，明明就求助于你这位程序设计专家，能否帮他写一个程序，构造出序列的前9项，然后当明明需要知道序列中的哪一项的时，你就把那一项的数字告诉明明。

明明的问题可以归结为：根据题目描述中所描述的序列产生规则构造序列的前9项，然后告诉你一个正整数n，要求你输出序列的第n项。

输入说明 :

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

输出说明 :

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

输入范例 :

3
4
5
输出范例 :

13231
1432341
15435253451

#include
#include
int main(){
    char a[1010];
    int n,i,j,ins,length,count;
    while((scanf("%d",&n))!=EOF)
    {
        memset(a,'\0',sizeof(a));
        strcpy(a,"11");
        for(ins=2;ins<=n;ins++)
        {
            length=strlen(a);
            for(i=0;i<length-1;i++)
            {
                if((a[i]-'0')+(a[i+1]-'0')==ins)
                {
                    for(j=length;j>i+1;j--)
                        a[j]=a[j-1];
                    a[i+1]=(ins+'0');
                    length++;
                    i++;
                }
            }
        }
        printf("%s\n",a);
    }
    return 0;
}

100 纯粹合数

问题描述 :

明明的爸爸是一位数学家，明明受他爸爸的影响从小就喜欢数学，经常向他爸爸学习或请教数学问题。

一天，明明问他爸爸什么是合数，明明的爸爸回答说：“首先，合数都是大于1的整数，其次合数是除了1和其本身外，还能被至少一个其他自然数整除的数，例如‘4’这个数，它除了能被1和4整除外，还能被2整除，因此‘4’就是合数；但是‘3’就不是合数，因为3只能被1和3这两个数整除，因此‘3’不是合数。”

聪明的明明很快就理解了他爸爸的意思，于是又接着问他爸爸：“那什么又是纯粹合数呢？”明明的爸爸接着回答说：“一个合数，去掉最高位，剩下的数是0或仍是合数；再去掉剩下的数的最高位，剩下的数还是0或合数；这样反复，一直到最后剩下的一位数仍为0或合数；我们把这样的数称为纯粹合数。

例如‘100’这个数，它能被1、2、4、5、10、20、50、100整除，因此100是个合数，我们去掉它的最高位，剩下的数是0（其实剩下的应该是00，但是前置0对一个整数来说没有意义，因此前置0被舍去，就剩下个位数上的0），因此‘100’是一个纯粹合数。有趣的是，100是最小的一个三位纯粹合数。

再例如‘104’这个数，104能被1、2、8、13、26、52、104整除，所以104是个合数；我们去掉它的最高位后剩下4，4能被1、2、4整除，所以4也是合数，所以‘104’是一个纯粹合数。

但是‘101’就不是纯粹合数，因为‘101’只能被1和101这两个数整除。”

明明对他爸爸的回答很满意，于是自己动手从100开始寻找纯粹合数，他一共找到了100个纯粹合数，调皮的明明开始反过来考爸爸了，问他爸爸能否告诉他第2个大于等于100的纯粹合数是哪个？第3个大于等于100的纯粹合数又是哪个？……明明的爸爸被这个突如其来的问题给难住了，他无法立刻回答出来，于是请求你的帮助，帮助他回答明明的这个问题。

明明的问题可以归结为：根据一个正整数n，求出从100开始从小到大的第n个纯粹合数。

输入说明 :

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

输出说明 :

对于每一组测试数据，你写的程序需要计算出一组相应的运算结果，并将每组运算结果依次写入到标准输出设备（通常为启动该程序的文本终端，例如Windows中的命令行终端）中。每组运算结果为一个整数，即从100开始从小到大的第n个纯粹合数。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。

输入范例 :

10
2
1
输出范例 :

124
104
100

#include
#include
int heshu(int n)
{
    int i;
    if(n<4) return 0;
    for(i=2;i<=sqrt(n);i++)
        if(n%i==0) return 1;
    return 0;
}
int ws(int n)
{
    int p=0;
    while(n)
    {
        n/=10;
        p++;
    }
    return p;
}
int chuncui(int n)
{
    int c,i,weishu;
    c=n;
    while(n)
    {
        if(heshu(n))
        {
            weishu=ws(n);
            n=n-(pow(10,weishu-1)*(int)(n/pow(10,weishu-1)));
        }
        else break;
    }
    if(n) return 0;
    else return 1;
}
int main(){
    int n,count,i;
    while((scanf("%d",&n))!=EOF)
    {
        count=0;
        for(i=100;;i++)
        {
            if(chuncui(i))
                count++;
            if(count==n)
            {
                printf("%d\n",i);
                break;
            }
        }
    }
    return 0;
}

101 找出质数

问题描述 :

明明学习数学已经有一段时间了。一次老师在课上讲了什么叫质数。质数就是大于等于2且只能被1和其本身整除的整数。明明觉得这很简单，以为这很容易掌握，于是就不多做练习。明的爸爸发现了这个问题，他想让明明多做练习，把质数这个知识点掌握牢固。但是，他也知道只是求质数会很无聊，明明一定不愿意多做。于是他想出了一个游戏，这个游戏叫“找出质数”，就是给明明一个数字串，要叫明明在这个数字串中找出一个最大的子串，要求这个子串是一个质数。 但是由于明明还太小，他的计算能力有限，因此明明的爸爸认为，找出长度大于4个字符的质数对明明来说太困难了。于是他降低了要求，只需找出小于10,000的最长的质数子串即可。 例如：有一个数字串为17，最大的子串就应该是17，因为1不是质数，7虽然是质数，但是7的长度只有1，17也是质数，它的长度为2，因此最大的子串就是17。 明明觉得这个游戏很有趣，就高兴地做了起来，明明的爸爸出了很多个数字串，由于数字串太多，所以明明爸爸自己找出最长的子串也要花很多的时间，于是明明的爸爸想让你帮他一个忙，写一个程序，找出数字串中最长的质数子串。

明明爸爸的问题可以归结为：输入一串数字，找出其中最长的不超过4个字符的质数子串。若有多个答案，则找出其中数值最大的一个。

输入说明 :

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

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一个整数，即最长的不超过4个字符的质数子串（测试数据保证这个子串存在）；若有多个答案，则输出其中数值最大的一个。每组运算结果单独形成一行数据，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

输入范例 :

17
121
1113
输出范例 :

17
2
113

#include
#include
#include
int sushu(int n)
{
    int i;
    if(n<2) return 0;
    for(i=2;i<=sqrt(n);i++)
        if(n%i==0) return 0;
    return 1;
}
int main(){
    char a[30];
    int i,j,k,max,temp,len;
    while(gets(a))
    {
        len=strlen(a);
        /**这里strlen函数有个坑，99题也反应出来了，
           strlen尽量在for语句外面提前求出，否则直接
           放在for中会乱套，具体原因可以百度
        */
        max=0;
        for(i=1;i<=4;i++)
        {
            for(j=0;j<len-i+1;j++)
            {
                temp=0;
                for(k=0;k<i;k++)
                    temp=temp*10+(a[j+k]-'0');
                if(max<temp&&sushu(temp))
                    max=temp;
            }
        }
        printf("%d\n",max);
    }
    return 0;
}

102 翻译字符串

问题描述 :

在现代战争中，情报战越来越显示出它的重要性，敌我双方都想方设法得到对方的情报，然后一举歼灭对方。然而，随着加密技术的出现，对情报进行加密变得越来越频繁，想破解敌方的情报也越来越难。明明是一名富有经验的情报工作人员，他的主要任务就是破解敌方的情报，从而得到对己方有利的信息。在一次破解情报任务中，明明再次成功地破解了敌方的情报。明明的破解方法如下：一串以‘@’为结束标志的字符串，从左至右对其进行翻译，若字符串中当前字符是整数n（0≤n≤9），则表示将后一个字符重复n+1次，不论后一个字符是否为数字，且后一个字符无需再次翻译；若当前字符非数字，则表示自己，无需翻译，直接输出即可。最后，输出翻译完的字符串。

例如字符串为：2d352d@，因为第一个字符为数字2，则将后一个字符d输出3次，而d则不需再翻译，然后翻译3，3也是一个数字，则将后一个字符5输出4次，而5则不需再翻译，然后翻译2，2也是一个数字，将后一个字符d输出3次，而d则不需再翻译，最后一个字符为@，表示自己，直接输出即可，最后的输出为：ddd 555 5dd d@；（注：在翻译时，‘@’当作字符处理。） 这样翻译字符串的方法虽然简单，但是由于敌方的文件巨大，仅仅靠手工翻译是很难在短时间内完成的。于是明明就求助于你这位程序专家，按照明明提供的破译方法写一个程序，帮助明明快速把敌方文件翻译完成。

明明的问题可以归结为：按照文中提供的破译情报的方法，对字符串进行翻译，然后输出翻译后的字符串。

输入说明 :

你写的程序要求从标准输入设备（通常，键盘为标准输入设备）中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，每组测试数据仅占一行，每行包含一个以‘@’为结束标志的字符串，字符串由数字、小写字母以及‘@’组成，中间不包含空格，字符串长度不大于10。每组测试数据与其后一组测试数据之间没有任何空行，第一组测试数据前面以及最后一组测试数据后面也都没有任何空行。

输出说明 :

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

输入范例 :

a1b2c3d4@
2d352d@
dsegweg@

输出范例 :

abb ccc ddd d@@ @@@
ddd 555 5dd d@
dse gwe g@

#include
#include
int main(){
    char a[30];
    int i,j,k,count;
    while(gets(a))
    {
        count=0;
        for(i=0;i<strlen(a);i++)
        {
            if(a[i-1]>='0'&&a[i-1]<='9'&&i>=0)
            {
                for(j=0;j<=(a[i-1]-'0');j++)
                {
                    if(count%3==0&&count)
                        printf(" ");
                    printf("%c",a[i]);
                    count++;
                }
                a[i]='*';//一次数字起作用后，废除该字符，避免字符是数字而作用下一组
            }
            else if(a[i]<'0'||a[i]>'9')
            {
                if(count%3==0&&count)
                    printf(" ");
                printf("%c",a[i]);
                count++;
            }
        }
        printf("\n");
    }
    return 0;
}

103 分割数字并排序

问题描述 :

输入一行数字，如果我们把这行数字中的‘5’都看成空格，那么就得到一行用空格分割的若干非负整数（可能有些整数以‘0’开头，这些头部的‘0’应该被忽略掉，除非这个整数就是由若干个‘0’组成的，这时这个整数就是0）。

你的任务是：对这些分割得到的整数，依从小到大的顺序排序输出。

输入说明 :

输入包含多组测试用例，第一行，测试案例个数，每组输入数据只有一行数字（数字之间没有空格），这行数字的长度不大于1000。

输入数据保证：分割得到的非负整数不会大于100000000；输入数据不可能全由‘5’组成。

输出说明 :

对于每个测试用例，输出分割得到的整数排序的结果，相邻的两个整数之间用一个空格分开，每组输出占一行。

输入范例 :

2
0051231232050775
4000050005045453356356456454564567677686564654
输出范例 :

0 77 12312320
0 4 4 4 4 33 63 64 64 64 646 40000 67677686

#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(){
    char a[1010];
    int c,i,j,k,b[1010],n,len;
    while((scanf("%d",&n))!=EOF)
    {
        getchar();
        for(c=0;c<n;c++)
        {
            k=0;
            memset(b,0,sizeof(b));
            a[0]='5';
            gets(a+1);
            len=strlen(a);
            for(i=0;i<len;i++)
            {
                if(a[i]=='5')
                {
                    for(j=i+1;j<len;j++)
                    {
                        if(a[j]=='5') break;
                        else
                            b[k]=b[k]*10+(a[j]-'0');
                    }
                    if(i+1==j) b[k]=-1;//两个5之间无数字 作废
                    k++;
                    i=j-1;
                }
            }
            qsort(b,k);
            for(i=0;i<k;i++)
            {
                if(b[i]!=-1)
                {
                    printf("%d",b[i]);
                    if(i<k-1)
                        printf(" ");
                }
            }
            printf("\n");
        }
    }
    return 0;
}

104 A == B ?

问题描述 :

给你两个非负实数A和B，如果A等于B，输出 “YES”, 否则输出"NO"

输入说明 :

第一行N，表示有N组测试数据。

以下N行，每行两个非负实数 A和B。每个实数不超过1000位，且可能在前面和后面有0存在。

输出说明 :

对于每组测试数据，如果A和B相等则输出 “YES”， 否则输出 “NO”。

每组测试数据占一行，两组测试数据之间无空行。行首与行尾均无空格。

输入范例 :

2
100.0 00100
0100.1234576 00000000100.123457

输出范例 :

YES
NO

#include
#include
int main(){
    char a[1010],b[1010],c[1010],d[1010],e[1010],f[1010];
    int i,j,n,p,len1,len2,n1,n2,n3,n4,flag1,flag2,flag3,flag4;
    while((scanf("%d",&n))!=EOF)
    {
        getchar();
        for(p=0;p<n;p++)
        {
            memset(b,'\0',sizeof(b));
            memset(c,'\0',sizeof(c));
            memset(e,'\0',sizeof(e));
            memset(f,'\0',sizeof(f));
            n1=n2=n3=n4=flag1=flag2=flag3=flag4=0;
            scanf("%s",a);
            len1=strlen(a);
            for(i=0;i<len1;i++)
            {
                if(a[i]=='.')
                    break;
                if(a[i]!='0') flag1=1;
                if(flag1) b[n1++]=a[i];
            }
            for(i=i+1;i<len1;i++)
                c[n2++]=a[i];
            scanf("%s",d);
            len2=strlen(d);
            for(i=0;i<len2;i++)
            {
                if(d[i]=='.')
                    break;
                if(d[i]!='0') flag3=1;
                if(flag3) e[n3++]=d[i];
            }
            for(i=i+1;i<len2;i++)
                f[n4++]=d[i];
            for(i=n2-1;;i--)
                if(c[i]=='0') c[i]='\0';
                else break;
            for(i=n4-1;;i--)
                if(f[i]=='0') f[i]='\0';
                else break;
            if(!strcmp(b,e)&&!strcmp(c,f))
                printf("YES\n");
            else printf("NO\n");
        }
    }
    return 0;
}

105 母牛制造的回文

问题描述 :

据说如果你给无限只母牛和无限台巨型便携式电脑(有非常大的键盘),那么母牛们会制造出世上最棒的回文。你的工作就是去这些牛制造的奇观(最棒的回文)。在寻找回文时不用理睬那些标点符号、空格(但应该保留下来以便做为答案输出),只用考虑字母’A’-‘Z’和’a’-‘z’。要你寻找的最长的回文的文章是一个不超过20,000个字符的字符串。我们将保证最长的回文不会超过2,000个字符(在除去标点符号、空格之前)。

输入说明 :

一个不超过20,000个字符的文件。

输出说明 :

输出的第一行应该包括找到的最长的回文的长度。

下一个行或几行应该包括这个回文的原文(没有除去标点符号、空格), 把这个回文输出到一行或多行(如果回文中包括换行符)。如果有多个回文长度都等于最大值,输出那个前出现的。

输入范例 :

Confucius say: Madam, I’m Adam.
输出范例 :

11
Madam, I’m Adam

#include
#include
struct data{
    int pos;
    char zifu;
}a[20010],b[20010];
int huiwen(data a[],int start,int end)
{
    int i;
    for(i=start;i<=(start+end)/2;i++)
        if(a[i].zifu!=a[end-i+start].zifu)
            return 0;
    return 1;
}
int main(){
    int i=0,j,start,end,lena=0,lenb,maxlen=0;
    while(scanf("%c",&a[i].zifu)!=EOF)
    {
        a[i].pos=i;
        i++;
    }
    lenb=0;
    lena=i;
    for(i=0;i<lena;i++)
        if((a[i].zifu>='a'&&a[i].zifu<='z')||(a[i].zifu>='A'&&a[i].zifu<='Z'))
            b[lenb++]=a[i];
    for(i=0;i<lenb;i++)
        if(b[i].zifu>='A'&&b[i].zifu<='Z')
            b[i].zifu=b[i].zifu-'A'+'a';
    for(i=0;i<lenb;i++)
    {
        for(j=i;j<lenb;j++)
        {
            if(maxlen<j-i+1&&huiwen(b,i,j))
            {
                maxlen=j-i+1;
                start=b[i].pos;
                end=b[j].pos;
            }
        }
    }
    printf("%d\n",maxlen);
    for(i=start;i<=end;i++)
    {
        if(a[i].zifu=='\n')
            printf("\n");
        else
            printf("%c",a[i].zifu);
    }
    return 0;
}

106 大整数相加

问题描述 :

I have a very simple problem for you. Given two integers A and B, your job is to calculate the Sum of A + B.

输入说明 :

The first line of the input contains an integer T(1<=T<=20) which means the number of test cases. Then T lines follow, each line consists of two positive integers, A and B. Notice that the integers are very large, that means you should not process them by using 32-bit integer. You may assume the length of each integer will not exceed 1000.

输出说明 :

For each test case, you should output two lines. The first line is “Case #:”, # means the number of the test case. The second line is the an equation “A + B = Sum”, Sum means the result of A + B. Note there are some spaces int the equation. Output a blank line between two test cases.

输入范例 :

2
1 2
112233445566778899 998877665544332211
输出范例 :

Case 1:
1 + 2 = 3

Case 2:
112233445566778899 + 998877665544332211 = 1111111111111111110

#include
#include
int main(){
    char a[1010],b[1010],c[1010];
    int i,j,n,p,lena,lenb,temp,jinwei,k;
    while((scanf("%d",&n))!=EOF)
    {
        getchar();
        for(p=0;p<n;p++)
        {
            jinwei=k=0;
            memset(a,'\0',sizeof(a));
            memset(b,'\0',sizeof(b));
            memset(c,'\0',sizeof(c));
            scanf("%s %s",a,b);
            lena=strlen(a);
            lenb=strlen(b);
            for(i=lena-1,j=lenb-1;i>=0&&j>=0;i--,j--)
            {
                temp=(a[i]-'0')+(b[j]-'0')+jinwei;
                c[k++]=(temp%10)+'0';
                jinwei=temp/10;
            }
            if(j>=0)
            {
                strcpy(a,b);
                i=j;
            }
            for(;i>=0;i--)
            {
                temp=(a[i]-'0')+jinwei;
                c[k++]=(temp%10)+'0';
                jinwei=temp/10;
            }
            if(jinwei)
                c[k]=jinwei+'0';
            printf("Case %d:\n%s + %s = ",p+1,a,b);
            for(i=strlen(c)-1;i>=0;i--)
                printf("%c",c[i]);
            printf("\n\n");
        }
    }
    return 0;
}

107 16进制加法

问题描述 :

某天、小晨在路上背着单词，突遇一外星人，外星人对小晨很感兴趣，为了考验小晨的智商，就向小晨提问简单加法，由于外星人使用16进制，所以，小晨必须用16进制回答。

输入说明 :

首先输入一个整数T，

以下T行，每行两个16进制数字

输出说明 :

T行，每行一个16进制数，为求出的两数之和。

其中的英文字母a到f为小写。

输入范例 :

2
4b0d 4887
2745 7438
输出范例 :

9394
9b7d

#include
#include
int main(){
    char a[1010],b[1010],c[1010];
    int i,j,n,p,lena,lenb,temp,jinwei,k,ap,bp;
    while((scanf("%d",&n))!=EOF)
    {
        getchar();
        for(p=0;p<n;p++)
        {
            jinwei=k=0;
            memset(a,'\0',sizeof(a));
            memset(b,'\0',sizeof(b));
            memset(c,'\0',sizeof(c));
            scanf("%s %s",a,b);
            lena=strlen(a);
            lenb=strlen(b);
            for(i=lena-1,j=lenb-1;i>=0&&j>=0;i--,j--)
            {
                if(a[i]>='a'&&a[i]<='f')
                    ap=a[i]-'a'+10;
                else ap=a[i]-'0';
                if(b[j]>='a'&&b[i]<='f')
                    bp=b[j]-'a'+10;
                else bp=b[j]-'0';
                temp=ap+bp+jinwei;
                if(temp%16>=10)
                    c[k++]='a'+temp%16-10;
                else c[k++]=temp%16+'0';
                jinwei=temp/16;
            }
            if(j>=0)
            {
                strcpy(a,b);
                i=j;
            }
            for(;i>=0;i--)
            {
                if(a[i]>='a'&&a[i]<='f')
                    ap=a[i]-'a'+10;
                else ap=a[i]-'0';
                temp=ap+jinwei;
                if(temp%16>=10)
                    c[k++]='a'+temp%16-10;
                else c[k++]=temp%16+'0';
                jinwei=temp/16;
            }
            if(jinwei)
                c[k]=jinwei+'0';
            for(i=strlen(c)-1;i>=0;i--)
                printf("%c",c[i]);
            printf("\n");
        }
    }
    return 0;
}

108 纯粹素数

问题描述 :

明明的爸爸是一位数学家，明明受他爸爸的影响从小就喜欢数学，经常向他爸爸请教数学问题。一天，明明问爸爸什么是素数，爸爸回答说：“首先，素数都是大于1的自然数；其次，素数是只能被1和其本身整除的数。例如‘3’这个数，它只能被1和3这两个整数整除，因此‘3’就是素数；但是‘4’就不是素数，因为4除了能被1和4整除外，也能被2整除，因此‘4’就不是一个素数。”

聪明的明明很快就理解了他爸爸的意思，于是又接着问他爸爸：“那么纯粹素数又是什么呢？”明明的爸爸接着回答说：“一个素数，去掉最高位，剩下的数仍为素数，再去掉剩下的数的最高位，余下的数还是素数，这样下去一直到最后剩下的个位数也还是素数，我们把这样的数称为纯粹素数。例如‘1013’这个数，它只能被1和1013整除，因此‘1013’是一个素数，我们去掉它的最高位，剩下的数是13（其实剩下的应该是013，但是前置0对一个整数来说没有意义，因此0被舍去，就剩下13），13只能被1和13整除，因此13也是个素数，我们再接着去掉它的最高位，剩下的个位数是3，3当然也是素数，因此‘1013’就是纯粹素数。更有趣的是，1013是第一个大于1000的纯粹素数，因为：

1000能被1、2、……、1000整除，其本身不是素数；

1001能被1、7、……、1001整除，其本身不是素数；

1002能被1、2、……、1000整除，其本身不是素数；

1003能被1、17、……、1003整除，其本身不是素数；

1004能被1、2、……、1004整除，其本身不是素数；

1005能被1、3、……、1005整除，其本身不是素数；

1006能被1、2、……、1006整除，其本身不是素数；

1007能被1、19、……、1007整除，其本身不是素数；

1008能被1、2、……、1008整除，其本身不是素数；

1009是一个素数，但是9能被1、3、9整除，不是素数；

1010能被1、2、……、1010整除，其本身不是素数；

1011能被1、3、……、1011整除，其本身不是素数；

1012能被1、2、……、1012整除，其本身不是素数；

所以从1000到1012，每个数都不是纯粹素数。”

明明对他爸爸的回答很满意，于是自己动手从1000开始寻找纯粹素数，不一会儿他就找到了20个纯粹素数，调皮的明明开始反过来考爸爸了，问他爸爸能否告诉他第2个大于1000的纯粹素数是哪个？第3个大于1000的纯粹素数是哪个？……明明的爸爸被这些突如其来的问题给难住了，他无法立刻回答出来，于是请求你帮助他回答明明的这些问题。

明明的问题可以归结为：跟据一个正整数n，求出从1,000开始从小到大的第n个纯粹素数。

输入说明 :

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

输出说明 :

对于每一组测试数据，你写的程序需要计算出一组相应的运算结果，并将每组运算结果依次写入到标准输出设备（通常为启动该程序的文本终端，例如Windows中的命令行终端）中。每组运算结果为一个整数，即从1,000开始从小到大的第n个纯粹素数。。每组运算结果单独形成一行，其行首和行尾都没有任何空格，每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。

输入范例 :

1
10
20
输出范例 :

1013
1607
2137

#include
#include
int sushu(int n)
{
    int i;
    if(n<=1) return 0;
    if(n==2) return 1;
    for(i=2;i<=sqrt(n);i++)
        if(n%i==0) return 0;
    return 1;
}
int ws(int n)
{
    int p=0;
    while(n)
    {
        n/=10;
        p++;
    }
    return p;
}
int chuncui(int n)
{
    int c,i,weishu;
    c=n;
    while(n)
    {
        if(sushu(n))
        {
            weishu=ws(n);
            n=n-(pow(10,weishu-1)*(int)(n/pow(10,weishu-1)));
        }
        else break;
    }
    if(n) return 0;
    else return 1;
}
int main(){
    int n,count,i;
    while((scanf("%d",&n))!=EOF)
    {
        count=0;
        for(i=1000;;i++)
        {
            if(chuncui(i))
                count++;
            if(count==n)
            {
                printf("%d\n",i);
                break;
            }
        }
    }
    return 0;
}

109 大实数加法

问题描述 :

给你两个正的实数A和B，你的任务是计算出A+B的值。

输入说明 :

本题目包含T组测试数据。

每一组测试数据在一行里面包含两个长度不大于400的正实数A和B，A和B均无多余的前导0。

输出说明 :

对于每一组测试数据，请在一行里面输出输出A+B的值，行首与行尾均无空格。

运算结果最后的0（比如1.400）不需要输出（输出为1.4）。

输入范例 :

3
1.1 2.9
1.1111111111 2.3444323343
1 1.1
输出范例 :

4
3.4555434454
2.1

目前遇到最恶心

#include
#include
int main(){
    char a[1010],b[1010],c[1010],ta[1010],tb[1010],re[1010];
    int i,j,n,p,u,v,lena,lenb,temp,jinwei,k,tab1,tab2,tabp,q,o;
    while((scanf("%d",&n))!=EOF)
    {
        getchar();
        for(p=0;p<n;p++)
        {
            jinwei=k=0;
            memset(a,'\0',sizeof(a));
            memset(b,'\0',sizeof(b));
            memset(ta,'\0',sizeof(ta));
            memset(tb,'\0',sizeof(tb));
            memset(c,'\0',sizeof(c));
            memset(re,'\0',sizeof(re));
            scanf("%s %s",ta,tb);
            int lenta=strlen(ta),lentb=strlen(tb);
            for(i=0;i<lenta;i++)//录入小数点左部
            {
                if(ta[i]=='.') break;
                else a[i]=ta[i];
            }
            for(j=0;j<lentb;j++)
            {
                if(tb[j]=='.') break;
                else b[j]=tb[j];
            }
            if(lenta-i>lentb-j)//ta的小数位多，则以tb的小数位长度为界，录入新字符串中
            {
                o=0;
                tabp=lentb-j;
                for(u=1;u<tabp;u++)
                    a[i++]=ta[i];
                for(v=1;v<tabp;v++)
                    b[j++]=tb[j];
                for(q=i+1;q<lenta;q++)//将剩余小数位另存
                    re[o++]=ta[q];
            }
            else
            {
                o=0;
                tabp=lenta-i;
                for(u=1;u<tabp;u++)
                    a[i++]=ta[i];
                for(v=1;v<tabp;v++)
                    b[j++]=tb[j];
                for(q=i+1;q<lentb;q++)
                    re[o++]=tb[q];
            }
            //套用整数加法处理相同小数位之前的加法
            lena=strlen(a);
            lenb=strlen(b);
            for(i=lena-1,j=lenb-1;i>=0&&j>=0;i--,j--)
            {
                temp=(a[i]-'0')+(b[j]-'0')+jinwei;
                c[k++]=(temp%10)+'0';
                jinwei=temp/10;
            }
            if(j>=0)
            {
                strcpy(a,b);
                i=j;
            }
            for(;i>=0;i--)
            {
                temp=(a[i]-'0')+jinwei;
                c[k++]=(temp%10)+'0';
                jinwei=temp/10;
            }
            if(jinwei)
                c[k]=jinwei+'0';
            //printf("%s\n%s\n",a,b);
            //处理小数点
            for(i=strlen(c)-1;i>=tabp-1;i--)
            {
                if(c[i]>='0'&&c[i]<='9')
                printf("%c",c[i]);
            }
            int flag=0;//是否输出小数点
            for(i=o-1;i>=0;i--)//筛选尾部
            {
                if(re[i]=='0'&&flag==0)
                    re[i]='\0';
                else flag=1;
            }
            if(flag==0)//尾部都是0，继续筛选至小数点前
            {
                for(i=0;i<tabp-1;i++)
                {
                    if(c[i]=='0'&&flag==0)
                    c[i]='\0';
                    else flag=1;
                }
            }
            if(flag)
                printf(".");
            for(i=tabp-2;i>=0;i--)
            {
                if(c[i]>='0'&&c[i]<='9')
                    printf("%c",c[i]);
            }
            for(i=0;i<strlen(re);i++)
                if(re[i]>='0'&&re[i]<='9')
                    printf("%c",re[i]);
            printf("\n");
        }
    }
    return 0;
}

110 考试排名

问题描述 :

C++编程考试使用的实时提交系统，具有即时获得成绩排名的特点。它的功能是怎么实现的呢？

我们做好了题目的解答，提交之后，要么“AC”，要么错误，不管怎样错法，总是给你记上一笔，表明你曾经有过一次错误提交，因而当你一旦提交该题“AC”后，就要与你算一算帐了，总共该题错误提交了几回。虽然你在题数上，大步地跃上了一个台阶，但是在耗时上要摊上你共花去的时间。特别是，曾经有过的错误提交，每次都要摊上一定的单位时间分。这样一来，你在做出的题数上，可能领先别人很多，但是，在做出同样题数的人群中，你可能会在耗时上处于排名的劣势。

例如：某次考试一共8题（A，B，C，D，E，F，G，H），每个人做的题都在对应的题号下有个数量标记，负数表示该学生在该题上有过的错误提交次数，但到现在还没有AC，正数表示AC所耗的时间，如果正数a跟上一对括号，里面有个整数b，那就表示该学生提交该题AC了，耗去了时间a，同时，曾经错误提交了b次（如果b为0则没有括号及b），因此对于下述输入数据：

若每次错误提交的罚分为20分，即每错误提交一次，在总耗时时增加20分钟，则其排名从高到低应该是这样的：
Josephus 5 376
John 4 284
Alice 4 352
Smith 3 167
Bob 2 325
Bush 0 0

输入说明 :

输入数据的第一行是考试题数n（1≤n≤12）以及单位罚分数m（10≤m≤20），每行数据描述一个学生的用户名（不多于10个字符的字串）以及对所有n道题的答题现状，其描述采用问题描述中的数量标记的格式，见上面的表格，提交次数总是小于100，AC所耗时间总是小于1000。

学生数小于100。

输出说明 :

将这些学生的考试现状，输出一个实时排名。实时排名显然先按AC题数的多少排，多的在前，再按时间分的多少排，少的在前，如果凑巧前两者都相等，则按名字的字典序排，小的在前。每个学生占一行，输出名字（10个字符宽，左对齐），做出的题数（2个字符宽，右对齐）和时间分（4个字符宽，右对齐）。除上面所描述的为了对齐输出的空格外，名字、题数和时间分相互之间有一个空格。

输入范例 :

8 20
Smith -1 -16 8 0 0 120 39 0
John 116 -2 11 0 0 82 55(1) 0
Josephus 72(3) 126 10 -3 0 47 21(2) -2
Bush 0 -1 -8 0 0 0 0 0
Alice -2 67(2) 13 -1 0 133 79(1) -1
Bob 0 0 57(5) 0 0 168 -7 0
输出范例 :

Josephus 5 376
John 4 284
Alice 4 352
Smith 3 167
Bob 2 325
Bush 0 0

#include
#include
struct student{
    char name[20];
    char score[20][10];
    int time;
    int count;
}a[110],t;
int main(){
    int i=0,j,k,n,m,len,len0,temp1,temp2;
    scanf("%d %d",&n,&m);
    getchar();
    while(~scanf("%s",a[i].name))
    {
        for(j=0;j<n;j++)
            scanf("%s",a[i].score[j]);
        i++;
    }
    len=i;
    for(i=0;i<len;i++)
    {
        a[i].time=a[i].count=0;
        for(j=0;j<n;j++)
        {
            temp1=temp2=0;
            if(a[i].score[j][0]!='-'&&a[i].score[j][0]!='0')
            {
                a[i].count++;
                len0=strlen(a[i].score[j]);
                for(k=0;k<len0;k++)
                {
                    if(a[i].score[j][k]=='(')//计算括号里的数字
                    {
                        for(int p=k+1;p<len0-1;p++)
                            temp2=temp2*10+(a[i].score[j][p]-'0');
                        a[i].time+=(temp2*m);
                        temp2=0;
                        break;
                    }
                    else
                        temp1=temp1*10+(a[i].score[j][k]-'0');
                }
                a[i].time+=temp1;
            }
        }
    }
    for(i=0;i<len-1;i++)//冒泡排序，写的很长，因为条件多
    {
        for(j=0;j<len-i-1;j++)
        {
            if(a[j].count<a[j+1].count)
            {
                t=a[j];
                a[j]=a[j+1];
                a[j+1]=t;
            }
            else if(a[j].count==a[j+1].count)
            {
                if(a[j].time>a[j+1].time)
                {
                    t=a[j];
                    a[j]=a[j+1];
                    a[j+1]=t;
                }
                else if(a[j].time==a[j+1].time)
                {
                    int l1=strlen(a[j].name);
                    int l2=strlen(a[j+1].name);
                    int lenz=l1>l2?l2:l1;
                    for(int z=0;z<lenz;z++)//比较名字
                    {
                        if(a[j].name[z]>a[j+1].name[z])
                        {
                            t=a[j];
                            a[j]=a[j+1];
                            a[j+1]=t;
                            break;
                        }
                        else if(a[j].name[z]<a[j+1].name[z])
                            break;
                    }
                }
            }
        }
    }
    for(i=0;i<len;i++)
    {
        printf("%-10s %2d %4d\n",a[i].name,a[i].count,a[i].time);
    }
    return 0;
}

111 统计候选人的票数

问题描述 :

设有3个候选人zhang、li、wang（候选人姓名不区分大小写），10个选民，选民每次输入一个得票的候选人的名字，若选民输错候选人姓名，则按废票处理。选民投票结束后，程序自动显示各候选人的得票结果和废票信息。要求用结构体数组candidate表示3个候选人的姓名和得票结果。

输入说明 :

输入十行，每行表示一个选民的投票，每行包含一个候选人姓名。若选民输错候选人姓名，则按废票处理。

输出说明 :

选民投票结束后，程序自动显示各候选人的得票结果和废票信息。

每行输出“姓名: 票数”， 如zang:10。

最后一行输出：“Wrong election:票数”。

输入范例 :

li
li
li
li
zhang
zhang
zhang
ll
wang
wang
输出范例 :

li:4
zhang:3
wang:2
Wrong election:1

#include
#include
int main(){
    int li=0,wang=0,zhang=0,wrong=0,i=0,j;
    char a[20][110];
    while(gets(a[i])) i++;
    for(i=0;i<10;i++)
    {
        if(strcmp(a[i],"li")==0)
            li++;
        else if(strcmp(a[i],"zhang")==0)
            zhang++;
        else if(strcmp(a[i],"wang")==0)
            wang++;
        else wrong++;
    }
    printf("li:%d\nzhang:%d\nwang:%d\nWrong election:%d\n",li,zhang,wang,wrong);
    return 0;
}

112 密码分析

问题描述 :

密码分析学中常常需要统计字符出现的频度。给定若干行短文，要求按字符出现的频度由高到低输出，当两个字符出现的频度相同时，按字符大小的顺序输出。

注意：只需要统计英文字母的频度，非英文字母一律忽略。

输入说明 :

输入由多组数据组成。每组数据由一行长度不超过100的字符串组成，不区分字母大小写，如A与a看作同一个字母。

输出说明 :

对每组输入数据都有若干行输出，每行有两个输出数据，第一个数据为某个大写字母，第二个数据为该字母出现的频度，两个数据之间有一个空格。输出顺序按字母出现的频度由高到低输出，当两个字母的频度相同时，按字母大小的顺序输出。两组输出之间有一行空行。

输入范例 :

Do what you say, say what you do.
This is a test.
Count me 1 2 3 4 5.
输出范例 :

A 4
O 4
Y 4
D 2
H 2
S 2
T 2
U 2
W 2

S 3
T 3
I 2
A 1
E 1
H 1

C 1
E 1
M 1
N 1
O 1
T 1
U 1

#include
#include
int main(){
    int i,j,b[30],len,max,maxpos;
    char a[110];
    while(gets(a))
    {
        max=0;
        maxpos=-1;
        memset(b,0,sizeof(b));
        len=strlen(a);
        for(i=0;i<len;i++)
            if(a[i]>='a'&&a[i]<='z')
                a[i]=a[i]-32;
        for(i=0;i<len;i++)
            if(a[i]>='A'&&a[i]<='Z')
                b[a[i]-'A']++;
        for(i=0;;i++)
        {
            for(j=0;j<26;j++)
            {
                if(b[j]>max)
                {
                    max=b[j];
                    maxpos=j;
                }
            }
            if(!max) break;
            printf("%c %d\n",maxpos+'A',max);
            b[maxpos]=max=0;
        }
        printf("\n");
    }
    return 0;
}

113 学生信息

问题描述 :

你的程序需要从标准输入设备（通常为键盘）中输入N（1≤N≤10）个学生的信息，每项信息包含该学生的编号、姓名、性别、年龄、成绩共五项，按成绩进行排序，然后按成绩从低到高输出，输入保证没有相同的成绩。

输入说明 :

首先输入一个N（1≤N≤10），代表有几条学生记录，接下来N行每行包含一条学生记录，按照编号、姓名、性别、年龄、成绩的顺序给出，数据项之间以空格分隔，除了这五项之间的4个空格外，无其他空格。所有数据前后没有多余的空行，两个学生的记录之间也没有多余的空行。

输出说明 :

你的程序需要对学生的成绩按升序排序后输出所有学生的信息，每行一个学生的信息，同一个学生的信息之间以一个空格分隔。所有数据前后没有多余的空行，在行首和行尾没有多余的空格。

输入范例 :

2
1 aa male 13 1
2 bb female 14 0
输出范例 :

2 bb female 14 0
1 aa male 13 1

#include
#include
struct student{
    char number[20];
    char name[20];
    char sex[20];
    int age;
    int score;
}a[20],t;
int main(){
    int N,i,j;
    while(~scanf("%d",&N))
    {
        getchar();
        for(i=0;i<N;i++)
            scanf("%s %s %s %d %d",a[i].number,a[i].name,a[i].sex,&a[i].age,&a[i].score);
        for(i=0;i<N-1;i++)
            for(j=0;j<N-1-i;j++)
            {
                if(a[j].score>a[j+1].score)
                {
                    t=a[j];
                    a[j]=a[j+1];
                    a[j+1]=t;
                }
            }
        for(i=0;i<N;i++)
            printf("%s %s %s %d %d\n",a[i].number,a[i].name,a[i].sex,a[i].age,a[i].score);
    }
    return 0;
}

114 成绩统计

问题描述 :

每次通过键盘输入5位学生如下表所示的数据，然后计算并输出每位学生的平均成绩，再输出数学成绩最高的学生的姓名及成绩。

姓名

数学成绩

政治成绩

John

88

89

Jack

90

86

Marry

76

80

Kite

55

58

Jane

56

68

输入说明 :

从键盘输入5位学生如下表所示的数据

姓名

数学成绩

政治成绩

John

88

89

Jack

90

86

Marry

76

80

Kite

55

58

Jane

56

68

输入信息包括5行，每行包括姓名、数学成绩、政治成绩。
输出说明 :

首先输出5行，每行包括学生的姓名和平均成绩，平均成绩为数学成绩加政治成绩整除2（即丢掉小数部分）。

第6行为数学成绩最高的学生的姓名及成绩。

输入范例 :

John 88 89
Jack 80 86
Marry 76 80
Kite 55 58
Jane 56 68

输出范例 :

John 88
Jack 83
Marry 78
Kite 56
Jane 62
John 88 89

#include
#include
struct student{
    char name[20];
    int shuxue;
    int zhengzhi;
}a[110],max;
int main(){
    int i=0,j;
    while(~scanf("%s",a[i].name))
    {
        scanf("%d %d",&a[i].shuxue,&a[i].zhengzhi);
        i++;
    }
    for(j=0;j<i;j++)
        printf("%s %d\n",a[j].name,(a[j].shuxue+a[j].zhengzhi)/2);
    max=a[0];
    for(j=1;j<i;j++)
    {
        if(a[j].shuxue>max.shuxue)
            max=a[j];
    }
    printf("%s %d %d\n",max.name,max.shuxue,max.zhengzhi);
    return 0;
}

115 摩托车

问题描述 :

明明是一家摩托车厂的老板，他的厂为了迎合市场中不同消费者的需求，会生产不同型号的摩托车，这为明明的厂带来了不小的收益。有一次，一位大客户来到明明的厂洽谈生意，他需要采购一批型号各不相同的摩托车，然后他把需要的摩托车的型号告诉了明明，接着明明就需要在他所生产的摩托车中寻找到型号匹配的，如果有则卖给那个客户，如果没有则只能对客户说抱歉了。明明忙了一个上午，终于把那个客户需要的摩托车全部配齐了，然后成功的谈成了这笔生意。 事后，明明发现了一个问题，如果每个客户来，都需要这样忙一个上午，才能够知道自己生产的摩托车能否满足客户的需要，这样的工作效率实在太低了，更有可能损失很多客户，这样对工厂未来的发展也是很不利的。

于是明明找到了你，你是一名程序设计专家，明明希望你能够帮他写一个程序，程序中记录了他工厂生产的所有摩托车的数据，然后当有客户拿着摩托车的订单来洽谈生意时，只要在这个程序中输入摩托车的型号数据，程序就能够查询出工厂是否生产这类的摩托车，这样就能提高明明工厂的工作效率，有助于工厂进一步发展。

摩托车需要记录的数据有以下一些：

               摩托车的型号，摩托车的颜色和摩托车马达的类型。

例如，客户需要的摩托车型号如下：

摩托车型号

a1

a2

明明拥有的摩托车类型如下：

摩托车型号 摩托车颜色 摩托车马达型号

a1 yellow r1

a3 red r3

a4 blue r4

从中可以看出，明明的工厂只有a1这个型号的摩托车。

明明的问题可以归结为：写一个程序，程序中输入客户需要的摩托车型号和明明工厂拥有的摩托车的型号。在记录明明工厂的摩托车时，还要记录摩托车的颜色和摩托车马达的类型。程序要判断明明工厂拥有的摩托车是否能满足客户的需要。

输入说明 :

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

输出说明 :

对于每一组测试数据，你写的程序要求计算出一组相应的运算结果，并将这一组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。每组运算结果为一行或多行数据，这些数据表示明明工厂可以满足客户需要的摩托车的型号、颜色和马达型号，这三个数据之间用一个空格隔开。如果有多行，则输出时按照摩托车型号升序排列输出。

如果明明工厂没有一种型号的摩托车可以满足客户的需要，则输出“Not found!”，不包括双引号。详细格式请参考输出样例。每组运算结果与其后一组运算结果之间没有任何空行，第一组运算结果前面以及最后一组运算结果后面也都没有任何空行。 注：通常，显示屏为标准输出设备。

输入范例 :

3 5
a1
a2
a3
b1 blue r1
c1 red r2
d1 blue r3
a1 green r2
a2 yellow r1
1 1
a1
b1 blue r1
输出范例 :

a1 green r2
a2 yellow r1
Not found!

#include
#include
struct motuo{
    char num[20];
    char yanse[20];
    char mada[20];
}a[110],b[110],t;
int main(){
    int n,m,i,j,count;
    while(~scanf("%d %d",&n,&m))
    {
        getchar();
        for(i=0;i<n;i++) gets(b[i].num);
        for(i=0;i<m;i++)
            scanf("%s %s %s",a[i].num,a[i].yanse,a[i].mada);
        for(i=0;i<n-1;i++)//排序
        {
            for(j=0;j<n-1-i;j++)
            {
                if(strcmp(b[j].num,b[j+1].num)>0)
                {
                    t=b[j];
                    b[j]=b[j+1];
                    b[j+1]=t;
                }
            }
        }
        count=0;
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
            {
                if(strcmp(b[i].num,a[j].num)==0)
                {
                    printf("%s %s %s\n",a[j].num,a[j].yanse,a[j].mada);
                    count++;
                }
            }
        }
        if(!count) printf("Not found!\n");
    }
    return 0;
}

116 扑克牌

问题描述 :

明明和他的三位同学在玩一种非常有趣的扑克牌游戏。

在这个游戏中，一副牌的大小怪被除去，然后把剩下的52张牌随机发给4个人，这样每个人的手中就有13张牌。

接下来的任务就是每个人把自己手中的牌按一定的顺序整理好。理牌的顺序如下：

首先按牌的大小整理，牌的大小顺序为：A，K，Q，J，T(10)，9，…，2，如果牌的大小相等，则按如下的花色顺序整理：黑桃（S），红心（H），方块（D），草花（C）。

例如有一个人手中拿到的牌如下：

ST CQ S8 D8 HQ D2 H3 HK H9 H2 HT SK CK

经过整理后的牌的顺序会变为：

SK HK CK HQ CQ ST HT H9 S8 D8 H3 H2 D2

其中SK、HK、CK这三张牌的大小相同，都是K，于是根据花色的顺序整理，先是S，再是H，最后是C，所以顺序为SK、HK、CK。

当每个人把自己手中的牌整理完后，他们就开始玩非常有趣的扑克游戏了。但是玩着玩着，他们发现了一个问题：理牌的时间太长，这使得他们玩牌的兴致被大大减弱了。于是他们来求助于你，能否帮他们写一个理牌程序，帮助他们理牌，这样他们就可以不必把大量的时间花在理牌上面，而尽情享受玩牌的乐趣了。

明明的问题可以归结为：给你每人手中顺序打乱的13张牌，一共有4套，然后通过题目中描述的理牌顺序，理好这4套牌。

输入说明 :

你写的程序要求从标准输入设备中读入测试数据作为你所写程序的输入数据。标准输入设备中有多组测试数据，测试数据的第一行有一个整数n，表示有几副牌需要整理，接着每副牌分四行输入，每行13张牌；每张牌用两个字母表示，首字母表示花色，尾字母表示点数，两张牌之间有一个空格。每副牌与每副牌之间没有任何空行，第一副牌前面以及最后一副牌后面也都没有任何空行。 注：通常，键盘为标准输入设备。

输出说明 :

对于每一副牌，你写的程序要求计算出一组相应的运算结果，并将每组运算结果作为你所写程序的输出数据依次写入到标准输出设备中。对于每组输入的牌，输出排序后的牌，分四行输出，输出样式与输入相同。每组运算结果与其后一组运算结果之间有一个空行，第一组运算结果前面及最后一组运算结果后面没有空行。 注：通常，显示屏为标准输出设备。

输入范例 :

2
ST CQ S8 D8 HQ D2 H3 HK H9 H2 HT SK CK
D9 HJ H7 DJ S2 SQ DT C2 H4 H5 DA D4 D5
D6 S4 S9 S5 S7 SJ H8 D3 C8 S3 C4 S6 C9
SA C7 HA H6 DK CJ D7 CA C5 CT DQ C6 C3
D6 S4 S9 S5 S7 SJ H8 D3 C8 S3 C4 S6 C9
D9 HJ H7 DJ S2 SQ DT C2 H4 H5 DA D4 D5
ST CQ S8 D8 HQ D2 H3 HK H9 H2 HT SK CK
SA C7 HA H6 DK CJ D7 CA C5 CT DQ C6 C3
输出范例 :

SK HK CK HQ CQ ST HT H9 S8 D8 H3 H2 D2
DA SQ HJ DJ DT D9 H7 H5 D5 H4 D4 S2 C2
SJ S9 C9 H8 C8 S7 S6 D6 S5 S4 C4 S3 D3
SA HA CA DK DQ CJ CT D7 C7 H6 C6 C5 C3

SJ S9 C9 H8 C8 S7 S6 D6 S5 S4 C4 S3 D3
DA SQ HJ DJ DT D9 H7 H5 D5 H4 D4 S2 C2
SK HK CK HQ CQ ST HT H9 S8 D8 H3 H2 D2
SA HA CA DK DQ CJ CT D7 C7 H6 C6 C5 C3

#include
#include
struct puke{
    char pai[20];
    int huase;
    int daxiao;
}a[110],t;
int convert(char c)
{
    if(c=='A') return 1;
    if(c=='K') return 2;
    if(c=='Q') return 3;
    if(c=='J') return 4;
    if(c=='T') return 5;
    if(c=='9') return 6;
    if(c=='8') return 7;
    if(c=='7') return 8;
    if(c=='6') return 9;
    if(c=='5') return 10;
    if(c=='4') return 11;
    if(c=='3') return 12;
    if(c=='2') return 13;
    if(c=='S') return 1;
    if(c=='H') return 2;
    if(c=='D') return 3;
    if(c=='C') return 4;
}
int main(){
    int c,n,i,j,k;
    while(~scanf("%d",&n))
    {
        for(c=0;c<n;c++)
        {
            if(c) printf("\n");
            for(i=0;i<4;i++)
            {
                for(j=0;j<13;j++)
                {
                    scanf("%s",a[j].pai);
                    a[j].huase=convert(a[j].pai[0]);
                    a[j].daxiao=convert(a[j].pai[1]);
                }
                for(j=0;j<12;j++)
                {
                    for(k=0;k<12-j;k++)
                    {
                        if(a[k].daxiao>a[k+1].daxiao)
                        {
                            t=a[k];
                            a[k]=a[k+1];
                            a[k+1]=t;
                        }
                        else if(a[k].daxiao==a[k+1].daxiao&&a[k].huase>a[k+1].huase)
                        {
                            t=a[k];
                            a[k]=a[k+1];
                            a[k+1]=t;
                        }
                    }
                }
                for(j=0;j<13;j++)
                {
                    printf("%s",a[j].pai);
                    if(j<12) printf(" ");
                }
                printf("\n");
            }
        }
    }
    return 0;
}

117 混合牛奶

问题描述 :

牛奶包装是一个如此低利润的生意,所以尽可能低的控制初级产品(牛奶)的价格变得十分重要。请帮助快乐的牛奶制造者(Merry Milk Makers)以可能的最廉价的方式取得他们所需的牛奶。快乐的牛奶制造公司从一些农民那购买牛奶，每个农民卖给牛奶制造公司的价格不一定相同。而且,如一头母牛一天只能生产一定量的牛奶,农民每一天只有一定量的牛奶可以卖。每天,快乐的牛奶制造者从每个农民那购买一定量的牛奶,少于或等于农民所能提供的最大值。给出快乐牛奶制造者的每日的牛奶需求,连同每个农民的可提供的牛奶量和每加仑的价格,请计算快乐的牛奶制造者所要付出钱的最小值。注意: 每天农民生产的牛奶的总数对快乐的牛奶制造者来说足够的。

输入说明 :

第 1 行:二个整数, N 和 M。

第一个数值N(0<= N<=2,000,000)是快乐的牛奶制造者的一天需要牛奶的数量。第二个数值,M,(0<= M<=5,000)是农民的数目。

第 2 到 M+1 行：每行二个整数：Pi 和 Ai。 Pi(0<= Pi<=1,000) 是农民 i 牛奶的价格。 Ai(0<= Ai <= 2,000,000)是农民 i 一天能卖给快乐的牛奶制造者的牛奶数量。

输出说明 :

单独的一行包含单独的一个整数，表示快乐的牛奶制造者拿到所需的牛奶所要的最小费用

输入范例 :

100 5
5 20
9 40
3 10
8 80
6 30
输出范例 :

630

#include
#include
struct farmer{
    int price;
    int count;
}a[5010],t;
int main(){
    int n,m,i,j,sum;
    while(~scanf("%d%d",&n,&m))
    {
        sum=0;
        for(i=0;i<m;i++)
            scanf("%d%d",&a[i].price,&a[i].count);
        for(i=0;i<m-1;i++)
        {
            for(j=0;j<m-1-i;j++)
            {
                if(a[j].price>a[j+1].price)
                {
                    t=a[j];
                    a[j]=a[j+1];
                    a[j+1]=t;
                }
            }
        }
        for(i=0;i<m;i++)
        {
            if(n>=a[i].count)
            {
                n-=a[i].count;
                sum+=(a[i].count*a[i].price);
            }
            else if(n<a[i].count)
            {
                sum+=(n*a[i].price);
                break;
            }
        }
        printf("%d\n",sum);
    }
    return 0;
}

118 商店购物（待解决）

问题描述 :

在商店中，每一种商品都有一个价格（用整数表示）。例如,一朵花的价格是 2 zorkmids （z），而一个花瓶的价格是 5z 。为了吸引更多的顾客，商店举行了促销活动。

促销活动把一个或多个商品组合起来降价销售，例如： 三朵花的价格是 5z 而不是 6z， 两个花瓶和一朵花的价格是 10z 而不是 12z。

编写一个程序，计算顾客购买一定商品的花费，尽量利用优惠使花费最少。

尽管有时候添加其他商品可以获得更少的花费，但是你不能这么做。

对于上面的商品信息，购买三朵花和两个花瓶的最少花费是：以优惠价购买两个花瓶和一朵花（10z），以原价购买两朵花（4z）

输入说明 :

输入包括一些商店提供的优惠信息，接着是购物清单。

第一行 优惠商品的种类数（0 <= s <= 99）。

第二行…第s+1 行 每一行都用几个整数来表示一种优惠方式。

        第一个整数 n （1 <= n <= 5），表示这种优惠方式由 n 种商品组成。后面 n 对整数 c 和 k 表示 k （1 <= k <= 5）个编号为 c （1 <= c <= 999）的商品共同构成这种优惠，最后的整数 p 表示这种优惠的优惠价（1 <= p <= 9999）。优惠价总是比原价低。

第 s+2 行 这一行有一个整数 b （0 <= b <= 5），表示需要购买 b 种不同的商品。

第 s+3 行…第 s+b+2 行 这 b 行中的每一行包括三个整数：c ，k ，和 p 。c 表示唯一的商品编号（1 <= c <= 999），k 表示需要购买的 c 商品的数量（1 <= k <= 5）。p 表示 c 商品的原价（1<= p <= 999）。

最多购买 5*5=25 个商品。

输出说明 :

只有一行，输出一个整数：购买这些物品的最低价格。

输入范例 :

4
2 81 1 62 1 149
2 62 1 113 1 147
2 113 1 34 1 77
2 81 1 34 1 75
4
81 1 27
62 2 135
113 3 27
34 4 56
输出范例 :

558

119 挤牛奶

问题描述 :

三个农民每天清晨5点起床，然后去牛棚给3头牛挤奶。第一个农民在300时刻(从5点开始计时，秒为单位)给他的牛挤奶，一直到1000时刻。第二个农民在700时刻开始，在 1200时刻结束。第三个农民在1500时刻开始2100时刻结束。期间最长的至少有一个农民在挤奶的连续时间为900秒(从300时刻到1200时刻)，而最长的无人挤奶的连续时间(从挤奶开始一直到挤奶结束)为300秒(从1200时刻到1500时刻)。 你的任务是编一个程序，读入一个有N个农民(1 <= N <= 5000)挤N头牛的工作时间列表，计算以下两点(均以秒为单位): 最长至少有一人在挤奶的时间段。 最长的无人挤奶的时间段。

输入说明 :

Line 1: 一个整数N。 Lines 2…N+1: 每行两个小于1000000的非负整数，表示一个农民的开始时刻与结束时刻。

输出说明 :

一行，两个整数，即题目所要求的两个答案，以一个空格分隔。

输入范例 :

3
300 1000
700 1200
1500 2100
输出范例 :
900 300

#include
struct farmer{
    int start;
    int end;
}a[10100],b[10100],t;
int main()
{
    int i,j,k,N,maxlian,maxkong;
    while(~scanf("%d",&N))
    {
        k=0;
        for(i=0;i<N;i++)
            scanf("%d%d",&a[i].start,&a[i].end);
        for(i=0;i<N-1;i++)//按起始时间排序
        {
            for(j=0;j<N-1-i;j++)
            {
                if(a[j].start>a[j+1].start)
                {
                    t=a[j];
                    a[j]=a[j+1];
                    a[j+1]=t;
                }
            }
        }
        maxlian=a[0].end-a[0].start;
        maxkong=a[0].start;
        i=0;j=1;//两个指针，i指向某段起点，j指向某段终点
        b[k].start=a[i].start;
        b[k].end=a[i].end;
        while(j<N&&i<N)
        {
            if(a[j].start<a[i].end&&j<N)//两段可以无缝衔接
            {
                if(a[j].end>=a[i].end)//一二段合并
                {
                    b[k].end=a[j].end;
                    if(b[k].end-b[k].start>maxlian) maxlian=b[k].end-b[k].start;
                }
                j++;
            }
            else//两段断开
            {
                if(b[k].end-b[k].start>maxlian) maxlian=b[k].end-b[k].start;//清算上一部分
                if(a[j].start-b[k].end>maxkong) maxkong=a[j].start-b[k].end;
                i=j;k++;
                b[k].start=a[i].start;
                b[k].end=a[i].end;
            }
        }
        printf("%d %d\n",maxlian,maxkong);
    }
    return 0;
}

120 顺序的分数

问题描述 :

输入一个自然数N，请写一个程序来增序输出分母小于等于N的既约真分数(即无法再进行约分的小于1的分数)

输入说明 :

单独的一行，一个自然数N(1…20)

输出说明 :

每个分数单独占一行

按照分数大小升序排列

对于分子为0的分数，仅输出0/1，不输出其它分母的分数，比如0/2, 0/3。

输入范例 :

4
输出范例 :

0/1
1/4
1/3
1/2
2/3
3/4

#include
struct number{
    double num;
    int zi,mu;
}a[10100],t;
int main()
{
    int N,fenmu,fenzi,i,j,len,flag;
    while(~scanf("%d",&N))
    {
        i=flag=0;
        for(fenmu=1;fenmu<=N;fenmu++)
        {
            for(fenzi=0;fenzi<fenmu;fenzi++)
            {
                if(fenzi==0&&fenmu==1)
                {
                    a[i].num=(double)fenzi/fenmu;
                    a[i].zi=fenzi;
                    a[i].mu=fenmu;
                    i++;
                }
                else if(fenzi==0&&fenmu!=1) continue;
                else if(fenmu%fenzi!=0)
                {
                    for(int p=2;p<fenzi;p++)
                        if(fenzi%p==0&&fenmu%p==0) flag=1;
                    if(!flag)
                    {
                        a[i].num=(double)fenzi/fenmu;
                        a[i].zi=fenzi;
                        a[i].mu=fenmu;
                        i++;
                    }
                    flag=0;
                }
                else if(fenzi==1&&fenmu!=1)
                {
                    a[i].num=(double)fenzi/fenmu;
                    a[i].zi=fenzi;
                    a[i].mu=fenmu;
                    i++;
                }
            }
        }
        len=i;
        for(i=0;i<len-1;i++)
            for(j=0;j<len-i-1;j++)
            {
                if(a[j].num>a[j+1].num)
                {
                    t=a[j];
                    a[j]=a[j+1];
                    a[j+1]=t;
                }
            }
        for(i=0;i<len;i++)
            printf("%d/%d\n",a[i].zi,a[i].mu);
    }
    return 0;
}

后面不更了

太菜了 很多题目都是参考别人代码写的