PTA 程序设计天梯赛（41~60题）

制作不易，喜欢请点个赞，我是王睿，很高兴认识大家！

41、整除光棍 (20 分)

L1-046 整除光棍 (20 分)
这里所谓的“光棍”，并不是指单身汪啦~ 说的是全部由1组成的数字，比如1、11、111、1111等。传说任何一个光棍都能被一个不以5结尾的奇数整除。比如，111111就可以被13整除。 现在，你的程序要读入一个整数x，这个整数一定是奇数并且不以5结尾。然后，经过计算，输出两个数字：第一个数字s，表示x乘以s是一个光棍，第二个数字n是这个光棍的位数。这样的解当然不是唯一的,题目要求你输出最小的解。

提示：一个显然的办法是逐渐增加光棍的位数，直到可以整除x为止。但难点在于，s可能是个非常大的数 —— 比如，程序输入31，那么就输出3584229390681和15，因为31乘以3584229390681的结果是111111111111111，一共15个1。

输入格式：
输入在一行中给出一个不以5结尾的正奇数x（<1000）。

输出格式：
在一行中输出相应的最小的s和n，其间以1个空格分隔。

输入样例：
31
输出样例：
3584229390681 15

#include<stdio.h>  
int main ()
 {  
    int n, len=0,p=0,now=1;  
    char ans[1000];  
    scanf("%d",&n);  
    while (!0)
{  
   len++;                 //1,11,111,111....尝试能不能整除 
        if(p||now/n)          //商第一位是0时，不输出,p==0,保证了第一位，不让不止第一位不输出0了   
        ans[p++]='0'+now/n;   //保存商，转化为字符   
        now%=n;               //取余数是模拟除法的关键之1 
        if(now==0) 
{                   //余数是0，说明能整除了   
            ans[p]='\0'; //由自己一步一步建的字符串要加上字符串结束符   
            printf("%s %d\n", ans, len);  
            break;  
        }  
        now=now*10+1; //乘10是模拟除法的关键之2  
    }  
    return 0;  
}

42、 装睡 (10 分)

L1-047 装睡 (10 分)
你永远叫不醒一个装睡的人 —— 但是通过分析一个人的呼吸频率和脉搏，你可以发现谁在装睡！医生告诉我们，正常人睡眠时的呼吸频率是每分钟15-20次，脉搏是每分钟50-70次。下面给定一系列人的呼吸频率与脉搏，请你找出他们中间有可能在装睡的人，即至少一项指标不在正常范围内的人。

输入格式：
输入在第一行给出一个正整数N（≤10）。随后N行，每行给出一个人的名字（仅由英文字母组成的、长度不超过3个字符的串）、其呼吸频率和脉搏（均为不超过100的正整数）。

输出格式：
按照输入顺序检查每个人，如果其至少一项指标不在正常范围内，则输出其名字，每个名字占一行。

输入样例：
4
Amy 15 70
Tom 14 60
Joe 18 50
Zoe 21 71
输出样例：
Tom
Zoe

#include<stdio.h>
int main(void)
{
	int N;	//输入一个正整数
	scanf("%d",&N);
	char name[8][4];	//名字      //这里一定要注意多设一位
	int huxi[8];		//呼吸频率
	int maibo[8];		//脉搏
	int i;				//用于循环和数组下标
	for(i=0;i<N;i++)	//提供输入功能
		scanf("%s%d%d",&name[i][0],&huxi[i],&maibo[i]);
	for(i=0;i<N;i++)
		if(huxi[i]<15 || huxi[i]>20 || maibo[i]<50 || maibo[i]>70)
			puts(name[i]);
}

43、矩阵A乘以B (15 分)

L1-048 矩阵A乘以B (15 分)
给定两个矩阵A和B，要求你计算它们的乘积矩阵AB。需要注意的是，只有规模匹配的矩阵才可以相乘。即若A有R
​a
​​ 行、C
​a
​​ 列，B有R
​b
​​ 行、C
​b
​​ 列，则只有C
​a
​​ 与R
​b
​​ 相等时，两个矩阵才能相乘。

输入格式：
输入先后给出两个矩阵A和B。对于每个矩阵，首先在一行中给出其行数R和列数C，随后R行，每行给出C个整数，以1个空格分隔，且行首尾没有多余的空格。输入保证两个矩阵的R和C都是正数，并且所有整数的绝对值不超过100。

输出格式：
若输入的两个矩阵的规模是匹配的，则按照输入的格式输出乘积矩阵AB，否则输出Error: Ca != Rb，其中Ca是A的列数，Rb是B的行数。

