【解题笔记】编程初学者入门训练

1.实践出真知

描述

于老师经常告诉我们“学习编程最好的办法就是上机实践，因为你要对计算机下指令，想让计算机帮你干活，就得多和计算机‘交流’，实践才能出真知。”

输入描述：

本题没有输入

输出描述：

Practice makes perfect!

#include 
int main()
{
	printf("Practice makes perfect!\n");
	return 0;
}
//printf()打印函数
//stdio标准输入输出库，包含printf函数

 2.我是大V

描述

每个人都想成为大V (VIP：Very Important Person)，但要一点一点积累才行，先从小v做起。要求输出由小写字母v组成的大V。

输入描述：

无

输出描述：

v   v

 v v

  v

#include 
int main()
{
	printf("v   v\n");
	printf(" v v\n");
	printf("  v");
	return 0;
}
//直接打印

#include 
int main()
{
	int i, j;
	for (i = 0; i < 3; i++) {
		for (j = 0; j < i; j++) {
			printf(" ");
		}
		printf("v");
		for (j = 0; j < 3 - 2 * i; j++) {
			printf(" ");
		}
		if (i != 2) {
			printf("v\n");
		}
	}
	return 0;
}
//使用循环实现

3.有容乃大

描述

确定不同整型数据类型在内存中占多大（字节），输出不同整型数据类型在内存中占多大（字节）。 

输入描述：

无

输出描述：

不同整型数据类型在内存中占多大（字节），具体格式详见输出样例，输出样例中的?为不同整型数据类型在内存中占的字节数。输出样例如下：
The size of short is ? bytes.
The size of int is ? bytes.
The size of long is ? bytes.
The size of long long is ? bytes.

#include 
int main()
{
	printf("The size of short is %d bytes.\n", sizeof(short));
	printf("The size of int is %d bytes.\n", sizeof(int));
	printf("The size of long is %d bytes.\n", sizeof(long));
	printf("The size of long long is %d bytes.\n", sizeof(long long));
	return 0;
}
//sizeof() 库函数，求()里面所占字节的大小

4.小飞机

描述

KiKi学会了printf在屏幕输出信息，他想输出一架小飞机。请帮他编写程序输出这架小飞机。

输入描述：

无

输出描述：

#include 
int main()
{
	printf("     **\n");
	printf("     **\n");
	printf("************\n");
	printf("************\n");
	printf("    *  *\n");
	printf("    *  *\n");
	return 0;
}
//直接打印

5.所短二进制

描述

我们处理的整数通常用十进制表示，在计算机内存中是以二进制补码形式存储，但通常二进制表示的整数比较长，为了便于在程序设计过程中理解和处理数据，通常采用八进制和十六进制，缩短了二进制补码表示的整数，但保持了二进制数的表达特点。请输出十进制整数1234对应的八进制和十六进制。

输入描述：

无

输出描述：

十进制整数1234对应的八进制和十六进制（字母大写），用空格分开，并且要求，在八进制前显示前导0，在十六进制数前显示前导0X。

备注：

printf可以使用使用格式控制串“%o”、“%X”分别输出八进制整数和十六进制整数，并使用修饰符“#”控制前导显示

#include 
int main()
{
    int a = 1234;
    printf("%#o %#X",a,a);
    return 0;
}
//%#能显示前导，%o 打印八进制，%x 打印十六进制
//八进制 是以 0 开头
//十六进制是以 0x开头

6.十六进制转十进制

描述

BoBo写了一个十六进制整数ABCDEF，他问KiKi对应的十进制整数是多少。

输入描述：

无

输出描述：

十六进制整数ABCDEF对应的十进制整数，所占域宽为15。

备注：

printf可以使用使用格式控制串“%md”输出域宽为m的十进制整数。

#include 
int main()
{
	printf("%15d\n", 0xABCDEF);
	return 0;
}
//0x是十六进制，%md 是打印出来的宽度是m，右对齐

7.printf返回值

描述

KiKi写了一个输出“Hello world!”的程序，BoBo老师告诉他printf函数有返回值，你能帮他写个程序输出printf(“Hello world!”)的返回值吗？

输入描述：

无

输出描述：

包括两行：
第一行为“Hello world!”
第二行为printf(“Hello world!”)调用后的返回值。

#include 
int main()
{
	int ret = printf("Hello world!");
	printf("\n");
	printf("%d", ret);
	return 0;
}
//printf()是打印函数，返回值是成功打印的个数
//Hello world! 共有12个

8.成绩输入输出

描述

输入3科成绩，然后把三科成绩输出，成绩为整数形式。

数据范围： 0  =<  n  <=  100

输入描述：

一行，3科成绩，用空格分隔，范围（0~100）。

输出描述：

一行，把3科成绩显示出来，输出格式详见输出样例。 

#include 
int main()
{
	int a, b, c;
	scanf("%d %d %d", &a, &b, &c);
	printf("score1=%d,score2=%d,score3=%d", a, b, c);
	return 0;
}

9.学生基本信息输入输出

描述

依次输入一个学生的学号，以及3科（C语言，数学，英语）成绩，在屏幕上输出该学生的学号，3科成绩（注：输出成绩时需进行四舍五入且保留2位小数）。

数据范围：学号满足  1 =< n <= 20000000 ，各科成绩使用百分制，且不可能出现负数

输入描述：

学号以及3科成绩，学号和成绩之间用英文分号隔开，成绩之间用英文逗号隔开。

输出描述：

学号，3科成绩，输出格式详见输出样例。

#include 
int main()
{
	int id;
	float a, b, c;
	scanf("%d;%f,%f,%f", &id, &a, &b, &c);
	printf("The each subject score of No. %d is %.2f, %.2f, %.2f.", id, a, b, c);
	return 0;
}
//a,b,c是浮点类型，
//id和成绩之间用英文的分号，所以在引号之内将分号加上，表示在读取完一个整数之后，需要读取一个分号，然后再读取下一浮点数...

10.字符圣诞树

描述

输入一个字符，用它构造一个边长为5的三角形圣诞树。

数据范围：保证输入的字符是一个 char 类型的值

输入描述：

输入只有一行，一个字符。

输出描述：

该字符构成的三角形圣诞树。

#include 
int main() 
{
	char ch;
	scanf("%c", &ch);
	for (int i = 0; i < 5; i++) {
		for (int j = 1; j < 5 - i; j++) {
			printf(" ");
		}
		for (int j = 0; j <= i; j++) {
			printf("%c ", ch);
		}
		printf("\n");
	}
	return 0;
}
//第一行有4个空格，1个字符
//第二行有3个空格，2个字符
//第三行有2个空格，3个字符...
//使用循环，直接打印

#include 
int main()
{
	char ch;
	scanf("%c", &ch);
	printf("    %c\n", ch);
	printf("   %c %c\n", ch, ch);
	printf("  %c %c %c\n", ch, ch, ch);
	printf(" %c %c %c %c\n", ch, ch, ch, ch);
	printf("%c %c %c %c %c\n", ch, ch, ch, ch, ch);
	return 0;
}
//直接打印

11.ASCII码

描述

BoBo教KiKi字符常量或字符变量表示的字符在内存中以ASCII码形式存储。BoBo出了一个问题给KiKi，转换以下ASCII码为对应字符并输出他们。

73, 32, 99, 97, 110, 32, 100, 111, 32, 105, 116 , 33

输入描述：

无

输出描述：

转换输出题目中给出的所有ASCII到对应的字符。

#include 
int main()
{
	int arr[] = { 73, 32, 99, 97, 110, 32, 100, 111, 32, 105, 116 , 33 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++) {
		printf("%c", arr[i]);
	}
	return 0;
}
//先将需要转换的存在数组内，求出数组的大小，然后循环打出

#include 
int main()
{

	int arr[] = { 73, 32, 99, 97, 110, 32, 100, 111, 32, 105, 116 , 33 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++) {
		printf("%c", *(arr + i));
	}
	return 0;
}
//* == []
//解引用和下标引用的效果相同

12.出生日期输入输出

描述

输入一个人的出生日期（包括年月日），将该生日中的年、月、日分别输出。

数据范围：年份满足  1990 =< y =< 2015，月份满足   ，日满足  

输入描述：

输入只有一行，出生日期，包括年月日，年月日之间的数字没有分隔符。

输出描述：

三行，第一行为出生年份，第二行为出生月份，第三行为出生日期。输出时如果月份或天数为1位数，需要在1位数前面补0。

#include 
int main()
{
	int year, month, day;
	scanf("%4d%2d%2d", &year, &month, &day);
	printf("year=%4d\nmonth=%02d\ndate=%02d", year, month, day);
	return 0;
}
//scanf()里面的%4d %2d %2d是指输入一个数，将这个数宽度为四的放在第一个，再将接着宽度为2的放在第二个，再将宽度为2的放在第三个
//%02d 表示宽度为2，当没有数据时，用0来补齐

 13.按照格式输入并交换输出

描述

输入两个整数，范围-231~231-1，交换两个数并输出。

输入描述：

输入只有一行，按照格式输入两个整数，范围，中间用“,”分隔。

输出描述：

把两个整数按格式输出，中间用“,”分隔。

#include 
int main()
{
	int a, b, tem;
	scanf("a=%d,b=%d", &a, &b);
	tem = a;
	a = b;
	b = tem;
	printf("a=%d,b=%d", a, b);
	return 0;
}
//创建一个中间变量，完成两个数的交换

#include 
int main()
{
	int a, b;
	scanf("a=%d,b=%d", &a, &b);
	a = a + b;
	b = a - b;
	a = a - b;
	printf("a=%d,b=%d", a, b);
	return 0;
}
//先将两个数的和赋给一个数，
//另一个数用和减去这个数
//a = a + b
//b = a - b = a + b - b = a
//a = a - b = a + b - a = b

#include 
int main()
{
	int a, b;
	scanf("a=%d,b=%d", &a, &b);
	a = a ^ b;
	b = a ^ b;
	a = a ^ b;
	printf("a=%d,b=%d", a, b);
	return 0;
}
//使用位运算
//a = a ^ b
//b = a ^ b = a ^ b ^ b = a ^ 0 = a
//a = a ^ b = a ^ b ^ a = a ^ a ^ b = b
//一个数和他本身按位异或，得到的是0，
//一个数与0按位异或，得到的是这个数
//按位异或，相同为0，不同为1

#include 
int main()
{
	int a, b;
	scanf("a=%d,b=%d", &a, &b);
	printf("a=%d,b=%d", b, a);
	return 0;
}

14.字符转ASCII码

描述

BoBo教KiKi字符常量或字符变量表示的字符在内存中以ASCII码形式存储。BoBo出了一个问题给KiKi，输入一个字符，输出该字符相应的ASCII码。

输入描述：

一行，一个字符。

输出描述：

一行，输出输入字符对应的ASCII码。 

#include 
int main()
{
	char ch;
	scanf("%c", &ch);
	printf("%d", ch);
	return 0;
}
//字符在电脑中以数字的形式存储，可以通过ASCII码找到

15.计算表达式的值

输入描述：

无。

输出描述：

(-8+22)×a-10+c÷2计算之后的结果，为一个整数。

#include 
int main()
{
    int a = 40, c = 212;
    int e = (-8 + 22) * a - 10 + c / 2;
    printf("%d", e);
    return 0;
}

 16.计算带余除法

描述

给定两个整数a和b (0 < a,b < 10,000)，计算a除以b的整数商和余数。

输入描述：

一行，包括两个整数a和b，依次为被除数和除数（不为零），中间用空格隔开。

输出描述：

一行，包含两个整数，依次为整数商和余数，中间用一个空格隔开。

#include 
int main()
{
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%d %d", a / b, a % b);
    return 0;
}

17.反向输出一个四位数

描述

将一个四位数，反向输出。

输入描述：

一行，输入一个整数n（1000 <= n <= 9999）。

输出描述：

针对每组输入，反向输出对应四位数。

#include 
int main()
{
	int a, b, c, d;
	scanf("%1d%1d%1d%1d", &a, &b, &c, &d);
	printf("%d%d%d%d", d, c, b, a);
	return 0;
}
//在读取的时候一个一个读取，分别储存起来，然后分别打印

#include 
void print(int n)
{
	if (n) {
		printf("%d", n % 10);
		print(n / 10);
	}	
}
int main()
{
	int n;
	scanf("%d", &n);
	print(n);
	return 0;
}
//利用函数，将他们倒着打印出来

#include 
int main()
{
	int n;
	scanf("%d", &n);
	for (int i = 0; i < 4; i++) {
		printf("%d", n % 10);
		n /= 10;
	}
	return 0;
}
//利用循环

#include 
int main()
{
	int num1 = 0;
	scanf("%d", &num1);
	printf("%d%d%d%d", (((num1 % 1000) % 100) % 10), (((num1 % 1000) % 100 / 10)), ((num1 % 1000) / 100), (num1 / 1000));
	return 0;
}
//直接求

18.KIKI算数

描述

问题：KiKi今年5岁了，已经能够认识100以内的非负整数，并且并且能够进行 100 以内的非负整数的加法计算。不过，BoBo老师发现KiKi在进行大于等于100的正整数的计算时，规则如下：

1.只保留该数的最后两位，例如：对KiKi来说1234等价于34；

2.如果计算结果大于等于 100， 那么KIKI也仅保留计算结果的最后两位，如果此两位中十位为0，则只保留个位。

例如：45+80 = 25

要求给定非负整数 a和 b，模拟KiKi的运算规则计算出 a+b 的值。

数据范围： 0 =< a, b <= 2 ^ 31 - 1

输入描述：

一行，输入两个非负整数a和b，用一个空格分隔。（0 <= a,b<= 231-1）。

输出描述：

针对每组输入，输出按照KiKi的运算规则计算出 a+b 的值。

#include 
int main()
{
	int a, b, sum;
	scanf("%d %d", &a, &b);
	sum = (a % 100 + b % 100) % 100;
	printf("%d", sum);
	return 0;
}
//先取得a和b的后两位，在相加，取得相加后的两位

int getSum(int a, int b) {
    int sum = a ^ b;
    int carry = ((unsigned int)a & b) << 1;
    if (carry != 0) {
        return getSum(sum, carry);
    }
    return sum;
}
//函数解释：
//    一个数与另一个数按位异或，相当于两个数相加，没有进位，
//    这两个数在按位与，再向左移动一位，就相当于将进的1补出来，
//    然后将那两个数相加，当没有进位时，就是结果
#include 
int main()
{
    int a, b, sum;
    scanf("%d %d", &a, &b);
    sum = getSum(a % 100, b % 100);
    sum %= 100;
    printf("%d", sum);
    return 0;
}
//定义一个加法函数，不使用加法可以实现加法的功能

19.浮点数的个位数字

描述

给定一个浮点数，要求得到该浮点数的个位数。

数据范围： 0 < n <= 200

输入描述：

一行，包括一个浮点数。

输出描述：

一行，包含一个整数，为输入浮点数对应的个位数。

#include 
int main()
{
	int f;
	scanf("%d", &f);
	printf("%d", f % 10);
	return 0;
}
//将一个数按照整数的形式读取，然后用这个数模10
//整数和浮点数在内存中存储的方式不一样，不同位数的机器浮点数存储的方式不一样

20.你能活多少秒

描述

问题：一年约有 3.156×107 s，要求输入您的年龄，显示该年龄合多少秒。

数据范围： 0 < age <= 200

输入描述：

