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

1、Hello World (5 分)

这道超级简单的题目没有任何输入。

你只需要在一行中输出著名短句“Hello World!”就可以了。

输入样例：
无
输出样例：
Hello World!

public class Main {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

2、打印沙漏 (20 分)

L1-002 打印沙漏 (20 分)
本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”，要求按下列格式打印

---

---

---

---

所谓“沙漏形状”，是指每行输出奇数个符号；各行符号中心对齐；相邻两行符号数差2；符号数先从大到小顺序递减到1，再从小到大顺序递增；首尾符号数相等。

给定任意N个符号，不一定能正好组成一个沙漏。要求打印出的沙漏能用掉尽可能多的符号。

输入格式:
输入在一行给出1个正整数N（≤1000）和一个符号，中间以空格分隔。

输出格式:
首先打印出由给定符号组成的最大的沙漏形状，最后在一行中输出剩下没用掉的符号数。

输入样例:
19 *
输出样例:

---

---

---

---

2

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		int i,j,k;		//用于循环
		int n;			//有几个正整数
		int b=1;		//表示一行的最大个数		
		int h=1;		//计算行数
		int sum=1;		//至少会打印1个星
		int g=0;		//决定打印空格的元素
		int index;		//记住下半行的打印星数
		String Str;		//符号
		char c;
		Scanner dx = new Scanner(System.in);
		n = dx.nextInt();
		Str = dx.nextLine();	//先输入一个字符串
		c = Str.charAt(1);		//再利用字符串转为字符方法得到字符
		if(n<7) {
			System.out.println(c);
			System.out.println(n-1);
			System.exit(0);		//请求终止JVM
		}
		else {
			while(sum<=n) {
				b = b+2;
				sum = sum + b*2;
				h++;
			}
		}
		h=h-1;		//因为K初始值为1，所以会多算出一行，要减去1才是真实的上半部分与下半部分的行数
		index = h;	//保护下半行行数
		sum = sum - 2*b;	//减去上下两边的最大行数，即为多算的个数
		sum = n -sum;
		for(i=h;i>=1;i--)		//打印上半部分【包括中间的符号】
		{
			for(j=1;j<=g;j++)
				System.out.print(" ");
			for(k=1;k<=2*i-1;k++)
				System.out.print(c);
			System.out.println();
			g++;
		}
		for(i=2;i<=index;i++){
			for(j=1;j<=(g-2);j++){
				System.out.print(" ");
			}
			for(k=1;k<=2*i-1;k++){
				System.out.print(c);
			}
			System.out.println();
			g--;
		}
		System.out.println(sum);
	}
}

3、个位数统计 (15 分)

L1-003 个位数统计 (15 分)
给定一个 k 位整数 N=d
​k−1
​​ 10
​k−1
​​ +⋯+d
​1
​​ 10
​1
​​ +d
​0
​​ (0≤d
​i
​​ ≤9, i=0,⋯,k−1, d
​k−1
​​ >0)，请编写程序统计每种不同的个位数字出现的次数。例如：给定 N=100311，则有 2 个 0，3 个 1，和 1 个 3。

输入格式：
每个输入包含 1 个测试用例，即一个不超过 1000 位的正整数 N。

输出格式：
对 N 中每一种不同的个位数字，以 D:M 的格式在一行中输出该位数字 D 及其在 N 中出现的次数 M。要求按 D 的升序输出。

输入样例：
100311
输出样例：
0:2
1:3
3:1

import java.util.Scanner;

public class Main {
	
	public static void main(String[] args) {
		
		int shu[] = new int[10];
		Scanner sc = new Scanner(System.in);
		String a = sc.nextLine();
		int len = a.length();
		for(int i = 0 ; i < len ; i++) {
			shu[a.charAt(i)-48]++;
		}
		for(int i = 0 ; i < 10 ; i++) {
			if(shu[i]!=0)
				System.out.println(i+":"+shu[i]);
		}
		
	}

}

4、计算摄氏温度 (5 分)

给定一个华氏温度F，本题要求编写程序，计算对应的摄氏温度C。计算公式：C=5×(F−32)/9。题目保证输入与输出均在整型范围内。

输入格式:
输入在一行中给出一个华氏温度。

输出格式:
在一行中按照格式“Celsius = C”输出对应的摄氏温度C的整数值。

输入样例:
150
输出样例:
Celsius = 65

import java.util.Scanner;
public class Main{
	public static void main(String[] args) {
			Scanner scanner = new Scanner(System.in);
			int f = scanner.nextInt();
			System.out.println("Celsius = " + (5*(f-32)/9));
		}
}

5、考试座位号 (15 分)

每个 PAT 考生在参加考试时都会被分配两个座位号，一个是试机座位，一个是考试座位。正常情况下，考生在入场时先得到试机座位号码，入座进入试机状态后，系统会显示该考生的考试座位号码，考试时考生需要换到考试座位就座。但有些考生迟到了，试机已经结束，他们只能拿着领到的试机座位号码求助于你，从后台查出他们的考试座位号码。

输入格式：
输入第一行给出一个正整数 N（≤1000），随后 N 行，每行给出一个考生的信息：准考证号 试机座位号 考试座位号。其中准考证号由 16 位数字组成，座位从 1 到 N 编号。输入保证每个人的准考证号都不同，并且任何时候都不会把两个人分配到同一个座位上。

考生信息之后，给出一个正整数 M（≤N），随后一行中给出 M 个待查询的试机座位号码，以空格分隔。

输出格式：
对应每个需要查询的试机座位号码，在一行中输出对应考生的准考证号和考试座位号码，中间用 1 个空格分隔。

输入样例：
4
3310120150912233 2 4
3310120150912119 4 1
3310120150912126 1 3
3310120150912002 3 2
2
3 4
输出样例：
3310120150912002 2
3310120150912119 1

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
public class Main{
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int n=Integer.parseInt(br.readLine());
		HashMap map = new HashMap();
		while(--n>=0){
			String s=br.readLine();
			String s2[]=s.split(" ");
			map.put(s2[1],s2[0]+" "+s2[2]);
		}
		int m=Integer.parseInt(br.readLine());
		String s3[]=br.readLine().split(" ");
		int j=0;
		while(--m>=0){
			System.out.println(map.get(s3[j]));
			j++;
		}
	}
}

6、连续因子 (20 分)

一个正整数 N 的因子中可能存在若干连续的数字。例如 630 可以分解为 3×5×6×7，其中 5、6、7 就是 3 个连续的数字。给定任一正整数 N，要求编写程序求出最长连续因子的个数，并输出最小的连续因子序列。

输入格式：
输入在一行中给出一个正整数 N（1<N<2
​31
​​ ）。

输出格式：
首先在第 1 行输出最长连续因子的个数；然后在第 2 行中按 因子1因子2……*因子k 的格式输出最小的连续因子序列，其中因子按递增顺序输出，1 不算在内。

输入样例：
630
输出样例：
3
567

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		long n=s.nextInt();
		long start=0,len=0;
		long sum=0;
		for(int i=2;i<Math.sqrt(n);i++) {
			sum=1;
			for(int j=i;sum*i<=n;j++) {
				sum*=j;
				if(n%sum==0&&j-i+1>len) {
					start=i;
					len=j-i+1;
				}
			}
		}
		if(start==0) {
			start=n;
			len=1;
		}
		System.out.println(len);
		for(int i=0;i<len-1;i++) {
			System.out.print(start+i+"*");
		}
		System.out.print(start+len-1);
	}
}

7、A-B (20 分)

本题要求你计算A−B。不过麻烦的是，A和B都是字符串 —— 即从字符串A中把字符串B所包含的字符全删掉，剩下的字符组成的就是字符串A−B。

输入格式：
输入在2行中先后给出字符串A和B。两字符串的长度都不超过10
​4
​​ ，并且保证每个字符串都是由可见的ASCII码和空白字符组成，最后以换行符结束。

输出格式：
在一行中打印出A−B的结果字符串。

输入样例：
I love GPLT! It’s a fun game!
aeiou
输出样例：
I lv GPLT! It’s fn gm!

#include<stdio.h>
#include<string.h>
int main()
{
	int i=0,j=0;			//用于循环和数组下标
	char str1[10010];		//用来存储A、B两个字符串
	char str2[10010];		//用来存储要删除的字符串字母
	int length;				//用来存储字符串长度
	gets(str1);
	gets(str2);
	length = strlen(str2);	//这里只需要记住str2字符串的长度即可
	while(str1[i]!='\0')	//将str1字符串从第一个字母开始带进去一一查验
	{
		for(j=0;j<length;j++)//将这个字母放到str2中一一查询是否有对应的，若有对应的
		{					//那么for循环就会提前跳出，并且j的值不可能会等于length，
			if(str1[i]==str2[j])//记住关键词，提前！所以从这里就可以肯定若for循环执行
				break;			//到了最后，那么证明这个字母在str2中是找不到对应的，
		}						//那么自然需要显示啦！
		if(j==length)
			printf("%c",str1[i]);
		i++;
	}
	printf("\n");
	return 0;
}
	

8、计算指数 (5 分)

真的没骗你，这道才是简单题 —— 对任意给定的不超过 10 的正整数 n，要求你输出 2
​n
​​ 。不难吧？

输入格式：
输入在一行中给出一个不超过 10 的正整数 n。

输出格式：
在一行中按照格式 2^n = 计算结果 输出 2
​n
​​ 的值。

输入样例：
5
输出样例：
2^5 = 32
作者: 陈越
单位: 浙江大学
时间限制: 400 ms
内存限制: 64 MB

#include<stdio.h>
#include<math.h>
int main()
{
	int n;
	int result;
	scanf("%d",&n);
	if(n<1 || n>10)		return 0;
	result=pow(2,n);
	printf("2^%d = %d\n",n,result);
	return 0;
}

9、 计算阶乘和 (10 分)

对于给定的正整数N，需要你计算 S=1!+2!+3!+…+N!。

输入格式：
输入在一行中给出一个不超过10的正整数N。

输出格式：
在一行中输出S的值。

输入样例：
3
输出样例：
9
作者: 陈越
单位: 浙江大学
时间限制: 400 ms
内存限制: 64 MB

#include<stdio.h>
int main()
{
	int N;
	int i;	//用于循环
	int sum=0,mix=1;	//求和
	scanf("%d",&N);
	if(N<1 || N>10)		return 0;
	for(i=1;i<=N;i++)
	{
		mix=i*mix;
		sum=sum+mix;
	}
	printf("%d\n",sum);
	return 0;
}

10、 简单题 (5 分)

这次真的没骗你 —— 这道超级简单的题目没有任何输入。

你只需要在一行中输出事实：This is a simple problem. 就可以了。

输入样例：
无
输出样例：
This is a simple problem.

#include<stdio.h>
int main()
{
	printf("This is a simple problem.\n");
	return 0;
}

11、 跟奥巴马一起画方块 (15 分)

美国总统奥巴马不仅呼吁所有人都学习编程，甚至以身作则编写代码，成为美国历史上首位编写计算机代码的总统。2014年底，为庆祝“计算机科学教育周”正式启动，奥巴马编写了很简单的计算机代码：在屏幕上画一个正方形。现在你也跟他一起画吧！

输入格式：
输入在一行中给出正方形边长N（3≤N≤21）和组成正方形边的某种字符C，间隔一个空格。

输出格式：
输出由给定字符C画出的正方形。但是注意到行间距比列间距大，所以为了让结果看上去更像正方形，我们输出的行数实际上是列数的50%（四舍五入取整）。

输入样例：
10 a
输出样例：
aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa

#include<stdio.h>
int main()
{
	int N;
	char c;
	int i,j;
	scanf("%d %c",&N,&c);
	if(N%2==0){
		for(i=0;i<N/2;i++){
			for(j=0;j<N;j++){
				printf("%c",c);
			}
				printf("\n");
		}
	}else{
		for(i=0;i<N/2+1;i++){		//因为不管怎么除小数点都是0.5所以加1
			for(j=0;j<N;j++){
				printf("%c",c);
			}
			printf("\n");
		}
	}
	return 0;
}

12、查验身份证 (15 分)

L1-016 查验身份证 (15 分)
一个合法的身份证号码由17位地区、日期编号和顺序编号加1位校验码组成。校验码的计算规则如下：

首先对前17位数字加权求和，权重分配为：{7，9，10，5，8，4，2，1，6，3，7，9，10，5，8，4，2}；然后将计算的和对11取模得到值Z；最后按照以下关系对应Z值与校验码M的值：

Z：0 1 2 3 4 5 6 7 8 9 10
M：1 0 X 9 8 7 6 5 4 3 2
现在给定一些身份证号码，请你验证校验码的有效性，并输出有问题的号码。

输入格式：
输入第一行给出正整数N（≤100）是输入的身份证号码的个数。随后N行，每行给出1个18位身份证号码。

输出格式：
按照输入的顺序每行输出1个有问题的身份证号码。这里并不检验前17位是否合理，只检查前17位是否全为数字且最后1位校验码计算准确。如果所有号码都正常，则输出All passed。

输入样例1：
4
320124198808240056
12010X198901011234
110108196711301866
37070419881216001X
输出样例1：
12010X198901011234
110108196711301866
37070419881216001X
输入样例2：
2
320124198808240056
110108196711301862
输出样例2：
All passed

#include <stdio.h>  
#include <stdlib.h>  
   
int charToInt(char c)
{  
     return (int)(c-'0');  
 }  
 int main(int argc, char *argv[]) 
 {  
     int n,i,j,k=0,s,  
     a[]={7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};  
     char cur,b[11]={'1','0','X','9','8','7','6','5','4','3','2'},  
     c[20];  
     scanf("%d",&n);  
     for(i = 0; i < n;i++)
	 {  
         s=0;  
         scanf("%s",&c);  
         for(j= 0;j<17;j++)
		 {  
             if(c[j]>='0'&&c[j]<='9')
			 {  
                 s+=charToInt(c[j])*a[j];  
			 }
			 else
			 {  
                 printf("%s",c);  
                 if(i<n-1)
				 {  
                     printf("\n");  
                 }  
                 s=-1;  
                 break;  
             }     
         }  
         if(b[s%11]==c[j]&&s!=-1)
		 {  
             k++;  
         }
		 else if(b[s%11]!=c[j]&&s!=-1)
		 {  
             printf("%s",c);  
             if(i<n-1)
			 {  
                 printf("\n");  
			 }  
         }  
     }  
     if(k==n)
	 {  
         printf("All passed");  
     }  
     return 0;  
}  

13、 到底有多二 (15 分)

L1-017 到底有多二 (15 分)
一个整数“犯二的程度”定义为该数字中包含2的个数与其位数的比值。如果这个数是负数，则程度增加0.5倍；如果还是个偶数，则再增加1倍。例如数字-13142223336是个11位数，其中有3个2，并且是负数，也是偶数，则它的犯二程度计算为：3/11×1.5×2×100%，约为81.82%。本题就请你计算一个给定整数到底有多二。

输入格式：
输入第一行给出一个不超过50位的整数N。

输出格式：
在一行中输出N犯二的程度，保留小数点后两位。

输入样例：
-13142223336
输出样例：
81.82%
鸣谢安阳师范学院段晓云老师和软件工程五班李富龙同学补充测试数据！

#include<stdio.h>
#include<string.h>
int main()
{
	char N[50];
	int i;
	float count=0,sum=0; 
	scanf("%s",&N);
	int x=strlen(N);		//计算字符串长度
	for(i=0;i<x;i++){		//计算有多少个二
		if(N[i]=='2')
			count++;		
	}
	if(N[0]=='-'){				//负数
			sum=(count/(x-1))*1.5*100;
	}else{						//正数
		sum=count/x*100;
	}
		if(N[x-1]%2==0)			//偶数
			sum*=2;
	printf("%.2f%%",sum);
	return 0;
}

14、大笨钟 (10 分)

L1-018 大笨钟 (10 分)
微博上有个自称“大笨钟V”的家伙，每天敲钟催促码农们爱惜身体早点睡觉。不过由于笨钟自己作息也不是很规律，所以敲钟并不定时。一般敲钟的点数是根据敲钟时间而定的，如果正好在某个整点敲，那么“当”数就等于那个整点数；如果过了整点，就敲下一个整点数。另外，虽然一天有24小时，钟却是只在后半天敲1~12下。例如在23:00敲钟，就是“当当当当当当当当当当当”，而到了23:01就会是“当当当当当当当当当当当当”。在午夜00:00到中午12:00期间（端点时间包括在内），笨钟是不敲的。

下面就请你写个程序，根据当前时间替大笨钟敲钟。

输入格式：
输入第一行按照hh:mm的格式给出当前时间。其中hh是小时，在00到23之间；mm是分钟，在00到59之间。

输出格式：
根据当前时间替大笨钟敲钟，即在一行中输出相应数量个Dang。如果不是敲钟期，则输出：

Only hh:mm. Too early to Dang.
其中hh:mm是输入的时间。

输入样例1：
19:05
输出样例1：
DangDangDangDangDangDangDangDang
输入样例2：
07:05
输出样例2：
Only 07:05. Too early to Dang.

#include<stdio.h>
main()
{
	int m, n,h,i,k;
	scanf("%d:%d", &m, &n);
	if (m >= 13 && m < 24)
	{
		h = m - 12;
		if (n != 0)
			k = h + 1;
		else if (n == 0)
			k = h;

		for (i = 0; i < k; i++)
		{
			printf("Dang");
		}
	}
	else
		printf("Only %02d:%02d.  Too early to Dang.",m,n);
}

15、 谁先倒 (15 分)

L1-019 谁先倒 (15 分)
划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为：每人口中喊出一个数字，同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和，谁就输了，输家罚一杯酒。两人同赢或两人同输则继续下一轮，直到唯一的赢家出现。

下面给出甲、乙两人的酒量（最多能喝多少杯不倒）和划拳记录，请你判断两个人谁先倒。

输入格式：
输入第一行先后给出甲、乙两人的酒量（不超过100的非负整数），以空格分隔。下一行给出一个正整数N（≤100），随后N行，每行给出一轮划拳的记录，格式为：

甲喊 甲划 乙喊 乙划
其中喊是喊出的数字，划是划出的数字，均为不超过100的正整数（两只手一起划）。

输出格式：
在第一行中输出先倒下的那个人：A代表甲，B代表乙。第二行中输出没倒的那个人喝了多少杯。题目保证有一个人倒下。注意程序处理到有人倒下就终止，后面的数据不必处理。

输入样例：
1 1
6
8 10 9 12
5 10 5 10
3 8 5 12
12 18 1 13
4 16 12 15
15 1 1 16
输出样例：
A
1

#include<stdio.h>
int main()

{

	int N,A,B;		//A,B酒量

	int i;

	int countA=0,countB=0;

	int Ahan[100],Ahua[100],Bhan[101],Bhua[100];

	scanf("%d%d",&A,&B);

	scanf("%d",&N);

	for(i=0;i<N;i++)

		scanf("%d%d%d%d",&Ahan[i],&Ahua[i],&Bhan[i],&Bhua[i]);

	for(i=0;i<N;i++){

			if((Ahua[i]==(Ahan[i]+Bhan[i]))&&(Bhua[i]==(Bhan[i]+Bhan[i])))

				continue;

		if(Ahua[i]==(Ahan[i]+Bhan[i])){

			countA++;				//杯数加1

			A--;					//酒量减少

			if(A<0){

				printf("A\n%d\n",countB);		//count输出没倒那个

				break;

			}

		}

		else
 
			if(Bhua[i]==(Ahan[i]+Bhan[i])){

				countB++;

				B--;

				if(B<0){

					printf("B\n%d\n",countA);

					break;

				}

			}

	}

	return 0;

}

16、 帅到没朋友 (20 分)

L1-020 帅到没朋友 (20 分)
当芸芸众生忙着在朋友圈中发照片的时候，总有一些人因为太帅而没有朋友。本题就要求你找出那些帅到没有朋友的人。

输入格式：
输入第一行给出一个正整数N（≤100），是已知朋友圈的个数；随后N行，每行首先给出一个正整数K（≤1000），为朋友圈中的人数，然后列出一个朋友圈内的所有人——为方便起见，每人对应一个ID号，为5位数字（从00000到99999），ID间以空格分隔；之后给出一个正整数M（≤10000），为待查询的人数；随后一行中列出M个待查询的ID，以空格分隔。

注意：没有朋友的人可以是根本没安装“朋友圈”，也可以是只有自己一个人在朋友圈的人。虽然有个别自恋狂会自己把自己反复加进朋友圈，但题目保证所有K超过1的朋友圈里都至少有2个不同的人。

输出格式：
按输入的顺序输出那些帅到没朋友的人。ID间用1个空格分隔，行的首尾不得有多余空格。如果没有人太帅，则输出No one is handsome。

注意：同一个人可以被查询多次，但只输出一次。

输入样例1：
3
3 11111 22222 55555
2 33333 44444
4 55555 66666 99999 77777
8
55555 44444 10000 88888 22222 11111 23333 88888
输出样例1：
10000 88888 23333
输入样例2：
3
3 11111 22222 55555
2 33333 44444
4 55555 66666 99999 77777
4
55555 44444 22222 11111
输出样例2：
No one is handsome

#include <stdio.h>
#include <string.h>
int love[100010];		//存储ID号空间
int main()
{
	int n;			//有几个朋友圈
	int k;			//每个朋友圈中有几个人
	int m;			//待查询人数
	int id;			//id号码
	int newid;		//待查询的id号码
	int i,j;		//用于循环和数组下标
	int flag=0;		//用来判断输出结果是否是因为太帅没有朋友
	scanf("%d",&n);
	    
        for(i=0;i<n;i++)			
		{							
            scanf("%d",&k);
            for(j=0;j<k;j++)
			{
                scanf("%d",&id);
                if(k == 1)break;//只有自己的朋友圈排出
                love[id] = 1;   //每个人ID肯定都是不同的，所以让朋友圈中已知的都值为1
            }
        }
        scanf("%d",&m);
        for(i=0;i<m;i++)
		{
            scanf("%d",&newid);
            if(!love[newid])//这里要注意判断条件为非真为假，非假为真的特性，已存在时
            {               //就无需在输出，利用这一特点，我们只要把事先没有存在的输出即可
                if(++flag > 1) printf(" ");
                printf("%05d",newid);
                love[newid] = 1;
            }
        }
        if(flag == 0) printf("No one is handsome");
        printf("\n");
    return 0;
}

17、 重要的话说三遍 (5 分)

L1-021 重要的话说三遍 (5 分)
这道超级简单的题目没有任何输入。

你只需要把这句很重要的话 —— “I’m gonna WIN!”——连续输出三遍就可以了。

注意每遍占一行，除了每行的回车不能有任何多余字符。

输入样例：
无
输出样例：
I’m gonna WIN!
I’m gonna WIN!
I’m gonna WIN!

#include <stdio.h>
void f()
{
	printf("I'm gonna WIN!\n");
}
int main()
{
	f();
	f();
	f();
	return 0;
}

18、 奇偶分家 (10 分)

L1-022 奇偶分家 (10 分)
给定N个正整数，请统计奇数和偶数各有多少个？

输入格式：
输入第一行给出一个正整N（≤1000）；第2行给出N个非负整数，以空格分隔。

输出格式：
在一行中先后输出奇数的个数、偶数的个数。中间以1个空格分隔。

输入样例：
9
88 74 101 26 15 0 34 22 77
输出样例：
3 6

#include <stdio.h>
int main()
{
	int N;				//要输入多少个数
	int i;				//用于循环
	int a[1000];		//给定最大数组空间存储输入数据，以防下标越界
	int num1=0,num2=0;	//用于计算奇\偶个数
	scanf("%d",&N);
	if(N<=0 || N>1000) return 0;	//大于0的自然数为正整数
	for(i=0;i<N;i++)
		scanf("%d",&a[i]);
	for(i=0;i<N;i++)
	{
		if(a[i]%2!=0)
			num1++;
		else
			num2++;
	}
	printf("%d %d\n",num1,num2);
	return 0;
}

19、 输出GPLT (20 分)

L1-023 输出GPLT (20 分)
给定一个长度不超过10000的、仅由英文字母构成的字符串。请将字符重新调整顺序，按GPLTGPLT…这样的顺序输出，并忽略其它字符。当然，四种字符（不区分大小写）的个数不一定是一样多的，若某种字符已经输出完，则余下的字符仍按GPLT的顺序打印，直到所有字符都被输出。

输入格式：
输入在一行中给出一个长度不超过10000的、仅由英文字母构成的非空字符串。

输出格式：
在一行中按题目要求输出排序后的字符串。题目保证输出非空。

输入样例：
pcTclnGloRgLrtLhgljkLhGFauPewSKgt
输出样例：
GPLTGPLTGLTGLGLL

#include<stdio.h>
#include<string.h>
int main()
{
	char str[10010];			//储存输入的字符串内存空间
	int g=0,p=0,l=0,t=0;		//这四个变量分别用来计算字符串中出现的次数
	int i,j;					//用于循环和数组下标
	int n;						//得到所输入的字符串长度
	gets(str);					//提供输入功能
	n = strlen(str);			//得到str字符串的长度并赋值给n
	for(i=0;i<n;i++)			//从第一个字母开始一一寻找有没有g,G,t,T,l,L,p,P这些字母
	{							//若存在，则会在for循环都算好其出现的次数，因为每对应依次都会+1
		if(str[i]=='g' || str[i]=='G')
			g++;
		else if(str[i]=='p' || str[i]=='P')
			p++;
		else if(str[i]=='l' || str[i]=='L')
			l++;
		else if(str[i]=='t' || str[i]=='T')
			t++;
	}
	while(n)					//然后之后就是输出环节，每对应一个字母就将其输出，并减1
	{							//直到它们都恢复为了初始值0时，无需打印，则赋n=0，判断为假结束循环
		if(g!=0)
		{	printf("G");	g--;	}
		if(p!=0)
		{	printf("P");	p--;	}
		if(l!=0)
		{	printf("L");	l--;	}
		if(t!=0)
		{	printf("T");	t--;	}
		if(g==0 && p==0 && l==0 && t==0)
			n=0;
	}
	printf("\n");
	return 0;
}

20、 后天 (5 分)

L1-024 后天 (5 分)
如果今天是星期三，后天就是星期五；如果今天是星期六，后天就是星期一。我们用数字1到7对应星期一到星期日。给定某一天，请你输出那天的“后天”是星期几。

输入格式：
输入第一行给出一个正整数D（1 ≤ D ≤ 7），代表星期里的某一天。

输出格式：
在一行中输出D天的后天是星期几。

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

#include<stdio.h>
int main()
{
	int d;	//输入
	scanf("%d",&d);
	if(d<1 || d>7)	return 0;
	if(d<=5)
		printf("%d",d+2);
	else
		printf("%d",d-7+2);
	return 0;
}

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

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

21、正整数A+B (15 分)

L1-025 正整数A+B (15 分)
题的目标很简单，就是求两个正整数A和B的和，其中A和B都在区间[1,1000]。稍微有点麻烦的是，输入并不保证是两个正整数。

输入格式：
输入在一行给出A和B，其间以空格分开。问题是A和B不一定是满足要求的正整数，有时候可能是超出范围的数字、负数、带小数点的实数、甚至是一堆乱码。

注意：我们把输入中出现的第1个空格认为是A和B的分隔。题目保证至少存在一个空格，并且B不是一个空字符串。

输出格式：
如果输入的确是两个正整数，则按格式A + B = 和输出。如果某个输入不合要求，则在相应位置输出?，显然此时和也是?。