输入样例1：
2 3
1 2 3
4 5 6
3 4
7 8 9 0
-1 -2 -3 -4
5 6 7 8
输出样例1：
2 4
20 22 24 16
53 58 63 28
输入样例2：
3 2
38 26
43 -5
0 17
3 2
-11 57
99 68
81 72
输出样例2：
Error: 2 != 3

#include<stdio.h>
#define N 100
#define M 100
int main()
{
	int a[N][M]={0},b[N][M]={0},c[N][M]={0};
	int i,j,k;				//用于循环和数组下标
	int ra,ca,rb,cb,rc,cc;	//分别表示矩形A的行和列、矩形B的行和列、矩形C的行和列
	int n;					//
	scanf("%d %d",&ra,&ca);
	for(i=0;i<ra;i++)	//矩形A
		for(j=0;j<ca;j++)
			scanf("%d",&a[i][j]);
	scanf("%d %d",&rb,&cb);

	for(i=0;i<rb;i++)	//矩形B
		for(j=0;j<cb;j++)
			scanf("%d",&b[i][j]);
	if(ca == rb)
	{	//注意，因为咱们是将要两个矩形相乘，那么可以肯定是这两个长相不一样的矩形，
		//当一样的条件被我们判断了之后另两个条件将是决定矩形C的行列标准，所以
		//这里咱们应该要将矩形A的行和矩形B的列综合起来作为矩形C的形状，从而参与计算

		rc = ra;	//这里将矩形A的行作为矩形C的行
		cc = cb;	//这里将矩形B的列作为矩形C的列
		n = ca;		//这里是决定k循环的因素
		printf("%d %d\n",rc,cc);
		for(i=0;i<rc;i++)		//控制行数
		{
			for(j=0;j<cc;j++)	//控制列数
			{
				for(k=0;k<n;k++)	//求出矩形A里第一行的元素分别乘以矩形b第一列的元素，求总和输出
				{					//以此类推
					c[i][j]+=a[i][k]*b[k][j];
				}
				if(j!=cc-1)
					printf("%d ",c[i][j]);
				else
					printf("%d",c[i][j]);
			}
			printf("\n");			//每输出完矩形C的一列数据完后就换行一次
		}
	}
	else	//当数据完全匹配时输出此话
		printf("Error: %d != %d\n",ca,rb);
	return 0;
}

44、 倒数第N个字符串 (15 分)

L1-050 倒数第N个字符串 (15 分)
给定一个完全由小写英文字母组成的字符串等差递增序列，该序列中的每个字符串的长度固定为 L，从 L 个 a 开始，以 1 为步长递增。例如当 L 为 3 时，序列为 { aaa, aab, aac, …, aaz, aba, abb, …, abz, …, zzz }。这个序列的倒数第27个字符串就是 zyz。对于任意给定的 L，本题要求你给出对应序列倒数第 N 个字符串。

输入格式：
输入在一行中给出两个正整数 L（2 ≤ L ≤ 6）和 N（≤10
​5
​​ ）。

输出格式：
在一行中输出对应序列倒数第 N 个字符串。题目保证这个字符串是存在的。

输入样例：
3 7417
输出样例：
pat

#include<stdio.h>
#include<math.h>
#define L 6

int main()
{
	char ch[26]={'z','y','x','w','v','u','t','s','r','q','p','o','n','m'
	             ,'l','k','j','i','h','g','f','e','d','c','b','a'};
	char arr[L];
	int n,l,a,i;         //l为序列长度，n为序列所处倒序的位置,a为所求字符串的某个字符在ch数组中的位置 
	scanf("%d %d",&l,&n);
	n=n-1;               //根据推导过程发现，减去1后最后一个字符才是正确的
	for(i=0;i<l;i++)
	{
		a=n/pow(26,l-i-1);
		arr[i]=ch[a];
		n=n-a*pow(26,l-i-1);
	}
	for(i=0;i<l;i++)
	{
		printf("%c",arr[i]);
	}
	return 0;
 }

45、打折 (5 分)

L1-051 打折 (5 分)
去商场淘打折商品时，计算打折以后的价钱是件颇费脑子的事情。例如原价 ￥988，标明打 7 折，则折扣价应该是 ￥988 x 70% = ￥691.60。本题就请你写个程序替客户计算折扣价。

输入格式：
输入在一行中给出商品的原价（不超过1万元的正整数）和折扣（为[1, 9]区间内的整数），其间以空格分隔。

输出格式：
在一行中输出商品的折扣价，保留小数点后 2 位。

输入样例：
988 7
输出样例：
691.60