一行，包括一个整数age(0

输出描述：

一行，包含一个整数，输出年龄对应的秒数。

#include 
#include 
int main()
{
	int age;
	long long int second;
	scanf("%d", &age);
	second = age * 3.156 * pow(10, 7);
	printf("%lld", second);
	return 0;
}
//pow()函数，求幂，pow(a,b)是求a的b次幂
//将second定义long long int 类型，防止溢出
//%ll 是以long long int 的形式打印

21.时间转换

描述

给定秒数 seconds ，把秒转化成小时、分钟和秒。

数据范围： 0 < seconds < 100000000

输入描述：

一行，包括一个整数，即给定的秒数。

输出描述：

一行，包含三个整数，依次为输入整数对应的小时数、分钟数和秒数（可能为零），中间用一个空格隔开。

#include 
int main()
{
	long long int second;//防止溢出
	int h, m, s;//小时，分钟，秒
	scanf("%lld", &second);
	h = second / 3600;//秒除以3600等于有多少个小时
	m = second % 3600 / 60;//秒模上3600后，在除以60后得到的是分钟
	s = second % 3600 % 60;//秒模上3600后，在模上60后得到的是秒
	printf("%d %d %d", h, m, s);
	return 0;
}

22.总成绩和平均计算

描述

依次输入一个学生的3科成绩，在屏幕上输出该学生的总成绩以及平均成绩。

输入描述：

一行，3科成绩，成绩之间用一个空格隔开。

输出描述：

一行，总成绩和平均成绩（小数点后保留两位），用一个空格隔开。

#include 
int main()
{
	float s1, s2, s3, sum, ave;
	scanf("%f %f %f", &s1, &s2, &s3);
	sum = s1 + s2 + s3;
	ave = sum / 3.0;
	printf("%.2f %.2f", sum, ave);
	return 0;
}

23.计算体重指数

描述

问题：计算BMI指数（身体质量指数）。BMI指数（即身体质量指数，简称体质指数又称体重，英文为Body Mass Index，简称BMI），是用体重公斤数除以身高米数平方得出的数字，是目前国际上常用的衡量人体胖瘦程度以及是否健康的一个标准。主要用于统计用途，当我们需要比较及分析一个人的体重对于不同高度的人所带来的健康影响时，BMI值是一个中立而可靠的指标。

数据范围：输入的数据满足  50 =< n < = 180

输入描述：

一行，两个整数，分别表示体重（公斤），身高（厘米），中间用一个空格分隔。

输出描述：

一行，BMI指数（保留两位小数）。 

#include 
int main()
{
	int height, weight;
	float BMI;
	scanf("%d %d", &weight, &height);
	BMI = (float)weight / (height * height);
	printf("%.2f", BMI * 10000);
	return 0;
}
//BMI 的计算公式，体重除以身高的平方
//整数之间相除得到的是整数的结果，含有浮点数的除法得到的结果是一个浮点数，
//计算出的BMI是一个浮点数，所以在用公式计算时，要将公式中的最少一个数转换成浮点数

24.计算三角形周长和面积

描述

根据给出的三角形3条边a, b, c，计算三角形的周长和面积。

数据范围： 0 < a, b, c <= 100000

输入描述：

一行，三角形3条边（能构成三角形），中间用一个空格隔开。

输出描述：

一行，三角形周长和面积（保留两位小数），中间用一个空格隔开，输出具体格式详见输出样例。

#include 
#include 
int main()
{
	int Side_length1, Side_length2, Side_length3;
	double S, C, ave;
	scanf("%d %d %d", &Side_length1, &Side_length2, &Side_length3);
	C = Side_length1 + Side_length2 + Side_length3;
	ave = (Side_length1 + Side_length2 + Side_length3) / 2.0;
	S = sqrt(ave * (ave - Side_length1) * (ave - Side_length2) * (ave - Side_length3));
	printf("circumference=%.2f area=%.2f", C, S);
	return 0;
}
//Side_length1, Side_length2, Side_length3用来分别表示三角形的三条边长
//三角形的周长等于三边之和，三角形的面积等于根号下p * (p - a ) * (p - b) * (p - c) p = (a + b +c) / 2
//sqrt() 是求算数平方根的函数，在#include 这个头文件中

25.计算球体积

描述

给定一个球体的半径，计算其体积。其中球体体积公式为 V = 4/3*πr3，其中 π = 3.1415926。

数据范围：输入一个浮点值  0 <= n <= 15

输入描述：

一行，用浮点数表示的球体的半径。

输出描述：

一行，球体的体积，小数点后保留3位。

#include 
#include 
int main()
{
	double n, v;
	scanf("%lf", &n);
	v = 4 / 3.0 * 3.1415926 * pow(n, 3);
	printf("%.3lf", v);
	return 0;
}
//pow(),求幂函数，
//%.3f是小数点后面保留三位，lf是以double类型输出，打印

26.大小写转换

描述

实现字母的大小写转换。多组输入输出。

输入描述：

多组输入，每一行输入大写字母。

输出描述：

针对每组输入输出对应的小写字母。

#include 
int main()
{
	char ch;
	while (~scanf("%c", &ch)) {
		if (ch >= 'A' && ch <= 'Z') {
			ch += 32;
			printf("%c\n", ch);
		}
	}
	return 0;
}
//scanf返回值是成功读取的个数，当读取失败时，返回-1
//-1  10000000 00000000 00000000 00000001 源码
//-1  11111111 11111111 11111111 11111110 反码
//-1  11111111 11111111 11111111 11111111 补码
//~-1 00000000 00000000 00000000 00000000 补码
//~-1 = 0;
//~x = - (x + 1)
//while(x),x为0时，循环终止，x为非0时，循环进行，0为假，非0为真

27.2的n次方计算

描述

不使用累计乘法的基础上，通过移位运算（<<）实现2的n次方的计算。

数据范围：0 =< n <= 31

输入描述：

一行输入整数n（0 <= n < 31）。

输出描述：

输出对应的2的n次方的结果。

#include 
#include 
int main()
{
	int n;
	scanf("%d", &n);
	printf("%d", (int)pow(2, n));
	return 0;
}

#include 
int main()
{
	int n, i, ret = 1;
	scanf("%d", &n);
	for (i = 0; i < n; i++) {
		ret <<= 1;
	}
	printf("%d", ret);
	return 0;
}
// <<1 相当于十进制的数乘以2
// >>1 相当于十进制的数除以2

28.KIKI和酸奶

描述

BoBo买了一箱酸奶，里面有n盒未打开的酸奶，KiKi喜欢喝酸奶，第一时间发现了酸奶。KiKi每h分钟能喝光一盒酸奶，并且KiKi在喝光一盒酸奶之前不会喝另一个，那么经过m分钟后还有多少盒未打开的酸奶？

输入描述：

多组输入，每组输入仅一行，包括n，h和m（均为整数）。输入数据保证m <= n * h。

输出描述：

针对每组输入，输出也仅一行，剩下的未打开的酸奶盒数。

#include 
int main()
{
	int n, h, m, ret;
	while (~scanf("%d %d %d", &n, &h, &m)) {
		ret = n - m / h;
		if (m % h != 0) {
			ret--;
		}
		printf("%d\n", ret);
	}
	return 0;
}
//当m能整除h时，喝的酸奶是m / h
//当m不能整除h时，喝的酸奶是m / h + 1

29.发布信息

描述

你的手机丢了，在屏幕上输出信息告诉大家。

输入描述：

无

输出描述：

I lost my cellphone!

#include 
int main()
{
	printf("I lost my cellphone!\n");
	return 0;
}

30.输出学生信息

描述

学生信息管理系统是学校教学管理的重要工具，现有一名学生基本信息如下：姓名-Jack，年龄-18，性别-Man，请按照输出样例的格式输出该学生的信息。

输入描述：

无

输出描述：

输出分为三行，分别为标题行，分隔行，信息行。
第一行，标题行，每个标题之间间隔4个空格。
第二行，分隔行，一共21个减号"-"。
第三行，信息行，每列输出信息和标题首字母对齐。输出样例如下：
Name Age Gender
---------------------
Jack 18 man 

#include 
int main()
{
    printf("Name    Age    Gender\n");
    printf("---------------------\n");
    printf("Jack    18     man");
    return 0;
}

31.计算平均成绩

描述

从键盘输入5个学生的成绩（整数），求他们的平均成绩（浮点数，保留一位小数）。

输入描述：

一行，连续输入5个整数（范围0~100），用空格分隔。

输出描述：

一行，输出5个数的平均数（保留一位小数）。 

#include 
int main()
{
	int a, b, c, d, e, sum;
	float ave;
	scanf("%d %d %d %d %d", &a, &b, &c, &d, &e);
	sum = a + b + c + d + e;
	ave = sum / 5.0;
	printf("%.1f", ave);
	return 0;
}

32.进制A+B

描述

输入一个十六进制数a，和一个八进制数b，输出a+b的十进制结果（范围-231~231-1）。

输入描述：

一行，一个十六进制数a，和一个八进制数b，中间间隔一个空格。

输出描述：

一行，a+b的十进制结果。

#include 
int main()
{
	int a, b, sum;
	scanf("%x %o", &a, &b);
	sum = a + b;
	printf("%d", sum);
	return 0;
}
//%x 读取十六进制的数字， %o 读取八进制的数字
//%d 打印十进制的数字

33.判断字母

描述

从键盘任意输入一个字符，编程判断是否是字母（包括大小写）。

输入描述：

输入包括一个字符。

输出描述：

输出该字符是字母（YES）或不是（NO）。

#include 
int main()
{
    char ch;
    scanf("%c", &ch);
    if((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
        printf("YES");
    else
        printf("NO");
    return 0;
}

34.健康评估

描述

BMI指数（即身体质量指数）是用体重公斤数除以身高米数平方得出的数字，是目前国际上常用的衡量人体胖瘦程度以及是否健康的一个标准。例如：一个人的身高为1.75米，体重为68千克，他的BMI=68/(1.75^2)=22.2（千克/米^2）。当BMI指数为18.5～23.9时属正常，否则表示身体存在健康风险。编程判断人体健康情况。

输入描述：

一行，输入一个人的体重（千克）和身高（米），中间用一个空格分隔。

输出描述：

一行，输出身体Normal(正常)或Abnormal(不正常)。

#include 
int main()
{
    double height, weight, BMI;
    scanf("%lf %lf", &weight, &height);
    BMI = weight / (height * height);
    if(BMI >= 18.5 && BMI <= 23.9){
        printf("Normal");
    }else{
        printf("Abnormal");
    }
    return 0;
}

35.网购

描述

KiKi非常喜欢网购，在一家店铺他看中了一件衣服，他了解到，如果今天是“双11”（11月11日）则这件衣服打7折，“双12” （12月12日）则这件衣服打8折，如果有优惠券可以额外减50元（优惠券只能在双11或双12使用），求KiKi最终所花的钱数。

数据范围：衣服价格满足 1 =< val <= 100000

输入描述：

一行，四个数字，第一个数表示小明看中的衣服价格，第二和第三个整数分别表示当天的月份、当天的日期、第四个整数表示是否有优惠券（有优惠券用1表示，无优惠券用0表示）。 注：输入日期保证只有“双11”和“双12”。

输出描述：

一行，小明实际花的钱数（保留两位小数）。（提示：不要指望商家倒找你钱）

#include 
int main()
{
	float a, f;
	int b, c, d;
	scanf("%f %d %d %d", &a, &b, &c, &d);
	if (b == 11 && c == 11)
	{
		if (d == 1)
		{
			f = a * (0.7) - 50;
			if (f < 0)
				printf("0.00");
			else
				printf("%.2f", f);
		}
		else
		{
			f = a * (0.7);
			if (f < 0)
				printf("0.00");
			else
				printf("%.2f", f);
		}
	}
	else
	{
		if (d == 1)
		{
			f = a * (0.8) - 50;
			if (f < 0)
				printf("0.00");
			else
				printf("%.2f", f);
		}
		else
		{
			f = a * (0.8);
			if (f < 0)
				printf("0。00");
			else
				printf("%.2lf", f);
		}
	}
	return 0;
}

#include 
int main()
{
	float a, f;
	int b, c, d;
	scanf("%f %d %d %d", &a, &b, &c, &d);
	if (d == 1) {
		if (b == 11 && c == 11) {
			f = a * (0.7) - 50;
		}
		else if (b == 12 && c == 12) {
			f = a * (0.8) - 50;
		}
	}
	else {
		if (b == 11 && c == 11) {
			f = a * (0.7);
		}
		else if (b == 12 && c == 12) {
			f = a * (0.8);
		}
	}
	if (f < 0)
		f = 0.00;
	printf("%.2f", f);
	return 0;
}

36.变种水仙花

描述

变种水仙花数 - Lily Number：把任意的数字，从中间拆分成两个数字，比如1461 可以拆分成（1和461）,（14和61）,（146和1),如果所有拆分后的乘积之和等于自身，则是一个Lily Number。

例如：

655 = 6 * 55 + 65 * 5

1461 = 1*461 + 14*61 + 146*1

求出 5位数中的所有 Lily Number。

输入描述：

无

输出描述：

一行，5位数中的所有 Lily Number，每两个数之间间隔一个空格。

int main()
{
	for (int i = 10000; i < 100000; i++) {
			if (i == (i / 10) * (i % 10) + (i / 100) * (i % 100) + (i / 1000) * (i % 1000) + (i / 10000) * (i % 10000))
				printf("%d ", i);
	}
	return 0;
}
//在10000倒100000之内进行遍历，一个一个查找

37.争夺前5名

描述38.

期中考试开始了，大家都想取得好成绩，争夺前五名。从键盘输入 n 个学生成绩，输出每组排在前五高的成绩。

数据范围： 5 =< n <= 50 ，成绩采取百分制并不会出现负数

输入描述：

两行，第一行输入一个整数，表示n个学生（>=5），第二行输入n个学生成绩（整数表示，范围0~100），用空格分隔。

输出描述：

一行，输出成绩最高的前五个，用空格分隔。

#include 
#include 
int cmp(const void* pa, const void * pb) {
	return *(int*)pb - *(int*)pa;
}
int main()
{
	int arr[50] = { 0 }, n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &arr[i]);
	}
	qsort(arr, n, sizeof(int), cmp);
	for (int i = 0; i < 5; i++) {
		printf("%d ", arr[i]);
	}
	return 0;
}
//qsort 快速排序函数，
//qsort(arr, n, sizeof(int), cmp);
//arr 是需要排序的数组
//n   是需要排序的个数
//sizeof(int) 是排序元素的大小
//cmp 是排序函数

38.竞选社长

描述

假设你们社团要竞选社长，有两名候选人分别是A和B，社团每名同学必须并且只能投一票，最终得票多的人为社长.

输入描述：

一行，字符序列，包含A或B，输入以字符0结束。

输出描述：

一行，一个字符，A或B或E，输出A表示A得票数多，输出B表示B得票数多，输出E表示二人得票数相等。

#include 
int main()
{
    char arr[100];
    scanf("%s", arr);
    int A = 0, B = 0;
    int sz = strlen(arr);//求字符串的长度
    for(int i = 0; i < sz; i++){
        if('A' == *(arr + i))
            A++;//如果有字符A,A自增
        else if('B' == *(arr + i))
            B++;//如果有字符B,B自增
        else 
            ;
    }
    if(A > B)
        printf("A");
    else if(B > A)
        printf("B");
    else
        printf("E");
    return 0;
}

39.你是天才吗？

描述

据说智商140以上者称为天才，KiKi想知道他自己是不是天才，请帮他编程判断。输入一个整数表示一个人的智商，如果大于等于140，则表明他是一个天才，输出“Genius”。

输入描述：

多组输入，每行输入包括一个整数表示的智商。

输出描述：

针对每行输入，输出“Genius”。

#include 
int main()
{
	int IQ = 0;
	while (~scanf("%d", &IQ)) {
		if (IQ >= 140)
			printf("Genius\n");
	}
	return 0;
}

40.完美成绩

描述

KiKi想知道他的考试成绩是否完美，请帮他判断。从键盘输入一个整数表示的成绩，编程判断成绩是否在90~100之间，如果是则输出“Perfect”。

输入描述：

多组输入，每行输入包括一个整数表示的成绩（90~100）。

输出描述：

针对每行输入，输出“Perfect”。

#include 
int main()
{
    int Grade;    
    while(~scanf("%d", &Grade)){
        if(Grade >= 90 && Grade <= 100)
            printf("Perfect\n");
    }
    return 0;
}

41.及格分数

描述

KiKi想知道他的考试分数是否通过，请帮他判断。从键盘任意输入一个整数表示的分数，编程判断该分数是否在及格范围内，如果及格，即：分数大于等于60分，是输出“Pass”，否则，输出“Fail”。

输入描述：

多组输入，每行输入包括一个整数表示的分数（0~100）。

输出描述：

针对每行输入，输出“Pass”或“Fail”。

#include 
int main()
{
    int grade;
    while(~scanf("%d", &grade)){
        if(grade >= 60)
            printf("Pass\n");
        else
            printf("Fail");
    }
    return 0;
}

42.判断整数奇偶

描述

KiKi想知道一个整数的奇偶性，请帮他判断。从键盘任意输入一个整数（范围-231~231-1），编程判断它的奇偶性。

输入描述：

多组输入，每行输入包括一个整数。

输出描述：

针对每行输入，输出该数是奇数（Odd）还是偶数（Even）。

#include 
int main()
{
    int n;
    while(~scanf("%d", &n)){
        if(n & 1){
            printf("Odd\n");
        }else{
            printf("Even\n");
        }
    }
    return 0;
}
//偶数按位与1 等于 0
//奇数按位与1 等于1

#include 
int main()
{
    int n;
    while(~scanf("%d", &n)){
        if(n % 2){
            printf("Odd\n");
        }else{
            printf("Even\n");
        }
    }
    return 0;
}
//奇数模二等于1
//偶数模二等于0

43.最高分数

描述

KiKi参加了语文、数学、外语的考试，请帮他判断三科中的最高分。从键盘任意输入三个整数表示的分数，编程判断其中的最高分。

数据范围： 0 =< n <= 100

输入描述：

输入一行包括三个整数表示的分数（0~100），用空格分隔。

输出描述：

输出为一行，即三个分数中的最高分。

#include 
int main()
{

	int arr[3], max = 0;
	scanf("%d %d %d", &arr[0], &arr[1], &arr[2]);
	for (int i = 0; i < 3; i++) {
		if (arr[i] > max)
			max = arr[i];
	}
	printf("%d", max);
	return 0;
}
//将最大值设置为0，只要比0大就将那个值赋给最大值

44.判断元音还是辅音

描述

KiKi开始学习英文字母，BoBo老师告诉他，有五个字母A(a), E(e), I(i), O(o),U(u)称为元音，其他所有字母称为辅音，请帮他编写程序判断输入的字母是元音（Vowel）还是辅音（Consonant）。

输入描述：

多组输入，每行输入一个字母。

输出描述：

针对每组输入，输出为一行，如果输入字母是元音（包括大小写），输出“Vowel”，如果输入字母是非元音，输出“Consonant”。