输入样例1：
123 456
输出样例1：
123 + 456 = 579
输入样例2：
22. 18
输出样例2：
? + 18 = ?
输入样例3：
-100 blabla bla…33
输出样例3：
? + ? = ?

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
	static String a,b;
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		a = scan.next();
		b = scan.next();
		boolean a1 = isNumeric(a);
		boolean a2 = isNumeric(b);
		if(a1&&a2) {			//如果都是数字
		int number1 = Integer.valueOf(a);
		int number2 = Integer.valueOf(b);
		System.out.println(number1 + " + " + number2 + " = " + (number1+number2));
		}
		else if(a1==true&&a2==false){		//a是数字b不是
			int number1 = Integer.valueOf(a);
			System.out.println(number1 + " + " + "?" + " = " + "?");
		}else if(a1==false&&a2==true) {		//b是数字a不是
			int number1 = Integer.valueOf(b);
			System.out.println("?" + " + " + number1 + " = " + "?");
		}else {								//都不是
			System.out.println("?" + " + " + "?" + " = " + "?");
		}
	}
	 public static boolean isNumeric(String str ){		//判断是不是数字
         Pattern pattern = Pattern.compile("[0-9]*");
         Matcher isNum = pattern.matcher(str);
         if( !isNum.matches() ){
             return false;
         }
         return true;
  }
}

22、I Love GPLT (5 分)

L1-026 I Love GPLT (5 分)
这道超级简单的题目没有任何输入。

你只需要把这句很重要的话 —— “I Love GPLT”——竖着输出就可以了。

所谓“竖着输出”，是指每个字符占一行（包括空格），即每行只能有1个字符和回车。

输入样例：
无
输出样例：
I

L
o
v
e

G
P
L
T
注意：输出的两个空行中各有一个空格。

#include<stdio.h>
#include<string.h>
int main()
{
	char a[]="I Love GPLT";
	int m=strlen(a);
	for(int i=0;i<m;i++)
		printf("%c\n",a[i]);
}

23、出租 (20 分)

L1-027 出租 (20 分)
下面是新浪微博上曾经很火的一张图：

一时间网上一片求救声，急问这个怎么破。其实这段代码很简单，index数组就是arr数组的下标，index[0]=2 对应 arr[2]=1，index[1]=0 对应 arr[0]=8，index[2]=3 对应 arr[3]=0，以此类推…… 很容易得到电话号码是18013820100。

本题要求你编写一个程序，为任何一个电话号码生成这段代码 —— 事实上，只要生成最前面两行就可以了，后面内容是不变的。

输入格式：
输入在一行中给出一个由11位数字组成的手机号码。

输出格式：
为输入的号码生成代码的前两行，其中arr中的数字必须按递减顺序给出。

输入样例：
18013820100
输出样例：
int[] arr = new int[]{8,3,2,1,0};
int[] index = new int[]{3,0,4,3,1,0,2,4,3,4,4};

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
 
public class Main {
 
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		ArrayList<Integer> alist = new ArrayList<Integer>();
		String s = sc.nextLine();//获取电话号码
		//将电话号码存放到alist数组中
		for (int i = 0; i < s.length(); i++) {
			if (!alist.contains(Integer.valueOf(s.charAt(i) + ""))) {
				alist.add(Integer.valueOf(s.charAt(i) + ""));
			}
		}
		//排序(从小到大)
		Collections.sort(alist);
		//逆序
		Collections.reverse(alist);
		System.out.print("int[] arr = new int[]{");
		//输出
		for (int i = 0; i < alist.size(); i++) {
			if (i == 0) {
				System.out.print(alist.get(i));
			} else {
				System.out.print("," + alist.get(i));
			}
		}
		System.out.println("};");
		System.out.print("int[] index = new int[]{");
		
		//输出电话号顺序的下标
		for (int i = 0; i < s.length(); i++) {
			if (i == 0) {
				System.out.print(alist.indexOf(Integer.valueOf(s.charAt(i) + "")));
			} else {
				System.out.print("," + alist.indexOf(Integer.valueOf(s.charAt(i) + "")));
			}
		}
		System.out.println("};");
	}
}

24、 是不是太胖了 (5 分)

L1-029 是不是太胖了 (5 分)
据说一个人的标准体重应该是其身高（单位：厘米）减去100、再乘以0.9所得到的公斤数。已知市斤是公斤的两倍。现给定某人身高，请你计算其标准体重应该是多少？（顺便也悄悄给自己算一下吧……）

输入格式：
输入第一行给出一个正整数H（100 < H ≤ 300），为某人身高。

输出格式：
在一行中输出对应的标准体重，单位为市斤，保留小数点后1位。

输入样例：
169
输出样例：
124.2

#include <stdio.h>
int main()
{
	float H;		//输入一个正整数表示某人身高
	scanf("%f",&H);
	if(H<=100 || H>300)		return 0;
	//根据公式：（公斤）标准体重=身高-100*0.9
	//1市斤=2公斤	【2倍关系】
	printf("%.1f\n",((H-100)*0.9)*2);		//题目要求结果保留一位小数
	return 0;
}

25、一帮一 (15 分)

L1-030 一帮一 (15 分)
“一帮一学习小组”是中小学中常见的学习组织方式，老师把学习成绩靠前的学生跟学习成绩靠后的学生排在一组。本题就请你编写程序帮助老师自动完成这个分配工作，即在得到全班学生的排名后，在当前尚未分组的学生中，将名次最靠前的学生与名次最靠后的异性学生分为一组。

输入格式：
输入第一行给出正偶数N（≤50），即全班学生的人数。此后N行，按照名次从高到低的顺序给出每个学生的性别（0代表女生，1代表男生）和姓名（不超过8个英文字母的非空字符串），其间以1个空格分隔。这里保证本班男女比例是1:1，并且没有并列名次。

输出格式：
每行输出一组两个学生的姓名，其间以1个空格分隔。名次高的学生在前，名次低的学生在后。小组的输出顺序按照前面学生的名次从高到低排列。

输入样例：
8
0 Amy
1 Tom
1 Bill
0 Cindy
0 Maya
1 John
1 Jack
0 Linda
输出样例：
Amy Jack
Tom Linda
Bill Maya
Cindy John

#include<stdio.h>
int main()
{
	int N;				//表示全班总人数
	int sex[50];		//性别
	char name[50][15];	//姓名
	int i,j,k;			//用于循环
	scanf("%d",&N);
	if(N<=0 || N>50 ||N%2!=0)	return 0;	//正偶数，在1~50之间
	for(i=0;i<N;i++)
		scanf("%d %s",&sex[i],&name[i][0]);
	for(i=0;i<N/2;i++)		//控制行数，因为一共8人，所以最多4行
	{
		for(j=i;j==i;j++)	//控制从高名次开始往下查找，以高名次
		{
			for(k=N-1;k>=N/2;k--)	//控制从低往高查找，因为一共8人，所以下面最多4个与上面4个对应，只用循环4次即可
			{
				if(sex[j]!=sex[k]&&sex[j]<=1&&sex[k]<=1)
				{
					sex[j]=10;		//因为男生是1，女生是0，这里随便配上一个数10以后，搭配上面的逻辑判断就能排除掉已经选中人
					sex[k]=10;		//因为男生是1，女生是0，这里随便配上一个数10以后，搭配上面的逻辑判断就能排除掉已经选中人
					printf("%s %s\n",name[i],name[k]);
					break;
				}
			}
		}
	}
}

26、 到底是不是太胖了 (10 分)

L1-031 到底是不是太胖了 (10 分)
据说一个人的标准体重应该是其身高（单位：厘米）减去100、再乘以0.9所得到的公斤数。真实体重与标准体重误差在10%以内都是完美身材（即 | 真实体重 − 标准体重 | < 标准体重×10%）。已知市斤是公斤的两倍。现给定一群人的身高和实际体重，请你告诉他们是否太胖或太瘦了。

输入格式：
输入第一行给出一个正整数N（≤ 20）。随后N行，每行给出两个整数，分别是一个人的身高H（120 < H < 200；单位：厘米）和真实体重W（50 < W ≤ 300；单位：市斤），其间以空格分隔。

输出格式：
为每个人输出一行结论：如果是完美身材，输出You are wan mei!；如果太胖了，输出You are tai pang le!；否则输出You are tai shou le!。

输入样例：
3
169 136
150 81
178 155
输出样例：
You are wan mei!
You are tai shou le!
You are tai pang le!

#include<stdio.h>
#include<math.h>
int main()
{
	int n;				//有几个人
	float height;		//身高
	float weight;		//真实体重
	float biao;			//标准体重
	int i;				//用于循环和数组下标
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%f %f",&height,&weight);
		biao = (height-100)*0.9*2;	//得到标准体重，单位市斤
		if(fabs(weight-biao)<biao*0.1)
			printf("You are wan mei!\n");
		else if(biao>weight)
			printf("You are tai shou le!\n");
		else
			printf("You are tai pang le!\n");
	}
	return 0;
}

27、Left-pad (20 分)

L1-032 Left-pad (20 分)
根据新浪微博上的消息，有一位开发者不满NPM（Node Package Manager）的做法，收回了自己的开源代码，其中包括一个叫left-pad的模块，就是这个模块把javascript里面的React/Babel干瘫痪了。这是个什么样的模块？就是在字符串前填充一些东西到一定的长度。例如用去填充字符串GPLT，使之长度为10，调用left-pad的结果就应该是*****GPLT。Node社区曾经对left-pad紧急发布了一个替代，被严重吐槽。下面就请你来实现一下这个模块。

输入格式：
输入在第一行给出一个正整数N（≤10
​4
​​ ）和一个字符，分别是填充结果字符串的长度和用于填充的字符，中间以1个空格分开。第二行给出原始的非空字符串，以回车结束。

输出格式：
在一行中输出结果字符串。

输入样例1：
15 _
I love GPLT
输出样例1：
____I love GPLT
输入样例2：
4 *
this is a sample for cut
输出样例2：
cut

#include<stdio.h>
#include<string.h>
int main()
{
	int  i;				//用于循环和数组下标
	int  n;				//填充字符串的长度
	char c;				//填充字符串的字符
	char a[60000];		//申请字符串输入空间
	int lenght;			//字符串的长度
	scanf("%d %c",&n,&c);
	getchar();
	gets(a);
	lenght=strlen(a);	//计算字符串的长度
	if(lenght<n)		//当输入的字符串<填充字符串长度时
	{
		for(i=0;i<n-lenght;i++)
			printf("%c",c);
		puts(a);
	}
	else				//否则
	{
		for(i=lenght-n;i<lenght;i++)
			printf("%c",a[i]);
	}
	return 0;
}

28、 出生年 (15 分)

L1-033 出生年 (15 分)

以上是新浪微博中一奇葩贴：“我出生于1988年，直到25岁才遇到4个数字都不相同的年份。”也就是说，直到2013年才达到“4个数字都不相同”的要求。本题请你根据要求，自动填充“我出生于y年，直到x岁才遇到n个数字都不相同的年份”这句话。

输入格式：
输入在一行中给出出生年份y和目标年份中不同数字的个数n，其中y在[1, 3000]之间，n可以是2、或3、或4。注意不足4位的年份要在前面补零，例如公元1年被认为是0001年，有2个不同的数字0和1。

输出格式：
根据输入，输出x和能达到要求的年份。数字间以1个空格分隔，行首尾不得有多余空格。年份要按4位输出。注意：所谓“n个数字都不相同”是指不同的数字正好是n个。如“2013”被视为满足“4位数字都不同”的条件，但不被视为满足2位或3位数字不同的条件。

输入样例1：
1988 4
输出样例1：
25 2013
输入样例2：
1 2
输出样例2：
0 0001

#include<stdio.h>
#include<string.h>
int main(){
	int cnt=0,same=0;
	int a[10];
	//memset(a,0,sizeof(a));
	int year,t,d;
	int i;
	scanf("%d%d",&year,&d);
	t=year;
	while(1){
	    memset(a,0,sizeof(a));
		for(i=0;i<4;i++){
			a[t%10] = 1;
			t/=10;
		}
		same=0;
		for(i=0;i<10;i++) same+=a[i];
		if(same==d) break;
		cnt++;
		year++;
		t=year;
	}
	printf("%d %04d",cnt,year);
	return 0;
}

29、 点赞 (20 分)

L1-034 点赞 (20 分)
微博上有个“点赞”功能，你可以为你喜欢的博文点个赞表示支持。每篇博文都有一些刻画其特性的标签，而你点赞的博文的类型，也间接刻画了你的特性。本题就要求你写个程序，通过统计一个人点赞的纪录，分析这个人的特性。

输入格式：
输入在第一行给出一个正整数N（≤1000），是该用户点赞的博文数量。随后N行，每行给出一篇被其点赞的博文的特性描述，格式为“K F
​1
​​ ⋯F
​K
​​ ”，其中1≤K≤10，F
​i
​​ （i=1,⋯,K）是特性标签的编号，我们将所有特性标签从1到1000编号。数字间以空格分隔。

输出格式：
统计所有被点赞的博文中最常出现的那个特性标签，在一行中输出它的编号和出现次数，数字间隔1个空格。如果有并列，则输出编号最大的那个。

输入样例：
4
3 889 233 2
5 100 3 233 2 73
4 3 73 889 2
2 233 123
输出样例：
233 3

#include<stdio.h>
#define N 1001
int main()
{	
	int n;					//点赞数量
	int i,j;				//用于循环和数组下标
	int k;					//表示要几个特性标签
	int app[N]={0};			//存储标签编号
	int id;					//id编号
	int index1=0;			//标记最多出现次数
	int index2=0;			//标记最多出现的这个数
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%d",&k);
		for(j=0;j<k;j++)
		{
			scanf("%d",&id);
			app[id]++;		//这里就相当于a[3]++一个道理，也就是每输入进来一个值，
							//对应那个坐标就自增1
		}
	}
	for(i=0;i<N;i++)		//根据for循环，从最小的编号开始进行查验
	{
		if(app[i]>=index1)	//当a[i]里面保存的值大于之前标记的最大次数时，
		{					//那么index1就应该要标记住新出现的次数
			index1=app[i];	//因为循环是从小到大进行，所以若后面有正好相等并且ID
			index2=i;		//编号还比前面大的情况下，也会执行if语句
		}					//这样就避免了同等次数下，比较编号大小的问题^_^
	}
	printf("%d %d\n",index2,index1);
	return 0;
}

30、 情人节 (15 分)

L1-035 情人节 (15 分)

以上是朋友圈中一奇葩贴：“2月14情人节了，我决定造福大家。第2个赞和第14个赞的，我介绍你俩认识…………咱三吃饭…你俩请…”。现给出此贴下点赞的朋友名单，请你找出那两位要请客的倒霉蛋。

输入格式：
输入按照点赞的先后顺序给出不知道多少个点赞的人名，每个人名占一行，为不超过10个英文字母的非空单词，以回车结束。一个英文句点.标志输入的结束，这个符号不算在点赞名单里。

输出格式：
根据点赞情况在一行中输出结论：若存在第2个人A和第14个人B，则输出“A and B are inviting you to dinner…”；若只有A没有B，则输出“A is the only one for you…”；若连A都没有，则输出“Momo… No one is for you …”。

输入样例1：
GaoXZh
Magi
Einst
Quark
LaoLao
FatMouse
ZhaShen
fantacy
latesum
SenSen
QuanQuan
whatever
whenever
Potaty
hahaha
.
输出样例1：
Magi and Potaty are inviting you to dinner…
输入样例2：
LaoLao
FatMouse
whoever
.
输出样例2：
FatMouse is the only one for you…
输入样例3：
LaoLao
.
输出样例3：
Momo… No one is for you …

#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
	char str1[10010][11];	//字符串保存空间
	int i;					//用于循环和数组下标
	int n=0;				//决定输出结果，根据朋友名单分三种情况
	int t;			
	for(i=0;i<1000;i++)
	{
		gets(str1[i]);
		if(strcmp(str1[i],".")==0)	//“.”代表输入结束，利用字符串比较函数
		{	t=i;break;	}
		n++;				//每有一个朋友，n就自增一次，利用n来作为输出结果的标准
	}
	if(n>=14)
		printf("%s and %s are inviting you to dinner...\n",str1[1],str1[13]);
	else if(n<2)
		printf("Momo... No one is for you ...\n");
	else if(n<14 && n>=2)
		printf("%s is the only one for you...\n",str1[1]);
	return 0;
}

31、 A乘以B (5 分)

L1-036 A乘以B (5 分)
看我没骗你吧 —— 这是一道你可以在 10 秒内完成的题：给定两个绝对值不超过 100 的整数 A 和 B，输出 A 乘以 B 的值。

输入格式：
输入在第一行给出两个整数 A 和 B（−100≤A,B≤100），数字间以空格分隔。

输出格式：
在一行中输出 A 乘以 B 的值。

输入样例：
-8 13
输出样例：
-104

#include<stdio.h>
int main()
{
	int A,B;
	scanf("%d %d",&A,&B);
	if(A<-100 || A>100 || B<-100 || B>100)	return 0;
	printf("%d\n",A*B);
	return 0;
}

32、A除以B (10 分)

真的是简单题哈 —— 给定两个绝对值不超过100的整数A和B，要求你按照“A/B=商”的格式输出结果。

输入格式：
输入在第一行给出两个整数A和B（−100≤A,B≤100），数字间以空格分隔。

输出格式：
在一行中输出结果：如果分母是正数，则输出“A/B=商”；如果分母是负数，则要用括号把分母括起来输出；如果分母为零，则输出的商应为Error。输出的商应保留小数点后2位。

输入样例1：
-1 2
输出样例1：
-1/2=-0.50
输入样例2：
1 -3
输出样例2：
1/(-3)=-0.33
输入样例3：
5 0
输出样例3：
5/0=Error

#include<stdio.h>
int main()
{
    int a,b;
	float s;
    scanf("%d%d",&a,&b);
    s=1.0*a/b;			//像这种求商并且保留两位小数的计算，最好是通过用
    if(b>0)				//*0.1的方式来转换为保留两位小数，因为这样不会影响到其值
        printf("%d/%d=%.2f",a,b,s);	//如果一开始都设为double可能会在保留时对于四舍五入处理不恰当
    if(b==0)
        printf("%d/%d=Error",a,b);
    if(b<0)
        printf("%d/(%d)=%.2f",a,b,s);
    return 0;
}

33、 新世界 (5 分)

L1-038 新世界 (5 分)
这道超级简单的题目没有任何输入。

你只需要在第一行中输出程序员钦定名言“Hello World”，并且在第二行中输出更新版的“Hello New World”就可以了。

输入样例：
无
输出样例：
Hello World
Hello New World

#include<stdio.h>
int main()
{
	printf("Hello World\n");
	printf("Hello New World\n");
	return 0;
}

34、古风排版 (20 分)

L1-039 古风排版 (20 分)
中国的古人写文字，是从右向左竖向排版的。本题就请你编写程序，把一段文字按古风排版。

输入格式：
输入在第一行给出一个正整数N（<100），是每一列的字符数。第二行给出一个长度不超过1000的非空字符串，以回车结束。

输出格式：
按古风格式排版给定的字符串，每列N个字符（除了最后一列可能不足N个）。

输入样例：
4
This is a test case
输出样例：
asa T
st ih
e tsi
ce s

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(void)
{
	int i,j,n;
	scanf("%d",&n);
	char s[10010];
	getchar();
	gets(s);
	int t = strlen(s);
	int k = t/n;
	if(t%n!=0)
	k++; 
	for(i=0;i<n;i++)
	{
		for(j=n*k-n+i; j>=0;j=j-n)
		{
			printf("%c",s[j]);
		}
		printf("\n");
	}
	return 0;
}

35、 最佳情侣身高差 (10 分)

L1-040 最佳情侣身高差 (10 分)
专家通过多组情侣研究数据发现，最佳的情侣身高差遵循着一个公式：（女方的身高）×1.09 =（男方的身高）。如果符合，你俩的身高差不管是牵手、拥抱、接吻，都是最和谐的差度。

下面就请你写个程序，为任意一位用户计算他/她的情侣的最佳身高。

输入格式：
输入第一行给出正整数N（≤10），为前来查询的用户数。随后N行，每行按照“性别 身高”的格式给出前来查询的用户的性别和身高，其中“性别”为“F”表示女性、“M”表示男性；“身高”为区间 [1.0, 3.0] 之间的实数。

输出格式：
对每一个查询，在一行中为该用户计算出其情侣的最佳身高，保留小数点后2位。

输入样例：
2
M 1.75
F 1.8
输出样例：
1.61
1.96

#include<stdio.h>
int main()
{
	int N;				
	char sex[10];		
	float	height[10];	
	int i;			
	scanf("%d",&N);
	if(N<1 || N>10)	return 0;
	for(i=0;i<N;i++)
		scanf("%s%f",&sex[i],&height[i]);
	for(i=0;i<N;i++)
	{
		if(sex[i] == 'M')
			printf("%.2f\n",height[i]/1.09);
		else
			printf("%.2f\n",height[i]*1.09);
	}
		return 0;
}

36、 寻找250 (10 分)

L1-041 寻找250 (10 分)

对方不想和你说话，并向你扔了一串数…… 而你必须从这一串数字中找到“250”这个高大上的感人数字。

输入格式：
输入在一行中给出不知道多少个绝对值不超过1000的整数，其中保证至少存在一个“250”。

输出格式：
在一行中输出第一次出现的“250”是对方扔过来的第几个数字（计数从1开始）。题目保证输出的数字在整型范围内。

输入样例：
888 666 123 -233 250 13 250 -222
输出样例：
5

#include<stdio.h>
int main()
{
	int i;			
	int a[10000];	
	for(i=0;i<10000;i++)
	{
		scanf("%d",&a[i]);
		if(a[i]==250)
		{
			printf("%d\n",i+1);
			break;
		}
	}
	return 0;
}

37、 日期格式化 (5 分)

L1-042 日期格式化 (5 分)
世界上不同国家有不同的写日期的习惯。比如美国人习惯写成“月-日-年”，而中国人习惯写成“年-月-日”。下面请你写个程序，自动把读入的美国格式的日期改写成中国习惯的日期。

输入格式：
输入在一行中按照“mm-dd-yyyy”的格式给出月、日、年。题目保证给出的日期是1900年元旦至今合法的日期。

输出格式：
在一行中按照“yyyy-mm-dd”的格式给出年、月、日。

输入样例：
03-15-2017
输出样例：
2017-03-15

#include<stdio.h>
int main()
{
	int month;	
	int day;	
	int year;	
	scanf("%d-%d-%d",&month,&day,&year);
	if(year>=1900)
	printf("%d-%02d-%02d\n",year,month,day);
	return 0;
}

38、 阅览室 (20 分)

L1-043 阅览室 (20 分)
天梯图书阅览室请你编写一个简单的图书借阅统计程序。当读者借书时，管理员输入书号并按下S键，程序开始计时；当读者还书时，管理员输入书号并按下E键，程序结束计时。书号为不超过1000的正整数。当管理员将0作为书号输入时，表示一天工作结束，你的程序应输出当天的读者借书次数和平均阅读时间。

注意：由于线路偶尔会有故障，可能出现不完整的纪录，即只有S没有E，或者只有E没有S的纪录，系统应能自动忽略这种无效纪录。另外，题目保证书号是书的唯一标识，同一本书在任何时间区间内只可能被一位读者借阅。

输入格式：
输入在第一行给出一个正整数N（≤10），随后给出N天的纪录。每天的纪录由若干次借阅操作组成，每次操作占一行，格式为：

书号（[1, 1000]内的整数） 键值（S或E） 发生时间（hh:mm，其中hh是[0,23]内的整数，mm是[0, 59]内整数）

每一天的纪录保证按时间递增的顺序给出。

输出格式：
对每天的纪录，在一行中输出当天的读者借书次数和平均阅读时间（以分钟为单位的精确到个位的整数时间）。

输入样例：
3
1 S 08:10
2 S 08:35
1 E 10:00
2 E 13:16
0 S 17:00
0 S 17:00
3 E 08:10
1 S 08:20
2 S 09:00
1 E 09:20
0 E 17:00
输出样例：
2 196
0 0
1 60

#include <stdio.h>

int main()
{
    int N;
    scanf("%d", &N);

    while (N--) {
        int id;
        int books[1001][2] = {0};
        char key;
        int hh, mm; 

        while (scanf("%d %c %d:%d", &id, &key, &hh, &mm) && id) {

            // 如果是借 
            if (key == 'S') {
                books[id][0] = -1;              // 设置借的标志 
                books[id][1] = hh * 60 + mm;    // 计算时间，分钟 
            } else if (books[id][0] == -1) {
                // 是还书, 且之前有借的记录

                // 完整借书次数加 1 
                books[0][0]++;

                // 计算借书的时间 
                int total = hh * 60 + mm - books[id][1];

                // 加入总借阅时间 
                books[0][1] += total;       

                // 还原书的借阅标志，允许下次再借 
                books[id][0]++;

            } // if-else

        } // while id != 0

        int ave_m = 0;
        if (books[0][0] > 0) {
            double m = books[0][1] * 1.0 / books[0][0];
            // 四舍五入，小心入坑 
            ave_m = (int)(m + 0.5);
        }

        printf("%d %d\n", books[0][0], ave_m);

    } // while (N-- > 0)

    return 0;
 }

39、 稳赢 (15 分)

L1-044 稳赢 (15 分)
大家应该都会玩“锤子剪刀布”的游戏：两人同时给出手势，胜负规则如图所示：

现要求你编写一个稳赢不输的程序，根据对方的出招，给出对应的赢招。但是！为了不让对方输得太惨，你需要每隔K次就让一个平局。

输入格式：
输入首先在第一行给出正整数K（≤10），即平局间隔的次数。随后每行给出对方的一次出招：ChuiZi代表“锤子”、JianDao代表“剪刀”、Bu代表“布”。End代表输入结束，这一行不要作为出招处理。

输出格式：
对每一个输入的出招，按要求输出稳赢或平局的招式。每招占一行。

输入样例：
2
ChuiZi
JianDao
Bu
JianDao
Bu
ChuiZi
ChuiZi
End
输出样例：
Bu
ChuiZi
Bu
ChuiZi
JianDao
ChuiZi
Bu

#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
	int i;			//用于循环
	int k;			//表示平局的间隔次数
	int index;		//标记平局次数
	char name[20];	//输入出招名字
	scanf("%d",&k);
	index=k;		//标记住间隔次数
	while(1)
	{
		scanf("%s",name);
		if(strcmp(name,"End")==0)
			break;
		else
		{
			if(index==0)
			{
				if(strcmp(name,"ChuiZi")==0)
					printf("ChuiZi\n");
				if(strcmp(name,"JianDao")==0)
					printf("JianDao\n");
				if(strcmp(name,"Bu")==0)
					printf("Bu\n");
				index = k;
			}
			else
			{
				if(strcmp(name,"ChuiZi")==0)
					printf("Bu\n");
				if(strcmp(name,"JianDao")==0)
					printf("ChuiZi\n");
				if(strcmp(name,"Bu")==0)
					printf("JianDao\n");
				index--;			//每赢一次，间隔次数就少了1，当=0时，要平局
			}
		}
	}
	return 0;
}

40、 宇宙无敌大招呼 (5 分)

L1-045 宇宙无敌大招呼 (5 分)
据说所有程序员学习的第一个程序都是在屏幕上输出一句“Hello World”，跟这个世界打个招呼。作为天梯赛中的程序员，你写的程序得高级一点，要能跟任意指定的星球打招呼。

输入格式：
输入在第一行给出一个星球的名字S，是一个由不超过7个英文字母组成的单词，以回车结束。