#include<stdio.h>
int main(void)
{
	double before_money;			//原价
	double after_money;			//打折后
	double zhe;					//折扣
	scanf("%lf %lf",&before_money,&zhe);
	after_money=before_money*zhe/10;
	printf("%.2lf\n",after_money);
}

46、 2018我们要赢 (5 分)

L1-052 2018我们要赢 (5 分)
2018年天梯赛的注册邀请码是“2018wmyy”，意思就是“2018我们要赢”。本题就请你用汉语拼音输出这句话。

输入格式：
本题没有输入。

输出格式：
在第一行中输出：“2018”；第二行中输出：“wo3 men2 yao4 ying2 !”。

输入样例：
无
输出样例：
2018
wo3 men2 yao4 ying2 !

#include<stdio.h>
int main(void)
{
	printf("2018\n");
	printf("wo3 men2 yao4 ying2 !\n");
	return 0;
}

47、电子汪 (10 分)

L1-053 电子汪 (10 分)
据说汪星人的智商能达到人类 4 岁儿童的水平，更有些聪明汪会做加法计算。比如你在地上放两堆小球，分别有 1 只球和 2 只球，聪明汪就会用“汪！汪！汪！”表示 1 加 2 的结果是 3。

本题要求你为电子宠物汪做一个模拟程序，根据电子眼识别出的两堆小球的个数，计算出和，并且用汪星人的叫声给出答案。

输入格式：
输入在一行中给出两个 [1, 9] 区间内的正整数 A 和 B，用空格分隔。

输出格式：
在一行中输出 A + B 个Wang!。

输入样例：
2 1
输出样例：
Wang!Wang!Wan

#include<stdio.h>
int main(void)
{
	int A;	
	int B;
	scanf("%d %d",&A,&B);
	for(int i=1;i<=A+B;i++)
		printf("Wang!");
	return 0;
}

48、 谁是赢家 (10 分)

L1-055 谁是赢家 (10 分)
某电视台的娱乐节目有个表演评审环节，每次安排两位艺人表演，他们的胜负由观众投票和 3 名评委投票两部分共同决定。规则为：如果一位艺人的观众票数高，且得到至少 1 名评委的认可，该艺人就胜出；或艺人的观众票数低，但得到全部评委的认可，也可以胜出。节目保证投票的观众人数为奇数，所以不存在平票的情况。本题就请你用程序判断谁是赢家。

输入格式：
输入第一行给出 2 个不超过 1000 的正整数 Pa 和 Pb，分别是艺人 a 和艺人 b 得到的观众票数。题目保证这两个数字不相等。随后第二行给出 3 名评委的投票结果。数字 0 代表投票给 a，数字 1 代表投票给 b，其间以一个空格分隔。

输出格式：
按以下格式输出赢家：

The winner is x: P1 + P2
其中 x 是代表赢家的字母，P1 是赢家得到的观众票数，P2 是赢家得到的评委票数。

输入样例：
327 129
1 0 1
输出样例：
The winner is a: 327 + 1
鸣谢安阳师范学院软件学院李栋同学完善测试数据。

作者: 陈越
单位: 浙江大学
时间限制: 400 ms
内存限制: 64 MB

#include<stdio.h>
int main(void)
{
	int Pa;			//a的得票数
	int Pb;			//b的得票数
	int num;		//评委投票
	int a=0,b=0;	//计算a、b评委投票总数
	scanf("%d %d",&Pa,&Pb);
	for(int i=0;i<3;i++)
	{
		scanf("%d",&num);
			if(num==0)
				a++;
			else
				b++;
	}
	if(Pa>Pb&&a!=0)
		printf("The winner is a: %d + %d\n",Pa,a);
	else if(Pa<Pb&&b!=0)
		printf("The winner is b: %d + %d\n",Pb,b);
	else if(Pa<Pb&&a==3)
		printf("The winner is a: %d + %d\n",Pa,a);
	else if(Pa>Pb&&b==3)
		printf("The winner is b: %d + %d\n",Pb,b);
}

49、链表去重 (25 分)

L2-002 链表去重 (25 分)
给定一个带整数键值的链表 L，你需要把其中绝对值重复的键值结点删掉。即对每个键值 K，只有第一个绝对值等于 K 的结点被保留。同时，所有被删除的结点须被保存在另一个链表上。例如给定 L 为 21→-15→-15→-7→15，你需要输出去重后的链表 21→-15→-7，还有被删除的链表 -15→15。

输入格式：
输入在第一行给出 L 的第一个结点的地址和一个正整数 N（≤10
​5
​​ ，为结点总数）。一个结点的地址是非负的 5 位整数，空地址 NULL 用 −1 来表示。

随后 N 行，每行按以下格式描述一个结点：