#include 
int main()
{
    char ch;
    while(~scanf(" %c", &ch)){
        if(ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U' || ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
            printf("Vowel\n");
        else
            printf("Consonant\n");
    }
    return 0;
}
//scanf内部留个空格，敲完回车后，会留下一个'\0'，这个空格能与'\0'对应，方便读取下一个符号
//若无空格，则下一次读取的是空格

45.判断是不是字母

描述

KiKi想判断输入的字符是不是字母，请帮他编程实现。

输入描述：

多组输入，每一行输入一个字符。

输出描述：

针对每组输入，输出单独占一行，判断输入字符是否为字母，输出内容详见输出样例。

#include 
int main()
{
    char ch;
    while(~scanf(" %c", &ch)){
        if((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
            printf("%c is an alphabet.\n", ch);
        else
            printf("%c is not an alphabet.\n", ch);
    }
    return 0;
}

46.字母大小写转换

描述

KiKi想完成字母大小写转换，有一个字符，判断它是否为大写字母，如果是，将它转换成小写字母；反之则转换为大写字母。

输入描述：

多组输入，每一行输入一个字母。

输出描述：

针对每组输入，输出单独占一行，输出字母的对应形式。

#include 
int main()
{
    char ch;
    while(~scanf(" %c", &ch)){
        if(ch >= 'A' && ch <= 'Z'){
            ch += 32;
            printf("%c\n", ch);
        }else if(ch >= 'a' && ch <= 'z'){
            ch -= 32;
            printf("%c\n", ch);
        }else{
            ;
        }
    }
    return 0;
}
//大写转换成小写，加等32
//小写转换成大写，减等32

47.判断两个数大小关系

描述

KiKi想知道从键盘输入的两个数的大小关系，请编程实现。

输入描述：

题目有多组输入数据，每一行输入两个整数（范围-231~231-1），用空格分隔。

输出描述：

针对每行输入，输出两个整数及其大小关系，数字和关系运算符之间没有空格，详见输入输出样例。

#include 
int main()
{
    int a, b;
    while(~scanf("%d %d", &a, &b)){
        if(a > b){
            printf("%d>%d\n", a, b);
        }else if(a < b){
            printf("%d<%d\n", a, b);
        }else{
            printf("%d=%d\n", a, b);
        }
    }
    return 0;
}

48.计算单位阶跃函数

描述

KiKi最近学习了信号与系统课程，这门课里有一个非常有趣的函数，单位阶跃函数，其中一种定义方式为：

现在试求单位冲激函数在时域t上的值。

输入描述：

题目有多组输入数据，每一行输入一个t(-1000

输出描述：

输出函数的值并换行。 

#include 
int main()
{
    int n;
    while(~scanf("%d", &n)){
        if(n > 0){
            printf("1\n");
        }else if(n == 0){
            printf("0.5\n");
        }else{
            printf("0\n");
        }
    }
    return 0;
}

49.三角形判断

描述

KiKi想知道已经给出的三条边a，b，c能否构成三角形，如果能构成三角形，判断三角形的类型（等边三角形、等腰三角形或普通三角形）。

输入描述：

题目有多组输入数据，每一行输入三个a，b，c(0

输出描述：

针对每组输入数据，输出占一行，如果能构成三角形，等边三角形则输出“Equilateral triangle!”，等腰三角形则输出“Isosceles triangle!”，其余的三角形则输出“Ordinary triangle!”，反之输出“Not a triangle!”。

#include 
#include 
int cmp(void const* pa, void const* pb) {
	return *(int*)pa - *(int*)pb;
}
int main()
{
	int arr[3];
	while (~scanf("%d %d %d", &arr[0], &arr[1], &arr[2])) {
		qsort(arr, 3, sizeof(int), cmp);
		if (arr[0] + arr[1] > arr[2]) {
			if (arr[0] == arr[1] && arr[0] == arr[2]) {
				printf("Equilateral triangle!\n");
			}
			else if ((arr[0] == arr[1] && arr[0] != arr[2]) || (arr[1] == arr[2] && arr[2] != arr[0])) {
				printf("Isosceles triangle!\n");
			}
			else {
				printf("Ordinary triangle!\n");
			}
		}else {
			printf("Not a triangle!\n");
		}
	}
	return 0;
}
//创建一个排序函数，若两个小的加起来比最大的小则不是三角形，否则是三角形

50.衡量人体胖瘦程度

描述

在计算BMI（BodyMassIndex ，身体质量指数）的案例基础上，判断人体胖瘦程度。BMI中国标准如下表所示。

输入描述：

多组输入，每一行包括两个整数，用空格隔开，分别为体重（公斤）和身高（厘米）。

输出描述：

针对每行输入，输出为一行，人体胖瘦程度，即分类。 

#include 
#include 
int main()
{
	int stature, weight;
	float BMI, mstature;
	while (~scanf("%d %d", &weight, &stature)){
		mstature = stature / 100.0;
		BMI = weight / pow(mstature, 2);
		if (BMI < 18.5){
			printf("Underweight\n");
		}else if (BMI >= 18.5 && BMI <= 23.9){
			printf("Normal\n");
		}else if (BMI > 23.9 && BMI <= 27.9){
			printf("Overweight\n");
		}else{
			printf("Obese\n");
		}
	}
	return 0;
}

51.计算一元二次方程

描述

从键盘输入a, b, c的值，编程计算并输出一元二次方程ax2 + bx + c = 0的根，当a = 0时，输出“Not quadratic equation”，当a ≠ 0时，根据△ = b2 - 4*a*c的三种情况计算并输出方程的根。

输入描述：

多组输入，一行，包含三个浮点数a, b, c，以一个空格分隔，表示一元二次方程ax2 + bx + c = 0的系数。

输出描述：

针对每组输入，输出一行，输出一元二次方程ax2 + bx +c = 0的根的情况。

  如果a = 0，输出“Not quadratic equation”；

  如果a ≠  0，分三种情况：

△ = 0，则两个实根相等，输出形式为：x1=x2=...。

△  > 0，则两个实根不等，输出形式为：x1=...;x2=...，其中x1  <=  x2。

△  < 0，则有两个虚根，则输出：x1=实部-虚部i;x2=实部+虚部i，即x1的虚部系数小于等于x2的虚部系数，实部为0时不可省略。实部= -b / (2*a),虚部= sqrt(-△ ) / (2*a)

所有实数部分要求精确到小数点后2位，数字、符号之间没有空格。

#include 
#include 
int main()
{
	double a, b, c, d, f, sb, xb;
	while (~scanf("%lf %lf %lf", &a, &b, &c)) {
		if (a == 0) {
			printf("Not quadratic equation\n");
		}else {
			d = (b * b) - (4 * a * c);
			f = abs(d);
			sb = (-b) / (2 * a);
			xb = sqrt(f) / (2 * a);
			if (sb == -0.00) {
				sb = 0.00;
			}
			if (d == 0) {
				printf("x1=x2=%.2lf\n", sb + xb);
			}else if (d > 0) {
				printf("x1=%.2lf;x2=%.2lf\n", sb - xb, sb + xb);
			}else {
				printf("x1=%.2lf-%.2lfi;x2=%.2lf+%.2lfi\n", sb, xb, sb, xb);
			}
		}
	}
	return 0;
}
//如果▲ = 0, 有一个解；x = (-b + sqrt(b * b - 4 * a * c)) / (2 * a);
//如果▲ > 0, 有两个不同的解；x = (-b +- sqrt(b * b - 4 * a * c)) / (2 * a);
//如果▲ < 0, 没有实根，有虚根

52.获得月份天数

描述

KiKi想获得某年某月有多少天，请帮他编程实现。输入年份和月份，计算这一年这个月有多少天。

输入描述：

多组输入，一行有两个整数，分别表示年份和月份，用空格分隔。

输出描述：

针对每组输入，输出为一行，一个整数，表示这一年这个月有多少天。

#include 
int main()
{
    int year, month, day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, day1;
    while(~scanf("%d %d", &year, &month)){
        day1 = day[month - 1];
        if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){
            if (month == 2)
                day1++;
        }
        printf("%d\n", day1);
    }
    return 0;
}
//先创建一个月份天数的表格，如果是闰年且是二月时，天数自增；

53.简单计算器

描述

KiKi实现一个简单计算器，实现两个数的“加减乘除”运算，用户从键盘输入算式“操作数1运算符操作数2”，计算并输出表达式的值，如果输入的运算符号不包括在（+、-、*、/）范围内，输出“Invalid operation!”。当运算符为除法运算，即“/”时。如果操作数2等于0.0，则输出“Wrong!Division by zero!”

数据范围：字符串长度满足 3 =< n =< 50 ，保证运算符是一个char类型字符。

输入描述：

输入一行字符串，操作数1+运算符+操作数2 （其中合法的运算符包括：+、-、*、/）。

输出描述：

输出为一行。

void Add(double a, double b){
    printf("%.4f+%.4f=%.4f\n", a, b, a + b);
}
void Mul(double a, double b){
    printf("%.4f*%.4f=%.4f\n", a, b, a * b);
}
void Div(double a, double b){
    if(b == 0){
        printf("Wrong!Division by zero!\n");
    }else {
        printf("%.4f/%.4f=%.4f\n", a, b, a / b);
    }
}
void Sub(double a, double b){
    printf("%.4f-%.4f=%.4f\n", a, b, a - b);
}
#include 
int main()
{
    char ch;
    double a, b;
    while(~scanf("%lf%c%lf", &a, &ch, &b)){
        if(ch == '+'){
            Add(a, b);
        }else if(ch == '-'){
            Sub(a, b);
        }else if(ch == '*'){
            Mul(a, b);
        }else if(ch == '/'){
            Div(a, b);
        }else{
            printf("Invalid operation!\n");
        }
    }
    return 0;
}
//先自定义创造一些函数，用来完成加减乘除

 54.线段图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的线段图案。

输入描述：

多组输入，一个整数（1~100），表示线段长度，即“*”的数量。

输出描述：

针对每行输入，输出占一行，用“*”组成的对应长度的线段。

#include 
int main()
{
    int n;
    while(~scanf("%d", &n)){
        while(n--){//打印n个*
            printf("*");
        }
        printf("\n");//用来换行，进行重新输入和打印下一行
    }
    return 0;
}

55.正方形图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的正方形图案。

输入描述：

多组输入，一个整数（1~20），表示正方形的长度，也表示输出行数。

输出描述：

针对每行输入，输出用“*”组成的对应边长的正方形，每个“*”后面有一个空格。

#include 
int main()
{
    int n;
    while (~scanf("%d", &n)) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                printf("* ");
            }
            printf("\n");
        }
    }
    return 0;
}

56.直角三角形图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的直角三角形图案。

输入描述：

多组输入，一个整数（2~20），表示直角三角形直角边的长度，即“*”的数量，也表示输出行数。

输出描述：

针对每行输入，输出用“*”组成的对应长度的直角三角形，每个“*”后面有一个空格。

#include 
int main()
{
    int n;
    while (~scanf("%d", &n)) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                printf("* ");
            }
            printf("\n");
        }
    }
    return 0;
}
//使用嵌套循环

57.翻转直角三角形图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的翻转直角三角形图案。

输入描述：

多组输入，一个整数（2~20），表示翻转直角三角形直角边的长度，即“*”的数量，也表示输出行数。

输出描述：

针对每行输入，输出用“*”组成的对应长度的翻转直角三角形，每个“*”后面有一个空格。

#include 
int main()
{
    int i, j, n;
    while(~scanf("%d", &n)){
        for(i = 0; i < n; i++){
            for(j = 0; j < n - i; j++){
                printf("* ");
            }
            printf("\n");
        }
    }
    return 0;
}

58.带空格直角三角形图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的带空格直角三角形图案。

输入描述：

多组输入，一个整数（2~20），表示直角三角形直角边的长度，即“*”的数量，也表示输出行数。

输出描述：

针对每行输入，输出用“*”组成的对应长度的直角三角形，每个“*”后面有一个空格。

#include 
int main()
{
    int i, j, n;
    while(~scanf("%d", &n)){
        for(i = 0; i < n; i++){
            for(j = 1; j < n - i; j++){
                printf("  ");
            }
            for(j = 0; j <= i; j++){
                printf("* ");
            }
            printf("\n");
        }
    }
    return 0;
}
//循环嵌套打印，先打印空格，后打印*

#include 
#include 
int main()
{
    int n, i, j;
    char ch[20];//整数的大小是2~20
    while(~scanf("%d", &n)){
        memset(ch, ' ', sizeof(char) * n);//设置一个哈希数表，将其全部初始化为' ';
        for(i = 0; i < n; i++){
            ch[n - i - 1] = '*';//每次将最后一个初始化为'*'
            for(j = 0; j < n; j++){
                printf("%c ", ch[j]);//每次初始化之后，将这个数组的内容打印出来
            }
            printf("\n");
        }
    }
    return 0;
}

#include 
#include 
int main()
{
    int n, i, j;
    while(~scanf("%d", &n)){
        char *ret = (char *)malloc(sizeof(char) * n);//动态分配一块内存，大小恰好是需要的大小
        memset(ret, ' ', sizeof(char) * n);//将动态分配下的内存初始化为空格
        for(i = 0; i < n; ++i){
            ret[n - i - 1] = '*';//从后倒前将'*'赋给数组
            for(j = 0; j < n; j++){
                printf("%c ", ret[j]);//将数组内容打印出来
            }
            printf("\n");
        }
    }
    return 0;
}

59.金字塔图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的金字塔图案。

输入描述：

多组输入，一个整数（2~20），表示金字塔边的长度，即“*”的数量，，也表示输出行数。

输出描述：

针对每行输入，输出用“*”组成的金字塔，每个“*”后面有一个空格。

#include 
int main()
{
    int n, i, j;
    while (~scanf("%d", &n)) {
        for (i = 0; i < n; i++) {
            for (j = 0; j < n - i - 1; ++j) {
                printf(" ");//打印每行的空格
            }
            for (j = 0; j <= i; ++j) {
                printf("* ");//打印每行的'*'
            }
            printf("\n");
        }
    }
    return 0;
}

60.翻转金字塔图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的翻转金字塔图案。

输入描述：

多组输入，一个整数（2~20），表示翻转金字塔边的长度，即“*”的数量，也表示输出行数。

输出描述：

针对每行输入，输出用“*”组成的金字塔，每个“*”后面有一个空格。

#include 
int main()
{
    int n, i, j;
    while(~scanf("%d", &n)){
        for(i = 0; i < n; ++i){
            for(j = 0; j < i; j++){
                printf(" ");//打印每行的空格
            }
            for(j = 0; j < n - i; ++j){
                printf("* ");//打印每行的'*'
            }
            printf("\n");
        }
    }
    return 0;
}

61.菱形图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的菱形图案。

输入描述：

多组输入，一个整数（2~20）。

输出描述：

针对每行输入，输出用“*”组成的菱形，每个“*”后面有一个空格。

#include 
int main()
{
    int n, i, j;
    while(~scanf("%d", &n)){
        for (i = 0; i <= n; ++i){//打印前n + 1 行
            for(j = 0; j < n - i; ++j){
                printf(" ");//打印每行的空格
            }
            for (j = 0; j <= i; ++j){
                printf("* ");//打印每行的'*'
            }
            printf("\n");//换行
        }
        for (i = 0; i < n; ++i){//打印后n行
            for(j = 0; j <= i; ++j){
                printf(" ");//打印每行的空格
            }
            for(j = 0; j < n - i; ++j){
                printf("* ");//打印每行的*
            }
            printf("\n");
        }
    }
    return 0;
}

62.k形图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的K形图案。

输入描述：

多组输入，一个整数（2~20）。

输出描述：

针对每行输入，输出用“*”组成的K形，每个“*”后面有一个空格。

#include 
int main()
{
    int i, j, n;
    while(~scanf("%d", &n)){
        for(i = 0; i <= n; ++i){//打印前n + 1 行的元素
            for(j = 0; j <= n - i; ++j){
                printf("* ");
            }
            printf("\n");
        }
        for(i = 0; i < n; ++i){//打印后n 行的元素
            for(j = 0; j <= i + 1; j++){
                printf("* ");
            }
            printf("\n");
        }
    }
    return 0;
}

63.箭形图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的箭形图案。

输入描述：

本题多组输入，每行一个整数（2~20）。

输出描述：

针对每行输入，输出用“*”组成的箭形。

#include 
int main()
{
    int i, j, n;
    while(~scanf("%d", &n)){
        for(i = 0; i <= n; ++i){//打印前n + 1 行
            for(j = 0; j < n - i; ++j){
                printf("  ");
            }
            for(j = 0; j <= i; ++j){
                printf("*");
            }
            printf("\n");
        }
        for(i = 0; i < n; ++i){//打印后n 行
            for(j = 0; j <= i; ++j){
                printf("  ");
            }
            for(j = 0; j < n - i; ++j){
                printf("*");
            }
            printf("\n");
        }
    }
    return 0;
}

 64.反斜线形图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的反斜线形图案。

输入描述：

多组输入，一个整数（2~20），表示输出的行数，也表示组成反斜线的“*”的数量。

输出描述：

针对每行输入，输出用“*”组成的反斜线。

#include 
int main()
{
    int i, j, n;
    while(~scanf("%d", &n)){
        for(i = 0; i < n; ++i){
            for(j = 0; j < i; ++j){
                printf(" ");
            }
            printf("*\n");
        }
    }
    return 0;
}

65.正斜线图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的正斜线形图案。

输入描述：

多组输入，一个整数（2~20），表示输出的行数，也表示组成正斜线的“*”的数量。

输出描述：

针对每行输入，输出用“*”组成的正斜线。

#include 
int main()
{
	int i, j, n;
	while (~scanf("%d", &n))
	{
		for (i = 0; i < n; i++)
		{
			for (j = 0; j < n - 1 - i; j++)
			{
				printf(" ");
			}
			printf("*\n");
		}
	}
	return 0;
}

66.X形图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的X形图案。

输入描述：

多组输入，一个整数（2~20），表示输出的行数，也表示组成“X”的反斜线和正斜线的长度。

输出描述：

针对每行输入，输出用“*”组成的X形图案。