输出格式：
在一行中输出Hello S，跟输入的S星球打个招呼。

输入样例：
Mars
输出样例：
Hello Mars

#include<stdio.h>
int main(void)
{
	char s[8];
	gets(s);
	printf("Hello ");
	puts(s);
}

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

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

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++;
	}
	
	
}

创作不易，有用请点个赞，感谢各位！

61、数素数 (20 分)

令 P
​i
​​ 表示第 i 个素数。现任给两个正整数 M≤N≤10
​4
​​ ，请输出 P
​M
​​ 到 P
​N
​​ 的所有素数。

输入格式：
输入在一行中给出 M 和 N，其间以空格分隔。

输出格式：
输出从 P
​M
​​ 到 P
​N
​​ 的所有素数，每 10 个数字占 1 行，其间以空格分隔，但行末不得有多余空格。

输入样例：
5 27
输出样例：
11 13 17 19 23 29 31 37 41 43
47 53 59 61 67 71 73 79 83 89
97 101 103

#include<stdio.h>
#include<math.h>
int scnprim(int n);
int main()
{	
	int i,m,n,count=0;
	scanf("%d %d",&m,&n);
 
	for(i=2;;i++)
	{
		if(scnprim(i))
		{
			count++;
			if(m<=count&&n>=count)
			{	if((count-m+1)%10==0)
				printf("%d\n",i);
				else if(count!=n)
				printf("%d ",i);
				else
				printf("%d",i);
			}
		}
		if(n<count)
		{
			break;
		}
	}
	return 0;
}
int scnprim(int n)//筛选素数
{
	int sqrtc,j;
	sqrtc=(int)sqrt(n);
	for(j=2;j<=sqrtc;j++)
	{
		if(n%j==0)
			return 0;
 
	}
	return n;
}

62、德才论 (25 分)

1015 德才论 (25 分)
宋代史学家司马光在《资治通鉴》中有一段著名的“德才论”：“是故才德全尽谓之圣人，才德兼亡谓之愚人，德胜才谓之君子，才胜德谓之小人。凡取人之术，苟不得圣人，君子而与之，与其得小人，不若得愚人。”

现给出一批考生的德才分数，请根据司马光的理论给出录取排名。

输入格式：
输入第一行给出 3 个正整数，分别为：N（≤10
​5
​​ ），即考生总数；L（≥60），为录取最低分数线，即德分和才分均不低于 L 的考生才有资格被考虑录取；H（<100），为优先录取线——德分和才分均不低于此线的被定义为“才德全尽”，此类考生按德才总分从高到低排序；才分不到但德分到线的一类考生属于“德胜才”，也按总分排序，但排在第一类考生之后；德才分均低于 H，但是德分不低于才分的考生属于“才德兼亡”但尚有“德胜才”者，按总分排序，但排在第二类考生之后；其他达到最低线 L 的考生也按总分排序，但排在第三类考生之后。

随后 N 行，每行给出一位考生的信息，包括：准考证号 德分 才分，其中准考证号为 8 位整数，德才分为区间 [0, 100] 内的整数。数字间以空格分隔。

输出格式：
输出第一行首先给出达到最低分数线的考生人数 M，随后 M 行，每行按照输入格式输出一位考生的信息，考生按输入中说明的规则从高到低排序。当某类考生中有多人总分相同时，按其德分降序排列；若德分也并列，则按准考证号的升序输出。

输入样例：
14 60 80
10000001 64 90
10000002 90 60
10000011 85 80
10000003 85 80
10000004 80 85
10000005 82 77
10000006 83 76
10000007 90 78
10000008 75 79
10000009 59 90
10000010 88 45
10000012 80 100
10000013 90 99
10000014 66 60
输出样例：
12
10000013 90 99
10000012 80 100
10000003 85 80
10000011 85 80
10000004 80 85
10000007 90 78
10000006 83 76
10000005 82 77
10000002 90 60
10000014 66 60
10000008 75 79
10000001 64 90

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct Student
{
	int name;	
	int de;
	int cai;
	int sum;
}love1[100100],love2[100100],love3[100100],love4[100100],love5[100100];	//love1是总的学生 
int comp(const void* a,const void* b)
{
	struct Student *aa = (struct Student *)a;
	struct Student *bb = (struct Student *)b;
	if(aa->sum != bb->sum)
	return ((bb->sum) - (aa->sum));
	else if(aa->de != bb->de)
	return ((bb->de) - (aa->de));
	else
	return ((aa->name) - (bb->name));
}
int main()
{
	int one=0,two=0,three=0,four=0,five=0;
	int i,j;
	int N,L,H;
	scanf("%d%d%d",&N,&L,&H);
	for(i=0;i<N;i++)
	{
		scanf("%d%d%d",&love1[i].name,&love1[i].de,&love1[i].cai);
		love1[i].sum = love1[i].de+love1[i].cai;
	}
	for(i=0;i<N;i++)
	{
		if(love1[i].de>=L && love1[i].cai>=L)
		{
			one++;
			if(love1[i].de>=H && love1[i].cai>=H)
			{	love2[two] = love1[i];		two++;		}
			else if(love1[i].cai<H && love1[i].de>=H)
			{	love3[three] = love1[i];	three++;	}
			else if(love1[i].de<H && love1[i].cai<H && love1[i].de>=love1[i].cai)
			{	love4[four] = love1[i];		four++;		}
			else
			{	love5[five] = love1[i];		five++;		}		
		}
	}
	printf("%d\n",one);
	qsort(love2,two,sizeof(love2[0]),comp);
	qsort(love3,three,sizeof(love3[0]),comp);
	qsort(love4,four,sizeof(love4[0]),comp);
	qsort(love5,five,sizeof(love5[0]),comp);
	
	for(i=0;i<two;i++)
	printf("%d %d %d\n",love2[i].name,love2[i].de,love2[i].cai);
	for(i=0;i<three;i++)
	printf("%d %d %d\n",love3[i].name,love3[i].de,love3[i].cai);
	for(i=0;i<four;i++)
	printf("%d %d %d\n",love4[i].name,love4[i].de,love4[i].cai);
	for(i=0;i<five;i++)
	printf("%d %d %d\n",love5[i].name,love5[i].de,love5[i].cai);
}

63、A除以B (20 分)

本题要求计算 A/B，其中 A 是不超过 1000 位的正整数，B 是 1 位正整数。你需要输出商数 Q 和余数 R，使得 A=B×Q+R 成立。

输入格式：
输入在一行中依次给出 A 和 B，中间以 1 空格分隔。

输出格式：
在一行中依次输出 Q 和 R，中间以 1 空格分隔。

输入样例：
123456789050987654321 7
输出样例：
17636684150141093474 3

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int i,j;
	int R,B,Q;
	//	余数、除数、商
	char s[1000010];	//被除数 
	scanf("%s%d",&s,&B);
	int len = strlen(s);
	Q = (s[0]-'0')/B;
	R = (s[0]-'0')%B;
	if(Q!=0||len==1)      //除数比商大的情况要考虑
		printf("%d",Q); 
	for(i=1;i<len;i++)
	{
		Q = (R*10 + s[i]-'0') / B;
		R = (R*10 + s[i]-'0') % B;
		printf("%d",Q); 
	}
	printf(" %d\n",R);
}

64、锤子剪刀布 (20 分)

1018 锤子剪刀布 (20 分)
大家应该都会玩“锤子剪刀布”的游戏：两人同时给出手势，胜负规则如图所示：

现给出两人的交锋记录，请统计双方的胜、平、负次数，并且给出双方分别出什么手势的胜算最大。

输入格式：
输入第 1 行给出正整数 N（≤10
​5
​​ ），即双方交锋的次数。随后 N 行，每行给出一次交锋的信息，即甲、乙双方同时给出的的手势。C 代表“锤子”、J 代表“剪刀”、B 代表“布”，第 1 个字母代表甲方，第 2 个代表乙方，中间有 1 个空格。

输出格式：
输出第 1、2 行分别给出甲、乙的胜、平、负次数，数字间以 1 个空格分隔。第 3 行给出两个字母，分别代表甲、乙获胜次数最多的手势，中间有 1 个空格。如果解不唯一，则输出按字母序最小的解。

输入样例：
10
C J
J B
C B
B B
B C
C C
C B
J B
B C
J J
输出样例：
5 3 2
2 3 5
B B
作者: CHEN, Yue
单位: 浙江大学
时间限制: 200 ms
内存限制: 64 MB
代码长度限制: 16 KB

#include<stdio.h>
int main()
{
	int n;
	int i;
	int a=0,b=0,c=0,d=0,e=0,f=0;
	int one=0,two=0,three=0,four=0,five=0,six=0;
	char js,ys;		//代表甲的最大胜招，代表乙的最大胜招 
	int ping=0;
	char j,y;	//代表甲、乙 出的招数 
	scanf("%d",&n);
	getchar();
	for(i=0;i<n;i++)
	{
		scanf("%c %c",&j,&y);
			 if(j=='C'&&y=='J')
		{ a++;		one++;		}
		else if(j=='J'&&y=='B')
		{	b++;	two++;		}
		else if(j=='B'&&y=='C')
		{	c++;	three++;	}
		else if(j=='B'&&y=='B')
		{		ping++;			}
		else if(j=='J'&&y=='J')
		{		ping++;			}
		else if(j=='C'&&y=='C')
		{		ping++;			}
			 if(y=='C'&&j=='J')
		{ 	d++;	four++;		}
		else if(y=='J'&&j=='B')
		{	e++;	five++;		}
		else if(y=='B'&&j=='C')
		{	f++;	six++;		}
		getchar();
	}
	
	//	先判断甲的最大胜招 
	if(one>two&&one>three)
		js='C';
	else if(two>one&&two>three)
		js='J';
	else if(three>one&&three>two)
		js='B';
	else if(two==one&&two>three)
		js='C';
	else if(two==three&&three>one)
		js='B';
	else if(one==three&&two>one)
		js='J';
	else
		js='B';
		
	//	判断乙的最大胜招
	if(four>five&&four>six)
		ys='C';
	else if(five>four&&five>six)
		ys='J';
	else if(six>four&&six>five)
		ys='B';
	else if(five==four&&five>three)
		ys='C';
	else if(five==six&&six>four)
		ys='B';
	else if(four==six&&five>four)
		ys='J';
	else
		ys='B';
		
		
	printf("%d %d %d\n",a+b+c,ping,(n-(a+b+c+ping)));
	printf("%d %d %d\n",d+e+f,ping,(n-(d+e+f+ping)));
	printf("%c %c\n",js,ys);
	
	
	return 0;
	
	
}

65、月饼 (25 分)

1020 月饼 (25 分)

月饼是中国人在中秋佳节时吃的一种传统食品，不同地区有许多不同风味的月饼。现给定所有种类月饼的库存量、总售价、以及市场的最大需求量，请你计算可以获得的最大收益是多少。

注意：销售时允许取出一部分库存。样例给出的情形是这样的：假如我们有 3 种月饼，其库存量分别为 18、15、10 万吨，总售价分别为 75、72、45 亿元。如果市场的最大需求量只有 20 万吨，那么我们最大收益策略应该是卖出全部 15 万吨第 2 种月饼、以及 5 万吨第 3 种月饼，获得 72 + 45/2 = 94.5（亿元）。

输入格式：
每个输入包含一个测试用例。每个测试用例先给出一个不超过 1000 的正整数 N 表示月饼的种类数、以及不超过 500（以万吨为单位）的正整数 D 表示市场最大需求量。随后一行给出 N 个正数表示每种月饼的库存量（以万吨为单位）；最后一行给出 N 个正数表示每种月饼的总售价（以亿元为单位）。数字间以空格分隔。

输出格式：
对每组测试用例，在一行中输出最大收益，以亿元为单位并精确到小数点后 2 位。

输入样例：
3 20
18 15 10
75 72 45
输出样例：
94.50

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct love{
	double ax;		// 得到每种月饼一吨的单价 
	double k;		// 得到每种月饼的库存量 
	double m;		//每种月饼的总售价 
}stu[1000];
int comp(const void* a,const void* b)
{
	struct love *aa = (struct love *)a;
	struct love *bb = (struct love *)b;
	return ((bb->ax)-(aa->ax));		//根据单价，成员排序好 
}
int main()
{
	int i,j;
	double money=0;
	double n;
	double d;		//最大需求量 
	scanf("%lf",&n);		//有几种月饼 
	scanf("%lf",&d);		//最大需求量 
	//输入月饼 的库存量 
	for(i=0;i<n;i++)	
	{
		scanf("%lf",&stu[i].k);
	}
	//输入月饼的总价 
	for(i=0;i<n;i++)
		scanf("%lf",&stu[i].m);	
	for(i=0;i<n;i++)
			stu[i].ax =  stu[i].m / stu[i].k;	//得到每种月饼的单价 
	qsort(stu,n,sizeof(stu[0]),comp);
	/*printf("%lf %d %d\n",stu[0].ax,stu[0].k,stu[0].m); //0下标为最大 
	printf("%lf %d %d\n",stu[1].ax,stu[1].k,stu[1].m); //0下标为最大 
	printf("%lf %d %d\n",stu[2].ax,stu[2].k,stu[2].m); //0下标为最大 */
	for(i=0;i<n;i++)
	{
		if(d<=stu[i].k)//如果最大需求量不大于当前库存 
		{
			money+=stu[i].ax*d;//最大收益即当前单价乘以最大需求量 
			break;//注意及时退出 
		}
		else
		{
			money+=stu[i].m;//否则最大收益累加当前总价 
			d-=stu[i].k;//需求量减去当前库存 
		}
	}
	printf("%.2lf\n",money);
}

66、个位数统计 (15 分)

给定一个 k 位整数 N=d
​k−1
​​ 10
​k−1
​​ +⋯+d
​1
​​ 10
​1
​​ +d
​0
​​ (0≤d
​i
​​ ≤9, i=0,⋯,k−1, d
​k−1
​​ >0)，请编写程序统计每种不同的个位数字出现的次数。例如：给定 N=100311，则有 2 个 0，3 个 1，和 1 个 3。

输入格式：
每个输入包含 1 个测试用例，即一个不超过 1000 位的正整数 N。

输出格式：
对 N 中每一种不同的个位数字，以 D:M 的格式在一行中输出该位数字 D 及其在 N 中出现的次数 M。要求按 D 的升序输出。

输入样例：
100311
输出样例：
0:2
1:3
3:1

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int i,j;
	int x[10]={0};
	int xing;
	char s[1001];
	gets(s);
	int k = strlen(s);	//得到长度
	for(i=0;i<k;i++)
	{
		xing=s[i]-48;	//将字符串中的数字转换为整型数字
		x[xing]++;		//将它作为数组下标，对应就+1
	}
	for(i=0;i<10;i++)
		if(x[i]!=0)
		printf("%d:%d\n",i,x[i]);
	return 0;
}

67、 D进制的A+B (20 分)

输入两个非负 10 进制整数 A 和 B (≤2
​30
​​ −1)，输出 A+B 的 D (1<D≤10)进制数。

输入格式：
输入在一行中依次给出 3 个整数 A、B 和 D。

输出格式：
输出 A+B 的 D 进制数。

输入样例：
123 456 8
输出样例：
1103

#include<stdio.h>
int main()
{
	int i,j;
	long  a,b,d;
	long  sum=0;
	int jin[31],k=0;
	scanf("%ld %ld %ld",&a,&b,&d);
	sum = a+b;
	if(sum==0)    //这里要注意判断当和等于0的情况，直接输出0，不然进入循环要入坑
	{
	  printf("0");  
	  return 0;
	}
	while(sum!=0)			//十进制转化为八进制就是一直除以8，每次的余数就是八进制的每一位数,当sum=0时，跳出循环
	{
		jin[k++]=sum%d;
		sum/=d;
	}
	for(i=k-1;i>=0;i--)		//数组输出八进制数时，要注意倒叙输出
		printf("%d",jin[i]);
	return 0;
}
		

68、组个最小数 (20 分)

给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。

现给定数字，请编写程序输出能够组成的最小的数。

输入格式：
输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……数字 9 的个数。整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。

输出格式：
在一行中输出能够组成的最小的数。

输入样例：
2 2 0 0 0 3 0 0 1 0
输出样例：
10015558

1023 组个最小数 (20 分)

#include<stdio.h>
int main()
{
	int i,j;
	int n;
	int flag = 0;
	int a[10]={0};
	for(i=0;i<10;i++)
	{
		scanf("%d",&a[i]);      //要注意题目要求开头不能是0，所以从1开始若有这个数就先输出一个，然后对应那个位置的值-1，下面在重新打印一次即可
		if(i>=1 && a[i]!=0 && flag>=0)
		{
			printf("%d",i);
			a[i]-=1;
			flag=-1;
			//	printf("\n-1\n");
		}
	}
	//printf("%d\t%d\t%d\n",a[0],a[1],a[2]);
	for(i=0;i<10;i++)
	{
		if(a[i]!=0)
		{
			while(a[i]--)
			printf("%d",i);
		}
	}
	return 0;
}

69、 查验身份证 (15 分)

一个合法的身份证号码由17位地区、日期编号和顺序编号加1位校验码组成。校验码的计算规则如下：

首先对前17位数字加权求和，权重分配为：{7，9，10，5，8，4，2，1，6，3，7，9，10，5，8，4，2}；然后将计算的和对11取模得到值Z；最后按照以下关系对应Z值与校验码M的值：

Z：0 1 2 3 4 5 6 7 8 9 10
M：1 0 X 9 8 7 6 5 4 3 2
现在给定一些身份证号码，请你验证校验码的有效性，并输出有问题的号码。

输入格式：
输入第一行给出正整数N（≤100）是输入的身份证号码的个数。随后N行，每行给出1个18位身份证号码。

输出格式：
按照输入的顺序每行输出1个有问题的身份证号码。这里并不检验前17位是否合理，只检查前17位是否全为数字且最后1位校验码计算准确。如果所有号码都正常，则输出All passed。

输入样例1：
4
320124198808240056
12010X198901011234
110108196711301866
37070419881216001X
输出样例1：
12010X198901011234
110108196711301866
37070419881216001X
输入样例2：
2
320124198808240056
110108196711301862
输出样例2：
All passed

#include <stdio.h>  
#include <stdlib.h>  
   
int charToInt(char c)
{  
     return (int)(c-'0');  
 }  
 int main(int argc, char *argv[]) 
 {  
     int n,i,j,k=0,s,  
     a[]={7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};  
     char cur,b[11]={'1','0','X','9','8','7','6','5','4','3','2'},  
     c[20];  
     scanf("%d",&n);  
     for(i = 0; i < n;i++)
	 {  
         s=0;  
         scanf("%s",&c);  
         for(j= 0;j<17;j++)
		 {  
             if(c[j]>='0'&&c[j]<='9')
			 {  
                 s+=charToInt(c[j])*a[j];  
			 }
			 else
			 {  
                 printf("%s",c);  
                 if(i<n-1)
				 {  
                     printf("\n");  
                 }  
                 s=-1;  
                 break;  
             }     
         }  
         if(b[s%11]==c[j]&&s!=-1)
		 {  
             k++;  
         }
		 else if(b[s%11]!=c[j]&&s!=-1)
		 {  
             printf("%s",c);  
             if(i<n-1)
			 {  
                 printf("\n");  
			 }  
         }  
     }  
     if(k==n)
	 {  
         printf("All passed");  
     }  
     return 0;  
}  

70、 跟奥巴马一起编程 (15 分)

美国总统奥巴马不仅呼吁所有人都学习编程，甚至以身作则编写代码，成为美国历史上首位编写计算机代码的总统。2014 年底，为庆祝“计算机科学教育周”正式启动，奥巴马编写了很简单的计算机代码：在屏幕上画一个正方形。现在你也跟他一起画吧！

输入格式：
输入在一行中给出正方形边长 N（3≤N≤20）和组成正方形边的某种字符 C，间隔一个空格。

输出格式：
输出由给定字符 C 画出的正方形。但是注意到行间距比列间距大，所以为了让结果看上去更像正方形，我们输出的行数实际上是列数的 50%（四舍五入取整）。

输入样例：
10 a
输出样例：
aaaaaaaaaa
a a
a a
a a
aaaaaaaaaa
作者: CHEN, Yue
单位: 浙江大学
时间限制: 400 ms
内存限制: 64 MB

1036 跟奥巴马一起编程 (15 分)

#include<stdio.h>
int main()
{
	int i,j,k;
	int n;
	char c;
	int flag=1;
	scanf("%d %c",&n,&c);
	for(i=0;i<n;i++)
	{
		printf("%c",c);
	}
	printf("\n");
	for(i=0;i<n-4;i++)
	{
		if(flag==-1)
		{
			//printf("\n");
			flag=1;
		}
		else
		{
			for(j=0;j<n;j++)
			{
				if(j==0||j==n-1)
				printf("%c",c);
				else
				printf(" ");
			}
			printf("\n");
			flag=-1;
		}
	}
	for(i=0;i<n;i++)
	{
		printf("%c",c);
	}
}

71、 划拳 (15 分)

1046 划拳 (15 分)
划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为：每人口中喊出一个数字，同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和，谁就赢了，输家罚一杯酒。两人同赢或两人同输则继续下一轮，直到唯一的赢家出现。

下面给出甲、乙两人的划拳记录，请你统计他们最后分别喝了多少杯酒。

输入格式：
输入第一行先给出一个正整数 N（≤100），随后 N 行，每行给出一轮划拳的记录，格式为：

甲喊 甲划 乙喊 乙划
其中喊是喊出的数字，划是划出的数字，均为不超过 100 的正整数（两只手一起划）。

输出格式：
在一行中先后输出甲、乙两人喝酒的杯数，其间以一个空格分隔。

输入样例：
5
8 10 9 12
5 10 5 10
3 8 5 12
12 18 1 13
4 16 12 15
输出样例：
1 2

1046 划拳 (15 分)

#include<stdio.h>
int main()
{
	int i,j;
	int sum=0;
	int a,b,c,d;
	int jia=0,yi=0;
	int n;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%d%d%d%d",&a,&b,&c,&d);
		sum=a+c;
		if(sum==b&&sum==d)
			continue;
		if(b==sum)
		yi++;
		else if(d==sum)
		jia++;
		sum=0;
	}
	printf("%d %d\n",jia,yi);
	
	
	
}

72、 组合数的和 (15 分)

1056 组合数的和 (15 分)
给定 N 个非 0 的个位数字，用其中任意 2 个数字都可以组合成 1 个 2 位的数字。要求所有可能组合出来的 2 位数字的和。例如给定 2、5、8，则可以组合出：25、28、52、58、82、85，它们的和为330。

输入格式：
输入在一行中先给出 N（1 < N < 10），随后给出 N 个不同的非 0 个位数字。数字间以空格分隔。

输出格式：
输出所有可能组合出来的2位数字的和。

输入样例：
3 2 8 5
输出样例：
330

1056 组合数的和 (15 分)

#include<stdio.h>
int main()
{
	int i,j;
	int n;
	int sum=0;
	int a[11];
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		if(i!=j)
			sum+=a[i]*10+a[j];
	}
	printf("%d\n",sum);
	
	
	
}

73、 判断题 (15 分)

1061 判断题 (15 分)
判断题的评判很简单，本题就要求你写个简单的程序帮助老师判题并统计学生们判断题的得分。

输入格式：
输入在第一行给出两个不超过 100 的正整数 N 和 M，分别是学生人数和判断题数量。第二行给出 M 个不超过 5 的正整数，是每道题的满分值。第三行给出每道题对应的正确答案，0 代表“非”，1 代表“是”。随后 N 行，每行给出一个学生的解答。数字间均以空格分隔。

输出格式：
按照输入的顺序输出每个学生的得分，每个分数占一行。

输入样例：
3 6
2 1 3 3 4 5
0 0 1 0 1 1
0 1 1 0 0 1
1 0 1 0 1 0
1 1 0 0 1 1
输出样例：
13
11
12

1061 判断题 (15 分)

#include<stdio.h>
int main()
{
	int i,j;
	int n,m;
	int a[100];
	int c[100];
	int b[100];
	scanf("%d%d",&n,&m);
	for(i=0;i<m;i++)
	{
		scanf("%d",&a[i]);		//输入每道题的分值 
	}
	for(i=0;i<m;i++)
		scanf("%d",&c[i]);
	int x,sum=0;
	for(j=0;j<n;j++)
	{
		for(i=0;i<m;i++)
		{
			scanf("%d",&x);
			if(c[i]==x)
			{
				sum+=a[i];
			}
		}
		printf("%d\n",sum);
		sum=0;
	}
}

74、图像过滤 (15 分)

1066 图像过滤 (15 分)
图像过滤是把图像中不重要的像素都染成背景色，使得重要部分被凸显出来。现给定一幅黑白图像，要求你将灰度值位于某指定区间内的所有像素颜色都用一种指定的颜色替换。

输入格式：
输入在第一行给出一幅图像的分辨率，即两个正整数 M 和 N（0<M,N≤500），另外是待过滤的灰度值区间端点 A 和 B（0≤A<B≤255）、以及指定的替换灰度值。随后 M 行，每行给出 N 个像素点的灰度值，其间以空格分隔。所有灰度值都在 [0, 255] 区间内。

输出格式：
输出按要求过滤后的图像。即输出 M 行，每行 N 个像素灰度值，每个灰度值占 3 位（例如黑色要显示为 000），其间以一个空格分隔。行首尾不得有多余空格。

输入样例：
3 5 100 150 0
3 189 254 101 119
150 233 151 99 100
88 123 149 0 255
输出样例：
003 189 254 000 000
000 233 151 099 000
088 000 000 000 255

1066 图像过滤 (15 分)

#include<stdio.h>
int main()
{
	int i,j;
	int m,n,a,b,c;
	int temp;
	int te[600][600];
	scanf("%d%d%d%d%d",&m,&n,&a,&b,&c);
	if(a>b)
	{
		temp=a;
		a=b;
		b=temp;
	}
	//printf("%d %d\n",a,b);
	for(i=0;i<m;i++)
	{
		for(j=0;j<n;j++)
		{
			scanf("%d",&te[i][j]);
			if(te[i][j]>=a&&te[i][j]<=b)
			{
				te[i][j]=c;
			}
		}
	}
	for(i=0;i<m;i++)
	{
		for(j=0;j<n-1;j++)
		{
			printf("%03d ",te[i][j]);
		}
		printf("%03d\n",te[i][j]);
	}
	//printf("sda");
	
	
	
}

75、 Wifi密码 (15 分)

1076 Wifi密码 (15 分)
下面是微博上流传的一张照片：“各位亲爱的同学们，鉴于大家有时需要使用 wifi，又怕耽误亲们的学习，现将 wifi 密码设置为下列数学题答案：A-1；B-2；C-3；D-4；请同学们自己作答，每两日一换。谢谢合作！！~”—— 老师们为了促进学生学习也是拼了…… 本题就要求你写程序把一系列题目的答案按照卷子上给出的对应关系翻译成 wifi 的密码。这里简单假设每道选择题都有 4 个选项，有且只有 1 个正确答案。

输入格式：
输入第一行给出一个正整数 N（≤ 100），随后 N 行，每行按照 编号-答案 的格式给出一道题的 4 个选项，T 表示正确选项，F 表示错误选项。选项间用空格分隔。

输出格式：
在一行中输出 wifi 密码。

输入样例：
8
A-T B-F C-F D-F
C-T B-F A-F D-F
A-F D-F C-F B-T
B-T A-F C-F D-F
B-F D-T A-F C-F
A-T C-F B-F D-F
D-T B-F C-F A-F
C-T A-F B-F D-F
输出样例：
13224143