地址 键值 下一个结点
其中地址是该结点的地址，键值是绝对值不超过10
​4
​​ 的整数，下一个结点是下个结点的地址。

输出格式：
首先输出去重后的链表，然后输出被删除的链表。每个结点占一行，按输入的格式输出。

输入样例：
00100 5
99999 -7 87654
23854 -15 00000
87654 15 -1
00000 -15 99999
00100 21 23854
输出样例：
00100 21 23854
23854 -15 99999
99999 -7 -1
00000 -15 87654
87654 15 -1

#include <stdio.h>
#include <string.h>
#include <math.h>
#define N 10*10*10*10*10+1
struct Node
{
    int jian,xia;		//jian→键位、xia→下一个结点
}node[N];
int main()
{
	int l,n;		//l→首个地址，n→有几个地址、输入几轮
    int first;		//每一轮的起始地址
	int i,j;		//用于循环和数组下标
	int tmp[10001]={0};
	//配合循环拆分链表时，检验这个下标是否出现过，若出现则赋值给被删除的链表
	int one[N],two[N];
	//  one → 表示去重后的链表，two → 表示被删除的链表
	int o=0,t=0;
	int num;		//num得到每一个地址的键值
	scanf("%d%d",&l,&n);
        for(i=0;i<n;i++)
        {
            scanf("%d",&first);
            scanf("%d%d",&node[first].jian,&node[first].xia);
        }
        for(i=l;node[i].xia != -1;)
        {
            int num=abs(node[i].jian);
            if(tmp[num]==0)
            {
                tmp[num]=1;
                one[o++]=i;		//存储地址
            }
            else
            {
                two[t++]=i;
            }
            i=node[i].xia;
        }
		num=abs(node[i].jian);//这里要注意一下最后一个下标
        if(tmp[num]==0)
        {	one[o++]=i;}
        else
        {   two[t++]=i;}
            printf("%05d %d ",one[0],node[one[0]].jian);
            for(j=1;j<o;j++)
            {
                printf("%05d\n",one[j]);
                printf("%05d %d ",one[j],node[one[j]].jian);
            }
            printf("%d\n",-1);
            if(t!=0)		//没删除过链表的情况需要判断一下
            {
                printf("%05d %d ",two[0],node[two[0]].jian);
                for(j=1;j<t;j++)
                {
                    printf("%05d\n",two[j]);
                    printf("%05d %d ",two[j],node[two[j]].jian);
                }
                printf("%d\n",-1);
            }
			return 0;
}

50、 名人堂与代金券 (25 分)

L2-027 名人堂与代金券 (25 分)
对于在中国大学MOOC（http://www.icourse163.org/ ）学习“数据结构”课程的学生，想要获得一张合格证书，总评成绩必须达到 60 分及以上，并且有另加福利：总评分在 [G, 100] 区间内者，可以得到 50 元 PAT 代金券；在 [60, G) 区间内者，可以得到 20 元PAT代金券。全国考点通用，一年有效。同时任课老师还会把总评成绩前 K 名的学生列入课程“名人堂”。本题就请你编写程序，帮助老师列出名人堂的学生，并统计一共发出了面值多少元的 PAT 代金券。

输入格式：
输入在第一行给出 3 个整数，分别是 N（不超过 10 000 的正整数，为学生总数）、G（在 (60,100) 区间内的整数，为题面中描述的代金券等级分界线）、K（不超过 100 且不超过 N 的正整数，为进入名人堂的最低名次）。接下来 N 行，每行给出一位学生的账号（长度不超过15位、不带空格的字符串）和总评成绩（区间 [0, 100] 内的整数），其间以空格分隔。题目保证没有重复的账号。

输出格式：
首先在一行中输出发出的 PAT 代金券的总面值。然后按总评成绩非升序输出进入名人堂的学生的名次、账号和成绩，其间以 1 个空格分隔。需要注意的是：成绩相同的学生享有并列的排名，排名并列时，按账号的字母序升序输出。

输入样例：
10 80 5
cy@zju.edu.cn 78
cy@pat-edu.com 87
1001@qq.com 65
uh-oh@163.com 96
test@126.com 39
anyone@qq.com 87
zoe@mit.edu 80
jack@ucla.edu 88
bob@cmu.edu 80
ken@163.com 70
输出样例：
360
1 uh-oh@163.com 96
2 jack@ucla.edu 88
3 anyone@qq.com 87
3 cy@pat-edu.com 87
5 bob@cmu.edu 80
5 zoe@mit.edu 80