#include 
int main()
{
    int n, i, j;
    while(~scanf("%d", &n)){
        if(n & 1){//打印奇数
            for(i = 0; i <= n / 2; ++i){
                for(j = 0; j < i; ++j){
                    printf(" ");
                }
                printf("*");
                for(j = 0; j < n - 2 - 2 * i; ++j){
                    printf(" ");
                }
                if(i != n / 2){
                    printf("*");
                }
                printf("\n");
            }
            for(i = 0; i < n / 2; ++i){
                for(j = 1; j < n / 2 - i; ++j){
                    printf(" ");
                }
                printf("*");
                for(j = 0; j <= 2 * i; ++j){
                    printf(" ");
                }
                printf("*\n");
            }
        }else{//打印偶数
            for(i = 0; i < n / 2; ++i){
                for(j = 0; j < i; ++j){
                    printf(" ");
                }
                printf("*");
                for(j = 0; j < n - 2 - 2 * i; ++j){
                    printf(" ");
                }
                printf("*\n");
            }
            for(i = 0; i < n / 2; ++i){
                for(j = 1; j < n / 2 - i; ++j){
                    printf(" ");
                }
                printf("*");
                for(j = 0; j < 2 * i; ++j){
                    printf(" ");
                }
                printf("*\n");
            }
        }
    }
    return 0;
}
//奇数和偶数中间行需要的*不一样，所以需要分类打印

#include 
int main()
{
    int i, j, n;
    while(~scanf("%d", &n)){
        for(i = 0; i < n; ++i){
            for(j = 0; j < n; ++j){
                if(i == j || j == n - 1 -i){
                    printf("*");
                }else{
                    printf(" ");
                }
            }
            printf("\n");
        }
    }
    return 0;
}
//每一行*下标之和相等

67.空心正方形图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的“空心”正方形图案。

输入描述：

多组输入，一个整数（3~20），表示输出的行数，也表示组成正方形边的“*”的数量。

输出描述：

针对每行输入，输出用“*”组成的“空心”正方形，每个“*”后面有一个空格。

#include 
int main()
{
    int i, j, n;
    while(~scanf("%d", &n)){
        for(i = 0; i < n; ++i){
            for(j = 0; j < n; ++j){
                if(i == 0 || i == n - 1 || j == 0 || j == n - 1){//只有第一列最后一列，第一行最后一行是*其余的全是空格
                    printf("* ");
                }else{
                    printf("  ");
                }
            }
            printf("\n");
        }
    }
    return 0;
}

68.空心三角形图案

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的“空心”三角形图案。

输入描述：

多组输入，一个整数（3~20），表示输出的行数，也表示组成三角形边的“*”的数量。

输出描述：

针对每行输入，输出用“*”组成的“空心”三角形，每个“*”后面有一个空格。

​
#include 
int main()
{
    int i, j, n;
    while(~scanf("%d", &n)){
        for(i = 0; i < n; ++i){
            for(j = 0; j < n; ++j){
                if(j == 0 || i == n - 1 || j == i){//最后一行，或行和列的下标相同时，是*
                    printf("* ");
                }else{
                    printf("  ");
                }
            }
            printf("\n");
        }
    }
    return 0;
}

​

69.新年快乐

描述

新年到来，输出信息迎接新年。

输入描述：

无

输出描述：

Happy New Year*2019*

#include 
int main()
{
	printf("Happy New Year*2019*\n");
	return 0;
}

70.平均身高

描述

从键盘输入5个人的身高（米），求他们的平均身高（米）。

输入描述：

一行，连续输入5个身高（范围0.00~2.00），用空格分隔。

输出描述：

一行，输出平均身高，保留两位小数。

#include 
int main()
{
	float a, b, c, d, e;
	scanf("%f %f %f %f %f", &a, &b, &c, &d, &e);
	printf("%.2f", (a + b + c + d + e) / 5.0);
	return 0;
}

71.挂科危险

描述

KiKi想知道这学期他的学习情况，BoBo老师告诉他这学期挂的科目累计的学分，根据所挂学分，判断KiKi学习情况，10分以上：很危险(Danger++)，4~9分：危险(Danger)，0~3:Good。

输入描述：

一行，一个整数（0~30），表示KiKi挂的科目累计的学分。

输出描述：

一行，根据输入的挂科学分，输出相应学习情况（Danger++，Danger，Good）。

#include 
int main()
{
    int n;
    scanf("%d", &n);
    if(n >= 10){
        printf("Danger++\n");
    }else if(n >= 4 && n <= 9){
        printf("Danger\n");
    }else{
        printf("Good\n");
    }
    return 0;
}

72.HTTP状态码

描述

KiKi访问网站，得到HTTP状态码，但他不知道什么含义，BoBo老师告诉他常见HTTP状态码：200（OK，请求已成功），202（Accepted，服务器已接受请求，但尚未处理。）400（Bad Request，请求参数有误），403（Forbidden，被禁止），404（Not Found，请求失败），500（Internal Server Error，服务器内部错误），502（Bad Gateway，错误网关）。

输入描述：

多组输入，一行，一个整数（100~600），表示HTTP状态码。

输出描述：

针对每组输入的HTTP状态，输出该状态码对应的含义，具体对应如下：
200-OK
202-Accepted
400-Bad Request
403-Forbidden
404-Not Found
500-Internal Server Error
502-Bad Gateway

#include 
int main()
{
	int n = 0;
	while (~scanf("%d", &n))
	{
		if (n == 200){
            printf("OK\n");
        }else if (n == 202){
            printf("Accepted\n");
        }else if (n == 400){
            printf("Bad Request\n");
        }else if (n == 403){
            printf("Forbidden\n");
        }else if (n == 404){
            printf("Not Found\n");
        }else if (n == 500){
            printf("Internal Server Error\n");
        }else if (n == 502){
            printf("Bad Gateway\n");
        }else{
            printf("\n");
        }
	}
	return 0;
}

73.数字三角形

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用数字组成的数字三角形图案。

输入描述：

多组输入，一个整数（3~20），表示数字三角形边的长度，即数字的数量，也表示输出行数。

输出描述：

针对每行输入，输出用数字组成的对应长度的数字三角形，每个数字后面有一个空格。

#include 
int main()
{
	int n, i, j;
	while (~scanf("%d", &n))
	{
		for (i = 0; i < n; i++)
		{
			for (j = 1; j <= i + 1; j++)
			{
				printf("%d ", j);
			}
			printf("\n");
		}
	}
	return 0;
}

#include 
int main()
{
    int i, j, n;
    int arr[20] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
    while(~scanf("%d", &n)){
        for(i = 0; i < n; ++i){
            for(j = 0; j <= i; ++j){
                printf("%d ", arr[j]);
            }
            printf("\n");
        }
    }
    return 0;
}

74.公务员面试

描述

公务员面试现场打分。有7位考官，从键盘输入若干组成绩，每组7个分数（百分制），去掉一个最高分和一个最低分，输出每组的平均成绩。

（注：本题有多组输入）

输入描述：

每一行，输入7个整数（0~100），代表7个成绩，用空格分隔。

输出描述：

每一行，输出去掉最高分和最低分的平均成绩，小数点后保留2位，每行输出后换行。

#include 
int main()
{
	int arr[7];
	while (~scanf("%d %d %d %d %d %d %d", &arr[0], &arr[1], &arr[2], &arr[3], &arr[4], &arr[5], &arr[6]))
	{
		int max = 0;
		int min = 100;
		int i = 0;
		float sum = 0;
		for (i = 0; i < 7; i++)
		{
			if (arr[i] > max)
				max = arr[i];
			if (arr[i] < min)
				min = arr[i];
		}
		printf("%.2f\n", (arr[0] + arr[1] + arr[2] + arr[3] + arr[4] + arr[5] + arr[6] - max - min) / 5.0);
	}
	return 0;
}

#include 
#include 
int cmp(const void *pa, const void *pb){
    return *(int *)pa - *(int *)pb;
}
int main()
{
    int arr[7], i, sum = 0;
    for(i = 0; i < 7; ++i){
        scanf("%d ", &arr[i]);
    }
    qsort(arr, 7, sizeof(int), cmp);
    for(i = 1; i < 6; ++i){
        sum += arr[i];
    }
    printf("%.2f", sum / 5.0);
    return 0;
}
//使用快速排序函数将元素的大小进行排序，将除去第一个和最后一个其余的全部加起来除以5

75.有序序列插入一个数

描述

有一个有序数字序列，从小到大排序，将一个新输入的数插入到序列中，保证插入新数后，序列仍然是升序。

输入描述：

第一行输入一个整数(0≤N≤50)。

第二行输入N个升序排列的整数，输入用空格分隔的N个整数。

第三行输入想要进行插入的一个整数。

输出描述：

输出为一行，N+1个有序排列的整数。

#include 
#include 
int cmp(const void *pa, const void *pb){
    return *(int *)pa - *(int *)pb;
}
int main()
{
    int n, arr[50] = { 0 }, i;
    scanf("%d", &n);
    for(i = 0; i < n; ++i){
        scanf("%d", &arr[i]);
    }
    scanf("%d", &arr[n]);
    qsort(arr, n + 1, sizeof(int), cmp);
    for(i = 0; i <= n; ++i){
        printf("%d ", arr[i]);
    }
    return 0;
}
//将全部的元素读取后，利用排序函数进行排序，将全部的元素打印出来

76.筛选法求素数

描述

用筛选法求n以内的素数。筛选法求解过程为：将2~n之间的正整数放在数组内存储，将数组中2之后的所有能被2整除的数清0，再将3之后的所有能被3整除的数清0 ，以此类推，直到n为止。数组中不为0 的数即为素数。

输入描述：

多组输入，每行输入一个正整数（不大于100）。

输出描述：

针对每行输入的整数n，输出两行，第一行，输出n之内（包括n）的素数，用空格分隔，

第二行，输出数组中2之后被清0 的个数。每行输出后换行。

#include 
#include 
int main()
{
	int n, i, j;
	while (~scanf("%d", &n))
	{
		int count = 0;
		for (i = 2; i <= n; i++){
			for (j = 2; j <= i; j++){
				if (i % j == 0)
					break;
			}
			if (i == j)
			{
				printf("%d ", i);
				count++;
			}
		}
		printf("\n");
		printf("%d\n", n - 1 - count);
	}
	return 0;
}

#include 
int is_prine(int i){
    int j;
    for(j = 2; j < i; ++j){                  //写一个函数，用来判断是不是素数，如果是，返回1，否则返回0
        if(i % j == 0)
            return 0;
    }
    return 1;
}
int main()
{
    int i, n, cnt;
    while(~scanf("%d", &n)){
        cnt = n - 1;
        for(i = 2; i <= n; ++i){
            if(is_prine(i) == 1){
                printf("%d ", i);
                cnt--;
            }
        }
        printf("\n%d ", cnt);
    }
    return 0;
}

77.图像相似度

描述

给出两幅相同大小的黑白图像（用0-1矩阵）表示，求它们的相似度。若两幅图像在相同位置上的像素点颜色相同，则称它们在该位置具有相同的像素点。两幅图像的相似度定义为相同像素点数占总像素点数的百分比。

输入描述：

第一行包含两个整数m和n，表示图像的行数和列数，用单个空格隔开。1≤m≤100, 1≤n≤100。之后m行，每行n个整数0或1，表示第一幅黑白图像上各像素点的颜色，相邻两个数用单个空格隔开。之后m行，每行n个整数0或1，表示第二幅黑白图像上各像素点的颜色，相邻两个数用单个空格隔开。

输出描述：

一个实数，表示相似度(以百分比的形式给出)，精确到小数点后两位。

#include 
int main()
{
	int m = 0;
	int n = 0;
	float count = 0.0;
	int i, j;
	int arr1[100][100];
	int arr2[100][100];
	scanf("%d %d", &m, &n);
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < n; j++)
		{
			scanf("%d", &arr1[i][j]);
		}
	}
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < n; j++)
		{
			scanf("%d", &arr2[i][j]);
		}
	}
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < n; j++)
		{
			if (arr1[i][j] == arr2[i][j])
				count++;
		}
	}
	printf("%.2f", (100*count) / ( m * n));
	return 0;
}

#include 
int main()
{
    int arr[100][100];
    int x, y, i, j, a;
    float cnt = 0.00;
    scanf("%d %d", &x, &y);
    for(i = 0; i < x; ++i){
        for(j = 0; j < y; ++j){
            scanf("%d", &arr[i][j]);
        }
    }
    for(i = 0; i < x; ++i){
        for(j = 0; j < y; ++j){
            scanf("%d ", &a);
                if(a == arr[i][j])
                    cnt++;
        }
    }
    printf("%.2f", (100 * cnt) / (x * y));
    return 0;
}

78.登记验证

描述

有个软件系统登录的用户名和密码为（用户名：admin，密码：admin），用户输入用户名和密码，判断是否登录成功。

输入描述：

多组测试数据，每行有两个用空格分开的字符串，第一个为用户名，第二个位密码。

输出描述：

针对每组输入测试数据，输出为一行，一个字符串（“Login Success!”或“Login Fail!”）。

#include 
#include 
int main()
{
	char a[6], b[6];
	while (~scanf("%s %s", &a, &b))
	{
		if (strcmp(a,"admin") == 0){
			if (strcmp(b, "admin") == 0){
				printf("Login Success!\n");
			}else{
                printf("Login Fail!\n");
            }
		}else{
                printf("Login Fail!\n");
        }
	}
	return 0;
}

#include 
#include 
int main()
{
    char arr1[6], arr2[6];
    while(~scanf("%s %s", arr1, arr2)){
        if(strcmp(arr1,"admin") == 0 && strcmp(arr2, "admin") == 0)
            printf("Login Success!\n");
        else{
            printf("Login Fail!\n");
        }
    }
    return 0;
}

79.学好C++

描述

C++是带类的C语言，这个“++”主要包含三部分内容：对C语言进行语法上的扩展、面向对象（封装、继承和多态），STL(即模板)。这学期你将学习C++，学好C++，其他编程语言都可以很轻松掌握。

输入描述：

无

输出描述：

I will learn C++ well!

#include 
int main()
{
	printf("I will learn C++ well!\n");
	return 0;
}

80.（a + b - c）* d的计算问题

描述

这是一个非常简单的题目，意在考察你编程的基础能力。千万别想难了哦。输入为一行，包括了用空格分隔的四个整数a、b、c、d（0 < a, b, c, d < 100,000）。输出为一行，为“(a+b-c)*d”的计算结果。

输入描述：

输入为一行，用空格分隔的四个整数a、b、c、d（0 < a, b, c, d < 100,000）。

输出描述：

输出为一行，为“(a+b-c)*d”的计算结果。

#include 
int main()
{
	int a, b, c, d;
	scanf("%d %d %d %d", &a, &b, &c, &d);
	printf("%d\n", (a + b - c) * d);
	return 0;
}

81.被5整除问题

描述

判断一个整数是否能5整除是一个挺简单的问题，懒惰的KiKi还是不想自己做，于是找到你帮他写代码，你就帮帮他吧。

输入描述：

输入包括一个整数M（1≤M≤100,000）。

输出描述：

输出包括一行，如果M可以被5整除就输出YES，否则输出NO（结果大小写敏感）。

#include 
int main()
{
    int a = 0;
    scanf("%d",&a);
    if(0 == a%5){
        printf("YES\n");
    }else{
        printf("NO\n");
    }
    return 0;
}

82.计算y的值

描述

已知一个函数y=f(x)，当x < 0时，y = 1；当x = 0时，y = 0；当x > 0时，y = -1。   

输入描述：

一行，输入一个整数x。（-10000

输出描述：

一行，输出y的值。

#include 
int main()
{
	int num = 0;
	scanf("%d", &num);
	if (num < 0){
		printf("1");
	}else if (num > 0){
		printf("-1");
	}else{
		printf("0");
	}
	return 0;
}

83.包含数字9的数

描述

今年是2019年，KiKi想知道1~2019中有多少个包含数字9的数。包含数字的数是指有某一位是“9”的数，例如“2019”、“199”等。

输入描述：

无

输出描述：

一行，一个整数，表示1~2019中共有多少个数包含数字9。

#include 
int main()
{
	int count = 0, i , m;
	for (i = 1; i <= 2019; i++)
	{
		m = i;
		while (m){
			if (m % 10 == 9){
				count++;
				break;
            }else{
				m /= 10;
			}
		}
	}
	printf("%d\n", count);
	return 0;
}

#include 
int main()
{
    int i, cnt = 0, n;
    for(i = 1; i <= 2019; i++){
        n = i;
        while(n){
            if(n % 10 == 9){
                cnt++;
                break;
            }
            n /= 10;
        }
    }
    printf("%d", cnt);
    return 0;
}

84.奇偶统计

描述

任意输入一个正整数N，统计1~N之间奇数的个数和偶数的个数，并输出。

输入描述：

一行，一个正整数N。（1≤N≤100,000）

输出描述：

一行，1~N之间奇数的个数和偶数的个数，用空格分开。

#include 
int main()
{
	int n = 0;
	scanf("%d", &n);
	if (n % 2 == 0){
		printf("%d %d\n", n / 2, n / 2);
	}
	else{
		printf("%d %d\n", n / 2 + 1, n / 2);
	}
    return 0;
}

85.统计成绩

描述

输入n科成绩（浮点数表示），统计其中的最高分，最低分以及平均分。

数据范围：1 =< n =< 100 ， 成绩使用百分制且不可能出现负数

输入描述：

两行，

第1行，正整数n（1≤n≤100）

第2行，n科成绩（范围0.0~100.0），用空格分隔。

输出描述：

输出一行，三个浮点数，分别表示，最高分，最低分以及平均分（小数点后保留2位），用空格分隔。

#include 
int main()
{
	float arr[100];
	int n = 0;
	float max = 0;
	float sum = 0;
	float min = 100;
	float ave = 0;
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		scanf("%f", &arr[i]);
	}
	for (int i = 0; i < n; i++)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}
		if (arr[i] < min)
		{
			min = arr[i];
		}
		sum += arr[i];
	}
	printf("%.2f %.2f %.2f\n", max, min, sum / n);
	return 0;
}

#include 
#include 