#include<stdio.h> 
#include<string.h> 
int main() { 
		int N; 
		scanf("%d", &N); // 8道
		getchar();
		for (int i = 0; i < N; i++)//每次处理一道题
		{ 
			char str[16]; 
			gets(str); //一整行  A-T B-F C-F D-F
			for (int j = 2; j < strlen(str); j += 4) 
				if (str[j] == 'T') 
					printf("%d", str[j - 2] - 'A' + 1); 
	} 
		return 0; 
}

76、 检查密码 (15 分)

1081 检查密码 (15 分)
本题要求你帮助某网站的用户注册模块写一个密码合法性检查的小功能。该网站要求用户设置的密码必须由不少于6个字符组成，并且只能有英文字母、数字和小数点 .，还必须既有字母也有数字。

输入格式：
输入第一行给出一个正整数 N（≤ 100），随后 N 行，每行给出一个用户设置的密码，为不超过 80 个字符的非空字符串，以回车结束。

输出格式：
对每个用户的密码，在一行中输出系统反馈信息，分以下5种：

如果密码合法，输出Your password is wan mei.；
如果密码太短，不论合法与否，都输出Your password is tai duan le.；
如果密码长度合法，但存在不合法字符，则输出Your password is tai luan le.；
如果密码长度合法，但只有字母没有数字，则输出Your password needs shu zi.；
如果密码长度合法，但只有数字没有字母，则输出Your password needs zi mu.。
输入样例：
5
123s
zheshi.wodepw
1234.5678
WanMei23333
pass*word.6
输出样例：
Your password is tai duan le.
Your password needs shu zi.
Your password needs zi mu.
Your password is wan mei.
Your password is tai luan le.

1081 检查密码 (15 分)

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int i,j;
	int n,k;
	char s[100];
	int flag=1;
	int shu=0,zi=0,luan=0,duan=0;
	scanf("%d",&n);
	getchar();
	for(i=0;i<n;i++)
	{
		gets(s);
		int len = strlen(s);
		if(len<6)
		{
			printf("Your password is tai duan le.\n");
			continue;
		} 
		for(j=0;j<len;j++)
		{
			if((((s[j]>='a'&&s[j]<='z')||(s[j]>='A'&&s[j]<='Z'))||(s[j]>='0'&&s[j]<='9'))==0&&s[j]!='.')
			{
				flag=1;
				break;
			}
			if(flag==-2&&(s[j]>='a'&&s[j]<='z')||(s[j]>='A'&&s[j]<='Z'))
			{
				flag=-4;
			}
			else if(flag==-3&&s[j]>='0'&&s[j]<='9')
			{
				flag=-4;
			}
			else if(flag!=-4)
			{
				if(s[j]>='0'&&s[j]<='9')
				{
					flag=-2;
				}
				else if((s[j]>='a'&&s[j]<='z')||(s[j]>='A'&&s[j]<='Z'))
				{
					flag=-3;
				}
			}
		}
		//printf("flag = %d\n",flag);
		if(flag==1)
			printf("Your password is tai luan le.\n");
		else if(flag==-4)
			printf("Your password is wan mei.\n");
		else if(flag==-2)
			printf("Your password needs zi mu.\n");
		else if(flag==-3)
			printf("Your password needs shu zi.\n");
		/*else if(flag==-1)
			printf("Your password is tai luan le.\n");*/
		flag=1;
		
	}
}

77、就不告诉你 (15 分)

1086 就不告诉你 (15 分)
做作业的时候，邻座的小盆友问你：“五乘以七等于多少？”你应该不失礼貌地围笑着告诉他：“五十三。”本题就要求你，对任何一对给定的正整数，倒着输出它们的乘积。

输入格式：
输入在第一行给出两个不超过 1000 的正整数 A 和 B，其间以空格分隔。

输出格式：
在一行中倒着输出 A 和 B 的乘积。

输入样例：
5 7
输出样例：
53

1086 就不告诉你 (15 分)

#include <stdio.h>
int main()
{
	int n1=0,n2=0,mul,count=0,i=0,flag=0; 
	int a[10];
	scanf("%d%d",&n1,&n2);
	mul=n1*n2;
	while(mul>0){
		a[count++]=mul%10;
		mul=mul/10;
	}
	for(i=0;i<count;i++){
		if(a[i]!=0){
			flag=1;
		}
		if(flag==1){
				printf("%d",a[i]);
		} 	
}
	return 0;
}
 

78、有多少不同的值 (20 分)

当自然数 n 依次取 1、2、3、……、N 时，算式 ⌊n/2⌋+⌊n/3⌋+⌊n/5⌋ 有多少个不同的值？（注：⌊x⌋ 为取整函数，表示不超过 x 的最大自然数，即 x 的整数部分。）

输入格式：
输入给出一个正整数 N（2≤N≤10
​4
​​ ）。

输出格式：
在一行中输出题面中算式取到的不同值的个数。

输入样例：
2017
输出样例：
1480

1087 有多少不同的值 (20 分)

#include<stdio.h>
int main()
{
	int i,j;
	int n;
	int num;
	int a[10010],k=0;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
	{
		num = i/2+i/3+i/5;
		//printf("num = %d\n",num);
		if(i==1)
			a[k++]=num;
		for(j=0;j<k;j++)
		{
			if(num==a[j])
				break;
		}
		if(j==k)
			a[k++]=num;
	}
	printf("%d\n",k);
}

79、 危险品装箱 (25 分)

1090 危险品装箱 (25 分)
集装箱运输货物时，我们必须特别小心，不能把不相容的货物装在一只箱子里。比如氧化剂绝对不能跟易燃液体同箱，否则很容易造成爆炸。

本题给定一张不相容物品的清单，需要你检查每一张集装箱货品清单，判断它们是否能装在同一只箱子里。

输入格式：
输入第一行给出两个正整数：N (≤10
​4
​​ ) 是成对的不相容物品的对数；M (≤100) 是集装箱货品清单的单数。

随后数据分两大块给出。第一块有 N 行，每行给出一对不相容的物品。第二块有 M 行，每行给出一箱货物的清单，格式如下：

K G[1] G[2] … G[K]
其中 K (≤1000) 是物品件数，G[i] 是物品的编号。简单起见，每件物品用一个 5 位数的编号代表。两个数字之间用空格分隔。

输出格式：
对每箱货物清单，判断是否可以安全运输。如果没有不相容物品，则在一行中输出 Yes，否则输出 No。

输入样例：
6 3
20001 20002
20003 20004
20005 20006
20003 20001
20005 20004
20004 20006
4 00001 20004 00002 20003
5 98823 20002 20003 20006 10010
3 12345 67890 23333
输出样例：
No
Yes
Yes

1090 危险品装箱 (25 分)

#include<stdio.h>
struct wu{
 	int wu1;
	int wu2;
}W[20010];
	int main(){
	 int N,M;
	 scanf("%d%d",&N,&M);
	 int c[100010]={0};
	 int e;
	 for(int i=0;i<N;i++){
	  int a,b;
	  scanf("%d%d",&a,&b);
	  c[a]++;
	  c[b]++;
	  W[i].wu1=a;
	  W[i].wu2=b;
	 }
	 for(int j=0;j<M;j++){
	  int K;
	  scanf("%d",&K);
	  int flag=0;
	  int b[100010]={0}; 
	  for(int i=0;i<K;i++){
	   int d;
	   scanf("%d",&d);
	   if(flag==1){
	    continue;
	   }
	   else if(b[d]==1){
	    flag=1;
	    continue;
	   }
	   else if(c[d]!=0){
	    e=c[d];
	    for(int i=0;i<N;i++){
	     if(d==W[i].wu1){
	      b[W[i].wu2]=1;
	      c[d]--;
	     }
	     else if(d==W[i].wu2){
	      b[W[i].wu1]=1;
	      c[d]--;
	     }
	     if(c[d]==0){
	      break;
	     }
	    }
	    c[d]=e;
	   }
	  }
	  if(flag==1){
	   printf("No\n");
	  }
	  else{
	   printf("Yes\n");
	  }
	 }
	 return 0;
	}

80、 N-自守数 (15 分)

1091 N-自守数 (15 分)
如果某个数 K 的平方乘以 N 以后，结果的末尾几位数等于 K，那么就称这个数为“N-自守数”。例如 3×92
​2
​​ =25392，而 25392 的末尾两位正好是 92，所以 92 是一个 3-自守数。

本题就请你编写程序判断一个给定的数字是否关于某个 N 是 N-自守数。

输入格式：
输入在第一行中给出正整数 M（≤20），随后一行给出 M 个待检测的、不超过 1000 的正整数。

输出格式：
对每个需要检测的数字，如果它是 N-自守数就在一行中输出最小的 N 和 NK
​2
​​ 的值，以一个空格隔开；否则输出 No。注意题目保证 N<10。

输入样例：
3
92 5 233
输出样例：
3 25392
1 25
No

1091 N-自守数 (15 分)

#include<stdio.h>
#include<math.h>
int funtion(int k)
{
	int mix=1;
	while(k)
	{
		mix*=10;
		k/=10;
	}
	return mix;
}
int main()
{
	int t;
	int n;
	int i,j;
	int x;
	int avg;
	int ge,shi,bai;
	int flag;
	int sum=0;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%d",&x);
		t = funtion(x);
		sum = pow(x,2);
		flag=0;
		for(j=1;j<10;j++)
		{
			avg = sum*j;
			/*ge = avg%10;
			shi = avg/10%10;
			bai = avg/100%10;*/
			if((avg-x)%t==0)
			{
				printf("%d %d\n",j,avg);
				flag=1;
				break;
			}
			/*else if(x==ge+shi*10)
			{
				printf("%d %d\n",j,avg);
				flag=-1;
				break;
			}
			else if(x==ge+shi*10+bai*100)
			{
				printf("%d %d\n",j,avg);
				flag=-1;
				break;
			}*/
		}
		if(flag==0)
			printf("No\n");
		//flag=1;	
	}
}

创作不易，有用请点个赞，感谢各位！

创作不易，有用请点个赞，感谢各位！

81、Programming in C is fun! (5 分)

本题要求编写程序，输出一个短句“Programming in C is fun!”。

输入格式:
本题目没有输入。

输出格式:
在一行中输出短句“Programming in C is fun!”。

#include<stdio.h>
int main(void)
{
	printf("Programming in C is fun!\n");
}

82、出租车计价 (15 分)

7-3 出租车计价 (15 分)
本题要求根据某城市普通出租车收费标准编写程序进行车费计算。具体标准如下：

起步里程为3公里，起步费10元；
超起步里程后10公里内，每公里2元；
超过10公里以上的部分加收50%的回空补贴费，即每公里3元；
营运过程中，因路阻及乘客要求临时停车的，按每5分钟2元计收（不足5分钟则不收费）。
输入格式:
输入在一行中给出输入行驶里程（单位为公里，精确到小数点后1位）与等待时间（整数，单位为分钟），其间以空格分隔。

输出格式:
在一行中输出乘客应支付的车费（单位为元），结果四舍五入，保留到元。

输入样例1:
2.6 2
输出样例1:
10
输入样例2:
5.1 4
输出样例2:
14
输入样例3:
12.5 9
输出样例3:
34

#include<stdio.h>
int main()
{
	double km;			//公里
	int m=0;			//分钟
	double money=0;		//钱
	int yu;
	scanf("%lf %d",&km,&m);
	if(m<5)				//	<5分钟的情况
	{
		if(km<=3)		//0~3公里
			money=10;
		else if(km<=10)	//3~10公里
			money=10+(km-3)*2;
		else			//10以上公里
			money=10+7*2+(km-10)*3;
	}
	else
	{
		if(km<=3)		//0~3公里
			money=10+(m/5)*2;
		else if(km<=10)	//3~10公里
			money=10+(km-3)*2+(m/5)*2;
		else			//10以上公里
			money=10+7*2+(km-10)*3+(m/5)*2;
	}
	printf("%1.lf\n",money);
	return 0;
}

83、求幂级数展开的部分和 (20 分)

已知函数e
​x
​​ 可以展开为幂级数1+x+x
​2
​​ /2!+x
​3
​​ /3!+⋯+x
​k
​​ /k!+⋯。现给定一个实数x，要求利用此幂级数部分和求e
​x
​​ 的近似值，求和一直继续到最后一项的绝对值小于0.00001。

输入格式:
输入在一行中给出一个实数x∈[0,5]。

输出格式:
在一行中输出满足条件的幂级数部分和，保留小数点后四位。

输入样例:
1.2
输出样例:
3.3201

#include<stdio.h>
#include<math.h>
double jiecheng(double n);
int main()
{
	double x;		//输入一个实数
	double n=0;		//下面我会给出一个推导公式，你就懂了兄弟
	double c=0;		//表示次方
	double sum=0;	//求总和
	double result;	//最后一项的绝对值
	scanf("%lf",&x);
	/*	题目公式：	 【1】   +  【x】   +【x^2/2!】+【x^3/3!】+【x^n/n!】	*/
	/*	上下中括号都有各5个，然而这5个其实都是对等的！不信你们就在本子上算呀^_^哈哈！ */
	/*	推到公式： 【x^0/0!】+【x^1/1!】+【x^2/2!】+【x^3+3!】+【x^n/n!】	*/
	do
	{
		result=pow(x,c)/(jiecheng(n));
		sum+=result;
		n++;
		c++;
	}while((jiecheng(n))>=0.00001);
	result=pow(x,c)/(jiecheng(n));
	sum+=result;
	printf("%.4f\n",sum);
	return 0;
}
double jiecheng(double n)
{
	int mix=1;
	for(int i=1;i<=n;i++)
		mix=mix*i;
	return mix;
}

84、 What is a computer? (5 分)

本题要求编写程序，输出一个短句“What is a computer?”。

输入格式:
本题目没有输入。

输出格式:
在一行中输出短句“What is a computer?”。

#include<stdio.h>
int main()
{
	printf("What is a computer?");
	return 0;
}

85、将x的平方赋值给y (5 分)

假设x的值为3，计算x的平方并赋值给y，分别以“y = x ∗ x”和“x ∗ x = y”的形式输出x和y的值。

输入格式：
本题无输入

输出格式：
按照下列格式输出代入x=3的结果：

y = x * x
x * x = y

#include<stdio.h>
int main()
{
	int x=3;
	int y;
	printf("%d = %d * %d\n%d * %d = %d\n",x*x,x,x,x,x,x*x);
	return 0;
}

86、 计算火车运行时间 (15 分)

本题要求根据火车的出发时间和达到时间，编写程序计算整个旅途所用的时间。

输入格式：
输入在一行中给出2个4位正整数，其间以空格分隔，分别表示火车的出发时间和到达时间。每个时间的格式为2位小时数（00-23）和2位分钟数（00-59），假设出发和到达在同一天内。

输出格式：
在一行输出该旅途所用的时间，格式为“hh:mm”，其中hh为2位小时数、mm为2位分钟数。

输入样例：
1201 1530
输出样例：
03:29

#include <stdio.h>
#include <stdlib.h>
int main() 
{
    int h;		//小时
	int m;		//分钟
	int num1;	//出发时间
	int num2;	//到达时间
    scanf("%d%d",&num1,&num2);
    h=num2/100-num1/100;            //4位整型取前2位(小时)
    m=num2%100-num1%100;            //4位整型取余后2位(分钟)
    if(m<0)                  //num1，num2都是在同一天,h一定大于0
    {
        m=60+m;                 //当m小于0，从h借来一小时，填补m的值
        h=h-1;
    }
    printf("%02d:%02d\n",h,m);	
	return 0;
}

87、计算工资 (15 分)

某公司员工的工资计算方法如下：一周内工作时间不超过40小时，按正常工作时间计酬；超出40小时的工作时间部分，按正常工作时间报酬的1.5倍计酬。员工按进公司时间分为新职工和老职工，进公司不少于5年的员工为老职工，5年以下的为新职工。新职工的正常工资为30元/小时，老职工的正常工资为50元/小时。请按该计酬方式计算员工的工资。

输入格式：
输入在一行中给出2个正整数，分别为某员工入职年数和周工作时间，其间以空格分隔。

输出格式：
在一行输出该员工的周薪，精确到小数点后2位。

输入样例1：
5 40
输出样例1：
2000.00
输入样例2：
3 50
输出样例2：
1650.00

#include<stdio.h>
int main()
{
	int year;					//工作年份
	int h;						//小时
	double money;
	scanf("%d %d",&year,&h);	//输入功能
	if(year<5)					//新员工情况
	{	
		if(h<=40)				//正常工作的情况
			money=h*30;
		else					//加班的情况
			money=40*30+(h-40)*1.5*30;
	}
	else						//老员工的情况
	{
		if(h<=40)				//正常工作的情况
			money=h*50;
		else					//加班的情况
			money=40*50+(h-40)*1.5*50;
	}
	printf("%.2lf\n",money);	
	return 0;
}

88、 日K蜡烛图 (15 分)

股票价格涨跌趋势，常用蜡烛图技术中的K线图来表示，分为按日的日K线、按周的周K线、按月的月K线等。以日K线为例，每天股票价格从开盘到收盘走完一天，对应一根蜡烛小图，要表示四个价格：开盘价格Open（早上刚刚开始开盘买卖成交的第1笔价格）、收盘价格Close（下午收盘时最后一笔成交的价格）、中间的最高价High和最低价Low。

如果Close<Open，表示为“BW-Solid”（即“实心蓝白蜡烛”）；如果Close>Open，表示为“R-Hollow”（即“空心红蜡烛”）；如果Open等于Close，则为“R-Cross”（即“十字红蜡烛”）。如果Low比Open和Close低，称为“Lower Shadow”（即“有下影线”），如果High比Open和Close高，称为“Upper Shadow”（即“有上影线”）。请编程序，根据给定的四个价格组合，判断当日的蜡烛是一根什么样的蜡烛。

输入格式：
输入在一行中给出4个正实数，分别对应Open、High、Low、Close，其间以空格分隔。

输出格式：
在一行中输出日K蜡烛的类型。如果有上、下影线，则在类型后加上with 影线类型。如果两种影线都有，则输出with Lower Shadow and Upper Shadow。

输入样例1：
5.110 5.250 5.100 5.105
输出样例1：
BW-Solid with Lower Shadow and Upper Shadow
输入样例2：
5.110 5.110 5.110 5.110
输出样例2：
R-Cross
输入样例3：
5.110 5.125 5.112 5.126
输出样例3：
R-Hollow

#include<stdio.h>
int main()
{
	double o;		//Open
	double h;		//High
	double l;		//Low
	double c;		//Close
	scanf("%lf%lf%lf%lf",&o,&h,&l,&c);
	if(c<o)
	{
		printf("BW-Solid");
		if(l<o && l<c && h>o && h>c)
			printf(" with Lower Shadow and Upper Shadow");
		else if(l<o && l<c)
			printf(" with Lower Shadow");
		else if(h>o && h>c)
			printf(" with Upper Shadow");
	}
	else if(c>o)
	{
		printf("R-Hollow");
		if(l<o && l<c && h>o && h>c)
			printf(" with Lower Shadow and Upper Shadow");
		else if(l<o && l<c)
			printf(" with Lower Shadow");
		else if(h>o && h>c)
			printf(" with Upper Shadow");
	}
	else if(c==o)
	{
		printf("R-Cross");
		if(l<o && l<c && h>o && h>c)
			printf(" with Lower Shadow and Upper Shadow");
		else if(l<o && l<c)
			printf(" with Lower Shadow");
		else if(h>o && h>c)
			printf(" with Upper Shadow");
	}
	return 0;
}

89、 到底是不是太胖了 (10 分)

据说一个人的标准体重应该是其身高（单位：厘米）减去100、再乘以0.9所得到的公斤数。真实体重与标准体重误差在10%以内都是完美身材（即 | 真实体重 − 标准体重 | < 标准体重×10%）。已知市斤是公斤的两倍。现给定一群人的身高和实际体重，请你告诉他们是否太胖或太瘦了。

输入格式：
输入第一行给出一个正整数N（≤ 20）。随后N行，每行给出两个整数，分别是一个人的身高H（120 < H < 200；单位：厘米）和真实体重W（50 < W ≤ 300；单位：市斤），其间以空格分隔。

输出格式：
为每个人输出一行结论：如果是完美身材，输出You are wan mei!；如果太胖了，输出You are tai pang le!；否则输出You are tai shou le!。

输入样例：
3
169 136
150 81
178 155
输出样例：
You are wan mei!
You are tai shou le!
You are tai pang le!

#include<stdio.h>
#include<math.h>
int main()
{
	int n;		//输入正整数
	int h;		//身高
	int w;		//真实体重
	int x;		//标准体重
	/*	标准体重（市斤） =（身高-100）*0.9*0.2	*/
	scanf("%d",&n);
	if(n<1 || n>20)		return 0;   //n<=20
	for(int i=1;i<=n;i++)
	{
		scanf("%d %d",&h,&w);
		if(h<120 || h>=200 || w<50 || w>300)	return 0;     // 120 < H < 200 和 50 < W ≤ 300
		x = (h-100)*0.9*2;
		if(fabs(w-x) < x*0.1)
			printf("You are wan mei!\n");
		else if((fabs(w-x) >= x*0.1) && w<x)
			printf("You are tai shou le!\n");
		else if((fabs(w-x) >= x*0.1) && w>x)
			printf("You are tai pang le!\n");
	}
	return 0;
}

90、找最小的字符串 (15 分)

本题要求编写程序，针对输入的N个字符串，输出其中最小的字符串。

输入格式：
输入第一行给出正整数N；随后N行，每行给出一个长度小于80的非空字符串，其中不会出现换行符，空格，制表符。

输出格式：
在一行中用以下格式输出最小的字符串：

Min is: 最小字符串
输入样例：
5
Li
Wang
Zha
Jin
Xian
输出样例：
Min is: Jin

7-7 找最小的字符串 (15 分)

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
int main(void)
{
	char a[10000][80];
	int n;
	int i,j;
	int min;
	char temp[80];
	scanf("%d",&n);
	getchar();
	for(i=0;i<n;i++)
		gets(a[i]);
	for(i=0;i<n-1;i++)
	{
		min=i;
		for(j=i+1;j<n;j++)
			if(strcmp(a[min],a[j])>0)
				min=j;
			if(min!=i)
			{
				strcpy(temp,a[min]);
				strcpy(a[min],a[i]);
				strcpy(a[i],temp);
			}
	}
	printf("Min is: %s",a[0]);
	return 0;
}

91、 字符串的冒泡排序 (20 分)

我们已经知道了将N个整数按从小到大排序的冒泡排序法。本题要求将此方法用于字符串序列，并对任意给定的K（<N），输出扫描完第K遍后的中间结果序列。

输入格式：
输入在第1行中给出N和K（1≤K<N≤100），此后N行，每行包含一个长度不超过10的、仅由小写英文字母组成的非空字符串。

输出格式：
输出冒泡排序法扫描完第K遍后的中间结果序列，每行包含一个字符串。

输入样例：
6 2
best
cat
east
a
free
day
输出样例：
best
a
cat
day
east
free

7-1 字符串的冒泡排序 (20 分)

#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
	int n,k;			//n→有几个字符串，k→扫描几次
	int i,j;			//用于循环和数组下标
	char a[100][11];	//用于存储字符串
	char temp[11];
	scanf("%d%d",&n,&k);	//提供输入n、k的功能
	getchar();
	for(i=0;i<n;i++)	//提供输入字符串的功能
		scanf("%s",a[i]);

	for(i=0;i<k;i++)
	{
		for(j=0;j<n-1-i;j++)
		{
			if(strcmp(a[j],a[j+1])>0)
			{
				strcpy(temp,a[j]);
				strcpy(a[j],a[j+1]);
				strcpy(a[j+1],temp);
			}
		}
	}

	for(i=0;i<n;i++)
		printf("%s\n",a[i]);
	return 0;
}

92、组织星期信息 (10 分)

输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：

定义一个指针数组将下面的星期信息组织起来，输入一个字符串，在表中查找，若存在，输出该字符串在表中的序号，否则输出-1。

Sunday Monday Tuesday Wednesday Thursday Friday Saturday

输入输出示例：括号内为说明，无需输入输出

输入样例 (repeat=3) :
3
Tuesday
Wednesday
year
输出样例:
3
4
-1

7-2 组织星期信息 (10 分)

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
	char *p[] ={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
	int repeat;		//输入几个数
	int i,j;		//用于循环和数组下标
	//int flag = 0;	//判断是否有输出那句话
	char tmp[50];	//输入的字符串
	scanf("%d",&repeat);
	getchar();
	for(i=0;i<repeat;i++)
	{
		gets(tmp);
		for(j=0;j<7;j++)
		{
			if(strcmp(tmp,p[j])==0)
			{	printf("%d\n",j+1);	break;	}
			else if(j==6)
				printf("-1\n");
		}
	}
	return 0;
}

93、 奇偶分家 (10 分)

给定N个正整数，请统计奇数和偶数各有多少个？

输入格式：
输入第一行给出一个正整N（≤1000）；第2行给出N个非负整数，以空格分隔。

输出格式：
在一行中先后输出奇数的个数、偶数的个数。中间以1个空格分隔。

输入样例：
9
88 74 101 26 15 0 34 22 77
输出样例：
3 6

7-3 奇偶分家 (10 分)

#include <stdio.h>
#include <math.h>
int main()
{
	int n;			//有几个数
	int a[1001];	//存储数据的空间
	int i;		//用于循环和数组下标
	int ji=0,ou=0;	//ji→统计奇数数量，ou→统计偶数数量
	scanf("%d",&n);
	for(i=0;i<n;i++)
		scanf("%d",&a[i]);
	for(i=0;i<n;i++)
	{
		if(a[i]%2==0)
			ou++;
		else
			ji++;
	}
	printf("%d %d\n",ji,ou);
	return 0;
}

94、 海盗分赃 (25 分)

P 个海盗偷了 D 颗钻石后来到公海分赃，一致同意如下分赃策略：

首先，P 个海盗通过抽签决定 1 - P 的序号。然后由第 1 号海盗提出一个分配方案（方案应给出每个海盗分得的具体数量），如果能够得到包括 1 号在内的绝对多数（即大于半数）同意，则按照该分配方案执行，否则 1 号将被投入大海喂鲨鱼；而后依次类似地由第 2 号、第 3 号等等海盗提出方案，直到能够获得绝对多数同意的方案出现为止，或者只剩下最后一位海盗，其独占所有钻石。请编写一个程序，给出第 1 号海盗的钻石分配方案中自己分得的钻石数量。

附带的三个假定：

“聪明”与“贪婪”假定：每个海盗总能够以本人利益最大化作为行为准则；
“人性化”假定：在能够取得尽量多钻石的情况下，海盗不会故意致同伙于死地；
“无偏见”假定：海盗之间没有个人恩怨，分给其他海盗钻石的次序以小序号优先为原则。
输入格式：
输入在一行中给出 2 个正整数 D 和 P（3≤P≤D≤100）。

输出格式：
输出第 1 号海盗的钻石分配方案中自己分得的钻石数量。

输入样例：
10 7
输出样例：
6

7-9 海盗分赃 (25 分)

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
	int d,p;					//d→钻石数量，p→人数
	scanf("%d %d",&d,&p);		//提供输入钻石、人数的功能
    if(p == 3){
        printf("%d",d-1);
    }
    else{
        printf("%d",d-(p/2+1));	//转化为数学规律 当人数超过三个人的时候 第一个海盗得到的金币为： D - (P / 2 + 1)
    }
 
 
    return 0;
}