原题链接：
L2-027 名人堂与代金券 (25 分)

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct stu{
int id;//名次
char edu[25];//账号
int score;//成绩
};
//排序算法?
int cmp(const void * a,const void * b)
{ 
	struct stu aa = *(struct stu *)a;
	struct stu bb = *(struct stu *)b;
	if(aa.score == bb.score)
	return strcmp(aa.edu,bb.edu); //当成绩一样时，我们比对账号?
	else
	return aa.score > bb.score ? -1 : 1;
	}
	int main()
	{
	int N,G,K;
	struct stu stud[10005];
	while(scanf("%d%d%d",&N,&G,&K) != EOF){
	
	int i;
	int ans = 0;
	
	for(i = 0 ; i < N ; i++){
	scanf("%s %d",stud[i].edu,&stud[i].score);
	if(stud[i].score >= 60 && stud[i].score < G){
	ans += 20;
	}
	if(stud[i].score >= G && stud[i].score <= 100){
	ans += 50;
	}
	}
	printf("%d\n",ans);//输出代金券?
	
	qsort(stud,N,sizeof(stud[0]),cmp);
	int num = 1;
	stud[0].id = 1;
	
	for(i = 1 ; i < N ; i++) //排好序后处理名次问题?
	{
	num++;
	if(stud[i].score == stud[i-1].score){
	stud[i].id = stud[i-1].id;
	}else{
	stud[i].id = num;
	}
	}
	
	for(i = 0 ; i < K ; i++)
	printf("%d %s %d\n",stud[i].id,stud[i].edu,stud[i].score);
	int k = K;
	while(stud[K-1].score == stud[k].score){//判断输出K名同学之后还有没有排名在小于等于K的同学?
	printf("%d %s %d\n",stud[k].id,stud[k].edu,stud[k].score);
	k++;
	}
	
	}
	return 0;
}

51、 凑零钱 (30 分)

L3-001 凑零钱 (30 分)
韩梅梅喜欢满宇宙到处逛街。现在她逛到了一家火星店里，发现这家店有个特别的规矩：你可以用任何星球的硬币付钱，但是绝不找零，当然也不能欠债。韩梅梅手边有 10
​4
​​ 枚来自各个星球的硬币，需要请你帮她盘算一下，是否可能精确凑出要付的款额。

输入格式：
输入第一行给出两个正整数：N（≤10
​4
​​ ）是硬币的总个数，M（≤10
​2
​​ ）是韩梅梅要付的款额。第二行给出 N 枚硬币的正整数面值。数字间以空格分隔。

输出格式：
在一行中输出硬币的面值 V
​1
​​ ≤V
​2
​​ ≤⋯≤V
​k
​​ ，满足条件 V
​1
​​ +V
​2
​​ +…+V
​k
​​ =M。数字间以 1 个空格分隔，行首尾不得有多余空格。若解不唯一，则输出最小序列。若无解，则输出 No Solution。

注：我们说序列{ A[1],A[2],⋯ }比{ B[1],B[2],⋯ }“小”，是指存在 k≥1 使得 A[i]=B[i] 对所有 i<k 成立，并且 A[k]<B[k]。

输入样例 1：
8 9
5 9 8 7 2 3 4 1
输出样例 1：
1 3 5
输入样例 2：
4 8
7 2 4 3
输出样例 2：
No Solution

原题链接：
L3-001 凑零钱 (30 分)

#include<stdio.h>  
#include<algorithm>  
#include<vector>  
using namespace std;  
int values[10001],dp[101],choose[10001][101];  
bool cmp(int a,int b)  
{  
    return a>b;  
}  
int main()  
{  
    int i,j,n,m,k,t;  
    scanf("%d %d",&n,&m);  
    for(i=1;i<=n;i++)  
    {  
        scanf("%d",&values[i]);  
    }  
    sort(values+1,values+n+1,cmp);  
    for(i=1;i<=n;i++)  
    {  
        for(j=m;j>=values[i];j--)  
        {  
            if(dp[j]<=dp[j-values[i]]+values[i])  
            {  
                choose[i][j]=1;  
                dp[j]=dp[j-values[i]]+values[i];  
            }  
  
        }  
    }  
    if(dp[m]!=m)  
    {  
        printf("No Solution\n");  
        return 0;  
    }  
    int index=n,sum=m;  
    vector<int> arr;  
    while(sum>0)  
    {  
        if(choose[index][sum]==1)  
        {  
  
           arr.push_back(values[index]);  
           sum-=values[index];  
        }  
        index--;  
    }  
    for(i=0;i<arr.size();i++)  
    {  
        if(i==0)  
        {  
            printf("%d",arr[i]);  
        }  
        else  
        {  
            printf(" %d",arr[i]);  
        }  
    }  
    printf("\n");  
    return 0;  
}