int cmp(const void *pa, const void *pb){
    return *(float *)pa - *(float *)pb;
}

int main()
{
    int n, i;
    float arr[100], sum = 0.0;
    while(~scanf("%d", &n)){
        for(i = 0; i < n; ++i){
            scanf("%f", &arr[i]);
            sum += arr[i];
        }
        qsort(arr, n, sizeof(float), cmp);//排大小
        printf("%.2f %.2f %.2f", arr[n - 1], arr[0], sum / n);
    }
    return 0;
}

86.有序插入一个数

描述

有一个有序数字序列，从小到大排序，将一个新输入的数插入到序列中，保证插入新数后，序列仍然是升序。

输入描述：

共三行，
第一行输入一个整数(0≤N≤50)。
第二行输入N个升序排列的整数，输入用空格分隔的N个整数。
第三行输入想要进行插入的一个整数。

输出描述：

输出为一行，N+1个有序排列的整数。

#include 
int main()
{
	int n = 0;
	int arr[51] = { 0 };
	int c = 0;
	scanf("%d", &n);
	for (int i = 0; i < n; i++)//读取
	{
		scanf("%d", &arr[i]);
	}
	scanf("%d", &c);//读取需要插入的数
	for (int i = n-1; i >= 0; i--)//从最后一个开始，若这个数大于等于比最后一个数，把这个把这个数放在最后面，否则将最后一个往后移动，重新和前面一个比较
	{
		if (c >= arr[i])
		{
			arr[i + 1] = c;
			break;
		}
		else
		{
			int tem = arr[i];
			arr[i] = c;
			arr[i + 1] = tem;
		}
	}
	for (int i = 0; i <= n; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

#include 
#include 
int cmp(const void *pa, const void *pb){
    return *(int *)pa - *(int *)pb;
}
int main()
{
    int N, i;
    scanf("%d", &N);
    int *ret = (int *)malloc(sizeof(int) * (N + 1));//动态分配内存，分配N + 1个内存空间
    for(i = 0; i < N; ++i){
        scanf("%d", &ret[i]);
    }
    scanf("%d", &ret[N]);
    qsort(ret, N + 1, sizeof(int), cmp);//排序函数
    for(i = 0; i <= N; ++i){
        printf("%d ", ret[i]);
    }
    return 0;
}

87.密码验证

描述

用户登录网站，通常需要注册，一般需要输入两遍密码。请编程判断输入的两次密码是否一致，一致输出“same”，不一致输出“different”

输入描述：

每行有两个用空格分开的字符串，第一个为密码，第二个为重复密码。

输出描述：

每组输出一个字符串（“same”或“different”）。

#include 
#include 
int main()
{
	char arr1[100] = { 0 };
	char arr2[100] = { 0 };
	scanf("%s %s", arr1, arr2);
	if (strcmp(arr1, arr2) == 0){
        printf("same\n");
    }else{
		printf("different\n");
    }
	return 0;
}
//strcmp是比较函数，用来比较两个字符串是否相同，返回值为0时，两个字符串相同

88.矩阵计算

描述

输入NxM矩阵，矩阵元素均为整数，计算其中大于零的元素之和。

输入描述：

第一行为N M(N: 矩阵行数；M: 矩阵列数,且M,N<=10)，接下来的N行为矩阵各行。

输出描述：

一行，其中大于零的元素之和。

#include 
int main()
{
	int n, m, sum = 0, arr[10][10] = { 0 };
	scanf("%d %d", &n, &m);
	for (int i = 0; i < n; i++){
		for (int j = 0; j < m; j++){
			scanf("%d", &arr[i][j]);
		}
	}
	for (int i = 0; i < n; i++){
		for (int j = 0; j < m; j++){
			if (arr[i][j] > 0)
				sum += arr[i][j];
		}
	}
	printf("%d\n", sum);
	return 0;
}

#include 
int main()
{
    int i, j, n, m, a, sum = 0;
    scanf("%d %d", &n, &m);
    for(i = 0; i < n; ++i){
        for(j = 0; j < m; ++j){
            scanf("%d ", &a);
            if(a >= 0){
                sum += a;        //大于0的时候加起来
            }
        }
    }
    printf("%d", sum);
    return 0;
}

89.成绩输入输出问题

描述

输入10科成绩，换行显示输入的10科成绩。

输入描述：

一行，输入10科成绩（整数表示，范围0~100），用空格分隔。

输出描述：

一行，输出输入的10科成绩，用空格分隔。

#include 
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	for (i = 0; i < 10; i++){
		scanf("%d", &arr[i]);
	}
	for (i = 0; i < 10; i++){
		printf("%d ", arr[i]);
	}
	return 0;
}

90.逆序输出

描述

输入10个整数，要求按输入时的逆序把这10个数打印出来。逆序输出，就是按照输入相反的顺序打印这10个数。

输入描述：

一行，输入10个整数（范围-231~231-1），用空格分隔。

输出描述：

一行，逆序输出输入的10个整数，用空格分隔。

#include 
int main()
{
	int arr[10];
	int* p = arr;
	for (int i = 0; i < 10; i++){
		scanf("%d", (p + i));
	}
	for (int i = 0; i < 10; i++){
		printf("%d ", *(p + 9 - i));
	}
	return 0;
}

#include 
int main()
{
    int arr[10], i;
    for(i = 0; i < 10; ++i){
        scanf("%d", &arr[i]);
    }
    for(i = 9; i >= 0; --i){
        printf("%d ", arr[i]);
    }
    return 0;
}

91.统计数据正负个数

描述

输入10个整数，分别统计输出正数、负数的个数。

输入描述：

输入10个整数（范围-231~231-1），用空格分隔。

输出描述：

两行，第一行正数个数，第二行负数个数，具体格式见样例。

#include 
int main()
{
	int a[10], positive, negative, *p, *q;
	for (p = a; p <= &a[9]; p++){
		scanf("%d", p);
	}
	for (q = a,positive =0,negative =0;q <= &a[9]; q++){
		if (*q > 0){
            positive++;
        }else if (*q < 0){
            negative++;
        }else{
            ;
        }
	}
	printf("positive:%d\nnegative:%d\n", positive, negative);
	return 0;
}

#include 
int main()
{
    int i, positive = 0, negative = 0, a;
    for(i = 0; i < 10; ++i){
        scanf("%d", &a);
        if(a > 0){
            positive++;
        }else if (a < 0){
            negative++;
        }else{
            ;
        }
    }
    printf("positive:%d\nnegative:%d", positive, negative);
    return 0;
}

92.N个数之和

描述

输入数字N，然后输入N个数，计算这N个数的和。

输入描述：

第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。

输出描述：

输出为一行，为第二行输入的“N个整数之和”的计算结果。

#include 
int main()
{
	int N, a[50] = { 0 }, sum = 0;
	scanf("%d", &N);
	for (int i = 0; i < N; i++){
		scanf("%d", &a[i]);
		sum += a[i];
	}
	printf("%d", sum);
	return 0;
}

#include 
int main()
{
    int N, a, i, sum = 0;
    scanf("%d", &N);
    for(i = 0; i < N; ++i){
        scanf("%d", &a);
        sum += a;
    }
    printf("%d", sum);
    return 0;
}

93.最高分与最低分之差

描述

输入n个成绩，换行输出n个成绩中最高分数和最低分数的差。

输入描述：

两行，第一行为n，表示n个成绩，不会大于10000。

第二行为n个成绩（整数表示，范围0~100），以空格隔开。

输出描述：

一行，输出n个成绩中最高分数和最低分数的差。

#include 
int main()
{
	int n, max = 0, min = 100, a[10000];
	scanf("%d", &n);
	for (int i = 0; i < n; i++){
		scanf("%d", &a[i]);
		if (a[i] > max)
			max = a[i];
		if (a[i] < min)
			min = a[i];
	}
	printf("%d", max - min);
	return 0;
}

#include 
#include 
int cmp(const void *pa, const void *pb){
    return *(int *)pa - *(int *)pb;
}
int main()
{
    int n, i, j, a[10000];
    scanf("%d", &n);
    for(i = 0; i < n; ++i){
        scanf("%d", &a[i]);
    }
    qsort(a, n, sizeof(int), cmp);
    printf("%d", a[n - 1] - a[0]);
    return 0;
}

94.有序序列判断

描述

输入一个整数序列，判断是否是有序序列，有序，指序列中的整数从小到大排序或者从大到小排序(相同元素也视为有序)。

数据范围： 3 =< n <= 50 序列中的值都满足  

输入描述：

第一行输入一个整数N(3≤N≤50)。

第二行输入N个整数，用空格分隔N个整数。

输出描述：

输出为一行，如果序列有序输出sorted，否则输出unsorted。

#include 
int main()
{
	int n;
	int a[50];
	int sorted = 0, unsorted = 0;
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &a[i]);
	}
	for (int i = 0; i < n - 1; i++)
	{
		if (a[i] <= a[i + 1])
			sorted++;
		if (a[i] >= a[i + 1])
			unsorted++;
	}
	if ((sorted == n - 1) || (unsorted == n - 1))
		printf("sorted\n");
	else
		printf("unsorted\n");
	return 0;
}
//当前两个元素按升序排时,sorted自增，当两个元素按降序排列时，unsorted自增，当sort 或 unsorted 为 n - 1时，为有序，否则无序

#include 
int cmp1 (const void *pa, const void *pb){
    return *(int *)pa - *(int *)pb;
}
int cmp2 (const void *pa, const void *pb){
    return *(int *)pb - *(int *)pa;
}
int main()
{
    int arr[50], i, j, n, a = 0;
    scanf("%d", &n);
    for(i = 0; i < n; ++i){
        scanf("%d", &arr[i]);
    }
    int *ret = (int *)malloc(sizeof(int) * n);
    int *oth = (int *)malloc(sizeof(int) * n);
    for(i = 0; i < n; ++i){
        ret[i] = oth[i] = arr[i];
    }
    qsort(ret, n, sizeof(int), cmp1);
    qsort(oth, n, sizeof(int), cmp2);
    if(arr[0] == ret[0]){
        for(i = 1; i < n; ++i){
            if(arr[i] != ret[i]){
                a = 1;
                break;
            }
        }
    }else{
        for(i = 0; i < n; ++i){
            if(arr[i] != oth[i]){
                a = 1;
                break;
            }
        }
    }
    if(a == 1){
        printf("unsorted");
    }else {
        printf("sorted");
    }
    return 0;
}
//设置两个比较函数，分别和递增和递减比，若相同，则有序，否则无序

95.有序序列插入一个整数

描述

有一个有序数字序列，从小到大排序，将一个新输入的数插入到序列中，保证插入新数后，序列仍然是升序。

输入描述：

第一行输入一个整数N(0≤N≤50)。

第二行输入N个升序排列的整数，输入用空格分隔的N个整数。

第三行输入想要进行插入的一个整数。

输出描述：

输出为一行，N+1个有序排列的整数

#include 
int main()
{
	int n = 0, b = 0, N[50] = { 0 };
	scanf("%d", &n);
	for (int i = 0; i < n; i++){
		scanf("%d", &N[i]);
	}
	scanf("%d", &b);
	for (int i = n-1; i >= 0; i--){
		if (b >= N[i]){
			N[i + 1] = b;
			break;
		}else{
			N[i + 1] = N[i];
			N[i] = b;
		}
	}
	for (int i = 0; i <= n; i++){
		printf("%d ", N[i]);
	}
	return 0;
}
//先将数字读取，和最后一个比大小，若比最后一个大，放在最后面面，如比最后一个小，则将后面的往后移，在和前面的比大小，迭代

#include 
#include 
int cmp(const void *pa, const void *pb){
    return *(int *)pa - *(int *)pb;
}
int main()
{
    int N, i;
    scanf("%d", &N);
    int *ret = (int *)malloc(sizeof(int) * (N + 1));
    for(i = 0; i < N; ++i){
        scanf("%d", &ret[i]);
    }
    scanf("%d", &ret[N]);
    qsort(ret, N + 1, sizeof(int), cmp);
    for(i = 0; i <= N; ++i){
        printf("%d ", ret[i]);
    }
    return 0;
}

96.序列中删除指定数字

描述

有一个整数序列（可能有重复的整数），现删除指定的某一个整数，输出删除指定数字之后的序列，序列中未被删除数字的前后位置没有发生改变。

数据范围：序列长度和序列中的值都满足 1 \le n \le 501≤n≤50

输入描述：

第一行输入一个整数(0≤N≤50)。

第二行输入N个整数，输入用空格分隔的N个整数。

第三行输入想要进行删除的一个整数。

输出描述：

输出为一行，删除指定数字之后的序列。

#include 
int main()
{
	int n = 0;
	int i = 0;
	int k = 0;
	int arr[50] = { 0 };
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		scanf("%d", &arr[i]);
	}
	scanf("%d", &k);
	for (i = 0; i < n; i++)
	{
		if (arr[i] != k)
		{
			printf("%d ", arr[i]);
		}
	}
	return 0;
}
//删除指定数字，当有那个数字时，不打印
//投机//

#include 
int main()
{
    int n, i, j, m;
    scanf("%d", &n);
    int *ret = (int *)malloc(sizeof(int) * n);//动态分配n块空间
    for(i = 0; i < n; ++i){
        scanf("%d", &ret[i]);   //将读取的数存在空间内
    }
    scanf("%d", &m);
    for(i = 0; i < n; ++i){ 
        if(ret[i] == m){                 //如果数和数组的数相同时，将这个数后面的数往前移动一位，然后i自减，n也自减，在这个位置的数和m重新比较
            for(j = i; j < n; ++j){
                ret[j] = ret[j + 1];
            }
            i--;
            n--;
        }
    }
    for(i = 0; i < n; ++i){
        printf("%d ", ret[i]);
    }
//打印出n个数
    return 0;
}

97.序列中整数去除

描述

输入n个整数的序列，要求对这个序列进行去重操作。所谓去重，是指对这个序列中每个重复出现的整数，只保留该数第一次出现的位置，删除其余位置。

输入描述：

输入包含两行，第一行包含一个正整数n（1 ≤ n ≤ 1000），表示第二行序列中数字的个数；第二行包含n个整数（范围1~5000），用空格分隔。

输出描述：

输出为一行，按照输入的顺序输出去重之后的数字，用空格分隔。

投机
#include 
int main()
{
	int n = 0;
	int a[1000] = { 0 };
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &a[i]);
	}
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < i; j++)
		{
			if (a[j] == a[i])
				a[i] = 0;
		}
	}
	for (int i = 0; i < n; i++)
	{
		if (a[i] != 0)
			printf("%d ", a[i]);
	}
	return 0;
}

#include 
int main()
{
    int n, i, j;
    scanf("%d", &n);
    int *ret = (int *)malloc(sizeof(int) * n);
    for(i = 0; i < n; ++i){
        scanf("%d", &ret[i]);
    }
    for(i = 0; i < n; ++i){
        for(j = i + 1; j < n; ++j){
            if(ret[j] == ret[i])
                ret[j] = 0;
        }
    }
    for(i = 0; i < n; ++i){
        if(!ret[i]){
            for(j = i; j < n; ++j){
                ret[j] = ret[j + 1];
            }
            i--;
            n--;
        }
    }
    for(i = 0; i < n; ++i){
        printf("%d ", ret[i]);
    }
    return 0;
}
//先选定数组中的一个数，若后面的数有和这个数相同的，则把那个数赋值为0，
//第二次循环时，若找到一个为0的数时，则将这个数后面的数全部往前移动一位

98.有序序列合并

描述

输入两个升序排列的序列，将两个序列合并为一个有序序列并输出。数据范围： 1 =< n, m =< 1000 ， 序列中的值满足  

输入描述：

输入包含三行，
第一行包含两个正整数n, m，用空格分隔。n表示第二行第一个升序序列中数字的个数，m表示第三行第二个升序序列中数字的个数。
第二行包含n个整数，用空格分隔。
第三行包含m个整数，用空格分隔。

输出描述：

输出为一行，输出长度为n+m的升序序列，即长度为n的升序序列和长度为m的升序序列中的元素重新进行升序序列排列合并。

#include 
int main()
{
	int n, m, i, j;
	int arr[2000] = { 0 };
	scanf("%d %d", &n, &m);
	for (i = 0; i < n; i++)
	{
		scanf("%d", &arr[i]);
	}
	for (i = 0; i < m; i++)
	{
		scanf("%d", &arr[n + i]);
	}
	for (i = 1; i < m + n; i++)
	{
		for (j = 0; j < m + n - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tem = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = tem;
		    }
		}
	}
	for (i = 0; i < m + n; i++)
	{
		printf("%d ",arr[i]);
	}
	return 0;
}
//使用冒牌排序，将这两个数组中的元素进行排序
//冒泡排序：(n个数)
//     相邻两个元素比较大小，将大的放在右边，小的放在左边，进行 (n - 1) * (n) / 2 次循环之后，得到从小到大的排序
//     相邻两个元素比较大小，将大的放在左边，小的放在右边，则得到的是从大到小排序

#include 
#include 
int cmp(const void *pa, const void *pb){
    return *(int *)pa - *(int *)pb;
}
int main()
{
    int n, m, i, j;
    scanf("%d %d", &n, &m);
    int *ret = (int *)malloc(sizeof(int) * (n + m));
    for(i = 0; i < n; ++i){
        scanf("%d", &ret[i]);
    }
    for(i = 0; i < m; ++i){
        scanf("%d", &ret[n + i]);
    }
    qsort(ret, n + m, sizeof(int), cmp);
    for(i = 0; i < m+ n; ++i){
        printf("%d ", ret[i]);
    }
    return 0;
}
//动态分配 n + m 块内存

//将他们读取在同一个数组内，使用快速排序（库函数自带）