95、 超速判断 (10 分)

模拟交通警察的雷达测速仪。输入汽车速度，如果速度超出60 mph，则显示“Speeding”，否则显示“OK”。

输入格式：
输入在一行中给出1个不超过500的非负整数，即雷达测到的车速。

输出格式：
在一行中输出测速仪显示结果，格式为：Speed: V - S，其中V是车速，S或者是Speeding、或者是OK。

输入样例1：
40
输出样例1：
Speed: 40 - OK
输入样例2：
75
输出样例2：
Speed: 75 - Speeding

7-4 超速判断 (10 分)

#include<stdio.h>
int main()
{
	int sudu;
	scanf("%d",&sudu);
	if(sudu<=60){
		printf("Speed: %d - OK\n",sudu);
	}else{
		printf("Speed: %d - Speeding\n",sudu);
	}
	return 0;
}

96、 jmu-ds-顺序表区间元素删除 (15 分)

若一个线性表L采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。

输入格式:
三行数据，第一行是顺序表的元素个数，第二行是顺序表的元素，第三行是x和y。

输出格式:
删除元素值在[x,y]之间的所有元素后的顺序表。

输入样例:
10
5 1 9 10 67 12 8 33 6 2
3 10

输出样例:
1 67 12 33 2

7-8 jmu-ds-顺序表区间元素删除 (15 分)

import java.util.Scanner;
public class Main {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int g=0,t=0;
		int x,y;
		int L[]={1,2,3,4,5,6,7,8,9,21213,123,1123,1,132123,123
				,123,132,23,123,12,32,123,123,12,132,123,12,32
				,123,12,132,123,1,23,132,123,312,321
				,12312,32,123,123,1,1231,231,23,123,1321,32
				,12,132,123,132,123,123,132,12,123,
				123,123,123,1,231,231,231,231,231,21,321,231,231,3
				,1,1,3,1321,1,1,132,123,1,1321,1,32,32,
				123,123,123,132,23,1321,321,1,23,1
				,123,13,1231,32,231,1,321,
				123,1,132,123,123,132,123,132,12,132,123,132,132,321,132
		  ,123,23,132,132,132,132,13,213,2,132,1,231,32,132,132,132,132
		  ,23,132,132,132,132,13,213,2,132,1,231,32,132,132,132,13
		  ,23,132,132,132,132,13,213,2,132,1,231,32,132,132,132,13};
		int i,j;
		for(i=0;i<n;i++)
			L[i]=scanner.nextInt();
		x = scanner.nextInt();
		y = scanner.nextInt();
		for(i=0;i<n;i++)
		{
			if(L[i]>=x && L[i]<=y)
			{	L[i]=0;}
		}
		for(i=0;i<n;i++)
			if(L[i]!=0)
				g++;
		for(i=0;i<n;i++)
		{
			if(L[i]!=0){
				if(t!=g-1)
				System.out.print(L[i] + " ");
				else
				System.out.print(L[i]);
				t++;
			}
		}
	}
}

97、查找指定字符 (15 分)

本题要求编写程序，从给定字符串中查找某指定的字符。

输入格式：
输入的第一行是一个待查找的字符。第二行是一个以回车结束的非空字符串（不超过80个字符）。

输出格式：
如果找到，在一行内按照格式“index = 下标”输出该字符在字符串中所对应的最大下标（下标从0开始）；否则输出"Not Found"。

输入样例1：
m
programming
输出样例1：
index = 7
输入样例2：
a
1234
输出样例2：
Not Found

#include<stdio.h>
int main(void)
{
	char c,b[10010];	//待查询的字符，输入的字符串
	int index=-1;		//标记
	scanf("%c",&c);
	getchar();		//吃掉一个空格，否则会被认为是字符串中的内容
	gets(b);		受到gets输入的影响，字符串都以\0作为结尾
	for(int i=0;b[i]!='\0';i++)	//所以这里就从0开始，一直执行到等于\0时才结束
		if(b[i]==c)	//当出现一次待查询字符时，就标记一次，一直到循环结束为止
			index=i;
	if(index==-1)
		printf("Not Found\n");
	else
		printf("index = %d\n",index);
}

98、复数四则运算 (15 分)

本题要求编写程序，计算2个复数的和、差、积、商。

输入格式：
输入在一行中按照a1 b1 a2 b2的格式给出2个复数C1=a1+b1i和C2=a2+b2i的实部和虚部。题目保证C2不为0。

输出格式：
分别在4行中按照(a1+b1i) 运算符 (a2+b2i) = 结果的格式顺序输出2个复数的和、差、积、商，数字精确到小数点后1位。如果结果的实部或者虚部为0，则不输出。如果结果为0，则输出0.0。

输入样例1：
2 3.08 -2.04 5.06
输出样例1：
(2.0+3.1i) + (-2.0+5.1i) = 8.1i
(2.0+3.1i) - (-2.0+5.1i) = 4.0-2.0i
(2.0+3.1i) * (-2.0+5.1i) = -19.7+3.8i
(2.0+3.1i) / (-2.0+5.1i) = 0.4-0.6i
输入样例2：
1 1 -1 -1.01
输出样例2：
(1.0+1.0i) + (-1.0-1.0i) = 0.0
(1.0+1.0i) - (-1.0-1.0i) = 2.0+2.0i
(1.0+1.0i) * (-1.0-1.0i) = -2.0i
(1.0+1.0i) / (-1.0-1.0i) = -1.0

7-3 复数四则运算 (15 分)

#include<stdio.h>
void shizi(double x,double y);		//负责打印式子
void result(double x,double y);		//负责打印结果
struct Love{		
	double shi,xu;	//表示实部，虚部
}love1,love2;
int main()
{	
	scanf("%lf%lf%lf%lf",&love1.shi,&love1.xu,&love2.shi,&love2.xu);
	//下面的计算根据复数的实部与虚部计算公式：
	//求加法的实部与虚部值
	double jia_shi = love1.shi + love2.shi;
	double jia_xu  = love1.xu  + love2.xu;

	//求减法的实部与虚部值
	double jian_shi = love1.shi - love2.shi;
	double jian_xu  = love1.xu  - love2.xu;

	//求乘法的实部与虚部值
	double cheng_shi = love1.shi*love2.shi-love1.xu*love2.xu;
	double cheng_xu  = love1.xu*love2.shi+love1.shi*love2.xu;
	
	//求除法的实部与虚部值
	double chu_shi = (love1.shi*love2.shi+love1.xu*love2.xu)/(love2.shi*love2.shi+love2.xu*love2.xu);
	double chu_xu  = (love1.xu*love2.shi-love1.shi*love2.xu)/(love2.shi*love2.shi+love2.xu*love2.xu);
	
	//因为题目的输出结果要分多种情况，那就在函数里来判断情况输出吧
	
	//加法
	shizi(love1.shi,love1.xu);	//式子
	printf(" + ");
	shizi(love2.shi,love2.xu);	//式子
	printf(" = ");
	result(jia_shi,jia_xu);		//结果

	//减法
	shizi(love1.shi,love1.xu);	//式子
	printf(" - ");
	shizi(love2.shi,love2.xu);	//式子
	printf(" = ");
	result(jian_shi,jian_xu);		//结果
	
	//乘法
	shizi(love1.shi,love1.xu);	//式子
	printf(" * ");
	shizi(love2.shi,love2.xu);	//式子
	printf(" = ");
	result(cheng_shi,cheng_xu);		//结果

	//除法
	shizi(love1.shi,love1.xu);	//式子
	printf(" / ");
	shizi(love2.shi,love2.xu);	//式子
	printf(" = ");
	result(chu_shi,chu_xu);		//结果
	return 0;
}
void shizi(double x,double y)		//负责打印式子
{
	if(y<0)							//虚部为负数的时候不用加'+'号
		printf("(%.1lf%.1lfi)",x,y);
	else
		printf("(%.1lf+%.1lfi)",x,y);	//反之成立
}
void result(double rshi,double rxu)
{	
	//虚部不存在时，只需输出实部
	if(rxu<=0.05&&rxu>=-0.05)	//其实这里也判断了两段都没有的情况，输出0.0
		printf("%.1lf\n",rshi);
	else if(rshi<=0.05&&rshi>=-0.05)	//实部不存在时，输出虚部单个即可
		printf("%.1lfi\n",rxu);
	else if(rxu<0)
		printf("%.1lf%.1lfi\n",rshi,rxu);	//结果虚部为负数的时候不用加'+'号
	else
		printf("%.1lf+%.1lfi\n",rshi,rxu);	//反之成立
}

99、 输出三角形字符阵列 (15 分)

本题要求编写程序，输出n行由大写字母A开始构成的三角形字符阵列。

输入格式：
输入在一行中给出一个正整数n（1≤n<7）。

输出格式：
输出n行由大写字母A开始构成的三角形字符阵列。格式见输出样例，其中每个字母后面都有一个空格。

输入样例：
4
输出样例：
A B C D
E F G
H I
J

输出三角形字符阵列 (15 分)

#include<stdio.h>
int main()
{
	int n,i,j;
	char x=64;  //从A开始，A的ASCLL是65，进j循环时+1
	scanf("%d",&n);
	for(i=0;i<n;i++)  //控制行数
	{
		for(j=0;j<n-i;j++)  //控制打印
		{ 
			x += 1; //每一次都要+1，A→65，B→66
			printf("%c ",x);
		}
		printf("\n");
	}
	return 0;
}

100、找最长的字符串 (15 分)

本题要求编写程序，针对输入的N个字符串，输出其中最长的字符串。

输入格式：
输入第一行给出正整数N；随后N行，每行给出一个长度小于80的非空字符串，其中不会出现换行符，空格，制表符。

输出格式：
在一行中用以下格式输出最长的字符串：

The longest is: 最长的字符串
如果字符串的长度相同，则输出先输入的字符串。

输入样例：
5
li
wang
zhang
jin
xiang
输出样例：
The longest is: zhang

7-5 找最长的字符串 (15 分)

#include<stdio.h>
#include<string.h>
int main()
{
	int n,i;
	char a[100],b[100];	//a→拿来输入的，b→拿来得到最长的字符串
	scanf("%d",&n);
	getchar();	//吃掉空格
	for(i=0;i<n;i++){
		gets(a);
		if(i==0)
			strcpy(b,a);	//第一此需复制，防止第一个就是最长的情况
		if(strlen(b)<strlen(a))	//若新来的比原来的还要长，那么就复制新来的来覆盖掉原来的
			strcpy(b,a);
	}
	printf("The longest is: ");
	puts(b);
	return 0;
}

创作不易，有用请点个赞，感谢各位！

创作不易，有用请点个赞，感谢各位！

101、整数的分类处理 (20 分)

给定 N 个正整数，要求你从中得到下列三种计算结果：

A1 = 能被 3 整除的最大整数
A2 = 存在整数 K 使之可以表示为 3K+1 的整数的个数
A3 = 存在整数 K 使之可以表示为 3K+2 的所有整数的平均值（精确到小数点后 1 位）
输入格式：
输入首先在第一行给出一个正整数 N，随后一行给出 N 个正整数。所有数字都不超过 100，同行数字以空格分隔。

输出格式：
在一行中顺序输出 A1、A2、A3的值，其间以 1 个空格分隔。如果某个数字不存在，则对应输出NONE。

输入样例 1：
8
5 8 7 6 9 1 3 10
输出样例 1：
9 3 6.5
输入样例 2：
8
15 18 7 6 9 1 3 10
输出样例 2：
18 3 NONE

7-7 整数的分类处理 (20 分)

#include<stdio.h>
int main()
{
	int n,a2=0,a3=0,i,x,max=0,sum=0;
	scanf("%d",&n);
	for(i=0;i<n;i++){
		scanf("%d",&x);
		if(x%3==0&&x>max)	//得到A1数
			max=x;	
		if((x-1)%3==0)		//成立的个数==A2
			a2++;
		if((x-2)%3==0)		//成立的整数和/成立的个数==A3
		{	a3++;	sum+=x;	}
	}
	if(max==0)	printf("NONE ");	//按照题目说的a1,a2,a3中某个值不在就输出HONE
	else		printf("%d ",max);
	if(a2==0)	printf("HONE ");
	else		printf("%d ",a2);
	if(sum==0)	printf("HONE");
	else		printf("%.1f",sum*1.0/a3);
	return 0;
}

102、统计工龄 (20 分)

给定公司N名员工的工龄，要求按工龄增序输出每个工龄段有多少员工。

输入格式:
输入首先给出正整数N（≤10
​5
​​ ），即员工总人数；随后给出N个整数，即每个员工的工龄，范围在[0, 50]。

输出格式:
按工龄的递增顺序输出每个工龄的员工个数，格式为：“工龄:人数”。每项占一行。如果人数为0则不输出该项。

输入样例:
8
10 2 0 5 7 2 5 2
输出样例:
0:1
2:3
5:2
7:1
10:1
7-8 统计工龄 (20 分)

#include<stdio.h>
int main()
{
	int i,n,a,b[52]={0};
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%d",&a);
			b[a]++;
	}
	for(i=0;i<52;i++)
		if(b[i]!=0)
			printf("%d:%d\n",i,b[i]);

	return 0;
}

103、7-10 数组循环左移 (20 分)

本题要求实现一个对数组进行循环左移的简单函数：一个数组a中存有n（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向左移m（≥0）个位置，即将a中的数据由（a
​0
​​ a
​1
​​ ⋯a
​n−1
​​ ）变换为（a
​m
​​ ⋯a
​n−1
​​ a
​0
​​ a
​1
​​ ⋯a
​m−1
​​ ）（最前面的m个数循环移至最后面的m个位置）。如果还需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

输入格式:
输入第1行给出正整数n（≤100）和整数m（≥0）；第2行给出n个整数，其间以空格分隔。

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

输入样例：
8 3
1 2 3 4 5 6 7 8
输出样例：
4 5 6 7 8 1 2 3

7-10 数组循环左移 (20 分)

#include<stdio.h>
int main(void){
	
	int a[101];
	int n,m,i;
	while(scanf("%d%d",&n,&m)!=EOF){
		
		for( i=0;i < n;i++)
		  scanf("%d",&a[i]);
		
		for( i =m;i<n+m;i++){
			
			if( i >=n)
			  printf("%d",a[ i%n]);
			else printf("%d",a[i]);
			
			if( i == n+m -1)
			  printf("\n");
			else printf(" ");    
	 	}
	 }
 return 0;
}

104、求链式线性表的倒数第K项 (20 分)

给定一系列正整数，请设计一个尽可能高效的算法，查找倒数第K个位置上的数字。

输入格式:
输入首先给出一个正整数K，随后是若干正整数，最后以一个负整数表示结尾（该负数不算在序列内，不要处理）。

输出格式:
输出倒数第K个位置上的数据。如果这个位置不存在，输出错误信息NULL。

输入样例:
4 1 2 3 4 5 6 7 8 9 0 -1
输出样例:
7

7-11 求链式线性表的倒数第K项 (20 分)

#include<stdio.h>
#include<string.h>
#define maxn 0x7fffffff
int a[maxn];
int main()
{
    int k;
    scanf("%d",&k);
    int count=0,x;
    while(1)
    {
        scanf("%d",&x);
        if(x<0)break;
        else 
        {
            a[count]=x;
            count++; 
        } 
    }
    if(count-k<0)
     printf("NULL\n");
    else
     printf("%d\n",a[count-k]); 
    return 0;
}

105、方阵循环右移 (20 分)

本题要求编写程序，将给定n×n方阵中的每个元素循环向右移m个位置，即将第0、1、⋯、n−1列变换为第n−m、n−m+1、⋯、n−1、0、1、⋯、n−m−1列。

输入格式：
输入第一行给出两个正整数m和n（1≤n≤6）。接下来一共n行，每行n个整数，表示一个n阶的方阵。

输出格式：
按照输入格式输出移动后的方阵：即输出n行，每行n个整数，每个整数后输出一个空格。

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

7-12 方阵循环右移 (20 分)

#include <stdio.h>
//时间：2018年4月23日20:08:02
//思路：通过思考发现，循环输出主要是数组下标的控制问题，只要能够控制列的下标就可实现
//      循环的打印出循环右移后的二维数组，正是因为循环右移，所以需要将数值m控制在0至n-1中。
int main()
{
	int a[10][10];
	int i, j, n, m;
	scanf("%d%d",&m,&n);
	for (i = 0; i<n; i++)
	{
		for (j = 0; j<n; j++)
		{
			scanf("%d", &a[i][j]);
		}
	}
	m %= n; //使得m的取值为小于n的值，钳制在0至n-1中，便于下面下标的控制。
	for (i = 0; i<n; i++)
	{
		for (j = 0; j<n; j++)
		{
			printf("%d ", a[i][(n - m + j) % n]); //循环输出下标的控制 a[i][(n-m+j) % n]
		}
		printf("\n");
	}
	return 0;
}

106、组个最小数 (20 分)

给定数字0-9各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意0不能做首位）。例如：给定两个0，两个1，三个5，一个8，我们得到的最小的数就是10015558。

现给定数字，请编写程序输出能够组成的最小的数。

输入格式：
输入在一行中给出10个非负整数，顺序表示我们拥有数字0、数字1、……数字9的个数。整数间用一个空格分隔。10个数字的总个数不超过50，且至少拥有1个非0的数字。

输出格式：
在一行中输出能够组成的最小的数。

输入样例：
2 2 0 0 0 3 0 0 1 0
输出样例：
10015558

7-3 组个最小数 (20 分)

#include<stdio.h>
int main(int argc, char const *argv[])
{
	int i,j;
	int x[9];
	for(i=0;i<10;i++)
		scanf("%d",&x[i]);
	for(i=1;i<10;i++)
		if(x[i])
		{	printf("%d",i);  x[i]--;  break;	}
	for(i=0;i<10;i++)
		while(x[i])
		{	printf("%d",i);	x[i]--;		}
	return 0;
}

107、猴子吃桃问题 (15 分)

一只猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个；第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半加一个。到第N天早上想再吃时，见只剩下一个桃子了。问：第一天共摘了多少个桃子？

输入格式:
输入在一行中给出正整数N（1<N≤10）。

输出格式:
在一行中输出第一天共摘了多少个桃子。

输入样例:
3
输出样例:
10

7-1 猴子吃桃问题 (15 分)

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int i,j;
	int n;
	int sum=2;
	scanf("%d",&n);
	for(i=1;i<n;i++)
	{
		if(i==n-1)
			sum*=2;
		else
			sum=sum*2+1;
	}
	printf("%d\n",sum);
	return 0;
}

108、字符串字母大小写转换 (15 分)

本题要求编写程序，对一个以“#”结束的字符串，将其小写字母全部转换成大写字母，把大写字母全部转换成小写字母，其他字符不变输出。

输入格式：
输入为一个以“#”结束的字符串（不超过30个字符）。

输出格式：
在一行中输出大小写转换后的结果字符串。

输入样例：
Hello World! 123#
输出样例：
hELLO wORLD! 123

7-2 字符串字母大小写转换 (15 分)

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int i,j;
	char a[10010];
	gets(a);
	int k = strlen(a);
	a[k-1] = '\0';
	for(i=0;a[i]!='\0';i++)
	{
		if(((a[i]>='a'&&a[i]<='z') || (a[i]>='A'&&a[i]<='Z')) ==0)
			continue;
		else if(a[i]>='a'&&a[i]<='z')
			a[i]-=32;
		else
			a[i]+=32;
	}
	puts(a);
	return 0;
}

109、计算分段函数[3] (10 分)

本题目要求计算下列分段函数f(x)的值：

输入格式：
输入在一行中给出实数x。

输出格式：
在一行中按“f(x) = result”的格式输出，其中x与result都保留一位小数。

输入样例1：
10
输出样例1：
f(10.0) = 0.1
输入样例2：
234
输出样例2：
f(234.0) = 234.0

7-5 计算分段函数[3] (10 分)

#include<string.h>
#include<stdlib.h>
int main()
{
	float x;
	float result=0;
	scanf("%f",&x);
	if(x!=10)
		result = x;
	else
		result = 1/x;
	printf("f(%.1f) = %.1f\n",x,result);
	return 0;
}

110、查找整数 (10 分)

本题要求从输入的N个整数中查找给定的X。如果找到，输出X的位置（从0开始数）；如果没有找到，输出“Not Found”。

输入格式：
输入在第一行中给出两个正整数N（≤20）和X，第二行给出N个整数。数字均不超过长整型，其间以空格分隔。

输出格式：
在一行中输出X的位置，或者“Not Found”。

输入样例1：
5 7
3 5 7 1 9
输出样例1：
2
输入样例2：
5 7
3 5 8 1 9
输出样例2：
Not Found

7-6 查找整数 (10 分)

#include<stdio.h>
#include<math.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int n,x,i;
	int c[10010];
	scanf("%d%d",&n,&x);
	for(i=0;i<n;i++)
	{
		scanf("%d",&c[i]);
		if(c[i]==x)
			break;
	}
	if(i==n)
	printf("Not Found\n");
	else
	printf("%d\n",i);
	return 0;
}

111、旅游规划 (25 分)

有了一张自驾旅游路线图，你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序，帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的，那么需要输出最便宜的一条路径。

输入格式:
输入说明：输入数据的第1行给出4个正整数N、M、S、D，其中N（2≤N≤500）是城市的个数，顺便假设城市的编号为0~(N−1)；M是高速公路的条数；S是出发地的城市编号；D是目的地的城市编号。随后的M行中，每行给出一条高速公路的信息，分别是：城市1、城市2、高速公路长度、收费额，中间用空格分开，数字均为整数且不超过500。输入保证解的存在。

输出格式:
在一行里输出路径的长度和收费总额，数字间以空格分隔，输出结尾不能有多余空格。

输入样例:
4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20
输出样例:
3 40

7-7 旅游规划 (25 分)

这是一次比赛出现的提醒，正确答案我就不放了，这是我当时写的17分代码，让你们看看大概思路，如果这道题想要的满分，要对迪…啥的那个算法才可以！

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
int main()
{
	int cheng1[5010];	//城市1
	int cheng2[5010];	//城市2
	int chang[5010];		//高速公路长度
	int money[5010];		//收费总额
	int i,j;
	int N;	//城市编号
	int M;	//高速公路条数
	int S;	//出发地的城市编号
	int D;	//目的地的城市编号
	int MIN=0;	//最短路径
	int result=0;	//收费额
	int shangMIN=0;
	int shangResult=0;
	int index;
	scanf("%d%d%d%d",&N,&M,&S,&D);
	for(i=0;i<M;i++)
		//输入每一条高速公路的信息
		scanf("%d%d%d%d",&cheng1[i],&cheng2[i],&chang[i],&money[i]);
	for(i=0;i<M;)
	{
		if((cheng1[i]==0)&&(cheng2[i]==N-1))
		{	result=money[i];	MIN=chang[i];index=1;}
		else
		{
			MIN=chang[i]+chang[i+1];
			result=money[i]+money[i+1];
			index=2;
		}
		if(i==0)
		{
			shangMIN = MIN;
			shangResult=result;
		}
		else
		{
			if(MIN==shangMIN && result<shangResult)
			{
				shangMIN=MIN;
				shangResult=result;
			}
		}
		if(index==1)
			i++;
		else if(index==2)
			i=i+2;
	}
	printf("%d %d\n",shangMIN,shangResult);
	return 0;
}

112、黑洞数 (20 分)

黑洞数也称为陷阱数，又称“Kaprekar问题”，是一类具有奇特转换特性的数。

任何一个各位数字不全相同的三位数，经有限次“重排求差”操作，总会得到495。最后所得的495即为三位黑洞数。所谓“重排求差”操作即组成该数的数字重排后的最大数减去重排后的最小数。（6174为四位黑洞数。）

例如，对三位数207：

第1次重排求差得：720 - 27 ＝ 693；
第2次重排求差得：963 - 369 ＝ 594；
第3次重排求差得：954 - 459 ＝ 495；
以后会停留在495这一黑洞数。如果三位数的3个数字全相同，一次转换后即为0。

任意输入一个三位数，编程给出重排求差的过程。

输入格式：
输入在一行中给出一个三位数。

输出格式：
按照以下格式输出重排求差的过程：

序号: 数字重排后的最大数 - 重排后的最小数 = 差值
序号从1开始，直到495出现在等号右边为止。

输入样例：
123
输出样例：
1: 321 - 123 = 198
2: 981 - 189 = 792
3: 972 - 279 = 693
4: 963 - 369 = 594
5: 954 - 459 = 495

7-8 黑洞数 (20 分)

#include<stdio.h>
#include<math.h>
#include<string.h>
#include<stdlib.h>
int number[6] = {0};
int MAX,MIN;
int sum=0;
int swap2(int x,int y)
{
	if(x<y)
		return x;
	else
		return y;
}
int swap(int x,int y)
{
	if(x>y)
		return x;
	else
		return y;
}
int main()
{
	int n;
	int ci=1;
	int i=0,j;
	int index;
	int ge,shi,bai;
	int result;
	scanf("%d",&n);
	index = n;
	while(1)
	{
		ge=index%10;
		shi=index/10%10;
		bai=index/100;
			number[0] = ge + shi*100 + bai*10;
			number[1] = shi + ge*10 + bai*100;
			number[2] = shi + ge*100 + bai*10;
			number[3] = bai + shi*10 + ge*100;
			number[4] = bai + shi*100 + ge*10;
			number[5] = index;
			MAX=number[0];
			MIN=number[0];
		for(i=1;i<6;i++)
			MAX = swap(number[i],MAX);
		for(i=1;i<6;i++)
			MIN = swap2(number[i],MIN);
		sum = MAX-MIN;
		printf("%d: %d - %d = %d\n",ci,MAX,MIN,sum);

		ci++;
		index = sum;
		if(sum==495)
			break;
	}
	return 0;
}

113、龟兔赛跑 (20 分)

乌龟与兔子进行赛跑，跑场是一个矩型跑道，跑道边可以随地进行休息。乌龟每分钟可以前进3米，兔子每分钟前进9米；兔子嫌乌龟跑得慢，觉得肯定能跑赢乌龟，于是，每跑10分钟回头看一下乌龟，若发现自己超过乌龟，就在路边休息，每次休息30分钟，否则继续跑10分钟；而乌龟非常努力，一直跑，不休息。假定乌龟与兔子在同一起点同一时刻开始起跑，请问T分钟后乌龟和兔子谁跑得快？

输入格式：
输入在一行中给出比赛时间T（分钟）。

输出格式：
在一行中输出比赛的结果：乌龟赢输出@@，兔子赢输出^_，平局则输出--；后跟1空格，再输出胜利者跑完的距离。

输入样例：
242
输出样例：
@_@ 726

7-9 龟兔赛跑 (20 分)

#include<stdio.h>
#include<math.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int fen;
	int i,j;
	int gui=0,tu=0;
	int index=0;	//标记兔子休息时间
	int swap=1;		//决定兔子是否还继续跑
	scanf("%d",&fen);
	for(i=1;i<=fen;i++)
	{
		if(index==30)
		{	index=0;	swap=1;	}
		if(swap!=-1)
		{
			gui+=3;
			tu+=9;
		}
		else
		{
			gui+=3;
			index++;
		}
		if(i%10==0)
		{
			if(tu>gui)
				swap=-1;
		}		
	}
	if(gui>tu)
	printf("@_@ %d\n",gui);
	else if(gui==tu)
	printf("-_- %d\n",gui);
	else
	printf("^_^ %d\n",tu);
	//printf("gui = %d,tu = %d\n",gui,tu);
	return 0;
}