52、 害死人不偿命的(3n+1)猜想 (15 分)

1001 害死人不偿命的(3n+1)猜想 (15 分)
卡拉兹(Callatz)猜想：

对任何一个正整数 n，如果它是偶数，那么把它砍掉一半；如果它是奇数，那么把 (3n+1) 砍掉一半。这样一直反复砍下去，最后一定在某一步得到 n=1。卡拉兹在 1950 年的世界数学家大会上公布了这个猜想，传说当时耶鲁大学师生齐动员，拼命想证明这个貌似很傻很天真的命题，结果闹得学生们无心学业，一心只证 (3n+1)，以至于有人说这是一个阴谋，卡拉兹是在蓄意延缓美国数学界教学与科研的进展……

我们今天的题目不是证明卡拉兹猜想，而是对给定的任一不超过 1000 的正整数 n，简单地数一下，需要多少步（砍几下）才能得到 n=1？

输入格式：
每个测试输入包含 1 个测试用例，即给出正整数 n 的值。

输出格式：
输出从 n 计算到 1 需要的步数。

输入样例：
3
输出样例：
5

原题链接：1001 害死人不偿命的(3n+1)猜想 (15 分)

#include<stdio.h>
int main()
{
	int i,j;
	int n;
	int k=0;
	scanf("%d",&n);
	if(n==0){
	printf("0");return 0;
	}
	for(i=0;;i++)
	{
		if(n%2==0)
			n/=2;
		else
		{
			n= (3*n+1)/2;
		}
		k++;
		if(n==1)
		break;
	}
	printf("%d",k);
}

53、写出这个数 (20 分)

1002 写出这个数 (20 分)
读入一个正整数 n，计算其各位数字之和，用汉语拼音写出和的每一位数字。

输入格式：
每个测试输入包含 1 个测试用例，即给出自然数 n 的值。这里保证 n 小于 10
​100
​​ 。

输出格式：
在一行内输出 n 的各位数字之和的每一位，拼音数字间有 1 空格，但一行中最后一个拼音数字后没有空格。

输入样例：
1234567890987654321123456789
输出样例：
yi san wu

原题链接：1002 写出这个数 (20 分)

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int k=0;
	int sum=0,i=0,j;
	char n[1001];
	gets(n);
	int len = strlen(n);
	for(i=0;i<len;i++)
	{
		sum+=n[i]-'0';
	}
	//printf("%d\n",sum);		//调试是否得到135？
	int dayin[10];
	//printf("%d\n",lenght);
	i=0;
	while(sum!=0)
	{
		dayin[i++]=sum%10;
		sum/=10;
	}
	for(j=i-1;j>=0;j--)
	{
		if(j!=0){
		switch(dayin[j])
		{
		case 1:printf("yi ");break;
		case 2:printf("er ");break;
		case 3:printf("san ");break;
		case 4:printf("si ");break;
		case 5:printf("wu ");break;
		case 6:printf("liu ");break;
		case 7:printf("qi ");break;
		case 8:printf("ba ");break;
		case 9:printf("jiu ");break;
		case 0:printf("ling ");break;
		}
		}
		else
		{
		switch(dayin[j])
		{
		case 1:printf("yi");break;
		case 2:printf("er");break;
		case 3:printf("san");break;
		case 4:printf("si");break;
		case 5:printf("wu");break;
		case 6:printf("liu");break;
		case 7:printf("qi");break;
		case 8:printf("ba");break;
		case 9:printf("jiu");break;
		case 0:printf("ling");break;
		}
		}


	}
	return 0;
}

54、我要通过！ (20 分)

1003 我要通过！ (20 分)
“答案正确”是自动判题系统给出的最令人欢喜的回复。本题属于 PAT 的“答案正确”大派送 —— 只要读入的字符串满足下列条件，系统就输出“答案正确”，否则输出“答案错误”。

得到“答案正确”的条件是：

字符串中必须仅有 P、 A、 T这三种字符，不可以包含其它字符；
任意形如 xPATx 的字符串都可以获得“答案正确”，其中 x 或者是空字符串，或者是仅由字母 A 组成的字符串；
如果 aPbTc 是正确的，那么 aPbATca 也是正确的，其中 a、 b、 c 均或者是空字符串，或者是仅由字母 A 组成的字符串。
现在就请你为 PAT 写一个自动裁判程序，判定哪些字符串是可以获得“答案正确”的。

输入格式：
每个测试输入包含 1 个测试用例。第 1 行给出一个正整数 n (<10)，是需要检测的字符串个数。接下来每个字符串占一行，字符串长度不超过 100，且不包含空格。