99.班级成绩输入输出

描述

输入一个班级5个学生各5科成绩，输出5个学生各5科成绩及总分。

输入描述：

五行，每行输入一个学生各5科成绩（浮点数表示，范围0.0~100.0），用空格分隔。

输出描述：

五行，按照输入顺序每行输出一个学生的5科成绩及总分（小数点保留1位），用空格分隔。

#include 
int main()
{
	float stu[5][6] = { 0 };
	int i, j;
	float sum = 0;
	for (i = 0; i < 5; i++)
	{
		sum = 0;
		for (j = 0; j < 5; j++)
		{
			scanf("%f", &stu[i][j]);
			sum += stu[i][j];
		}
		stu[i][5] = sum;
	}
	for (i = 0; i < 5; i++)
	{
		for (j = 0; j < 6; j++)
		{
			printf("%.1f ", stu[i][j]);
		}
		printf("\n");
	}
	return 0;
}

//创建一个二维数组，5行6列，
//前五列存分数，后一列放总和

100.矩阵元素定位

描述

KiKi得到了一个n行m列的矩阵，现在他想知道第x行第y列的值是多少，请你帮助他完成这个任务。

数据范围：1 =< n, m =< 5 ，矩阵中的值满足 1 =< val =< 25

输入描述：

第一行包含两个数n和m，表示这个矩阵包含n行m列。从2到n+1行，每行输入m个整数（范围-231~231-1），用空格分隔，共输入n*m个数，表示矩阵中的元素。接下来一行输入x和y，用空格分隔，表示KiKi想得到的元素的位置。(1≤x≤n≤10，1≤y≤m≤10)

输出描述：

一行，输出一个整数值，为KiKi想知道的值。

#include 
int main()
{
	int n, m, x, y, i, j;
	int arr[5][5];
	scanf("%d %d", &n, &m);
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < m; j++)
		{
			scanf("%d", &arr[i][j]);
		}
	}
	scanf("%d %d", &x, &y);
	printf("%d", arr[x - 1][y - 1]);
	return 0;
}
//数组的下标是从0开始

101.序列重组矩阵

描述

KiKi现在得到一个包含n*m个数的整数序列，现在他需要把这n*m个数按顺序规划成一个n行m列的矩阵并输出，请你帮他完成这个任务。

输入描述：

一行，输入两个整数n和m，用空格分隔，第二行包含n*m个整数（范围-231~231-1）。(1≤n≤10, 1≤m≤10)

输出描述：

输出规划后n行m列的矩阵，每个数的后面有一个空格。

#include 
int main()
{
	int n, m, i, j;
	int arr[100] = { 0 };
	scanf("%d %d", &n, &m);
	for (i = 0; i < m * n; i++)
	{
		scanf("%d", &arr[i]);
	}
	int k = 0;
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < m; j++)
		{
			printf("%d ", arr[k]);
			k++;
		}
		printf("\n");
	}
	return 0;
}

#include 
int main()
{
    int n, m, i, j;
    scanf("%d %d", &n, &m);
    int **ret = (int **)malloc(sizeof(int *) * n);
    for(i = 0; i < n; ++i){
        ret[i] = (int *)malloc(sizeof(int *) * m);
    }
    for(i = 0; i < n; ++i){
        for(j = 0; j < m; ++j){
            scanf("%d", &ret[i][j]);
        }
    }
    for(i = 0; i < n; ++i){
        for(j = 0; j < m; ++j){
            printf("%d ", ret[i][j]);
        }
        printf("\n");
    }
    return 0;
}
//采用动态分配内存，分配一块二维数组的内存
//动态分配二维数组内存:
//      先开辟n块内存，每个内存放的是地址，
//      再在那个位置开辟m个内存，每个空间放目标元素

102.最高身高

描述

KiKi想从n行m列的方阵队列中找到身高最高的人的位置，请你帮助他完成这个任务。

输入描述：

第一行包含两个整数n和m，表示这个方阵队列包含n行m列。从2到n+1行，每行输入m个整数（范围-231~231-1），用空格分隔，共输入n*m个数，表示方阵中的所有人的身高（保证输入身高都不相同）。(1≤x≤n≤10，1≤y≤m≤10)

输出描述：

一行，输出两个整数，用空格分隔，表示方阵中身高最高的人所在的行号和列号。

#include 
int main()
{
	int n, m, i, j, x = 0, y = 0;
	int arr[10][10];
	int max = 0;
	scanf("%d %d", &n, &m);
//读取 n * m 个数字
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < m; j++)
		{
			scanf("%d", &arr[i][j]);
		}
	}
//查找最大的数
	for (i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (arr[i][j] > max)
				max = arr[i][j];
		}
	}
//找到最大值的下标
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < m; j++)
		{
			if (arr[i][j] == max)
				goto a;
		}
	}
	a:
	printf("%d %d", i+1, j+1);
	return 0;
}

#include 
int main()
{
    int n, m, i, j, max = 0, x, y;
    scanf("%d %d", &n, &m);
    int **ret = (int **)malloc(sizeof(int *) * n);
    for(i = 0; i < n; ++i){
        ret[i] = (int *)malloc(sizeof(int) * m);//动态分配二维数组
    }
    for(i = 0; i < n; ++i){
        for(j = 0; j < m; ++j){
            scanf("%d", &ret[i][j]);
            if(ret[i][j] > max){
                x = i + 1;            // 找到最大值， 并存储他的下标
                y = j + 1;
            }
        }
    }
    printf("%d %d\n", x, y);
    return 0;
}

103.矩阵相等判定

描述

KiKi得到了两个n行m列的矩阵，他想知道两个矩阵是否相等，请你回答他。(当两个矩阵对应数组元素都相等时两个矩阵相等)。

输入描述：

第一行包含两个整数n和m，表示两个矩阵包含n行m列，用空格分隔。

从2到n+1行，每行输入m个整数（范围-231~231-1），用空格分隔，共输入n*m个数，表示第一个矩阵中的元素。

从n+2行到2n+1，每行输入m个整数（范围-231~231-1），用空格分隔，共输入n*m个数，表示第二个矩阵中的元素。

1 < n,m < 10

输出描述：

一行，如果两个矩阵相等输出"Yes"并换行，否则输出"No"并换行。

#include 
int main()
{
	int n, m, i, j;
	int arr1[10][10] = { 0 };
	int arr2[10][10] = { 0 };
	scanf("%d %d", &n, &m);
//读取第一个数组
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < m; j++)
		{
			scanf("%d", &arr1[i][j]);
		}
	}
//读取第二个数组
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < m; j++)
		{
			scanf("%d", &arr2[i][j]);
		}
	}
//判断两个数组是否相等，如果不相等，则打印no并跳转
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < m; j++)
		{
			if (arr1[i][j] != arr2[i][j])
			{
				printf("No\n");
				goto a;
			}
		}
	}
	printf("Yes\n");
	a:
	return 0;
}

#include 
//生成二维数组函数
int **mymalloc(int n, int m){
    int i;
    int **ret = (int **)malloc(sizeof(int *) * n);
    for(i = 0; i < n; ++i){
        ret[i] = (int *)malloc(sizeof(int) * m);
    }
    return ret;
}
int main()
{
    int n, m, i, j, flag = 1;
    scanf("%d %d", &n, &m);
    int **ret1, **ret2;
    ret1 = mymalloc(n, m);
    ret2 = mymalloc(n, m);
    for(i = 0; i < n; ++i){
        for(j = 0; j < m; ++j){
            scanf("%d", &ret1[i][j]);
        }
    }
    for(i = 0; i < n; ++i){
        for(j = 0; j < m; ++j){
            scanf("%d", &ret2[i][j]);
        }
    }
    for(i = 0; i < n; ++i){
        for(j = 0; j < m; ++j){
            if(ret1[i][j] != ret2[i][j])
                flag = 0; //若两个数存在不同的，令flag为0，否则为1
        }
    }
    if(flag == 1){
        printf("Yes\n");
    } else{
        printf("No\n");
    }
    return 0;
}

104.上三角矩阵判定

描述

KiKi想知道一个n阶方矩是否为上三角矩阵，请帮他编程判定。上三角矩阵即主对角线以下的元素都为0的矩阵，主对角线为从矩阵的左上角至右下角的连线。

输入描述：

第一行包含一个整数n，表示一个方阵包含n行n列，用空格分隔。 (1≤n≤10)

从2到n+1行，每行输入n个整数（范围-231~231-1），用空格分隔，共输入n*n个数。

输出描述：

一行，如果输入方阵是上三角矩阵输出"YES"并换行，否则输出"NO"并换行。

#include 
int main()
{
	int n = 0;
	int arr1[10][10] = { 0 };
	int i, j;
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			scanf("%d", &arr1[i][j]);
		}
	}
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < i; j++)
		{
			if (arr1[i][j] != 0)
			{
				printf("NO\n");
				goto a;                      //如果主对角线下存在不是0的元素，则不是上三角矩阵
			}
		}
	}
	printf("YES\n");
	a:
	return 0;
}

#include 
int main()
{
    int n, i, j, flag = 1;
    scanf("%d", &n);
    int **ret = (int **)malloc(sizeof(int *) * n);
    for(i = 0; i < n; ++i){
        ret[i] = (int *)malloc(sizeof(int) * n);
    }
    for(i = 0; i < n; ++i){
        for(j = 0; j < n; ++j){
            scanf("%d", &ret[i][j]);
            if(j < i && ret[i][j] != 0)
                flag = 0;
        }
    }
    if(flag == 0){
        printf("NO\n");
    }else {
        printf("YES\n");
    }
    return 0;
}

105.矩阵转置

描述

KiKi有一个矩阵，他想知道转置后的矩阵（将矩阵的行列互换得到的新矩阵称为转置矩阵），请编程帮他解答。

输入描述：

第一行包含两个整数n和m，表示一个矩阵包含n行m列，用空格分隔。 (1≤n≤10,1≤m≤10)

从2到n+1行，每行输入m个整数（范围-231~231-1），用空格分隔，共输入n*m个数，表示第一个矩阵中的元素。

输出描述：

输出m行n列，为矩阵转置后的结果。每个数后面有一个空格。

#include 
int main()
{
	int n = 0;
	int m = 0;
	int i = 0;
	int j = 0;
	scanf("%d %d", &n, &m);
	int arr[10][10] = { 0 };
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < m; j++)
		{
			scanf("%d", &arr[i][j]);
		}
	}
	for (j = 0; j < m; j++)
	{
		for (i = 0; i < n; i++)
		{
			printf("%d ", arr[i][j]);     //答应第j列的元素
		}
		printf("\n");
	}
	return 0;
}

#include 
int **mymalloc(int n, int m){
    int **ret = (int **)malloc(sizeof(int *) * n);
    int i;
    for(i = 0; i < n; ++i){
        ret[i] = (int *)malloc(sizeof(int) * m);
    }
    return ret;
}
int main()
{
    int n, m, i, j;
    int **ret1, **ret2;
    scanf("%d %d", &n, &m);
    ret1 = mymalloc(n, m);
    ret2 = mymalloc(m, n);
    for(i = 0; i < n; ++i){
        for(j = 0; j < m; ++j){
            scanf("%d", &ret1[i][j]);
            ret2[j][i] = ret1[i][j];
        }
    }
    for(i = 0; i < m; ++i){
        for(j = 0; j < n; ++j){
            printf("%d ", ret2[i][j]);
        }
        printf("\n");
    }
    return 0;
}

106.矩阵交换

描述

KiKi有一个矩阵，他想知道经过k次行变换或列变换后得到的矩阵。请编程帮他解答。

输入描述：

第一行包含两个整数n和m，表示一个矩阵包含n行m列，用空格分隔。 (1≤n≤10,1≤m≤10)

从2到n+1行，每行输入m个整数（范围-231~231-1），用空格分隔，共输入n*m个数，表示第一个矩阵中的元素。

接下来一行输入k，表示要执行k次操作（1≤k≤5）。接下来有k行，每行包括一个字符t和两个数a和b，中间用空格格分隔，t代表需要执行的操作，当t为字符'r'时代表进行行变换，当t为字符'c'时代表进行列变换，a和b为需要互换的行或列（1≤a≤b≤n≤10，1≤a≤b≤m≤10）。

提示：当t为别的字符时不需要处理

输出描述：

输出n行m列，为矩阵交换后的结果。每个数后面有一个空格。

#include 
int main()
{
	int n, m, i, j, k, z, c, d;
	char t;
	int a[10][10] = { 0 };
	scanf("%d %d", &n, &m);
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < m; j++)
		{
			scanf("%d", &a[i][j]);
		}
	}
	scanf("%d", &k);
	for (z = 0; z < k; z++)
	{
		scanf(" %c%d%d", &t, &c, &d);
		if (t == 'r')
		{
			for (i = 0; i < m; i++)
			{
				int tem = a[c-1][i];
				a[c-1][i] = a[d-1][i];
				a[d-1][i] = tem;
			}

		}
		else if (t == 'c')
		{
			for (i = 0; i < n; i++)
			{
				int tem = a[i][c-1];
				a[i][c-1] = a[i][d-1];
				a[i][d-1] = tem;
			}
		}
		else
		{
			;
		}
	}
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < m; j++)
		{
			printf("%d ", a[i][j]);
		}
		printf("\n");
	}
	return 0;
}

include 
int main()
{
    int n, m, a, b, i, j, c, tem;
    char t;
    scanf("%d %d", &n, &m);
    int **ret = (int **)malloc(sizeof(int *) * n);
    for(i = 0; i < n; ++i){
        ret[i] = (int *)malloc(sizeof(int) * m);
        for(j = 0; j < m; ++j){
            scanf("%d", &ret[i][j]);
        }
    }
    scanf("%d", &c);
    while(c--){
        scanf(" %c %d %d", &t, &a, &b);// 将换行符消去，防止读取错误
        if(t == 'r'){
            for(i = 0; i < m; ++i){
                tem = ret[a - 1][i];
                ret[a - 1][i] = ret[b - 1][i];
                ret[b - 1][i] = tem;
            }
        }else if(t == 'c') {
            for(i = 0; i < n; ++i){
                tem = ret[i][a - 1];
                ret[i][a - 1] = ret[i][b - 1];
                ret[i][b - 1] = tem;
            }
        }else{
            ;
        }
    }
    for(i = 0; i < n; ++i){
        for(j = 0; j < m; ++j){
            printf("%d ", ret[i][j]);
        }
        printf("\n");
    }
    return 0;
}

107.杨辉三角形

描述

KiKi知道什么叫杨辉三角之后对杨辉三角产生了浓厚的兴趣，他想知道杨辉三角的前n行，请编程帮他解答。杨辉三角，本质上是二项式(a+b)的n次方展开后各项的系数排成的三角形。其性质包括：每行的端点数为1， 一个数也为1；每个数等于它左上方和上方的两数之和。

输入描述：

第一行包含一个整数数n。 (1≤n≤30)

输出描述：

包含n行，为杨辉三角的前n行，每个数输出域宽为5。

#include 
#include 
int main()
{
	int n = 0;
	int arr[30] = { 1 };
	scanf("%d", &n);
	printf("    1\n");
	for (int i = 1; i < n; i++)
	{
		for(int j = i; j >= 1; j--) {
			arr[j] = arr[j] + arr[j - 1];
		}
		for(int j = 0; j <= i; j++)
		{
			printf("%5d", arr[j]);//%5d  是宽度为5，右对齐
		}
		printf("\n");
	}
	return 0;
}

#include 
#include 
int **mymalloc(int n){
    int i;
    int **ret = (int **)malloc(sizeof(int *) * n);
    for(i = 0; i < n; ++i){
        ret[i] = (int *)malloc(sizeof(int) *(i + 1));
    }
    return ret;
}
int main()
{
    int n, **ret, i, j;
    scanf("%d", &n);
    ret = mymalloc(n);
    for(i = 0; i < n; ++i){
        ret[i][0] = ret[i][i] = 1;
        for(j = 1; j < i; ++j){
            ret[i][j] = ret[i - 1][j] + ret[i - 1][j - 1];//杨辉三角公式
        }
    }
    for(i = 0; i < n; ++i){
        for(j = 0; j <= i; ++j){
            printf("%5d", ret[i][j]);
        }
        printf("\n");
    }
    return 0;
}

108.井字棋

描述

KiKi和BoBo玩 “井”字棋。也就是在九宫格中，只要任意行、列，或者任意对角线上面出现三个连续相同的棋子，就能获胜。请根据棋盘状态，判断当前输赢。

输入描述：

三行三列的字符元素，代表棋盘状态，字符元素用空格分开，代表当前棋盘，其中元素为K代表KiKi玩家的棋子，为O表示没有棋子，为B代表BoBo玩家的棋子。

输出描述：

如果KiKi获胜，输出“KiKi wins!”；
如果BoBo获胜，输出“BoBo wins!”；
如果没有获胜，输出“No winner!”。

#include 
char is_win(char board[3][3])
{
	int i, j;
	if (board[0][0] == board[1][1] && board[0][0] == board[2][2] && board[1][1] != 'O')
		return board[0][0];
	if (board[2][0] == board[1][1] && board[1][1] == board[0][2] && board[1][1] != 'O')
		return board[1][1];
	for (i = 0; i < 3; i++)
	{
		if (board[i][0] == board[i][1] && board[i][0] == board[i][2] && board[i][1] != 'O')
			return board[i][0];
	}
	for (i = 0; i < 3; i++)
	{
		if (board[0][i] == board[1][i] && board[0][i] == board[2][i] && board[0][i] != 'O')
			return board[0][i];
	}
	return 'Q';

}
int main()
{
	char board[3][3];
	int i, j;
	for (i = 0; i < 3; i++) 
	{
		for (j = 0; j < 3; j++) 
		{
			scanf(" %c", &board[i][j]);
		}
	}
	char ret = is_win(board);
	if (ret == 'B')
		printf("BoBo wins!\n");
	if (ret == 'K')
		printf("KiKi wins!\n");
	if (ret == 'Q')
		printf("No winner!\n");
	return 0;
}