114、螺旋方阵 (20 分)

所谓“螺旋方阵”，是指对任意给定的N，将1到N×N的数字从左上角第1个格子开始，按顺时针螺旋方向顺序填入N×N的方阵里。本题要求构造这样的螺旋方阵。

输入格式：
输入在一行中给出一个正整数N（<10）。

输出格式：
输出N×N的螺旋方阵。每行N个数字，每个数字占3位。

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

7-4 螺旋方阵 (20 分)

#include<stdio.h>
int main()
{
	int n;
	int h=0,l=0;
	int result=1;
	int t;
	int a[100][100]={0};
	scanf("%d",&n);
	a[h][l]=1;
	while(n*n!=result)
	{
		for(t=result;;)		//横
	{
		if((l+1<n && !a[h][l+1])!=true)
			break;
		a[h][++l] = ++result;
	}
	for(t=result;;)		//竖
	{
		if((h+1<n && !a[h+1][l])!=true)
			break;
		a[++h][l] = ++result;
	}	
	for(t=result;;)		//横
	{
		if((l-1>=0 && !a[h][l-1])!=true)
			break;
		a[h][--l] = ++result;
	}
	for(t=result;;)		//竖
	{
		if((h-1>=0 && !a[h-1][l])!=true)
			break;
		a[--h][l] = ++result;
	}
	}
		
	for(h=0;h<n;h++)
	{
		for(l=0;l<n;l++)
			printf("%3d",a[h][l]);
		printf("\n");
	}
	return 0;
}

115、删除字符串中的子串 (20 分)

输入2个字符串S1和S2，要求删除字符串S1中出现的所有子串S2，即结果字符串中不能包含S2。

输入格式：
输入在2行中分别给出不超过80个字符长度的、以回车结束的2个非空字符串，对应S1和S2。

输出格式：
在一行中输出删除字符串S1中出现的所有子串S2后的结果字符串。

输入样例：
Tomcat is a male ccatat
cat
输出样例：
Tom is a male

7-5 删除字符串中的子串 (20 分)

#include<stdio.h>
#include<string.h>
char a[85],b[85],l,m;
void dete1(char *p,char *q){
   p=strstr(p,q);
   while(*(p+l)!='\0'){
   	*p=*(p+l);
   	*p++;
   }
   *p=*(p+l);
   return ;
}
int main(){
	int i,j,k;
    gets(a);
    gets(b);
	l=strlen(b);
	while(strstr(a,b)!=NULL){
		 m=strlen(a);
         dete1(a,b); 
	   }
     printf("%s\n",a);
	return 0;
} 

116、 A-B (20 分)

本题要求你计算A−B。不过麻烦的是，A和B都是字符串 —— 即从字符串A中把字符串B所包含的字符全删掉，剩下的字符组成的就是字符串A−B。

输入格式：
输入在2行中先后给出字符串A和B。两字符串的长度都不超过10
​4
​​ ，并且保证每个字符串都是由可见的ASCII码和空白字符组成，最后以换行符结束。

输出格式：
在一行中打印出A−B的结果字符串。

输入样例：
I love GPLT! It’s a fun game!
aeiou
输出样例：
I lv GPLT! It’s fn gm!

#include<stdio.h>
#include<string.h>
int main()
{
	int i=0,j=0;			//用于循环和数组下标
	char str1[10010];		//用来存储A、B两个字符串
	char str2[10010];		//用来存储要删除的字符串字母
	int length;				//用来存储字符串长度
	gets(str1);
	gets(str2);
	length = strlen(str2);	//这里只需要记住str2字符串的长度即可
	while(str1[i]!='\0')	//将str1字符串从第一个字母开始带进去一一查验
	{
		for(j=0;j<length;j++)//将这个字母放到str2中一一查询是否有对应的，若有对应的
		{					//那么for循环就会提前跳出，并且j的值不可能会等于length，
			if(str1[i]==str2[j])//记住关键词，提前！所以从这里就可以肯定若for循环执行
				break;			//到了最后，那么证明这个字母在str2中是找不到对应的，
		}						//那么自然需要显示啦！
		if(j==length)
			printf("%c",str1[i]);
		i++;
	}
	printf("\n");
	return 0;
}

117、猜数字 (20 分)

一群人坐在一起，每人猜一个 100 以内的数，谁的数字最接近大家平均数的一半就赢。本题就要求你找出其中的赢家。

输入格式：
输入在第一行给出一个正整数N（≤10
​4
​​ ）。随后 N 行，每行给出一个玩家的名字（由不超过8个英文字母组成的字符串）和其猜的正整数（≤ 100）。

输出格式：
在一行中顺序输出：大家平均数的一半（只输出整数部分）、赢家的名字，其间以空格分隔。题目保证赢家是唯一的。

输入样例：
7
Bob 35
Amy 28
James 98
Alice 11
Jack 45
Smith 33
Chris 62
输出样例：
22 Amy

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct E{
char name[11];
int num;
}a[10001];
int main(){
    int n,sum=0;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%s%d",a[i].name,&a[i].num);
        sum+=a[i].num;
    }
    int avg=(sum/n)/2,minm=11111,tag;
    for(int i=0;i<n;i++){
        if(abs(avg-a[i].num)<minm){
            minm=abs(avg-a[i].num);
            tag=i;
        }
    }
    printf("%d %s\n",avg,a[tag].name);
    return 0;
}

118、40059 四则运算 (15 分)

编写一个不考虑优先级的，能够进行加、减、乘、除四则运算的袖珍计算器。

输入格式:
如：键盘输入 10.83+0.10/10= 。

输出格式:
程序计算后输出结果1.093000（运算式子以‘＝’结尾）。

输入样例:
34.5－2.4*3.1/11=
输出样例:
9.722727

#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
	int i,j;
	double num1,num2;
	char c;
	scanf("%lf",&num1);
	for(i=0;;i++)
	{
		scanf("%c",&c);
		if(c=='=')
		break;
		scanf("%lf",&num2);
		if(c=='-')
			num1-=num2;
		else if(c=='+')
			num1+=num2;
		else if(c=='*')
			num1*=num2;
		else if(c=='/')
		{
//			if(num2==0)
//				num1=0;
//			else
			num1/=num2;
		}
	}
		printf("%lf\n",num1);
		return 0;
}

119、宿舍谁最高？ (20 分)

学校选拔篮球队员，每间宿舍最多有4个人。现给出宿舍列表，请找出每个宿舍最高的同学。定义一个学生类Student,有身高height，体重weight等。

输入格式:
首先输入一个整型数n （1<=n<=1000000），表示n位同学。
紧跟着n行输入,每一行格式为：宿舍号，name,height,weight。
宿舍号的区间为[0,999999]， name 由字母组成，长度小于16，height，weight为正整数。

输出格式:
按宿舍号从小到大排序，输出每间宿舍身高最高的同学信息。题目保证每间宿舍只有一位身高最高的同学。

输入样例:
7
000000 Tom 175 120
000001 Jack 180 130
000001 Hale 160 140
000000 Marry 160 120
000000 Jerry 165 110
000003 ETAF 183 145
000001 Mickey 170 115
输出样例:
000000 Tom 175 120
000001 Jack 180 130
000003 ETAF 183 145

#include<math.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct Student{
	int number;
	char name[18];
	int height;
	int weight;
}stu[10010]={0};
int main()
{
	int n;
	int i;
	char temp1[20];
	int index[100],k=0;
	int temp2;
	int number_new;
	char name_new[18];
	int height_new;
	int weight_new;

	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%d%s%d%d",&number_new,&name_new,&height_new,&weight_new);
		index[k++]=number_new;
		if(stu[number_new].height == 0)		//利用序号找身高是否有存过值
		{
			stu[number_new].number=number_new;
			strcpy(stu[number_new].name,name_new);
			stu[number_new].height=height_new;
			stu[number_new].weight=weight_new;
		}
		else
		{
			if(height_new>stu[number_new].height)
			{
				stu[number_new].number=number_new;
				strcpy(stu[number_new].name,name_new);
				stu[number_new].height=height_new;
				stu[number_new].weight=weight_new;
			}
		}
	}
	//printf("\n");
	for(i=0;i<k;i++)
	{
		if(stu[index[i]].number!=-1)
		{
		printf("%06d %s %d %d\n",stu[index[i]].number,stu[index[i]].name,stu[index[i]].height,stu[index[i]].weight);
		stu[index[i]].number=-1;
		}
	}
	//printf("%06d %s %d %d\n",stu[0].number,stu[0].name,stu[0].height,stu[0].weight);
	return 0;
}

120、阶梯电价 (15 分)

为了提倡居民节约用电，某省电力公司执行“阶梯电价”，安装一户一表的居民用户电价分为两个“阶梯”：月用电量50千瓦时（含50千瓦时）以内的，电价为0.53元/千瓦时；超过50千瓦时的，超出部分的用电量，电价上调0.05元/千瓦时。请编写程序计算电费。

输入格式:
输入在一行中给出某用户的月用电量（单位：千瓦时）。

输出格式:
在一行中输出该用户应支付的电费（元），结果保留两位小数，格式如：“cost = 应付电费值”；若用电量小于0，则输出"Invalid Value!"。

输入样例1:
10
输出样例1:
cost = 5.30
输入样例2:
100
输出样例2:
cost = 55.50

#include<stdio.h>
int main()
{
	double n;
	scanf("%lf",&n);
	if(n<0)
		printf("Invalid Value!\n");
	else if(n<=50)
		printf("cost = %.2lf\n",n*0.53);
	else if(n>50)
		printf("cost = %.2lf\n",(50*0.53+(n-50)*0.05));
	return 0;
}

创作不易，有用请点个赞，感谢各位！

原创不易，有用请点个赞，感谢各位！

121、高速公路超速处罚 (15 分)

按照规定，在高速公路上行使的机动车，达到或超出本车道限速的10%则处200元罚款；若达到或超出50%，就要吊销驾驶证。请编写程序根据车速和限速自动判别对该机动车的处理。

输入格式:
输入在一行中给出2个正整数，分别对应车速和限速，其间以空格分隔。

输出格式:
在一行中输出处理意见：若属于正常行驶，则输出“OK”；若应处罚款，则输出“Exceed x%. Ticket 200”；若应吊销驾驶证，则输出“Exceed x%. License Revoked”。其中x是超速的百分比，精确到整数。

输入样例1:
65 60
输出样例1:
OK
输入样例2:
110 100
输出样例2:
Exceed 10%. Ticket 200
输入样例3:
200 120
输出样例3:
Exceed 67%. License Revoked

#include<stdio.h>
#include<math.h>
int main()
{
	float chesu,xiansu;
	scanf("%f%f",&chesu,&xiansu);
	//if(chesu<xiansu*1.1)	之前写的判断，这种理解是错误的，弄我了自闭半天^_^哈哈
	if(chesu-xiansu<xiansu*0.1)
		printf("OK\n");
	else if(chesu<xiansu*1.5)
		printf("Exceed %1.f%%. Ticket 200\n",((chesu-xiansu)/xiansu)*100);
	else
		printf("Exceed %1.f%%. License Revoked\n",((chesu-xiansu)/xiansu)*100);
	return 0;
}

122、抓老鼠啊~亏了还是赚了？ (20 分)

某地老鼠成灾，现悬赏抓老鼠，每抓到一只奖励10元，于是开始跟老鼠斗智斗勇：每天在墙角可选择以下三个操作：放置一个带有一块奶酪的捕鼠夹(T)，或者放置一块奶酪©，或者什么也不放(X)。捕鼠夹可重复利用，不计成本，奶酪每块3元。
聪明的老鼠呢？它们每天可能会派出一只老鼠到墙角，看看墙角有啥：

若什么也没有(X)，老鼠们就不高兴了(Unhappy)，会有长达一天（也就是第二天）的不高兴期。在不高兴期间，不派出老鼠。不高兴期结束之后，派出老鼠。
若有捕鼠夹(T)，这只老鼠被引诱吃掉奶酪并被打死(Dead)，老鼠们会有长达两天（也就是第二和第三天）的伤心期。在伤心期间，不派出老鼠。伤心期结束之后，派出老鼠。在这种情况下，抓到1只老鼠可获得奖励10元，但同时也耗费了一块奶酪。注意，如果某一天放置了捕鼠夹但老鼠没有出现，则没有耗费奶酪。
若有奶酪©，老鼠吃了奶酪会很开心(Happy!)，会有长达两天（第二和第三天）的兴奋期。在兴奋期间，即使叠加了不高兴或者伤心，也必定派出老鼠。在这种情况下，没抓到老鼠，而且耗费了一块奶酪。注意，如果某一天放置了奶酪但老鼠没有出现，则奶酪可以下次再用，没有耗费。
现在给你连续几天的操作序列，且已知第一天肯定会派出老鼠，请判断老鼠每天的状态，并计算盈利。

输入格式:
输入在一行中给出连续的由C或T或X组成的不超过70个字符的字符串，以$结束。字符串中每个字符表示这一天的操作( 即X：什么都不放；T：放捕鼠夹；C：放奶酪）。题目保证至少有一天的操作输入。

输出格式:
要求在第一行输出连续的字符串，与输入相对应，给出老鼠的状态：

! 表示派出老鼠吃到奶酪
D 表示派出老鼠被打死
U 表示派出老鼠无所获

• 表示没有派出老鼠
  第二行则应输出一个整数表示盈利。（如果有亏损，则是负数）

输入样例1:
TXXXXC$
输出样例1:
D–U-!
4
输入样例2:
CTTCCX$
输出样例2:
!DD–U
11

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int money=0;
	int i,j;
	int flag=0,index=0,kong=1;
	int pai=1;
	char s[72];
	gets(s);
	//int len = strlen(s);
	//s[len-1]='\0';
	for(i=0;s[i]!='$';i++)
	{
		if(flag<=0 && index==0)
		{
			if(s[i]=='X')
			{	printf("U");	index=-1;pai-=1;	}
			else if(s[i]=='T')
			{	
				if(pai>=1)
				{
					printf("D");	index=-2;
					money+=7;
					pai-=2;
				}
			}
			else if(s[i]=='C')
			{	
				if(pai>=1)
				{
					printf("!");	flag=2;
					money-=3;
				}
			}
		}
		else if(flag>0 && kong>=0)
		{
			if(s[i]=='X')
			{	printf("U");		}
			else if(s[i]=='T')
			{	printf("D");kong--;money+=7;	}
			else if(s[i]=='C')
			{	printf("!");money-=3;}
			flag--;
		}
		if(kong==-1)
		{	kong=0;	index=-2;	}
		while(index<0 && s[i+1]!='$')
		{
			if(index!=0)
			{
				printf("-");
				++index;
			}
				i=i+1;
				if(pai<1)
				pai++;
		}
		if(pai<1)
		pai++;
	}
	printf("\n%d\n",money);
	return 0;
}

123、用天平找小球 (10 分)

三个球A、B、C，大小形状相同且其中有一个球与其他球重量不同。要求找出这个不一样的球。

输入格式：
输入在一行中给出3个正整数，顺序对应球A、B、C的重量。

输出格式：
在一行中输出唯一的那个不一样的球。

输入样例：
1 1 2
输出样例：
C

#include<stdio.h>
int max;
void swap(int a,int b,int c)
{
	max=a;
	if(max!=b&&max==c)
	{	max=b;	}
	else if(max!=c&&max==b)
	{	max=c;	}
}
int main()
{
	int a,b,c;
	scanf("%d%d%d",&a,&b,&c);
	swap(a,b,c);
	if(max==a)
		printf("A\n");
	else if(max==b)
		printf("B\n");
	else 
		printf("C\n");
	return 0;
}

124、求符合给定条件的整数集 (15 分)

给定不超过6的正整数A，考虑从A开始的连续4个数字。请输出所有由它们组成的无重复数字的3位数。

输入格式：
输入在一行中给出A。

输出格式：
输出满足条件的的3位数，要求从小到大，每行6个整数。整数间以空格分隔，但行末不能有多余空格。

输入样例：
2
输出样例：
234 235 243 245 253 254
324 325 342 345 352 354
423 425 432 435 452 453
523 524 532 534 542 543

#include<stdio.h>
int main()
{
	int i,j,k;
	int huan_hang=0;	//控制空格和换行
	int t,n;
	scanf("%d",&t);
	n=t;
	for(i=n;i<=n+3;i++)
	{
		for(j=n;j<=n+3;j++)
		{
			if(i!=j)
			{
				for(k=n;k<=n+3;k++)
				{
					if(j!=k&&i!=k)
					{
						huan_hang++;	//控制空格和换行
						if(huan_hang<=5)
							printf("%d%d%d ",i,j,k);
						else
							printf("%d%d%d",i,j,k);
						if(huan_hang%6==0)
						{
							printf("\n");
							huan_hang=0;
						}
					}
				}
			}
		}
	}
	return 0;
}

125、用扑克牌计算24点 (25 分)

一副扑克牌的每张牌表示一个数（J、Q、K 分别表示 11、12、13，两个司令都表示 6）。任取4 张牌，即得到 4 个 1~13 的数，请添加运算符（规定为加+ 减- 乘* 除/ 四种）使之成为一个运算式。每个数只能参与一次运算，4 个数顺序可以任意组合，4 个运算符任意取 3 个且可以重复取。运算遵从一定优先级别，可加括号控制，最终使运算结果为 24。请输出一种解决方案的表达式，用括号表示运算优先。如果没有一种解决方案，则输出 -1 表示无解。

输入格式：
输入在一行中给出 4 个整数，每个整数取值在 [1, 13]。

输出格式：
输出任一种解决方案的表达式，用括号表示运算优先。如果没有解决方案，请输出 -1。

输入样例：
2 3 12 12
输出样例：
((3-2)*12)+12

#include<stdio.h>
#define N 4

//下面这个函数用于分配不同的四种符号
static int result(int arr[],char op[]);

//根据不同的优先级不同的符号计算结果的函数
static double Result(double x, double y, int op);

//下面这五个函数是分配不同的优先级
//((A op B) op C) op D
static double result1(double num1,double num2,double num3,double num4,int op1,int op2,int op3);
//(A op (B op C)) op D
static double result2(double num1,double num2,double num3,double num4,int op1,int op2,int op3);
//A op (B op (C op D))
static double result3(double num1,double num2,double num3,double num4,int op1,int op2,int op3);
//A op ((B op C) op D)
static double result4(double num1,double num2,double num3,double num4,int op1,int op2,int op3);
//(A op B) op (C op D)
static double result5(double num1,double num2,double num3,double num4,int op1,int op2,int op3);

int main()
{			
		int num[N],i,j,k,t;
		char op[5] ={'睿','+','-','*','/'};	//把四种运算符都存入数组中
		for(i=0;i<N;i++)	//随意输入四个数
			scanf("%d",&num[i]);
		
		//将4个数字组合成各个位上互不相同的数
		for(i=0;i<N ;i++)
		{
			for(j=0;j<N;j++)
			{
				if(i==j) continue;
				for(k=0;k<N;k++)
				{
					if(i==k || j==k) continue;
					for(t=0;t<N;t++)
					{ 
						if(i==t || j==t || k==t) continue;
						int zuhe_num[N] = {num[i],num[j],num[k],num[t]};	/*	排列四种数字出现的不同顺序，因为有了运算符的不同，
																				所以计算的结果自然是不同的	*/
						int swap =	result(zuhe_num,op);	//得到值是是否已经有一组数据成立了 24的结果，有就直接结束
						if(swap)//若已有解，则直接结束程序
						{
							return 0;
						}
						
					}
				}
			}	
		}
		//无解
		printf("-1");	
}
static int result(int zuhe_num[],char op[])	//下面这个函数用于分配不同的四种符号
{
		double sum =0;
		//穷举所有运算组合
		for(int i=1;i<=N;i++)
		{
			for(int j=1;j<=N;j++)
			{
				for(int k=1;k<=N;k++)
				{
					sum = result1(zuhe_num[0],zuhe_num[1],zuhe_num[2],zuhe_num[3],i,j,k);
					if(sum==24)		//如果条件满足直接输出，并返回1结束程序，依次类推下面的一样
					{
						//((A op B) op C) op D
						printf("((%d%c%d)%c%d)%c%d\n",zuhe_num[0],op[i],zuhe_num[1],op[j],zuhe_num[2],op[k],zuhe_num[3]);
						return 1;
					}
					sum = result2(zuhe_num[0],zuhe_num[1],zuhe_num[2],zuhe_num[3],i,j,k);
					if(sum==24)
					{
						//(A op (B op C)) op D
						printf("(%d%c(%d%c%d))%c%d\n",zuhe_num[0],op[i],zuhe_num[1],op[j],zuhe_num[2],op[k],zuhe_num[3]);
						return 1;
					}
					sum = result3(zuhe_num[0],zuhe_num[1],zuhe_num[2],zuhe_num[3],i,j,k);
					if(sum==24)
					{
						//A op (B op (C op D))
						printf("%d%c(%d%c(%d%c%d))\n",zuhe_num[0],op[i],zuhe_num[1],op[j],zuhe_num[2],op[k],zuhe_num[3]);
						return 1;
					}
					sum = result4(zuhe_num[0],zuhe_num[1],zuhe_num[2],zuhe_num[3],i,j,k);
					if(sum==24)
					{
						//A op ((B op C) op D)
						printf("%d%c((%d%c%d)%c%d)\n",zuhe_num[0],op[i],zuhe_num[1],op[j],zuhe_num[2],op[k],zuhe_num[3]);
						return 1;
					}
					sum = result5(zuhe_num[0],zuhe_num[1],zuhe_num[2],zuhe_num[3],i,j,k);
					if(sum==24)
					{
						//(A op B) op (C op D)
						printf("(%d%c%d)%c(%d%c%d)\n",zuhe_num[0],op[i],zuhe_num[1],op[j],zuhe_num[2],op[k],zuhe_num[3]);
						return 1;
					}				
				}
			}
		}
		//如果没有解决方案
		return 0;
}
static double Result(double num1, double num2, int op)		//根据不同的优先级不同的符号计算结果的函数
{
	if(op==1)		//根据传过来的符号进行判断，并执行相应的计算
		return num1+num2;
	else if(op==2)
		return num1-num2;
	else if(op==3)
		return num1*num2;
	else if(op==4)
		return num1/num2;
	else
		return 0;
}
//下面这五个函数是分配不同的优先级
static double result1(double num1,double num2,double num3,double num4,int op1,int op2,int op3)	
{														//((A op B) op C) op D
		double r1,r2,r3;
		r1 = Result(num1,num2,op1);
		r2 = Result(r1,num3,op2);
		r3 = Result(r2,num4,op3);
		return r3;
}
static double result2(double num1,double num2,double num3,double num4,int op1,int op2,int op3)
{														//(A op (B op C)) op D
		double r1,r2,r3;
		r1 = Result(num2,num3,op2);
		r2 = Result(num1,r1,op1);
		r3 = Result(r2,num4,op3);
		return r3;
}
static double result3(double num1,double num2,double num3,double num4,int op1,int op2,int op3)
{														//A op (B op (C op D))
		double r1,r2,r3;
		r1 = Result(num3,num4,op3);
		r2 = Result(num2,r1,op2);
		r3 = Result(num1,r2,op1);
		return r3;	
}
static double result4(double num1,double num2,double num3,double num4,int op1,int op2,int op3)
{														//A op ((B op C) op D)
		double r1,r2,r3;
		r1 = Result(num2,num3,op2);
		r2 = Result(r1,num4,op3);
		r3 = Result(num1,r2,op1);
		return r3;
}

static double result5(double num1,double num2,double num3,double num4,int op1,int op2,int op3)
{														//(A op B) op (C op D)
		double r1,r2,r3;
		r1 = Result(num1,num2,op1);
		r2 = Result(num3,num4,op3);
		r3 = Result(r1,r2,op2);
		return r3;
}

126、近似求PI (15 分)

7-1 近似求PI (15 分)
本题要求编写程序，根据下式求π的近似值，直到最后一项小于给定精度eps。

输入格式：
输入在一行中给出精度eps，可以使用以下语句来读输入：

scanf("%le", &eps);
输出格式：
在一行内，按照以下格式输出π的近似值（保留小数点后5位）：

PI = 近似值
输入样例：
1E-5
输出样例：
PI = 3.14158

#include<stdio.h>
double fenzi(int n);
double fenmu(int n);
int main()
{
	int n=0;
	double sum=0;
	double eps;
	scanf("%le",&eps);
	do
	{
		sum+=fenzi(n)/fenmu(n);
			  		n++;
	}while((fenzi(n)/fenmu(n))>=eps);
	if(sum>=eps)
	sum+=fenzi(n)/fenmu(n);
	printf("PI = %.5lf", sum * 2);
	return 0;
}
double fenzi(int n)
{
	if(n==0)
	return 1;
	
	return n*fenzi(n-1);
}
double fenmu(int n)
{
	if(n==0)
	return 1;
	
	return (n*2+1) * fenmu(n-1);
}

127、两个数的简单计算器 (10 分)

本题要求编写一个简单计算器程序，可根据输入的运算符，对2个整数进行加、减、乘、除或求余运算。题目保证输入和输出均不超过整型范围。

输入格式：
输入在一行中依次输入操作数1、运算符、操作数2，其间以1个空格分隔。操作数的数据类型为整型，且保证除法和求余的分母非零。

输出格式：
当运算符为+、-、*、/、%时，在一行输出相应的运算结果。若输入是非法符号（即除了加、减、乘、除和求余五种运算符以外的其他符号）则输出ERROR。

输入样例1：
-7 / 2
输出样例1：
-3
输入样例2：
3 & 6
输出样例2：
ERROR

#include<stdio.h>
int main(int argc,char* argv[])
{
	int num1,num2;
	char c;
	scanf("%d %c %d",&num1,&c,&num2);
	switch(c)
	{
		case '+':printf("%d\n",num1+num2);break;
		case '-':printf("%d\n",num1-num2);break;
		case '*':printf("%d\n",num1*num2);break;
		case '/':printf("%d\n",num1/num2);break;
		case '%':printf("%d\n",num1%num2);break;
		default :printf("ERROR\n");
	}
	return 0;
}

128、算术入门之加减乘除 (10 分)

对于输入的两个整数，按照要求输出其和差积商。

输入格式:
在一行内输入两个不超过100的非负整数a和b，中间以一个空格间隔，且保证b不为0。

输出格式:
共四行，格式是：

[a] + [b] = [a+b]
[a] - [b] = [a-b]
[a] * [b] = [a*b]
[a] / [b] = [a/b]

其中，带有方括号的内容（如[a]、[b]、[a+b]等）表示相应整数或运算结果的值，在输出时要用实际的值代替。

并且：如果a能够被b整除，那么a/b应输出为整数格式，否则a/b输出为带两位小数的格式。

提示：注意表达式中的空格。

输入样例1:
6 3
输出样例1:
6 + 3 = 9
6 - 3 = 3
6 * 3 = 18
6 / 3 = 2
输入样例2:
8 6
输出样例2:
8 + 6 = 14
8 - 6 = 2
8 * 6 = 48
8 / 6 = 1.33

#include<stdio.h>
int main(int argc,char* argv[])
{
	int num1,num2;
	scanf("%d%d",&num1,&num2);
	printf("%d + %d = %d\n",num1,num2,num1+num2);
	printf("%d - %d = %d\n",num1,num2,num1-num2);
	printf("%d * %d = %d\n",num1,num2,num1*num2);
	double result = (num1*0.1/num2)*10;
	if(result == (int)result)
	printf("%d / %d = %d\n",num1,num2,num1/num2);
	else
	printf("%d / %d = %.2lf\n",num1,num2,result);
	return 0;
}