输出格式：
每个字符串的检测结果占一行，如果该字符串可以获得“答案正确”，则输出 YES，否则输出 NO。

输入样例：
8
PAT
PAAT
AAPATAA
AAPAATAAAA
xPATx
PT
Whatever
APAAATAA
输出样例：
YES
YES
YES
YES
NO
NO
NO
NO

原题链接：1003 我要通过！ (20 分)

#include<stdio.h>
int main()
{
    int n;          
    scanf("%d",&n);             
    while(n--){
        char str[110];
        int np=0,nt=0,other=0,lp,lt;
        scanf("%s",str);
        int len=strlen(str);
        for(int i=0;i<len;i++){                     //记录P,T和其他字母的个数以及P和T的位置 
            if(str[i]=='P'){
                np++;
                lp=i;
            }else if(str[i]=='T'){
                nt++;
                lt=i;
            }else if(str[i]!='A') 
                other++;
        }
        if((np!=1)||(nt!=1)||(other!=0)||(lt-lp<=1)){//P和T的个数必须为一，没有其他字母，P和T中间至少有一个A 
            printf("NO\n");
            continue;
        }
        int x=lp,y=lt-lp-1,z=len-lt-1;              
        if(x*y==z)
        printf("YES\n");
        else printf("NO\n");
    }
    return 0;

} 

55、 换个格式输出整数 (15 分)

1006 换个格式输出整数 (15 分)
让我们用字母 B 来表示“百”、字母 S 表示“十”，用 12…n 来表示不为零的个位数字 n（<10），换个格式来输出任一个不超过 3 位的正整数。例如 234 应该被输出为 BBSSS1234，因为它有 2 个“百”、3 个“十”、以及个位的 4。

输入格式：
每个测试输入包含 1 个测试用例，给出正整数 n（<1000）。

输出格式：
每个测试用例的输出占一行，用规定的格式输出 n。

输入样例 1：
234
输出样例 1：
BBSSS1234
输入样例 2：
23
输出样例 2：
SS123

原题链接：1006 换个格式输出整数 (15 分)

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int n;
	int i=0,j,num=1;
	int k[100]={0},k1=0;
	scanf("%d",&n);
	while(n!=0)
	{
		k[k1++]=n%10;
		n/=10;
	}
	int ci=k1;
	for(i=k1-1;i>=0;i--)
	{
		if(ci==3)
		{
			while(k[i]--){
				printf("B");
			}
		}
		else if(ci==2)
		{
			while(k[i]--){
				printf("S");
			}
		}
		else
		{
			while(k[i]--){
				printf("%d",num);
				num++;
			}
		}	
		ci--;	
	}
	return 0;
}

56、 素数对猜想 (20 分)

1007 素数对猜想 (20 分)
让我们定义d
​n
​​ 为：d
​n
​​ =p
​n+1
​​ −p
​n
​​ ，其中p
​i
​​ 是第i个素数。显然有d
​1
​​ =1，且对于n>1有d
​n
​​ 是偶数。“素数对猜想”认为“存在无穷多对相邻且差为2的素数”。

现给定任意正整数N(<10
​5
​​ )，请计算不超过N的满足猜想的素数对的个数。

输入格式:
输入在一行给出正整数N。

输出格式:
在一行中输出不超过N的满足猜想的素数对的个数。

输入样例:
20
输出样例:
4

原题链接：1007 素数对猜想 (20 分)

#include<stdio.h>
#include<math.h>
int main()
{
	int i,j;
	int r=0;
	int n;
	int a[2900],k=0;
	scanf("%d",&n);
	for(i=5;i<=n;i+=2)
	{
		for(j=3;j*j<=i;j+=2){
			if(i%j==0)
			break;
		}
		if(j==i)
		a[k++]=i;	//保存好2~n的所有素数 
	}
	for(i=0;i<k;i++)
	{
		if(a[i+1]-a[i]==2)
		r++;	
	}
	printf("%d\n",r);
	
	
	
}

57、 数组元素循环右移问题 (20 分)

1008 数组元素循环右移问题 (20 分)
一个数组A中存有N（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向右移M（≥0）个位置，即将A中的数据由（A
​0
​​ A
​1
​​ ⋯A
​N−1
​​ ）变换为（A
​N−M
​​ ⋯A
​N−1
​​ A
​0
​​ A
​1
​​ ⋯A
​N−M−1
​​ ）（最后M个数循环移至最前面的M个位置）。如果需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

输入格式:
每个输入包含一个测试用例，第1行输入N（1≤N≤100）和M（≥0）；第2行输入N个整数，之间用空格分隔。