109.小乐乐与进制转换

描述

小乐乐在课上学习了二进制八进制与十六进制后，对进制转换产生了浓厚的兴趣。因为他的幸运数字是6，所以他想知道一个数表示为六进制后的结果。请你帮助他解决这个问题。

输入描述：

输入一个正整数n  (1 ≤ n ≤ 109)

输出描述：

输出一行，为正整数n表示为六进制的结果

#include 
int main()
{
	int n, count = 0, i;
	int arr[1000];
	scanf("%d", &n);
	if (n == 0)
		printf("0\n");
	while (n)
	{
		count++;
		arr[count] = n % 6;
		n /= 6;
	}
	for (i = count; i > 0; i--)
	{
		printf("%d", arr[i]);
	}
	return 0;
}
//进制转换就是一个数一直除以某个数，记录每次的余数，当商为0时，所得的余数从下到上写

110.小乐乐求和

描述

小乐乐最近接触了求和符号Σ，他想计算

的结果。但是小乐乐很笨，请你帮助他解答。

输入描述：

输入一个正整数n  (1 ≤ n ≤ 109)

输出描述：

输出一个值，为求和结果。 

include 
int main()
{
	long long int n;
	scanf("%lld", &n);
	printf("%lld\n", n * (n + 1) / 2);
	return 0;
}
//自然数的求和公式：(n + 1) * n / 2;

int main()
{
	int n, i;
    long long int sum = 0;
	scanf("%d", &n);
	while (n--) {
		i = n + 1;
		sum += i;
	}
	printf("%lld\n", sum);
	return 0;
}

#include 
int main()
{
	int n, i;
	long long int sum = 0;
	scanf("%d", &n);
	for (i = 1; i <= n; ++i) {
		sum += i;
	}
	printf("%lld\n", sum);
	return 0;
}

111.小乐乐定闹钟

描述

小乐乐比较懒惰，他现在想睡觉，然后再去学习。他知道现在的时刻，以及自己要睡的时长，想设定一个闹钟叫他起床学习，但是他太笨了，不知道应该把闹钟设定在哪个时刻，请你帮助他。(只考虑时和分，不考虑日期)

输入描述：

输入现在的时刻以及要睡的时长k（单位：minute），中间用空格分开。

输入格式：hour:minute k(如hour或minute的值为1，输入为1，而不是01)

(0 ≤ hour ≤ 23，0 ≤ minute ≤ 59，1 ≤ k ≤ 109)

输出描述：

对于每组输入，输出闹钟应该设定的时刻，输出格式为标准时刻表示法（即时和分都是由两位表示，位数不够用前导0补齐）。

#include 
int main()
{
	int hour, minute, k;
	scanf("%d:%d %d", &hour, &minute, &k);
	hour = ((k + minute) / 60 + hour) % 24;//k + minute 表示要睡的分钟， 除以60 表示要睡多少个整小时，除以24表示转换成24小时格式
	minute = (k + minute) % 60;//表示睡多少分钟
	printf("%02d:%02d", hour, minute);
	return 0;
}
//%02d 表示位数不够，用0补齐

112.小乐乐排电梯

描述

小乐乐学校教学楼的电梯前排了很多人，他的前面有n个人在等电梯。电梯每次可以乘坐12人，每次上下需要的时间为4分钟（上需要2分钟，下需要2分钟）。请帮助小乐乐计算还需要多少分钟才能乘电梯到达楼上。（假设最初电梯在1层）

输入描述：

输入包含一个整数n (0 ≤ n ≤ 109)

输出描述：

输出一个整数，即小乐乐到达楼上需要的时间。

#include 
int main()
{
	int n = 0;
	scanf("%d", &n);
	int a = n / 12;//前面需要多少次
	int b = 2 + a * 4;//每次4分钟，再加上最后一次上去的2分钟
	printf("%d", b);
	return 0;
}

113.小乐乐与欧几里得

描述

小乐乐最近在课上学习了如何求两个正整数的最大公约数与最小公倍数，但是他竟然不会求两个正整数的最大公约数与最小公倍数之和，请你帮助他解决这个问题。

输入描述：

每组输入包含两个正整数n和m。(1 ≤ n ≤ 109，1 ≤ m ≤ 109)

输出描述：

对于每组输入，输出一个正整数，为n和m的最大公约数与最小公倍数之和。

#include 
int main()
{
	long long int n, m, d;
	scanf("%lld %lld", &n, &m);
	d = n * m;//存放两个数之和
	while (m)//计算最大公约数，存放在n
	{
		int tem =n % m;
		n = m;
		m = tem;
	}
	printf("%lld", n + d / n);
	return 0;
}
//求最大公约数和最小公倍数的和，先用辗转相处法得到最大公约数，两个数的积除以最大公约数就是最小公倍数

114.小乐乐改数字

描述

小乐乐喜欢数字，尤其喜欢0和1。他现在得到了一个数，想把每位的数变成0或1。如果某一位是奇数，就把它变成1，如果是偶数，那么就把它变成0。请你回答他最后得到的数是多少。

输入描述：

输入包含一个整数n (0 ≤ n ≤ 109)

输出描述：

输出一个整数，即小乐乐修改后得到的数字。

#include 
int main()
{
	int n = 0;
	int a = 0;
	int b = 0;
	int tem = 0;
	scanf("%d", &n);
	for (int i = 1; n != 0; i *= 10)
	{
		tem = n % 10;
		if ((tem % 2) == 1)
			a = 1;
		else
			a = 0;
		b = (a * i) + b;
		n = n / 10;
	}
	printf("%d\n", b);
	return 0;
}
//先判断数的最后一位是奇数或偶数，若是奇数的话 1 * 10 ^ 0, 否则 0 * 10 ^ 0
//然后这个数除以10，继续判断，若是奇数的话 1 * 10 ^ 1 + 上一个数, 否则 0 * 10 ^ 1  + 上一个数

#include 
int main()
{
    long long int n, a, b = 0;
    int i;
    scanf("%d", &n);
    for(i = 1; n != 0; i *= 10, n /= 10){
        if(n & 1 == 1){
            a = 1;
        }else {
            a = 0;
        }
        b = a * i + b;
    }
    printf("%d", b);
    return 0;
}
//若一个数是奇数，则最后一位是奇数；若一个数是偶数，则最后一位是偶数

115.小乐乐走台阶

描述

小乐乐上课需要走n阶台阶，因为他腿比较长，所以每次可以选择走一阶或者走两阶，那么他一共有多少种走法？

输入描述：

输入包含一个整数n (1 ≤ n ≤ 30)

输出描述：

输出一个整数，即小乐乐可以走的方法数。

#include 
int test(int x)
{
	if (x == 1)
		return 1;
	else if (x == 2)
		return 2;
	else
		return test(x - 1) + test(x - 2);
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	printf("%d\n", test(n));
	return 0;
}
//使用递归，第一个台阶有一种走法，第二个台阶有两种走法， 第n个有 n - 1  +   n - 2 种

#include 
int main()
{
    int n, i, a = 1, b = 2, tem;
    scanf("%d", &n);
    if(n == 1){
        b = 1;
    }else if(n == 2){
        b = 2;
    }else{
        for(i = 3; i <= n; ++i){
            tem = b;
            b = a + b;
            a = tem;
        }
    }
    printf("%d", b);
    return 0;
}
//使用迭代，能够减少计算的次数，提高效率

116.小乐乐与排序

描述

老师给了小乐乐一个正整数序列，要求小乐乐把这个序列去重后按从小到大排序。但是老师给出的序列太长了，小乐乐没办法耐心的去重并排序，请你帮助他。

输入描述：

第一行包含一个正整数n，表示老师给出的序列有n个数。接下来有n行，每行一个正整数k，为序列中每一个元素的值。(1 ≤ n ≤ 105，1 ≤ k ≤ n)

输出描述：

输出一行，为去重排序后的序列，每个数后面有一个空格。

#include 
#include 
int main()
{
	int a[100001], n, x, i, j;
	scanf("%d", &n);
	memset(a, 0, sizeof(a));
	for (i = 1; i <= n; i++)
	{
		scanf("%d", &x);//将下标为i为x的数自增
		a[x]++;
	}
	for (i = 1; i <= n; i++)
	{
		if (a[i])               //将下标不为0的数打印出来
			printf("%d ", i);
	}
	return 0;
}

#include 
#include 
int cmp(const void *pa, const void *pb){
    return *(int *)pa - *(int *)pb;
}
int main()
{
    int n, i, j;
    scanf("%d", &n);
    int *ret = (int *)malloc(sizeof(int) * n);
    for(i = 0; i < n; ++i){
        scanf("%d", &ret[i]);
    }
    qsort(ret, n, sizeof(int), cmp);
    for(i = 1; i < n; ++i){
        if(ret[i] == ret[i - 1]){
            for(j = i; j < n; ++j){
                ret[j] = ret[j + 1];
            }
            n--;
            i--;
        }
    }
    for(i = 0; i < n; ++i){
        printf("%d ", ret[i]);
    }
    return 0;
}
//先将数组的元素排序，然后去重

117.小乐乐与字符串

描述

在庆祝祖国母亲70华诞之际，老师给小乐乐出了一个问题。大家都知道China的英文缩写是CHN，那么给你一个字符串s，你需要做的是统计s中子序列“CHN”的个数。

子序列的定义：存在任意下标a < b < c，那么“s[a]s[b]s[c]”就构成s的一个子序列。如“ABC”的子序列有“A”、“B”、“C”、“AB”、“AC”、“BC”、“ABC”。

输入描述：

输入只包含大写字母的字符串s。(1 ≤ length ≤ 8000)

输出描述：

输出一个整数，为字符串s中子序列“CHN”的数量。

#include 
int main()
{
	char ch[8000] = { 0 };
	scanf("%s", ch);
	long long int cnt_c = 0, cnt_h = 0, cnt_n = 0, i;
	for (i = 0; ch[i] != '\0'; i++) {
		if (ch[i] == 'C') {
			cnt_c++;
		}
		if (ch[i] == 'H') {
			cnt_h += cnt_c;
		}
		if (ch[i] == 'N') {
			cnt_n += cnt_h;
		}
	}
	printf("%lld", cnt_n);
	return 0;
}
//统计按顺序能组成CHN的个数，设置三个计数器，分别计算C CH CHN 的个数
//    按照顺序统计C 的个数；当碰到H时，统计CH的个数，CH的个数就等于c * H的个数；当碰到N时，统计CHN的个数，等于CH的个数 * n的个数

118.小乐乐与二段数

描述

小乐乐从老师口中听到了二段数这个名词，想更深入的了解二段数。

二段数是这样的正整数：恰好包含两种不同的十进制数字s和t，s不是0，并且s的所有出现均排列在所有的t的前面。例如，44444411是二段数（s是4，t是1），41、10000000和5555556也是。但4444114和44444都不是二段数。

这时老师问小乐乐：给你一个任意的正整数n，你能求出比n大并且是n的倍数的最小二段数吗？请你帮助小乐乐解答这个问题。

输入描述：

多组输入，每组输入包含一个正整数n (1 ≤ n ≤ 99999)

题目保证测试数据总数不超过500组，当输入n=0时程序结束。

输出描述：

对于每组测试用例，输出正整数n，后面紧跟“: ”，输出答案并换行，即比n大且是n的倍数的最小二段数。

#include 
//判断这个数是不是二段数
int judge(long long n)
{
    int cnt = 1, d, r;//cnt 是计数器，计算不同的数字的个数，d是最后一位数，r的倒数第二位数字
    d = n % 10;
    n /= 10;
    while (n) {
        r = n % 10;
        if (r != d) {
            cnt++;
            if (cnt > 2) {
                break;
            }
            d = r;
        }
        n /= 10;
    }   
    if(cnt == 2){                        // 如果有两个不同的数，返回1，表示这个数是二段数，否则这个数不是二段数
        return 1;
    }else {
        return 0;
    }
}
int main()
{
    long long n, ans, k;
    while (~scanf("%lld", &n) && n != 0) {
        k = 2;
        while(1){
            ans = n * k++;
            if (judge(ans)) {//依次将n的倍数传入函数，判断是不是二段数
                break;
            }
        }
        printf("%lld: %lld\n", n, ans);
    }
    return 0;
}

#include 
int ones[9999], tens[999], n, i, j, k, s, t, api, apj, aps, apt;
//n 代表需要求这个数的二段数
//i 代表这个二段数的位数
//j 代表有j + 1 个 s
//k 进行遍历的j
//s 二段数的第一种数字
//t 二段数的第二种数字
//api 最终打印的位数
//apj 最终打印的s的位数
//aps 最终打印的第一种数字
//apt 最终打印的第二种数字
int ck() {
    int p, r;//用p来存储s，r来存储t
    if (i > 5)
        return 1;
    p = s;
    r = t;
    for (int q = 0; q < j; q++)
        p = p * 10 + s;                   //得到j个s
    for (int q = 0; q < i - j; q++)
        p = p * 10;                       //将这个数扩大 i - j 倍
    for (int q = 1; q < i - j; q++)
        r = r * 10 + t;                   //再得到i - j 个t
    return p + r > n;                     //将这两个数相加和n比大小，大于这个数是返回1，否则返回0；
}
int main() {
    while (scanf("%d", &n), n) {
        printf("%d: ", n);
        if (n == 1) {
            puts("10");
            continue;                    //一的二段数是10
        }
        ones[0] = 1;                  
        tens[0] = 1;
        for (i = 1; i < 9999; i++)
            ones[i] = (ones[i - 1] * 10 + 1) % n;
        for (i = 1; i < 999; i++) 
            tens[i] = tens[i - 1] * 10 % n;                 //进行两个数组的初始化
         
             //i代表总共的位数，先确定i的位数，然后枚举m,然后枚举s；
        for (i = 1, aps = 0, k = 0; i < 9999; i++) {               
            if ((n % 10 == 0 || n % 25 == 0) && i > 11)
                k = i - 11;                               //当一个数是10的倍数或是25的倍数时，当这个二段数的位数大于11时，必有 这个数减11个s，此时t为0
            for (j = k; j < i; j++)
                for (s = 1; s < 10; s++)
                    for (t = 0; t < (n % 10 ? 10 : 1); t++)
                        if (t != s && (((long long)ones[j]) * tens[i - j] * s + (long long)ones[i - j - 1] * t) % n == 0 && ck() && (!aps || s < aps || s == aps  && j > apj && s < apt)) {//当s和t不相等，且是n的倍数，且这个二段数比你大，而且aps不等于0或新的s小于原来的aps或者m的个数比原来的大，且s小于t
                            api = i;            // api 代表一共打印api + 1个位数   api + 1, 最少是两位数
                            apj = j;            // apj 代表打印的第一种数字的个数  apj + 1
                            aps = s;            // aps 代表前apj + 1位是 aps      
                            apt = t;            // apt 代表后api - apj位是 apt
                        }
            if (aps)                     // 当s不为0时，这是一个二段数
                break;
        }
        for (int x = 0; x < apj + 1; x++)
            printf("%d", aps);                   //将apj + 1个s打印出来
        for (int x = 0; x < api - apj; x++) 
            printf("%d", apt);                   //将剩余的位数打印成t
        printf("\n");
    }
    return 0;
}
//m 个 s 和 n 个 t 除以 n 的模  就等于   a[m] * b[n] * s + a[n] * t 除以 n 的模

119.小乐乐学编程

描述

小乐乐的编程老师BoBo，经常告诉小乐乐“学习编程最好的办法就是上机实践，因为你要对计算机下指令，想让计算机帮你干活，就得多和计算机‘交流’，实践才能出真知。”

输入描述：

无

输出描述：

Practice makes perfect!

#include 
int main()
{
    printf("Practice makes perfect!\n");
    return 0;
}

120.小乐乐算平均分

描述

小乐乐输入三科成绩，请编程帮他输出三科成绩总分及平均分。

输入描述：

一行，3科成绩（浮点数），成绩之间用一个空格隔开。

输出描述：

一行，总分和平均分（小数点后保留两位），用一个空格隔开。

#include 
int main ()
{
    double a, b, c, sum, ave;
    scanf("%lf %lf %lf",&a, &b, &c);
    sum = a + b + c;
    ave = sum / 3;
    printf("%.2f %.2f",sum, ave);
    return 0;
}

#include 
int main()
{
    int i;
    double a[3], sum = 0.00;
    for(i = 0; i < 3; ++i){
        scanf("%lf", &a[i]);
        sum += a[i];
    }
    printf("%.2lf %.2f", sum, sum / 3);
    return 0;
}

121.小乐乐找最大数

描述

小乐乐获得4个最大数，请帮他编程找到最大的数。

输入描述：

一行，4个整数，用空格分开。

输出描述：

一行，一个整数，为输入的4个整数中最大的整数。

#include 
int main()
{
	int arr[4] = { 0 };
	int max = 0;
	for (int i = 0; i < 4; i++) {
		scanf("%d", &arr[i]);
		if (arr[i] > max)
			max = arr[i];
	}
	printf("%d\n", max);
	return 0;
}

#include 
#include 
int cmp(const void *pa, const void *pb){
    return *(int *)pa - *(int *)pb;
}
int main()
{
    int i, arr[4];
    for(i = 0; i < 4; ++i){
        scanf("%d", &arr[i]);
    }
    qsort(arr, 4, sizeof(int), cmp);
    printf("%d", arr[3]);
    return 0;
}

122.小乐乐是否别叫家长