129、倒数第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;
 }

130、计算符号函数的值 (10 分)

7-6 计算符号函数的值 (10 分)
对于任一整数n，符号函数sign(n)的定义如下：

请编写程序计算该函数对任一输入整数的值。

输入格式:
输入在一行中给出整数n。

输出格式:
在一行中按照格式“sign(n) = 函数值”输出该整数n对应的函数值。

输入样例1:
10
输出样例1:
sign(10) = 1
输入样例2:
0
输出样例2:
sign(0) = 0
输入样例3:
-98
输出样例3:
sign(-98) = -1

#include<stdio.h>
int main(int argc,char* argv[])
{
	int n;
	int result;
	scanf("%d",&n);
	if(n<0)
	result=-1;
	else if(n==0)
	result=0;
	else
	result=1;
	printf("sign(%d) = %d",n,result);
	return 0;
}

131、12-24小时制 (15 分)

编写一个程序，要求用户输入24小时制的时间，然后显示12小时制的时间。

输入格式：
输入在一行中给出带有中间的:符号（半角的冒号）的24小时制的时间，如12:34表示12点34分。当小时或分钟数小于10时，均没有前导的零，如5:6表示5点零6分。

提示：在scanf的格式字符串中加入:，让scanf来处理这个冒号。

输出格式：
在一行中输出这个时间对应的12小时制的时间，数字部分格式与输入的相同，然后跟上空格，再跟上表示上午的字符串AM或表示下午的字符串PM。如5:6 PM表示下午5点零6分。注意，在英文的习惯中，中午12点被认为是下午，所以24小时制的12:00就是12小时制的12:0 PM；而0点被认为是第二天的时间，所以是0:0 AM。

输入样例：
21:11
输出样例：
9:11 PM

#include<stdio.h>
int main()
{
	int h,m;
	scanf("%d:%d",&h,&m);
	if(h<=12)
	{
		if(h<12)
		printf("%d:%d AM\n",h,m);
		else
		printf("%d:%d PM\n",h,m);
	}
	else
	{
		if(h<24)
		printf("%d:%d PM\n",h-12,m);
		else
		printf("%d:%d AM\n",h,m);
	}
}

132、成绩转换 (15 分)

本题要求编写程序将一个百分制成绩转换为五分制成绩。转换规则：

大于等于90分为A；
小于90且大于等于80为B；
小于80且大于等于70为C；
小于70且大于等于60为D；
小于60为E。
输入格式:
输入在一行中给出一个整数的百分制成绩。

输出格式:
在一行中输出对应的五分制成绩。

输入样例:
90
输出样例:
A

#include<stdio.h>
int main()
{
	int n;
	scanf("%d",&n);
	if(n>=90)
	printf("A\n");
	else if(n>=80)
	printf("B\n");
	else if(n>=70)
	printf("C\n");
	else if(n>=60)
	printf("D\n");
	else
	printf("E");
}

133、求组合数 (15 分)

本题要求编写程序，根据公式

​​ 算出从n个不同元素中取出m个元素（m≤n）的组合数。

建议定义和调用函数fact(n)计算n!，其中n的类型是int，函数类型是double。

输入格式:
输入在一行中给出两个正整数m和n（m≤n），以空格分隔。

输出格式:
按照格式“result = 组合数计算结果”输出。题目保证结果在double类型范围内。

输入样例:
2 7
输出样例:
result = 21

#include<stdio.h>
double jiecheng(int x);
int main()
{
	int n,m;
	scanf("%d%d",&m,&n);
	double result = jiecheng(n)/(jiecheng(m)*jiecheng(n-m));
	printf("result = %1.lf",result);
	return 0;
}
double jiecheng(int x)
{
	double mix=1;
	if(x==0)
		return 1;
	for(int i=2;i<=x;i++)
		mix*=i;
	return mix;
}

134、输出全排列 (20 分)

请编写程序输出前n个正整数的全排列（n<10），并通过9个测试用例（即n从1到9）观察n逐步增大时程序的运行时间。

输入格式:
输入给出正整数n（<10）。

输入样例：
3
输出样例：
123
132
213
231
312
321

#include <stdio.h>
int a[10],b[10],n;
void dfs(int step){
    if (step==n+1){
        for (int i=1;i<=n;i++)
        printf("%d",a[i]);
        printf("\n");
        return;
    }
    for (int i=1;i<=n;i++){
        if (b[i]==0){
            a[step]=i;
            b[i]=1;
            dfs(step+1);
            b[i]=0;
        }
    }
    return;
}
int main(){
    scanf("%d",&n);
    dfs(1);
    return 0;
}

135、魔法优惠券 (25 分)

在火星上有个魔法商店，提供魔法优惠券。每个优惠劵上印有一个整数面值K，表示若你在购买某商品时使用这张优惠劵，可以得到K倍该商品价值的回报！该商店还免费赠送一些有价值的商品，但是如果你在领取免费赠品的时候使用面值为正的优惠劵，则必须倒贴给商店K倍该商品价值的金额…… 但是不要紧，还有面值为负的优惠劵可以用！（真是神奇的火星）

例如，给定一组优惠劵，面值分别为1、2、4、-1；对应一组商品，价值为火星币M$7、6、-2、-3，其中负的价值表示该商品是免费赠品。我们可以将优惠劵3用在商品1上，得到M$28的回报；优惠劵2用在商品2上，得到M$12的回报；优惠劵4用在商品4上，得到M$3的回报。但是如果一不小心把优惠劵3用在商品4上，你必须倒贴给商店M$12。同样，当你一不小心把优惠劵4用在商品1上，你必须倒贴给商店M$7。

规定每张优惠券和每件商品都只能最多被使用一次，求你可以得到的最大回报。

输入格式:
输入有两行。第一行首先给出优惠劵的个数N，随后给出N个优惠劵的整数面值。第二行首先给出商品的个数M，随后给出M个商品的整数价值。N和M在[1, 10
​6
​​ ]之间，所有的数据大小不超过2
​30
​​ ，数字间以空格分隔。

输出格式:
输出可以得到的最大回报。

输入样例:
4 1 2 4 -1
4 7 6 -2 -3
输出样例:
43

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int yh[1000001];
int hx[1000001];
int comp(const void* num1,const void* num2)
{
	return *(int*)num2 - *(int*)num1;
}
int main()
{
	int N,M;
	int sum=0;
	int i,j;
	scanf("%d",&N);
	for(i=0;i<N;i++)
		scanf("%d",&yh[i]);
	scanf("%d",&M);
	for(i=0;i<M;i++)
		scanf("%d",&hx[i]);
	qsort(yh,N,sizeof(int),comp);
	qsort(hx,M,sizeof(int),comp);
	for(i=0,j=0; i<N&&j<M; i++,j++)
	{
			if(yh[i]>0&&hx[j]>0)
				sum+=yh[i]*hx[j];
	}
	for(i=N-1,j=M-1; i>=0&&j>=0 ;i--,j--)
	{
			if(yh[i]<0&&hx[j]<0)
				sum+=yh[i]*hx[j];
	}
	printf("%d\n",sum);
	return 0;
}

136、找出最小值 (20 分)

本题要求编写程序，找出给定一系列整数中的最小值。

输入格式：
输入在一行中首先给出一个正整数n，之后是n个整数，其间以空格分隔。

输出格式：
在一行中按照“min = 最小值”的格式输出n个整数中的最小值。

输入样例：
4 -2 -123 100 0
输出样例：
min = -123

#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int comp(const void* a,const void* b)
{
	return *(int*)a-*(int*)b;
}
int main(void)
{
	int i,j,a[1000];
	int min;
	int n;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	qsort(a,n,sizeof(int),comp);
	printf("min = %d",a[0]);
	return 0;
}

137、通讯录的录入与显示 (10 分)

通讯录中的一条记录包含下述基本信息：朋友的姓名、出生日期、性别、固定电话号码、移动电话号码。 本题要求编写程序，录入N条记录，并且根据要求显示任意某条记录。

输入格式：
输入在第一行给出正整数N（≤10）；随后N行，每行按照格式姓名 生日 性别 固话 手机给出一条记录。其中姓名是不超过10个字符、不包含空格的非空字符串；生日按yyyy/mm/dd的格式给出年月日；性别用M表示“男”、F表示“女”；固话和手机均为不超过15位的连续数字，前面有可能出现+。

在通讯录记录输入完成后，最后一行给出正整数K，并且随后给出K个整数，表示要查询的记录编号（从0到N−1顺序编号）。数字间以空格分隔。

输出格式：
对每一条要查询的记录编号，在一行中按照姓名 固话 手机 性别 生日的格式输出该记录。若要查询的记录不存在，则输出Not Found。

输入样例：
3
Chris 1984/03/10 F +86181779452 13707010007
LaoLao 1967/11/30 F 057187951100 +8618618623333
QiaoLin 1980/01/01 M 84172333 10086
2 1 7
输出样例：
LaoLao 057187951100 +8618618623333 F 1967/11/30
Not Found

#include<stdio.h>
struct Stu{
	char name[11];
	char year[11];
	char sex[2];
	char phone[17];
	char telephone[17];
}love[100];
int main()
{
	int i,j;
	int n;
	scanf("%d",&n);
	getchar();
	for(i=0;i<n;i++)
	{
		scanf("%s%s%s%s%s",&love[i].name,&love[i].year,&love[i].sex,&love[i].phone,&love[i].telephone);
	}
	int x;	//查询人数s 
	scanf("%d",&x);
	int cha;
	for(i=0;i<x;i++)
	{
		scanf("%d",&cha);
		if(cha<n && cha>=0)   //这里还要注意判断cha>0，搞我自闭了半天
		{
			printf("%s %s %s %s %s\n",love[cha].name,love[cha].phone,love[cha].telephone,love[cha].sex,love[cha].year);
		}
		else
		{
				printf("Not Found\n");
		}
	}
}

138、计算物体自由下落的距离 (5 分)

一个物体从100米的高空自由落下。编写程序，求它在前3秒内下落的垂直距离。设重力加速度为10米/秒
​2
​​ 。

输入格式:
本题目没有输入。

输出格式:
按照下列格式输出

height = 垂直距离值
结果保留2位小数。

#include<stdio.h>
int main()
{
	int a=10,t=3;
	printf("height = %.2lf\n",0.5*10*t*t);
}

139、时间换算 (15 分)

本题要求编写程序，以hh:mm:ss的格式输出某给定时间再过n秒后的时间值（超过23:59:59就从0点开始计时）。

输入格式：
输入在第一行中以hh:mm:ss的格式给出起始时间，第二行给出整秒数n（<60）。

输出格式：
输出在一行中给出hh:mm:ss格式的结果时间。

输入样例：
11:59:40
30
输出样例：
12:00:10

#include<stdio.h>
int main()
{
	int h,m,s;
	int n;
	scanf("%d:%d:%d",&h,&m,&s);
	scanf("%d",&n);
	s+=n;
	if(s>=60)
	{
		if(m==59)
		{
			h+=1;
			m=0;
			s-=60;
		}
		else
		{
			m+=1;
			s-=60;
		}
	}
	if(h>=24)
		h-=24;
	printf("%02d:%02d:%02d\n",h,m,s);
}

140、韩信点兵 (10 分)

在中国数学史上，广泛流传着一个“韩信点兵”的故事：韩信是汉高祖刘邦手下的大将，他英勇善战，智谋超群，为汉朝建立了卓越的功劳。据说韩信的数学水平也非常高超，他在点兵的时候，为了知道有多少兵，同时又能保住军事机密，便让士兵排队报数：

按从1至5报数，记下最末一个士兵报的数为1；
再按从1至6报数，记下最末一个士兵报的数为5；
再按从1至7报数，记下最末一个士兵报的数为4；
最后按从1至11报数，最末一个士兵报的数为10；
请编写程序计算韩信至少有多少兵。

输入格式：
本题无输入

输出格式：
输出韩信至少拥有的士兵人数。

#include<stdio.h>
int main()
{
	int i=1,j;
	while(1)
	{
	  if((i%5==1)&&(i%6)==5&&(i%7)==4&&(i%11)==10)
	  {
	    printf("%d",i);
	    break;
	  }
	  else
	  i++;
	}
}

原创不易，有用请点个赞，感谢各位！

创作不易，有用请点个赞，感谢各位！

141、BCD解密 (10 分)

BCD数是用一个字节来表达两位十进制的数，每四个比特表示一位。所以如果一个BCD数的十六进制是0x12，它表达的就是十进制的12。但是小明没学过BCD，把所有的BCD数都当作二进制数转换成十进制输出了。于是BCD的0x12被输出成了十进制的18了！

现在，你的程序要读入这个错误的十进制数，然后输出正确的十进制数。提示：你可以把18转换回0x12，然后再转换回12。

输入格式：
输入在一行中给出一个[0, 153]范围内的正整数，保证能转换回有效的BCD数，也就是说这个整数转换成十六进制时不会出现A-F的数字。

输出格式：
输出对应的十进制数。

输入样例：
18
输出样例：
12

#include<stdio.h>
int main()
{
	int n;
	int a[100000],k=0;
	int i,j;
	scanf("%d",&n);
	if(n==0)
	{
	  printf("0");
	  return 0;
	}
	while(n!=0)
	{
		a[k++]=n%16;
		n/=16;
	}
	for(i=k-1;i>=0;i--)
		printf("%d",a[i]);
}

142、掉入陷阱的数字 (15 分)

对任意一个自然数N
​0
​​ ，先将其各位数字相加求和，再将其和乘以3后加上1，变成一个新自然数N
​1
​​ ；然后对N
​1
​​ 重复这种操作，可以产生新自然数N
​2
​​ ；……多次重复这种操作，运算结果最终会得到一个固定不变的数N
​k
​​ ，就像掉入一个数字“陷阱”。

本题要求对输入的自然数，给出其掉入“陷阱”的过程。

输入格式:
在一行内给出一个自然数N
​0
​​ （N
​0
​​ <30000）。

输出格式:
对于输入的N
​0
​​ ，逐行输出其掉入陷阱的步骤。第i行描述N掉入陷阱的第i步，格式为： i:N
​i
​​ （i≥1）。当某一步得到的自然数结果N
​k
​​ (k≥1)与上一步N
​k−1
​​ 相同时，停止输出。

输入样例:
5
输出样例:
1:16
2:22
3:13
4:13

#include<stdio.h>
int number(int N);
int main (){
   int N=0,count=0,now=0,pre=0;
   scanf("%d",&N);
   now = number(N);
    while(1){
        count++;
        printf("%d:%d\n",count,now);
        pre=now;
        now=number(now);
        if(pre==now){
          if(now!=N)//如果这个数的最终结果和N相等，则不用再输出
            printf("%d:%d\n",count+1,now);
            break;
      }
  }
   return 0;
}
int number(int N){
    int add=0,num=N%10;
    if(num==N){
        add=N;
    }else{
        while(N!=0){
        add+=num;
        N/=10;
        num=N%10;
        }
    }
    return add*3+1;
}

143、简化的插入排序 (15 分)

本题要求编写程序，将一个给定的整数插到原本有序的整数序列中，使结果序列仍然有序。

输入格式：
输入在第一行先给出非负整数N（<10）；第二行给出N个从小到大排好顺序的整数；第三行给出一个整数X。

输出格式：
在一行内输出将X插入后仍然从小到大有序的整数序列，每个数字后面有一个空格。

输入样例：
5
1 2 4 5 7
3
输出样例：
1 2 3 4 5 7

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int comp(const void* a,const void* b)
{
	return *(int*)a - *(int*)b;
}
int main()
{
	int i;
	int a[12];
	int n;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	scanf("%d",&a[n]);
	qsort(a,n+1,sizeof(a[0]),comp);
	for(i=0;i<n+1;i++)
	printf("%d ",a[i]);
}

144、有理数比较 (10 分)

本题要求编写程序，比较两个有理数的大小。

输入格式：
输入在一行中按照“a1/b1 a2/b2”的格式给出两个分数形式的有理数，其中分子和分母全是整形范围内的正整数。

输出格式：
在一行中按照“a1/b1 关系符 a2/b2”的格式输出两个有理数的关系。其中“>”表示“大于”，“<”表示“小于”，“=”表示“等于”。

输入样例1：
1/2 3/4
输出样例1：
1/2 < 3/4
输入样例2：
6/8 3/4
输出样例2：
6/8 = 3/4

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int a1,b1,a2,b2;
	double sum1,sum2;
	scanf("%d/%d %d/%d",&a1,&b1,&a2,&b2);
	sum1 = a1*1.0/b1;
	sum2 = a2*1.0/b2;
	if(sum1>sum2)
	printf("%d/%d > %d/%d\n",a1,b1,a2,b2);
	else if(sum1 == sum2)
	printf("%d/%d = %d/%d\n",a1,b1,a2,b2);
	else
	printf("%d/%d < %d/%d\n",a1,b1,a2,b2);
}

145、计算职工工资 (15 分)

给定N个职员的信息，包括姓名、基本工资、浮动工资和支出，要求编写程序顺序输出每位职员的姓名和实发工资（实发工资=基本工资+浮动工资-支出）。

输入格式：
输入在一行中给出正整数N。随后N行，每行给出一位职员的信息，格式为“姓名 基本工资 浮动工资 支出”，中间以空格分隔。其中“姓名”为长度小于10的不包含空白字符的非空字符串，其他输入、输出保证在单精度范围内。

输出格式：
按照输入顺序，每行输出一位职员的姓名和实发工资，间隔一个空格，工资保留2位小数。

输入样例：
3
zhao 240 400 75
qian 360 120 50
zhou 560 150 80
输出样例：
zhao 565.00
qian 430.00
zhou 630.00

#include<stdio.h>
#define N 1000
struct yuan
{
  char name[11];
  double z1;//如果这里用int型，则显示错误
  double z2;
  double z3;
  double sum
}ren[N];
int main()
{
  int n,i;
  scanf("%d",&n);
  for(i=0;i<n;i++)
  {
    scanf("%s %lf %lf %lf",ren[i].name,&ren[i].z1,&ren[i].z2,&ren[i].z3);
    ren[i].sum=ren[i].z1+ren[i].z2-ren[i].z3;
  }
  for(i=0;i<n;i++)
  {
       printf("%s %.2lf\n",ren[i].name,ren[i].sum);
  }
  return 0;
}

146、猴子选大王 (20 分)

一群猴子要选新猴王。新猴王的选择方法是：让N只候选猴子围成一圈，从某位置起顺序编号为1~N号。从第1号开始报数，每轮从1报到3，凡报到3的猴子即退出圈子，接着又从紧邻的下一只猴子开始同样的报数。如此不断循环，最后剩下的一只猴子就选为猴王。请问是原来第几号猴子当选猴王？

输入格式：
输入在一行中给一个正整数N（≤1000）。

输出格式：
在一行中输出当选猴王的编号。

输入样例：
11
输出样例：
7

#include<stdio.h>
int sum=0,i;
int funtion(int x,int y)	//x = 11, y = 3
{
	for(i=y-1;i<=x;i++)		//根据数学规律，应从i的初始值 = 报的特殊数-1 
	{						//每次一到3的倍数时，sum=0，然后重新进行计算
		sum = (sum+3)%i;	//sum+特殊数%i 
	}
	return sum;
}
int main()
{
	int i,n,sum=0;
	scanf("%d",&n);
	printf("%d",funtion(n,3)+1);
}

147、逆序的三位数 (10 分)

程序每次读入一个正3位数，然后输出按位逆序的数字。注意：当输入的数字含有结尾的0时，输出不应带有前导的0。比如输入700，输出应该是7。

输入格式：
每个测试是一个3位的正整数。

输出格式：
输出按位逆序的数。

输入样例：
123
输出样例：
321

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int n;
	int i,j;
	int a[3];
	int flag=-1;
	scanf("%d",&n);
	for(i=0;i<3;i++)
	{
		a[i]=n%10;
		n/=10;
	}
	for(i=0;i<3;i++)
	{
		if(a[i]!=0)
			flag=1;
		if(flag!=-1)
		{
			printf("%d",a[i]);
		}
		else if(a[i]!=0)
		{
			printf("%d",a[i]);
		}
	}
}

148、评分规则 (5 分)

小明与伙伴们游戏，请来了5个裁判。对于每个孩子的表现，每个裁判给一个分数。总评分的计算规则是：去掉最高分，去掉最低分，剩下的分数计算平均分，作为总评分。请你帮小明编写程序计算总评分。

输入格式:
在一行中给出5个在0到100之间的整数，用一个空格隔开。这个5个整数已经按照从大到小顺序排好了。

输出格式:
在一行中输出总评分，要求保留小数点后2位。

输入样例:
100 99 98 97 96
输出样例:
98.00

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int comp(const void*a ,const void*b)
{
	return *(int*)a - *(int*)b;
}
int main()
{
	int a[5];
	int i,j;
	for(i=0;i<5;i++)
	{
		scanf("%d",&a[i]);
	}
	qsort(a,5,sizeof(a[0]),comp);
	a[0]=0;
	a[4]=0;
	double avg = (a[1]+a[2]+a[3])/3;
	printf("%.2lf\n",avg);
}

149、评委打分 (5 分)

班级里要搞智力竞赛啦!同学们都踊跃参加。进入最后决赛的是10个同学，随着一道道题目的出示，有时是1号选手得分，有时是5号选手得分，每次答对者得10分，最后结果如何呢?

输入格式:
第一行有十个整数，表示十位同学的初始分。第二行一个整数n，表示有n道题竞赛。 接下去有n行，每行有一个数字x，x表示本次可以加分的选手序号（每次答对者得10分）。

输出格式:
10个同学最终的得分值，每两位同学之间有一个空格。

输入样例:
10 0 0 0 10 10 0 0 0 10
3
1
10
1
输出样例:
30 0 0 0 10 10 0 0 0 20

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	int i,j;
	int a[10];
	for(i=0;i<10;i++)
	scanf("%d",&a[i]);
	int n;
	int b;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%d",&b);
		a[b-1]+=10;
	}
	for(i=0;i<10;i++)
	{
		if(i==10-1)
		printf("%d",a[i]);
		else
		printf("%d ",a[i]);
	}
}

150、特殊a串数列求和 (20 分)

给定两个均不超过9的正整数a和n，要求编写程序求a+aa+aaa++⋯+aa⋯a（n个a）之和。

输入格式：
输入在一行中给出不超过9的正整数a和n。

输出格式：
在一行中按照“s = 对应的和”的格式输出。

输入样例：
2 3
输出样例：
s = 246

#include<stdio.h>
#include<math.h>
int main()
{
	int a,n;
	scanf("%d%d",&a,&n);
	int i,j;
	int t=a;
	int sum=a;
	for(i=1;i<n;i++)
	{
			t = a*(pow(10,i))+t;
			//printf("%d\n",t);
			sum+=t;
	}
	printf("s = %d\n",sum);
}

151、换硬币 (20 分)

将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？

输入格式:
输入在一行中给出待换的零钱数额x∈(8,100)。

输出格式:
要求按5分、2分和1分硬币的数量依次从大到小的顺序，输出各种换法。每行输出一种换法，格式为：“fen5:5分硬币数量, fen2:2分硬币数量, fen1:1分硬币数量, total:硬币总数量”。最后一行输出“count = 换法个数”。

输入样例:
13
输出样例:
fen5:2, fen2:1, fen1:1, total:4
fen5:1, fen2:3, fen1:2, total:6
fen5:1, fen2:2, fen1:4, total:7
fen5:1, fen2:1, fen1:6, total:8
count = 4

#include<stdio.h>
#include<math.h>
int main()
{
	int i,j,k;
	int n;
	int t=0;
	scanf("%d",&n);
	for(i=n/5;i>=1;i--)
	{
		for(j=n/2;j>=1;j--)
		{
			for(k=n;k>=1;k--)
			{
				if(i*5+j*2+k==n)
				{
					t++;
					printf("fen5:%d, fen2:%d, fen1:%d, total:%d\n",i,j,k,i+j+k);
				}
			}
		}
	}
	printf("count = %d\n",t);
}

152、高空坠球 (20 分)

皮球从某给定高度自由落下，触地后反弹到原高度的一半，再落下，再反弹，……，如此反复。问皮球在第n次落地时，在空中一共经过多少距离？第n次反弹的高度是多少？

输入格式:
输入在一行中给出两个非负整数，分别是皮球的初始高度和n，均在长整型范围内。

输出格式:
在一行中顺序输出皮球第n次落地时在空中经过的距离、以及第n次反弹的高度，其间以一个空格分隔，保留一位小数。题目保证计算结果不超过双精度范围。

输入样例:
33 5
输出样例:
94.9 1.0

#include<stdio.h>
int main()
{
	double m;	//初始高度
	int n;	//第n次反弹的高度
	scanf("%lf%d",&m,&n);
	double sum=m;
	if(m==0 || n==0)
	{
	  printf("0.0 0.0\n");
	  return 0;
	}
	for(int i=2;i<=n;i++)
	{
		sum+=m;
		m/=2;
	//	printf("m = %lf sum = %lf\n",m,sum);
	}
	m/=2;
	printf("%.1lf %.1lf\n",sum,m);
}

153、输出学生成绩 (20 分)

本题要求编写程序，根据输入学生的成绩，统计并输出学生的平均成绩、最高成绩和最低成绩。建议使用动态内存分配来实现。

输入格式：
输入第一行首先给出一个正整数N，表示学生的个数。接下来一行给出N个学生的成绩，数字间以空格分隔。

输出格式：
按照以下格式输出：

average = 平均成绩
max = 最高成绩
min = 最低成绩
结果均保留两位小数。

输入样例：
3
85 90 95
输出样例：
average = 90.00
max = 95.00
min = 85.00

#include <stdio.h>
#include <stdlib.h>
 
int main()
{	
    int n,i;
    int *p; 
    float sMax,sMin,sSum =0;
    float sAvg;
    scanf("%d",&n); 
	//开启n个int的字节长度 
    p = (int *)malloc(sizeof(int) * n);
    for(i=0;i<n;i++)
    {
    	scanf("%d",p+i);
    	//如果是首个元素,就把首个元素同时赋值给最大最小值 
    	if(i == 0)
    	{
    		sMax = *(p+i);
    		sMin =  *(p+i);	
        }else
	    {
	    	if( *(p+i) > sMax)
	       		sMax =  *(p+i);
		    if( *(p+i) < sMin)
	        	sMin =  *(p+i);
	    }
	    sSum +=  *(p+i);
    }
	printf("average = %.2lf\n",sSum/n);
	printf("max = %.2lf\n",sMax);
	printf("min = %.2lf\n",sMin);
}

154、求整数的位数及各位数字之和 (15 分)

对于给定的正整数N，求它的位数及其各位数字之和。

输入格式：
输入在一行中给出一个不超过10
​9
​​ 的正整数N。

输出格式：
在一行中输出N的位数及其各位数字之和，中间用一个空格隔开。

输入样例：
321
输出样例：
3 6

#include<stdio.h>
#include<math.h>

int main()
{
	int n;
	int k=0;
	int sum=0;
	scanf("%d",&n);
	while(n!=0)
	{
		sum+=n%10;
		n/=10;
		k++;
	}
	printf("%d %d\n",k,sum);
}

155、 约分最简分式 (15 分)

分数可以表示为分子/分母的形式。编写一个程序，要求用户输入一个分数，然后将其约分为最简分式。最简分式是指分子和分母不具有可以约分的成分了。如6/12可以被约分为1/2。当分子大于分母时，不需要表达为整数又分数的形式，即11/8还是11/8；而当分子分母相等时，仍然表达为1/1的分数形式。