输出格式:
在一行中输出循环右移M位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。

输入样例:
6 2
1 2 3 4 5 6
输出样例:
5 6 1 2 3 4

原题链接：1008 数组元素循环右移问题 (20 分)

#include<stdio.h>
int main()
{
	int kr[100],k=0;
	int n,m;
	int i,j;
	scanf("%d%d",&n,&m);
	m%=n;		//△这里要注意n<m的情况，所以要求余，保证 也能正常打印 
	for(i=0;i<n;i++)	//先打印好开头 ，相当于数组右移了m位 
	scanf("%d",&kr[i]);
	for(i=n-m;i<n;i++)
	printf("%d ",kr[i]);
	for(i=0;i<n-m;i++)	//
	{
		if(i!=n-m-1)
		printf("%d ",kr[i]);
		else
		printf("%d",kr[i]);
	}
	
	/*  第二种输出方式  ：        很厉害也很经典*/
	/*    for (int i = 0;i < N - M - 1;i++)
        printf("%d ", ary[i]);
    printf("%d", ary[N - M - 1]);   */
	
	
}

58、 说反话 (20 分)

给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。

输入格式：
测试输入包含一个测试用例，在一行内给出总长度不超过 80 的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用 1 个空格分开，输入保证句子末尾没有多余的空格。

输出格式：
每个测试用例的输出占一行，输出倒序后的句子。

输入样例：
Hello World Here I Come
输出样例：
Come I Here World Hello

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int i=0,j;
	char c;
	char str[100][100];
	int dan=80;	//每一组单词 ，虽然是正序输入，但是这里控制了下标，所以单词会自动从末尾往前排 
	while((c=getchar())!='\n')
	{
		if(c==' ')
		{
			str[dan][i]='\0';
			dan--;
			i=0;
			continue;
		}
		else
		{
			str[dan][i]=c;
			i++;
		}
	}
	str[dan][i]='\0';	//换行后就跳出了循环，所以要记得给最后一个单词补结束符 
	for(i=dan;i<80;i++)		//别看这里是正序循环，是因为输入时倒序输入 
	printf("%s ",str[i]);
	printf("%s",str[i]);	//最后输入的一个单词没有空格 
	
}

59、 一元多项式求导 (25 分)

1010 一元多项式求导 (25 分)

设计函数求一元多项式的导数。（注：x
​n
​​ （n为整数）的一阶导数为nx
​n−1
​​ 。）

输入格式:
以指数递降方式输入多项式非零项系数和指数（绝对值均为不超过 1000 的整数）。数字间以空格分隔。

输出格式:
以与输入相同的格式输出导数多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。注意“零多项式”的指数和系数都是 0，但是表示为 0 0。

输入样例:
3 4 -5 2 6 1 -2 0
输出样例:
12 3 -10 1 6 0

原题链接：1010 一元多项式求导 (25 分)

#include<stdio.h>
int main()
{
	int k=0;
	int xi,zhi;
	while(scanf("%d %d",&xi,&zhi)!=EOF)
	{
		if(zhi)	//指数为0的情况是不存在的，所以不需要输出
		{
			if(k!=0)
			putchar(' ');
			k++;
			printf("%d %d",xi*zhi,zhi-1);	//系数与指数相乘，指数-1 
		 } 
	}
	if(k==0)	//导数为0要输出“0 0”
	printf("0 0\n");
	return 0;
 } 

60、 A+B 和 C (15 分)

1011 A+B 和 C (15 分)

给定区间 [−2
​31
​​ ,2
​31
​​ ] 内的 3 个整数 A、B 和 C，请判断 A+B 是否大于 C。

输入格式：
输入第 1 行给出正整数 T (≤10)，是测试用例的个数。随后给出 T 组测试用例，每组占一行，顺序给出 A、B 和 C。整数间以空格分隔。

输出格式：
对每组测试用例，在一行中输出 Case #X: true 如果 A+B>C，否则输出 Case #X: false，其中 X 是测试用例的编号（从 1 开始）。

输入样例：
4
1 2 3
2 3 4
2147483647 0 2147483646
0 -2147483648 -2147483647
输出样例：
Case #1: false
Case #2: true
Case #3: true
Case #4: false

#include<stdio.h>
int main()
{
  //这道题要注意，因为输入的数据很大，所以要定义成long型，才能保证数据不丢失，结果最准确
	int i;
	int k=1;
	long sum=0;
	int n;
	long a,b,c;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%ld%ld%ld",&a,&b,&c);
		sum=a+b;
			if(sum>c)
			printf("Case #%d: true\n",k);
			else
			printf("Case #%d: false\n",k);
			k++;
	}
	
	
}