描述

小乐乐的班级进行了一次期中考试，考试一共有3门科目：数学，语文，英语，小乐乐的班主任决定给没有通过考核的同学家长开一次家长会，考核的标准是三科平均分不低于60分，所以现在想请你帮忙算一算小乐乐会不会被叫家长。

输入描述：

一行，输入三个整数（表示小乐乐的数学、语文、英语的成绩），用空格分隔。

输出描述：

一行，如果小乐乐会被请家长则输出“YES”，否则输出“NO”。

#include 
int main()
{
	int a, b, c, ave;
	scanf("%d %d %d", &a, &b, &c);
	ave = (a + b + c) / 3;
	if (ave >= 60) {
		printf("NO\n");
	}
	else {
		printf("YES\n");
	}
	return 0;
}

123.小乐乐转换成绩

描述

小乐乐输入百分制成绩，他想将成绩转换成等级制。转换规则为：90-100为’A’，80-89为’B’，70-79为’C’，60-69为’D’，59以下为’E’。如果输入的成绩不在0-100之间，输出’F’。

输入描述：

一行，一个整数表示的成绩。

输出描述：

一行，转换后的等级。

#include 
int main()
{
	int a;
	scanf("%d", &a);
	if (a >= 90 && a <= 100)
		printf("A");
	else if (a >= 80 && a <= 89)
		printf("B");
	else if (a >= 70 && a <= 79)
		printf("C");
	else if (a >= 60 && a <= 69)
		printf("D");
	else if (a >= 0 && a <= 59)
		printf("E");
    else
        printf("F");
	return 0;
}

124.小乐乐算多少人被请家长

描述

小乐乐的班主任想统计一下班级里一共有多少人需要被请家长，三个成绩（语文，数学，外语）平均分低于60的将被请家长，小乐乐想编程帮助班主任算一下有多少同学被叫家长。

输入描述：

共n+1行
第一行，输入一个数n，代表小乐乐的班级中有n个同学。
在接下来的n行中每行输入三个整数代表班级中一个同学的三科成绩（语文，数学，外语），用空格分隔。

输出描述：

一行，一个整数，代表班级中需要被请家长的人数。

#include 
int main()
{
	int a, b, c, n, cnt = 0;
	scanf("%d", &n);
	while (n--)
	{
		scanf("%d %d %d", &a, &b, &c);
		if (a + b + c < 180)
			cnt++;
	}
	printf("%d", cnt);
	return 0;
}

125.小乐乐算最高分

描述

小乐乐的老师BoBo想知道班级中谁的数学成绩最高，请编程帮他实现。

输入描述：

共两行
第一行输入一个数n，代表小乐乐的班级中n个同学。
第二行输入n个数，用空格相隔，代表班级中每个人的数学成绩。

输出描述：

一个整数，代表班级中最高的数学成绩。

#include 
int main()
{
	int n, i, max = 0, a = 0;
	scanf("%d", &n);
	for (i = 0; i < n; i++) {
		scanf("%d", &a);
		if (a > max) {
			max = a;
		}
	}
	printf("%d", max);
	return 0;
}

#include 
int cmp(const void *pa, const void *pb){
    return *(int *)pa - *(int *)pb;
}
int main()
{
    int n, i;
    scanf("%d", &n);
    int *ret = (int *)malloc(sizeof(int) * n);
    for(i = 0; i < n; ++i){
        scanf("%d", &ret[i]);
    }
    qsort(ret, n, sizeof(int), cmp);
    printf("%d", ret[n - 1]);
    return 0;
}

126.小乐乐计算求和

描述

小乐乐想计算一下1!+2!+3!+...+n!。

输入描述：

一行，一个整数n。

输出描述：

一行，一个整数，表示1!+2!+3!+...+n!的结果。

#include 
int main()
{
	int n, i, j, mul = 1, sum = 0;
	scanf("%d", &n);
	for (i = 1; i <= n; i++) {
		mul *= i;
		sum += mul;
	}
	printf("%d", sum);
	return 0;
}

127.小乐乐计算函数

描述

小乐乐学会了自定义函数，BoBo老师给他出了个问题，根据以下公式计算m的值。

其中 max3函数为计算三个数的最大值，如： max3(1, 2, 3) 返回结果为3。

输入描述：

一行，输入三个整数，用空格隔开，分别表示a, b, c。

输出描述：

一行，一个浮点数，小数点保留2位，为计算后m的值。

#include 
int get_max(int a, int b, int c)
{
	if (a >= b && a >= c)
		return a;
	else if (b >= a && b >= c)
		return b;
	else
		return c;
}
int main()
{
	int a, b, c, max1, max2, max3;
	scanf("%d %d %d", &a, &b, &c);
	max1 = get_max(a + b, b, c);
	max2 = get_max(a, b + c, c);
	max3 = get_max(a, b, b + c);
	printf("%.2f", (float)max1 / (max2 + max3));
	return 0;
}

128.小乐乐查找数字

描述

给定n个整数和一个整数x，小乐乐想从n个整数中判断x出现几次，请编程帮他实现。

输入描述：

共3行
第一行，一个整数，表示n（1 <= n <= 100）。
第二行，共输入n个整数，两个整数之间用空格分隔。
第三行，输入一个整数，表示要查找的整数x。

输出描述：

一行，表示整数x出现的次数。

#include 
int main()
{
	int arr[100] = { 0 }, n, x, cnt = 0;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &arr[i]);
	}
	scanf("%d", &x);
	for (int i = 0; i < n; i++) {
		if (x == arr[i]) {
			cnt++;
		}
	}
	printf("%d", cnt);
	return 0;
}

#include 
int main()
{
    int n, i, j, h[101], x;
    memset(h, 0, sizeof(h));
    scanf("%d", &n);
    for(i = 0; i < n; ++i){
        scanf("%d", &x);
        h[x]++;
    }
    scanf("%d", &j);
    printf("%d", h[j]);
    return 0;
}
//利用哈希

129.KIKI学程序设计基础

描述

BoBo老师教了KiKi学习程序设计基础，他知道C++是带类的C语言，这个“++”主要包含三部分内容：对C语言进行语法上的扩展、面向对象（封装、继承和多态），STL(即模板)。这学期KiKi学习了C和C++，学好他们，其他编程语言都可以很轻松掌握。C和C++的输入有区别，请帮KiKi输出C和C++输出Hello world的代码。

输入描述：

无

输出描述：

printf("Hello world!\n");
cout << "Hello world!" << endl;

#include 
int main()
{
	printf("\printf(\"\Hello world!\\n\");\n");
	printf("\cout << \"Hello world!\" << endl;");
	return 0;
}

130.KIKI算期末成绩

描述

KiKi这学期努力学习程序设计基础，要期末考试了，BoBo老师告诉他，总成绩包括四个部分，如下：

总成绩 = 实验成绩 * 20% + 课堂表现成绩 * 10% + 过程考核成绩 * 20% + 期末上机考试成绩 * 50%，现在输入KiKi的各项成绩，请计算KiKi的总成绩。

输入描述：

一行，包括四个整数（百分制），用空格分隔，分别表示实验成绩，课堂表现成绩，过程考核成绩，期末上机考试成绩。

输出描述：

一行，总成绩，保留小数点一位。

#include 
int main()
{
	int a, b, c, d;
	scanf("%d %d %d %d", &a, &b, &c, &d);
	printf("%.1f", a * 0.2 + b * 0.1 + c * 0.2 + d * 0.5);
	return 0;
}

131.KIKI说祝福语

描述

2020年来到了，KiKi要对他的n位好朋友说n遍”Happy new year!Good luck!”的祝福语。

输入描述：

输入只有一行，其中含有一个正整数 n(1≤n≤20)，代表KiKi说祝福话的遍数。

输出描述：

输出 n行"Happy new year!Good luck!"。

#include 
int main()
{
	int n;
	scanf("%d", &n);
	while (n--) {
		printf("Happy new year!Good luck!\n");
	}
	return 0;
}

#include 
int main()
{
    int n, i;
    scanf("%d", &n);
    for(i = 0; i < n; ++i){
        printf("Happy new year!Good luck!\n");
    }
    return 0;
}

132.KIKI的最高分

描述

KiKi知道了大一三科比较重要课程的分数，包括：程序设计基础，高数，英语，请编程帮他找到三科中的最高分。

输入描述：

一行，三个整数，用空格分隔，代表三科成绩。

输出描述：

一行，一个整数，代表输入三科分数中的最高分数。

#include 
int main()
{
	int max = 0, i, a[3];
	for (i = 0; i < 3; i++) {
		scanf("%d", &a[i]);
		if (a[i] > max) {
			max = a[i];
		}
	}
	printf("%d", max);
	return 0;
}

#include 
int get_max(int a, int b, int c){
    if(a >= b && a >= c){
        return a;
    }else if (b >= a && b >= c){
        return b;
    }else {
        return c;
    }
}
int main()
{
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    printf("%d", get_max(a, b, c));
    return 0;
}

#include 
int cmp(const void *pa, const void *pb){
    return *(int *)pa - *(int *)pb;
}
int main()
{
    int a[3], i;
    for(i = 0; i < 3; ++i){
        scanf("%d", &a[i]);
    }
    qsort(a, 3, sizeof(int), cmp);
    printf("%d", a[2]);
    return 0;
}

133.KIKI求质数的个数

描述

KiKi知道了什么是质数（只能被1和他自身整除的数），他现在想知道所有三位整数中，有多少个质数。

输入描述：

无

输出描述：

一行，一个整数，表示所有三位整数中，有多少个质数。

#include 
int main()
{
	int i, cnt = 0, j;
	for (i = 100; i < 1000; i++) {
		for (j = 2; j < i; j++) {
			if (i % j == 0)
				break;
		}
		if (j == i) {
			cnt++;
		}
	}
	printf("%d", cnt);
	return 0;
}
// 质数 : 只有1和它本身，没有其他因式

#include 
#include 
int main()
{
	int i, cnt = 0, j;
	for (i = 100; i < 1000; i++) {
		for (j = 2; j <= sqrt(i); j++) {
			if (i % j == 0)
				break;
		}
		if (j > sqrt(i)) {
			cnt++;
		}
	}
	printf("%d", cnt);
	return 0;
}
//sqrt 是算数平方根
//如果一个数不是质数，则存在两个因子，一个大于算数平方根，一个小于算数平方根

134.KIKI去重整数并排序

描述

给定一个整数序列，KiKi想把其中的重复的整数去掉，并将去重后的序列从小到大排序输出。

输入描述：

第一行，输入一个整数n，表示序列有n个整数。

第二行输入n个整数（每个整数大于等于1，小于等于1000），整数之间用空格分隔。

输出描述：

去重并且从小到大排列的整数序列，整数之间用空格分隔。

#include 
#include 
int main()
{
	int n, hash[1001], x, i;
	scanf("%d", &n);
	memset(hash, 0, sizeof(hash));
	while (n--) {
		scanf("%d", &x);
		hash[x]++;
	}
	for (i = 1; i < 1001; i++) {
		if (hash[i]) {
			printf("%d ", i);
		}
	}
	return 0;
}
//去重并排序，利用哈希数表，读取一个数，将这个下标自增，然后按顺序打印数组不为0时的下标值

#include 
#include 
int cmp(const void *pa, const void *pb){
    return *(int *)pa - *(int *)pb;
}
int main()
{
    int n, i, j;
    scanf("%d", &n);
    int *ret = (int *)malloc(sizeof(int) * n);
    for(i = 0; i < n; ++i){
        scanf("%d", &ret[i]);
    }
    qsort(ret, n, sizeof(int), cmp);
    for(i = 1; i < n; ++i){
        if(ret[i] == ret[i - 1]){
            for(j = i; j < n - 1; ++j){
                ret[j] = ret[j + 1];
            }
            n--;
            i--;
        }
    }
    for(i = 0; i < n; ++i){
        printf("%d ", ret[i]);
    }
    return 0;
}
//先排序后去重

135.KIKI判断上三角矩阵

描述

KiKi想知道一个n阶方矩是否为上三角矩阵，请帮他编程判定。上三角矩阵即主对角线以下的元素都为0的矩阵，主对角线为从矩阵的左上角至右下角的连线。

输入描述：

第一行包含一个整数n，表示一个方阵包含n行n列，用空格分隔。 (2≤n≤10)

从2到n+1行，每行输入n个整数（范围-231~231-1），用空格分隔，共输入n*n个数。

输出描述：

一行，如果输入方阵是上三角矩阵输出"YES"并换行，否则输出"NO"并换行。

#include 
int main()
{
	int i, j, n, arr[10][10], cnt = 0;
	scanf("%d", &n);
	for (i = 0; i < n; i++) {
		for (j = 0; j < n; j++) {
			scanf("%d", &arr[i][j]);
		}
	}
	for (i = 0; i < n; i++) {
		for (j = 0; j < i; j++) {
			if (arr[i][j]) {
				cnt++;
			}
		}
	}
	if (cnt == 0) {
		printf("YES\n");
	}
	else {
		printf("NO\n");
	}
	return 0;
}
//统计主对角线元素非零的个数，若存在，则不是上三角矩阵；否则是上三角矩阵

#include 
int judge(int **ret, int n){
    int i, j;
    for(i = 0; i < n; ++i){
        for(j = 0; j < i; ++j){
            if(ret[i][j]){
                return 0;
            }
        }
    }
    return 1;
}
int main()
{
    int n, i, j;
    scanf("%d", &n);
    int **ret = (int **)malloc(sizeof(int *) * n);
    for(i = 0; i < n; ++i){
        ret[i] = (int *)malloc(sizeof(int) * n);
    }
    for(i = 0; i < n; ++i){
        for(j = 0; j < n; ++j){
            scanf("%d", &ret[i][j]);
        }
    }
    if(judge(ret, n)){
        printf("YES\n");
    }else {
        printf("NO\n");
    }
    return 0;
}
//利用函数进行判断

136.KIKI学结构体和指针

描述

KiKi学习了结构体和指针，他了解了结构体类型可以定义包含多个不同类型成员，而指针本质是内存地址，是引用数据的另外一种方式。现在他想将多个输入的数据通过结构体和指针的方式连接在一起，形成一个单向链表，即：每个结点是结构体类型，包括整型数据成员（data）和结构体指针类型成员（next），每个结点的指针部分指向下一个输入的结点。具体建立过程如下：先输入n个整数，按照数据输入的顺序建立一个带头结点的单链表，再输入一个数据m,将单链表中的值为m的结点全部删除。输出删除后的单链表信息。

输入描述：

包括三行：

第一行输入数据个数n (3≤n≤100);

第二行依次输入n个整数，用空格分隔;

第三行输入欲删除数据m。

输出描述：

包括两行：

第一行输出完成删除后的单链表长度；

第二行依次输出完成删除后的单链表数据。

#include 
int main()
{
	int n = 0, arr[100], i, cnt = 0, m;
	scanf("%d", &n);
	for (i = 0; i < n; i++) {
		scanf("%d", &arr[i]);             //读取
	}
	scanf("%d", &m);
	for (i = 0; i < n; i++) {
		if (arr[i] == m)                  //统计需要删去的元素的个数
			cnt++;
	}
	printf("%d\n", n - cnt);
	for (i = 0; i < n; i++) {
		if (arr[i] != m) {                //把除了这个元素之外的其余元素打印出来
			printf("%d ", arr[i]);
		}
	}
	return 0;
}

137.kiki定义电子日历类

描述

KiKi学习了面向对象技术，学会了通过封装属性（变量）和行为（函数）定义类，现在他要设计一个电子日历类TDate。

它有3个私有数据成员：Month,Day,Year和若干个公有成员函数，要求：

（1）带有默认形参值的构造函数，默认值为0, 0, 0；
（2）输出日期函数，用“日/月/年”格式输出日期；
（3）设置日期函数，从键盘输入年、月、日。

输入描述：

一行，三个整数，用空格分隔，分别表示年、月、日。

输出描述：

一行，用“日/月/年”格式输出日期。

#include 
int main()
{
	int num1, num2, num3 = 0;
	scanf("%d %d %d", &num1, &num2, &num3);
	printf("%d/%d/%d", num3, num2, num1);
	return 0;
}

138.kiki设计类继承

描述

KiKi理解了继承可以让代码重用，他现在定义一个基类shape，私有数据为坐标点x,y,  由它派生Rectangle类和Circle类，它们都有成员函数GetArea()求面积。派生类Rectangle类有数据：矩形的长和宽；派生类Circle类有数据：圆的半径。Rectangle类又派生正方形Square类，定义各类并测试。输入三组数据，分别是矩形的长和宽、圆的半径、正方形的边长，输出三组数据，分别是矩形、圆、正方形的面积。圆周率按3.14计算。

输入描述：

输入三行，

第一行为矩形的长和宽，

第二行为圆的半径，

第三行为正方形的边长。

输出描述：

三行，分别是矩形、圆、正方形的面积。

#include 
int main()
{
	int a, b, c, d;
	scanf("%d %d", &a, &b);
	scanf("%d", &c);
	scanf("%d", &d);
	printf("%d\n%g\n%d\n", a * b, 3.14 * c * c, d * d);
	return 0;
}

139.圣诞树

描述

今天是圣诞节，牛牛要打印一个漂亮的圣诞树送给想象中的女朋友，请你帮助他实现梦想。

输入描述：

输入圣诞树的高度h，1<= h <= 1001<=h<=100

输出描述：

输出对应的圣诞数

140.超级圣诞树

描述

今天是圣诞节，牛牛要打印一个漂亮的圣诞树送给想象中的女朋友，请你帮助他实现梦想。

输入描述：

输入圣诞树的大小 nn

1≤n≤81≤n≤8

输出描述：

输出对应的圣诞树