输入格式：
输入在一行中给出一个分数，分子和分母中间以斜杠/分隔，如：12/34表示34分之12。分子和分母都是正整数（不包含0，如果不清楚正整数的定义的话）。

提示：在scanf的格式字符串中加入/，让scanf来处理这个斜杠。

输出格式：
在一行中输出这个分数对应的最简分式，格式与输入的相同，即采用分子/分母的形式表示分数。如 5/6表示6分之5。

输入样例：
66/120
输出样例：
11/20

#include<stdio.h>
int gcd(int a,int b){
    /*if(a<b){
        int temp=a;
        a=b;
        b=temp;
    }
    if(b==0){
        return 1;
    }
    int r=a%b;
    if(r==0){
        return b;
    } else{
        return gcd(b,r)
    }*/ 
    int r=a%b;
    while(r){
        a=b;
        b=r;
        r=a%b;
    } 
    return b;
}
int main(){
    int a,b;
    scanf("%d/%d",&a,&b);
    int n=gcd(a,b);
    printf("%d/%d",a/n,b/n);
} 

156、我是升旗手 (10 分)

一年一度的升旗手选拔又要到了，学校要求每个班级选出一位同学做升旗手的候选人。因 为升旗手对身高有严格的要求，所以班主任决定选班级里个子最高的同学(如果两位同学 一样高，则选任意一位)。你能很快地给老师答案么?

输入格式:
输入包括两行。 第一行:包括一个整数n，表示班级里共有n位同学。 第二行:包含n个三位数，表示每一位同学的身高。

输出格式:
输出身高最高的同学的身高。

输入样例:
4
130 125 129 140
输出样例:
140

#include<stdio.h>
#include<math.h>

int main()
{
	int max=0;
	int n;
	int x;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&x);
		if(max<x)
			max=x;
	 } 
	 printf("%d\n",max);
}

157、人民币兑换 (15 分)

1元5角钱人民币兑换5分、2分和1分的硬币（每一种都要有）共100枚，会有很多种兑换方案。请编写程序给出各种兑换方案。

输入格式:
输入为一个正整数n，表示要求输出前n种可能的方案。方案的顺序，是按照5分硬币从少到多排列的。

输出格式:
显示前n种方案中5分、2分、1分硬币各多少枚。每行显示一种方案，数字之间空一格，最后一个数字后没有空格。

注意：如果全部方案不到n种，就顺序输出全部可能的方案。

输入样例:
5
输出样例:
1 46 53
2 42 56
3 38 59
4 34 62
5 30 65

#include<stdio.h>
int main()
{
	int i,j,k;
	int wu,er,san;
	int n;
	int t=0;
	scanf("%d",&n);
	for(i=1;i<=150/5;i++)		//5分一个，150分就有30个 
	{
		for(j=1;j<=150/2;j++)	//2分一个，150分就有75个 
		{
			for(k=1;k<=100;k++)	//因为硬币不能多于100枚，所以1分的情况最多只有100个 
			{
				if(i*5+j*2+k==150 && i+j+k==100 && t<n)	//题目要求说输出n种可能的方案，所以输入到n种就可以了 
				{
					printf("%d %d %d\n",i,j,k);
					t++;	//每有一种方案就+1，最多n种 
				}
			}
		}
	}
}

158、两个有序序列的中位数 (25 分)

已知有两个等长的非降序序列S1, S2, 设计函数求S1与S2并集的中位数。有序序列A
​0
​​ ,A
​1
​​ ,⋯,A
​N−1
​​ 的中位数指A
​(N−1)/2
​​ 的值,即第⌊(N+1)/2⌋个数（A
​0
​​ 为第1个数）。

输入格式:
输入分三行。第一行给出序列的公共长度N（0<N≤100000），随后每行输入一个序列的信息，即N个非降序排列的整数。数字用空格间隔。

输出格式:
在一行中输出两个输入序列的并集序列的中位数。

输入样例1:
5
1 3 5 7 9
2 3 4 5 6
输出样例1:
4
输入样例2:
6
-100 -10 1 1 1 1
-50 0 2 3 4 5
输出样例2:
1

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int comp(const void* a,const void* b)
{
	return *(int*)b - *(int*)a;
}
int main()
{
	int i;
	int n;
	int a[1000001];
	scanf("%d",&n);
	for(i=0;i<n*2;i++)
	{
		scanf("%d",&a[i]);
	}
	qsort(a,n*2,sizeof(a[0]),comp);
	printf("%d\n",a[n]);
	return 0;
}

159、找出总分最高的学生 (15 分)

给定N个学生的基本信息，包括学号（由5个数字组成的字符串）、姓名（长度小于10的不包含空白字符的非空字符串）和3门课程的成绩（[0,100]区间内的整数），要求输出总分最高学生的姓名、学号和总分。

输入格式：
输入在一行中给出正整数N（≤10）。随后N行，每行给出一位学生的信息，格式为“学号 姓名 成绩1 成绩2 成绩3”，中间以空格分隔。

输出格式：
在一行中输出总分最高学生的姓名、学号和总分，间隔一个空格。题目保证这样的学生是唯一的。

输入样例：
5
00001 huanglan 78 83 75
00002 wanghai 76 80 77
00003 shenqiang 87 83 76
10001 zhangfeng 92 88 78
21987 zhangmeng 80 82 75
输出样例：
zhangfeng 10001 258

#include<stdio.h>
struct Student{
	char xuehao[7];
	char name[12];
	int sum;
}love[100];
int comp(const void* a,const void* b)
{
	struct Student *aa = (struct Student *)a;
	struct Student *bb = (struct Student *)b;
	
	return ((bb->sum) - (aa->sum));	//根据总分从大到小排序学生信息库 
}
int main()
{
	int i,j;
	int n;
	int one,two,three;
	scanf("%d",&n);
	getchar();
	for(i=0;i<n;i++)
	{
		scanf("%s%s%d%d%d",&love[i].xuehao,&love[i].name,&one,&two,&three);
		love[i].sum = one+two+three;	//直接存总分就行 
	}
	qsort(love,n,sizeof(love[0]),comp);
	printf("%s %s %d\n",love[0].name,love[0].xuehao,love[0].sum);
}

160、求给定精度的简单交错序列部分和 (15 分)

本题要求编写程序，计算序列部分和 1 - 1/4 + 1/7 - 1/10 + … 直到最后一项的绝对值不大于给定精度eps。

输入格式:
输入在一行中给出一个正实数eps。

输出格式:
在一行中按照“sum = S”的格式输出部分和的值S，精确到小数点后六位。题目保证计算结果不超过双精度范围。

输入样例1:
4E-2
输出样例1:
sum = 0.854457
输入样例2:
0.02
输出样例2:
sum = 0.826310

#include<stdio.h>
int main()
{
	int i=0,j;		//循环 
	int flag = 1;	//控制偶数位正，奇数为负 
	int zi=1,mu=1;
	double a,b,sum=0;
	scanf("%lf",&a);
	do
	{
		b = zi*1.0/mu;	//这里要注意无理数的情况，所以要用浮点型计算，要*1.0 
		sum+=b*flag;	//对这个序列每次循环都进行求和，直到序列值b<=a时跳出循环 
		flag=-flag;		//-正数 = 负数，-负数 = 正数 
		mu+=3;			//分子不变，分母每次比上一次多3 
	}while(b>a);		//不大于的意思就是：不能等于也不能小鱼 
	printf("sum = %lf\n",sum);
}

创作不易，有用请点个赞，感谢各位！

原创不易，有用请点个赞，感谢各位！

161、单词长度 (15 分)

你的程序要读入一行文本，其中以空格分隔为若干个单词，以.结束。你要输出每个单词的长度。这里的单词与语言无关，可以包括各种符号，比如it’s算一个单词，长度为4。注意，行中可能出现连续的空格；最后的.不计算在内。

输入格式：
输入在一行中给出一行文本，以.结束

提示：用scanf("%c",…);来读入一个字符，直到读到.为止。

输出格式：
在一行中输出这行文本对应的单词的长度，每个长度之间以空格隔开，行末没有最后的空格。

输入样例：
It’s great to see you here.
输出样例：
4 5 2 3 3 4

#include<stdio.h>
int main()
{
  /* 这道题有四大最坑的点
     1. 第一个是只有一个单词的时候，开头不能有多余的空格，结尾有一个空格时，也一样
     2. 第二个就是当次数为0时不显示
     3. 第三是一定要注意空格不能有多余无论首、尾、还是中
     */
	char c;
	int flag=1;   //控制空格打印不能多余
	int k=0;
	scanf("%c",&c);
	while(c!='.')   //如果只有一个点，那不需要显示了
	{
		if(c ==' ')
		{
			if(k!=0)
			{
				if(flag)
				{
					printf("%d",k);
					flag=0; //第一个单词打印完后，后面就可以以 %d的形式来让末尾没有空格打印
				}
				else      
				{
					printf(" %d",k);
				}
				k=0;
			}
		}
		else
		{	k++;	}
		scanf("%c",&c);
	}
	if(k!=0)        //如果最后一个单词是空格不用打印
	{
		if(flag)      //负责防止首尾有多余空格
		{
			printf("%d",k);
		}
		else
		{
			printf(" %d",k);
		}
	}
}

162、表格输出 (5 分)

本题要求编写程序，按照规定格式输出表格。

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

输出格式：
要求严格按照给出的格式输出下列表格：

Province Area(km2) Pop.(10K)

Anhui 139600.00 6461.00
Beijing 16410.54 1180.70
Chongqing 82400.00 3144.23
Shanghai 6340.50 1360.26
Zhejiang 101800.00 4894.00

#include<stdio.h>
int main()
{
printf("------------------------------------\n");
printf("Province      Area(km2)   Pop.(10K)\n");
printf("------------------------------------\n");
printf("Anhui         139600.00   6461.00\n");
printf("Beijing        16410.54   1180.70\n");
printf("Chongqing      82400.00   3144.23\n");
printf("Shanghai        6340.50   1360.26\n");
printf("Zhejiang      101800.00   4894.00\n");
printf("------------------------------------\n");
}

163、装箱问题 (20 分)

输入格式：
输入第一行给出物品个数N（≤1000）；第二行给出N个正整数s
​i
​​ （1≤s
​i
​​ ≤100，表示第i项物品的大小）。

输出格式：
按照输入顺序输出每个物品的大小及其所在的箱子序号，每个物品占1行，最后一行输出所需的箱子数目。

输入样例：
8
60 70 80 90 30 40 10 20
输出样例：
60 1
70 2
80 3
90 4
30 1
40 5
10 1
20 2
5

#include<stdio.h>
#include<string.h>
struct Love{
	int xiang;
	int ji;
}love[1001];
int main()
{
	int b[1000]={100};
	int max=0;
	int i,j;
	int first;
	int n;
	int num=0;
	int k=0;
	int a[100],one=0;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%d",&love[i].xiang);
	}
	for(i=0;i<n;i++)
		b[i]=100;
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			if(love[i].xiang<=b[j])
			{
				love[i].ji = j;	
				b[j]-=love[i].xiang;
				if(max<j)
					max=j;
				break;
			}
		}
		
	}
	
	
	for(i=0;i<n;i++)
	{
		printf("%d %d\n",love[i].xiang,love[i].ji+1);
	}
	printf("%d\n",max+1);
}

164、求交错序列前N项和 (15 分)

本题要求编写程序，计算交错序列 1-2/3+3/5-4/7+5/9-6/11+… 的前N项之和。

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

输出格式:
在一行中输出部分和的值，结果保留三位小数。

输入样例:
5
输出样例:
0.917
作者: 陈建海
单位: 浙江大学
时间限制: 400 ms
内存限制: 64 MB

#include<stdio.h>
int main()
{
	int n;
	int i;
	int zi = 1,mu = 1;
	int flag=1;
	double sum=0;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		sum+=zi*1.0/mu*flag;
		flag=-flag;
		zi+=1;
		mu+=2;
	}
	printf("%.3lf\n",sum);
}

165、求集合数据的均方差 (15 分)

输入格式：
输入首先在第一行给出一个正整数 N（≤10
​4
​​ ），随后一行给出 N 个正整数。所有数字都不超过 1000，同行数字以空格分隔。

输出格式：
输出这N个数的均方差，要求固定精度输出小数点后5位。

输入样例 1：
10
6 3 7 1 4 8 2 9 11 5
输出样例 1：
3.03974
输入样例 2：
1
2
输出样例 2：
0.00000

#include<stdio.h>
#include<math.h>
int main()
{
	int n;
	int i,j;
	double x=0;
	int a[10005];
	double result;
	int sum=0;
	double avg; 
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{ 
		scanf("%d",&a[i]);
		sum+=a[i];
		//printf("1");
	}
	avg = sum*1.0/n;
	for(i=0;i<n;i++)
	{
		x += (a[i]-avg)*(a[i]-avg);
		//printf("2");
	}
	result = sqrt(x/n);
	printf("%.5lf\n",result);	
}

166、币值转换 (20 分)

输入一个整数（位数不超过9位）代表一个人民币值（单位为元），请转换成财务要求的大写中文格式。如23108元，转换后变成“贰万叁仟壹百零捌”元。为了简化输出，用小写英文字母a-j顺序代表大写数字0-9，用S、B、Q、W、Y分别代表拾、百、仟、万、亿。于是23108元应被转换输出为“cWdQbBai”元。

输入格式：
输入在一行中给出一个不超过9位的非负整数。

输出格式：
在一行中输出转换后的结果。注意“零”的用法必须符合中文习惯。

输入样例1：
813227345
输出样例1：
iYbQdBcScWhQdBeSf
输入样例2：
6900
输出样例2：
gQjB

这道题我没写对，没拿到满分，好像15分吧，我想纪念一下自己的代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
	int num;
	int i,j,n,xing=0;
	char s[100];
	char str1[100],a=-1;
	int k=0;		//计算位数
	int flag=1;
	gets(s);
	int len = strlen(s);
	for(i=0;i<len;i++)
	{
		num = s[i]-'0';
		if(num!=0)
		{
			xing++;
			flag=0;
		}
		if(i==len-1 && num!=0)
			flag=1;
	}
	for(i=0;s[i]!='\0';i++)
	{
		num = s[i]-'0';
		if(s[i]+=2)
		switch(num)
		{
		case 0:str1[++a]='a';break;
		case 1:str1[++a]='b';break;
		case 2:str1[++a]='c';break;
		case 3:str1[++a]='d';break;
		case 4:str1[++a]='e';break;
		case 5:str1[++a]='f';break;
		case 6:str1[++a]='g';break;
		case 7:str1[++a]='h';break;
		case 8:str1[++a]='i';break;
		case 9:str1[++a]='j';break;
		}
		a++;
		k++;
	}
	/*for(i=0;i<k;i++)
		printf("%c",str1[i]);*/		//调试
	n=0;
	for(i=k*2-1;i>=0;)
	{
		if(n==1 || n==5)
		{
			str1[i]='S';
		}
		else if(n==2 || n==6)
		{
			str1[i]='B';
		}
		else if(n==3 || n==7)
		{
			str1[i]='Q';
		}
		else if(n==4)
		{
			str1[i]='W';
		}
		else
		{
			str1[i]='Y';
		}
		
		n++;
		i-=2;
	}
	if(flag)
		for(i=0;i<k+k-1;i++)
			printf("%c",str1[i]);
	else
			for(i=0;i<k+k-1-xing*2+1;i++)
		printf("%c",str1[i]);
}

167、求矩阵的局部极大值 (15 分)

给定M行N列的整数矩阵A，如果A的非边界元素A[i][j]大于相邻的上下左右4个元素，那么就称元素A[i][j]是矩阵的局部极大值。本题要求给定矩阵的全部局部极大值及其所在的位置。

输入格式：
输入在第一行中给出矩阵A的行数M和列数N（3≤M,N≤20）；最后M行，每行给出A在该行的N个元素的值。数字间以空格分隔。

输出格式：
每行按照“元素值 行号 列号”的格式输出一个局部极大值，其中行、列编号从1开始。要求按照行号递增输出；若同行有超过1个局部极大值，则该行按列号递增输出。若没有局部极大值，则输出“None 总行数 总列数”。

输入样例1：
4 5
1 1 1 1 1
1 3 9 3 1
1 5 3 5 1
1 1 1 1 1
输出样例1：
9 2 3
5 3 2
5 3 4
输入样例2：
3 5
1 1 1 1 1
9 3 9 9 1
1 5 3 5 1
输出样例2：
None 3 5

#include<stdio.h>
struct Love{
	int hang;
	int lie;
	int max;
}Max[200];
int main()
{
	int m,n;
	int i,j;
	int a[300][300];
	//int max[20],k=0;
	int k=0;
	int flag=0;
	scanf("%d%d",&m,&n);
	for(i=0;i<m;i++)
	{
		for(j=0;j<n;j++)
		{
			scanf("%d",&a[i][j]);
		}
	}
	for(i=0;i<m;i++)
	{
		if(i==0)
			continue;
		if(i==m-1)
			break;
		for(j=0;j<n;j++)
		{
			if(j==0||j==n-1)
				continue;
			if(a[i][j]>a[i-1][j] && a[i][j]>a[i+1][j] && a[i][j]>a[i][j+1] && a[i][j]>a[i][j-1])
			{
									Max[k].max=a[i][j];
									Max[k].hang=i+1;
									Max[k].lie=j+1;
									k++;
									flag=1;
			}
		}
	}
	if(flag!=0)
	{
		for(i=0;i<k;i++)
		{
			printf("%d %d %d\n",Max[i].max,Max[i].hang,Max[i].lie);
		}
	}
	else
	{
		printf("None %d %d\n",m,n);
	}
}

168、查询水果价格 (15 分)

给定四种水果，分别是苹果（apple）、梨（pear）、桔子（orange）、葡萄（grape），单价分别对应为3.00元/公斤、2.50元/公斤、4.10元/公斤、10.20元/公斤。

首先在屏幕上显示以下菜单：

[1] apple
[2] pear
[3] orange
[4] grape
[0] exit
用户可以输入编号1~4查询对应水果的单价。当连续查询次数超过5次时，程序应自动退出查询；不到5次而用户输入0即退出；输入其他编号，显示价格为0。

输入格式:
输入在一行中给出用户连续输入的若干个编号。

输出格式:
首先在屏幕上显示菜单。然后对应用户的每个输入，在一行中按格式“price = 价格”输出查询结果，其中价格保留两位小数。当用户连续查询次数超过5次、或主动输入0时，程序结束。

输入样例1:
3 -1 0 2
输出样例1:
[1] apple
[2] pear
[3] orange
[4] grape
[0] exit
price = 4.10
price = 0.00
输入样例2:
1 2 3 3 4 4 5 6 7 8
输出样例2:
[1] apple
[2] pear
[3] orange
[4] grape
[0] exit
price = 3.00
price = 2.50
price = 4.10
price = 4.10
price = 10.20

#include<stdio.h>
int main()
{
	int i,j;
	int n;
	int x;
	printf("[1] apple\n");
	printf("[2] pear\n");
	printf("[3] orange\n");
	printf("[4] grape\n");
	printf("[0] exit\n");
	
	for(i=0;i<5;i++)
	{
		scanf("%d",&x);
		if(x==0)
		break;
		if(x<0 || x>4)
		printf("price = 0.00\n");
		if(x==1)
		printf("price = 3.00\n");
		else if(x==2)
		printf("price = 2.50\n");
		else if(x==3)
		printf("price = 4.10\n");
		else if(x==4)
		printf("price = 10.20\n");
		
	}
}

169、混合类型数据格式化输入 (5 分)

本题要求编写程序，顺序读入浮点数1、整数、字符、浮点数2，再按照字符、整数、浮点数1、浮点数2的顺序输出。

输入格式：
输入在一行中顺序给出浮点数1、整数、字符、浮点数2，其间以1个空格分隔。

输出格式：
在一行中按照字符、整数、浮点数1、浮点数2的顺序输出，其中浮点数保留小数点后2位。

输入样例：
2.12 88 c 4.7
输出样例：
c 88 2.12 4.70

#include<stdio.h>
int main()
{
	double a;
	int b;
	char c;
	double d;
	scanf("%lf%d %c%lf",&a,&b,&c,&d);
	printf("%c %d %.2lf %.2lf\n",c,b,a,d);
}

170、BCD解密 (10 分)

BCD数是用一个字节来表达两位十进制的数，每四个比特表示一位。所以如果一个BCD数的十六进制是0x12，它表达的就是十进制的12。但是小明没学过BCD，把所有的BCD数都当作二进制数转换成十进制输出了。于是BCD的0x12被输出成了十进制的18了！

现在，你的程序要读入这个错误的十进制数，然后输出正确的十进制数。提示：你可以把18转换回0x12，然后再转换回12。

输入格式：
输入在一行中给出一个[0, 153]范围内的正整数，保证能转换回有效的BCD数，也就是说这个整数转换成十六进制时不会出现A-F的数字。

输出格式：
输出对应的十进制数。

输入样例：
18
输出样例：
12

#include<stdio.h>
int main()
{
	int n;
	int a[100000],k=0;
	int i,j;
	scanf("%d",&n);
	if(n==0)
	{
	  printf("0");
	  return 0;
	}
	while(n!=0)
	{
		a[k++]=n%16;
		n/=16;
	}
	for(i=k-1;i>=0;i--)
		printf("%d",a[i]);
}

171、串的模式匹配 (25 分)

给定两个由英文字母组成的字符串 String 和 Pattern，要求找到 Pattern 在 String 中第一次出现的位置，并将此位置后的 String 的子串输出。如果找不到，则输出“Not Found”。

本题旨在测试各种不同的匹配算法在各种数据情况下的表现。各组测试数据特点如下：

数据0：小规模字符串，测试基本正确性；
数据1：随机数据，String 长度为 10
​5
​​ ，Pattern 长度为 10；
数据2：随机数据，String 长度为 10
​5
​​ ，Pattern 长度为 10
​2
​​ ；
数据3：随机数据，String 长度为 10
​5
​​ ，Pattern 长度为 10
​3
​​ ；
数据4：随机数据，String 长度为 10
​5
​​ ，Pattern 长度为 10
​4
​​ ；
数据5：String 长度为 10
​6
​​ ，Pattern 长度为 10
​5
​​ ；测试尾字符不匹配的情形；
数据6：String 长度为 10
​6
​​ ，Pattern 长度为 10
​5
​​ ；测试首字符不匹配的情形。
输入格式:
输入第一行给出 String，为由英文字母组成的、长度不超过 10
​6
​​ 的字符串。第二行给出一个正整数 N（≤10），为待匹配的模式串的个数。随后 N 行，每行给出一个 Pattern，为由英文字母组成的、长度不超过 10
​5
​​ 的字符串。每个字符串都非空，以回车结束。

输出格式:
对每个 Pattern，按照题面要求输出匹配结果。

输入样例:
abcabcabcabcacabxy
3
abcabcacab
cabcabcd
abcabcabcabcacabxyz
输出样例:
abcabcacabxy
Not Found
Not Found

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
	char str1[1000001],str2[1000001];
	int i,n;
	gets(str1);
	scanf("%d",&n);
	getchar();
	for(i=0;i<n;i++)
	{
		gets(str2);
		char *p=strstr(str1,str2);
		if(p!=NULL)
		{
			for(;*p!='\0';p++)
				printf("%c",*p);
			printf("\n");
		}
		else
			printf("Not Found\n");
	}
	return 0;
}

172、Say Hello to Integers (5 分)

Say hello to integers？ Yes! 你没看错！ 现在我们来向整数说“你好~” 本题读入两个整数，然后输出对她们的问候语。

输入格式:
在一行中给出两个绝对值不超过32767的整数A和B，两数之间有一个空格

输出格式:
在一行中输出 “Hello, A and B!” （其中A和B用实际输入的整数代替）

输入样例:
1949 2015
输出样例:
Hello, 1949 and 2015!

#include<stdio.h>
int main(void)
{
	int n,m;
	scanf("%d%d",&n,&m);
	printf("Hello, %d and %d!\n",n,m);
}

173、PTA使我精神焕发 (5 分)

PTA使我精神焕发.jpg

以上是湖北经济学院同学的大作。本题就请你用汉语拼音输出这句话。

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

输出格式：
在一行中按照样例输出，以惊叹号结尾。

输入样例：
无
输出样例：
PTA shi3 wo3 jing1 shen2 huan4 fa1 !

#include<stdio.h>
int main()
{
  printf("PTA shi3 wo3 jing1 shen2 huan4 fa1 !\n");
  return 0;
}

174、温度转换 (5 分)

本题要求编写程序，计算华氏温度150°F对应的摄氏温度。计算公式：C=5×(F−32)/9，式中：C表示摄氏温度，F表示华氏温度，输出数据要求为整型。

输入格式:
本题目没有输入。

输出格式:
按照下列格式输出

fahr = 150, celsius = 计算所得摄氏温度的整数值

#include<stdio.h>
int main()
{
  int f=150;
  printf("fahr = 150, celsius = %d\n",5*(f-32)/9);
  return 0;
}

175、输出菱形图案 (5 分)

本题要求编写程序，输出指定的由“A”组成的菱形图案。

输入格式：
本题无输入

输出格式：
按照下列格式输出由“A”组成的菱形图案。

A
A A
A

#include<stdio.h>
int main()
{
	printf("  A\n");
	printf("A   A\n");
	printf("  A\n");
}

176、吃鱼还是吃肉 (10 分)

国家给出了 8 岁男宝宝的标准身高为 130 厘米、标准体重为 27 公斤；8 岁女宝宝的标准身高为 129 厘米、标准体重为 25 公斤。

现在你要根据小宝宝的身高体重，给出补充营养的建议。

输入格式：
输入在第一行给出一个不超过 10 的正整数 N，随后 N 行，每行给出一位宝宝的身体数据：

性别 身高 体重
其中性别是 1 表示男生，0 表示女生。身高和体重都是不超过 200 的正整数。

输出格式：
对于每一位宝宝，在一行中给出你的建议：

如果太矮了，输出：duo chi yu!（多吃鱼）；
如果太瘦了，输出：duo chi rou!（多吃肉）；
如果正标准，输出：wan mei!（完美）；
如果太高了，输出：ni li hai!（你厉害）；
如果太胖了，输出：shao chi rou!（少吃肉）。
先评价身高，再评价体重。两句话之间要有 1 个空格。

输入样例：
4
0 130 23
1 129 27
1 130 30
0 128 27
输出样例：
ni li hai! duo chi rou!
duo chi yu! wan mei!
wan mei! shao chi rou!
duo chi yu! shao chi rou!

#include<stdio.h> 
int main()
{
	int a,s,h,w;
	scanf("%d",&a);
	while(a--)
	{
		scanf("%d %d %d",&s,&h,&w);
	    switch(s)
	    {
			case 1: 
			if(h==130) printf("wan mei! ");
			else if(h<130) printf("duo chi yu! ");
			else if(h>130) printf("ni li hai! ");
			if(w==27) printf("wan mei!\n");
			else if(w<27) printf("duo chi rou!\n");
			else if(w>27) printf("shao chi rou!\n");
			break;
			case 0:
			if(h==129) printf("wan mei! ");
			else if(h<129) printf("duo chi yu! ");
			else if(h>129) printf("ni li hai! ");
			if(w==25) printf("wan mei!\n");
			else if(w<25) printf("duo chi rou!\n");
			else if(w>25) printf("shao chi rou!\n");
			break;
		}
	}
	return 0;
}

原创不易，有用请点个赞，感谢各位！