小兔子酱#

【C语言】编程初学者入门训练（完结）

文章目录

1. 实践出真知
2. 我是大V
3. 有容乃大
4. 小飞机
5. 缩短2进制
6. 十六进制转十进制
7. printf的返回值
8. 成绩输入输出
9. 学生基本信息输入输出
10. 字符圣诞树
11. ASCII码
12. 出生日期输入输出
13. 按照格式输入并交换输出
14. 字符转ASCII码
15. 计算表达式的值
16. 计算带余除法
17. 反向输出一个四位数
18. kiki算数
19. 浮点数的个位数字
20. 你能活多少秒
21. 时间转换
22. 总成绩和平均分计算
23. 计算体重指数
24. 计算三角形的周长和面积
25. 计算球体的体积
26. 大小写转换
27. 2的n次方计算
28. kiki和酸奶
29. 发布信息
30. 输出学生信息
31. 计算平均成绩
32. 进制A+B
33. 判断字母
34. 健康评估
35. 网购
36. 变种水仙花
37. 争夺前五名
38. 竞选社长
39. 你是天才吗？
40. 完美成绩
41. 及格分数
42. 判断整数奇偶性
43. 最高分数
44. 判断元音还是辅音
45. 判断是不是字母
46. 字母大小写转换
47. 判断两个数的大小关系
48. 计算单位阶跃函数
49. 三角形判断
50. 衡量人体胖瘦程度
51. 计算一元二次方程
52. 获取月份天数
53. 简单计算器
54. 线段图案
55. 正方形图案
56. 直角三角形图案
57. 翻转直角三角形图案
58. 带空格直角三角形图案
59. 金字塔图案
60. 翻转金字塔图案
61. 菱形图案
62. k形图案
63. 箭形图案
64. 反斜线形图案
65. 正斜线图案
66. X形图案
67. 空心正方形图案
68. 空心三角形图案
69. 新年快乐
70. 平均身高
71. 挂科危险
72. HTTP状态码
73. 数字三角形
74. 公务员面试
75. 有序序列插入一个数
76. 筛选法求素数
77. 图像相似度
78. 登录验证
79. 学好C++
80. (a+b-c)*d的计算问题
81. 被5整除问题
82. 计算y的值
83. 包含数字9的数
84. 奇偶统计
85. 统计成绩
86. 密码验证
87. 矩阵计算
88. 成绩输入输出问题
89. 逆序输出
90. 统计数据正负个数
91. N个数之和
92. 最高分和最低分之差
93. 有序序列判断
94. 序列中删除指定数字
95. 序列中整数去重
96. 有序序列合并
97. 班级成绩输入输出
98. 矩阵元素定位
99. 序列重组矩阵
100. 最高身高
101. 矩阵相等判定
102. 上三角矩阵判定
103. 矩阵转置
104. 矩阵交换
105. 杨辉三角
106. 井字棋
107. 小乐乐与进制转换
108. 小乐乐求和
109. 小乐乐定闹钟
110. 小乐乐排电梯
111. 小乐乐与欧几里得
112. 小乐乐改数字
113. 小乐乐走台阶
114. 小乐乐与序列
115. 小乐乐与字符串
116. 小乐乐算平均分
117. 小乐乐找最大数
118. 小乐乐是否被叫家长
119. 小乐乐转换成绩
120. 小乐乐算多少人被请家长
121. 小乐乐算最高分
122. 小乐乐计算求和
123. 小乐乐计算函数
124. 小乐乐查找数字
125. kiki学程序设计基础
126. kiki算期末成绩
127. kiki说祝福语
128. kiki的最高分
129. 求质数的个数
130. kiki去重整数并排序
131. kiki学结构体和指针
132. kiki定义电子日历类
133. 圣诞树
134. 超级圣诞树

所有代码都通过牛客网编译。

1. 实践出真知

题目内容：于老师经常告诉我们“学习编程最好的办法就是上机实践，因为你要对计算机下指令，想让计算机帮你干活，就得多和计算机‘交流’，实践才能出真知。”
输入描述：无
输出描述：Practice makes perfect!
解析：本题是一个没有输入要求的题目，只考察输出，所以只需要准确无误的输出结果就行了。
代码实现：

#include 

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

2. 我是大V

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

v   v 
 v v  
  v

备注：换行使用转义字符 ‘\n’。
代码实现：

#include 

int main()
{
        printf("v   v\n");
        printf(" v v \n");
        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;
}

The size of short is 2 bytes.
The size of int is 4 bytes.
The size of long is 8 bytes.
The size of long long is 8 bytes.

4. 小飞机

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

代码实现：

#include 

int main()
{
        printf("     **     \n");
        printf("     **     \n");
        printf("************\n");
        printf("************\n");
        printf("    *  *    \n");
        printf("    *  *    \n");

        return 0;
}

     **     
     **     
************
************
    *  *    
    *  *

5. 缩短2进制

问题描述：我们处理的整数通常用十进制表示，在计算机内存中是以二进制补码形式存储，但通常二进制表示的整数比较长，为了便于在程序设计过程中理解和处理数据，通常采用八进制和十六进制，缩短了二进制补码表示的整数，但保持了二进制数的表达特点。请输出十进制整数1234对应的八进制和十六进制。
输入描述：无
输出描述：十进制整数1234对应的八进制和十六进制（字母大写），用空格分开，并且要求，在八进制前显示前导0，在十六进制数前显示前导0X。
备注：printf可以使用使用格式控制串“%o”、“%X”分别输出八进制整数和十六进制整数，并使用修饰符“#”控制前导显示。
代码实现：

#include 

int main()
{
        printf("%#o %#X\n",1234,1234);

        return 0;
}

02322 0X4D2

6. 十六进制转十进制

问题描述：BoBo写了一个十六进制整数ABCDEF，他问KiKi对应的十进制整数是多少。
输入描述：无
输出描述：十六进制整数ABCDEF对应的十进制整数，所占域宽为15。
备注：printf可以使用使用格式控制串“%md”输出域宽为m的十进制整数。
代码实现：

#include 

int main()
{
        int a = 0xABCDEF;
        printf("%15d\n",a);

        return 0;
}

11259375

7. printf的返回值

问题描述：KiKi写了一个输出“Hello world!”的程序，BoBo老师告诉他printf函数有返回值，你能帮他写个程序输出printf(“Hello world!”)的返回值吗？
输入描述：无
输出描述：包括两行：
- 第一行为“Hello world!”
- 第二行为printf(“Hello world!”)调用后的返回值。
代码实现：

#include 

int main()
{
        int a = printf("Hello world!");
        printf("\n%d\n",a);

        return 0;
}

Hello world!
12

8. 成绩输入输出

问题描述：输入3科成绩，然后把三科成绩输出，成绩为整数形式。
数据范围： 0 ≤ n ≤ 100
输入描述：一行，3科成绩，用空格分隔，范围（0~100）。
输出描述：一行，把3科成绩显示出来，输出格式详见输出样例。
- 输入：60 80 90
- 输出：score1=60,score2=80,score3=90
代码实现：

#include 

int main()
{
        int a,b,c;

        scanf("%d %d %d",&a,&b,&c);

        printf("score1= %d,score2= %d,score3= %d\n",a,b,c);

        return 0;
}

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

问题描述：依次输入一个学生的学号，以及3科（C语言，数学，英语）成绩，在屏幕上输出该学生的学号，3科成绩（注：输出成绩时需进行四舍五入且保留2位小数）。
数据范围：学号满足 1≤n≤20000000 ，各科成绩使用百分制，且不可能出现负数
输入描述：学号以及3科成绩，学号和成绩之间用英文分号隔开，成绩之间用英文逗号隔开。
输出描述：学号，3科成绩，输出格式详见输出样例。
- 示例1：
  - 输入：17140216;80.845,90.55,100.00
  - 输出：The each subject score of No. 17140216 is 80.85, 90.55, 100.00.
- 示例2：
  - 输入：123456;93.33,99.99,81.20
  - 输出：The each subject score of No. 123456 is 93.33, 99.99, 81.20.
代码实现：

#include 

int main()
{
        int a;
        float b,c,d;

        scanf("%d;%f,%f,%f",&a,&b,&c,&d);
        printf("The each subject score of No. %d is %.2f, %.2f, %.2f.",a,b,c,d);
        
        return 0;
}

10. 字符圣诞树

问题描述：输入一个字符，用它构造一个边长为5的三角形圣诞树。
数据范围：保证输入的字符是一个 char 类型的值
输入描述：输入只有一行，一个字符。
输出描述：该字符构成的三角形圣诞树。
示例：

代码实现：

#include 

int main(void)
{
    char a;
    int b,c,d,e;

    scanf("%c", &a);

    for (b = 5, c = 1; c <= b; c++)
    {
        for (d = 5 - c; d > 0; d--) 
        {
                printf(" ");
        }
        for (e = 1; e <= c; e++)
        {
                printf("%c ", a);
        }
        printf("\n");
    }

    return 0;
}

11. ASCII码

问题描述：BoBo教KiKi字符常量或字符变量表示的字符在内存中以ASCII码形式存储。BoBo出了一个问题给KiKi，转换以下ASCII码为对应字符并输出他们。73, 32, 99, 97, 110, 32, 100, 111, 32, 105, 116 , 33
输入描述：无
输出描述：一行输出转换题目中给出的所有ASCII码对应的字符，无需以空格隔开。
代码实现：

int main()
{
        printf("%c%c%c%c%c%c%c%c%c%c%c%c\n",73, 32, 99, 97, 110, 32, 100, 111, 32, 105, 116 , 33);

        return 0;
}

I can do it!

12. 出生日期输入输出

问题描述：输入一个人的出生日期（包括年月日），将该生日中的年、月、日分别输出。
数据范围：年份满足 1990≤y≤2015 ，月份满足 1≤m≤12 ，日满足 1≤d≤30
输入描述：输入只有一行，出生日期，包括年月日，年月日之间的数字没有分隔符。
输出描述：三行，第一行为出生年份，第二行为出生月份，第三行为出生日期。输出时如果月份或天数为1位数，需要在1位数前面补0。
示例：

输入：20130225 
输出：year=2013
	  month=02
	  date=25

备注：通过scanf函数的%m格式控制可以指定输入域宽，输入数据域宽（列数），按此宽度截取所需数据；通过printf函数的%0格式控制符，输出数值时指定左面不使用的空位置自动填0。
代码实现：

#include 

int main()
{
        int year,month,date;
        scanf("%4d%2d%2d",&year,&month,&date);

        printf("year=%d\n",year);
        printf("month=%02d\n",month);
        printf("date=%02d\n",date);

        return 0;
}

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

问题描述：输入两个整数，范围-231~231-1，交换两个数并输出。
输入描述：输入只有一行，按照格式输入两个整数，范围，中间用“,”分隔。
输出描述：把两个整数按格式输出，中间用“,”分隔。
示例1
- 输入：a=1,b=2
- 输出：a=2,b=1
备注：如果格式控制串中有非格式字符则输入时也要输入该非格式字符。
代码实现：

int main()
{
        int a,b,t;
        scanf("a=%d,b=%d",&a,&b);
                
        t = a;a = b;b = t;

        printf("a=%d,b=%d\n",a,b);

        return 0;
}

14. 字符转ASCII码

问题描述：BoBo教KiKi字符常量或字符变量表示的字符在内存中以ASCII码形式存储。BoBo出了一个问题给KiKi，输入一个字符，输出该字符相应的ASCII码。
输入描述：一行，一个字符。
输出描述：一行，输出输入字符对应的ASCII码。
示例：
- 输入：c
- 输出：99
代码实现

#include 

int main()
{
        char a;
        scanf("%c",&a);

        printf ("%d\n",a);

        return 0;
}

15. 计算表达式的值

问题描述：请计算表达式“(-8+22)×a-10+c÷2”，其中，a = 40，c = 212。
输入描述：无。
输出描述：(-8+22)×a-10+c÷2计算之后的结果，为一个整数。
代码实现：

#include 

int main()
{
        int a = 40,c = 212;
        int t = (-8 + 22)*a-10 + c/2;

        printf("%d\n",t);

        return 0;
}

16. 计算带余除法

问题描述：给定两个整数 a 和 b (0 < a,b < 10,000)，计算a除以b的整数商和余数。
输入描述：一行，包括两个整数 a 和 b，依次为被除数和除数（不为零），中间用空格隔开。
输出描述：一行，包含两个整数，依次为整数商和余数，中间用一个空格隔开。
示例：
- 输入：15 2
- 输出：7 1
代码实现：

#include 

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

        printf("%d %d\n",a/b,a%b);

        return 0;
}

17. 反向输出一个四位数

问题描述：将一个四位数，反向输出。
输入描述：一行，输入一个整数n（1000 <= n <= 9999）。
输出描述：针对每组输入，反向输出对应四位数。
示例：
- 输入：1234
- 输出：4321
代码实现：

#include 

int main()
{
        int n;
        scanf("%d",&n);
        int t = n;

        while(n)
        {
                printf("%d",n % 10);
                n /= 10;
        }
        putchar('\n');

        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³¹-1
输入描述：一行，输入两个非负整数a和b，用一个空格分隔。（0 <= a,b<= 231-1）。
输出描述：针对每组输入，输出按照KiKi的运算规则计算出 a+b 的值。
示例：
- 输入：45 80
- 输出：25
代码实现：

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

        printf("%d\n",(a + b)% 100);
        //因为只能认出最后两位数，所以 % 10保留最后两位 

        return 0;
}

19. 浮点数的个位数字

问题描述：给定一个浮点数，要求得到该浮点数的个位数。
数据范围： 0
输入描述：一行，包括一个浮点数。
输出描述：一行，包含一个整数，为输入浮点数对应的个位数。
示例：
- 输入：13.141
- 输出：3
代码实现：

int main()
{
        float n;
        scanf("%f",&n);
        printf("%d\n",(int)n %10);

        return 0;
}

20. 你能活多少秒

问题描述：一年约有 3.156×107 s，要求输入您的年龄，显示该年龄合多少秒。
数据范围：0
输入描述：一行，包括一个整数age。
输出描述：一行，包含一个整数，输出年龄对应的秒数。
示例:
- 输入：20
- 输出：631200000
代码实现：

#include 
#include 

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

        long long time = age * (3.156 * pow(10,7));

        if(0 < age <= 200)
        {
                printf("%lld\n",time);
        }

        return 0;
}

21. 时间转换

问题描述：给定秒数 seconds ，把秒转化成小时、分钟和秒。
数据范围：0
输入描述：一行，包括一个整数，即给定的秒数。
输出描述：一行，包含三个整数，依次为输入整数对应的小时数、分钟数和秒数（可能为零），中间用一个空格隔开。
示例：
- 输入：3661
- 输出：1 1 1
代码实现：

#include 

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

        int h = seconds / 3600;
        int m = seconds / 60 % 60;
        int s = seconds % 60;

        printf("%d %d %d\n",h,m,s);
        
        return 0;
}

22. 总成绩和平均分计算

问题描述：依次输入一个学生的3科成绩，在屏幕上输出该学生的总成绩以及平均成绩。
输入描述：一行，3科成绩，成绩之间用一个空格隔开。
输出描述：一行，总成绩和平均成绩（小数点后保留两位），用一个空格隔开。
示例：
- 输入：79.5 80.0 98.0
- 输出：257.50 85.83
代码实现：

#include 

int main()
{
        float Chinese,math,English;

        scanf("%f %f %f",&Chinese,&math,&English);

        float sum = Chinese + math + English;
        float average = sum / 3.0;

        printf("%.2f %.2f",sum,average);


        return 0;
}

23. 计算体重指数

问题描述：计算BMI指数（身体质量指数）。BMI指数（即身体质量指数，简称体质指数又称体重，英文为Body Mass Index，简称BMI），是用体重公斤数除以身高米数平方得出的数字，是目前国际上常用的衡量人体胖瘦程度以及是否健康的一个标准。主要用于统计用途，当我们需要比较及分析一个人的体重对于不同高度的人所带来的健康影响时，BMI值是一个中立而可靠的指标。
数据范围：输入的数据满足 50≤n≤180
输入描述：一行，两个整数，分别表示体重（公斤），身高（厘米），中间用一个空格分隔。
输出描述：一行，BMI指数（保留两位小数）。
示例：
- 输入：70 170
- 输出：24.22
代码实现：

#include 
#include 

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

        float BMI = weight / pow((float)height / 100.0 , 2);

        printf("%.2f\n",BMI);

        return 0;
}

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

问题描述：根据给出的三角形3条边a, b, c，计算三角形的周长和面积。
数据范围： 0
输入描述：一行，三角形3条边（能构成三角形），中间用一个空格隔开。
输出描述：一行，三角形周长和面积（保留两位小数），中间用一个空格隔开，输出具体格式详见输出样例。
示例：
- 输入：3 3 3
- 输出：circumference=9.00 area=3.90
代码实现：

#include 
#include 

int main()
{
        int a,b,c;

        scanf("%d %d %d",&a,&b,&c);

        float circumference,p,area;

        circumference = a + b + c;
        p = circumference / 2;
        area = sqrt(p * (p-a) * (p-b) * (p-c));

        printf("circumference=%.2f area=%.2f\n",circumference,area);

        return 0;
}

25. 计算球体的体积

问题描述：给定一个球体的半径，计算其体积。其中球体体积公式为 V = 4/3*πr3，其中 π = 3.1415926。
数据范围：输入一个浮点值 0≤n≤15
输入描述：一行，用浮点数表示的球体的半径。
输出描述：一行，球体的体积，小数点后保留3位。
示例：
- 输入：3.0
- 输出：113.097
代码实现：

#include 
#include 

int main()
{
        double r,V,n = 3.1415926;
        scanf("%f",&r);

        V = 4.0/3.0 * n * pow(r,3);
        printf("%.3f",V);
        
        return 0;
}

26. 大小写转换

问题描述：实现字母的大小写转换。多组输入输出。
输入描述：多组输入，每一行输入大写字母。
输出描述：针对每组输入输出对应的小写字母。
示例：

输入：
	A
	B

输出：
	a
	b

备注：多组输入过程中要注意“回车”也是字母，所以要“吸收”(getchar())掉该字母。
代码实现：

#include 

int main()
{
        char ch;

        while((ch = getchar()) != EOF)
        {
                getchar();
                printf("%c\n",ch + 32);
        }

        return 0;
}

27. 2的n次方计算

问题描述：不使用累计乘法的基础上，通过移位运算（<<）实现2的n次方的计算。
数据范围：0≤n≤31
输入描述：一行输入整数n（0 <= n < 31）。
输出描述：输出对应的2的n次方的结果。
示例1：
- 输入：2
- 输出：4
示例2：
- 输入：10
- 输出：1024
代码实现：

#include 

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

        if(0 <= n <= 31)
        {
                printf("%d\n",1 << n);
                
        }

        return 0;
}

28. kiki和酸奶

问题描述：BoBo买了一箱酸奶，里面有n盒未打开的酸奶，KiKi喜欢喝酸奶，第一时间发现了酸奶。KiKi每h分钟能喝光一盒酸奶，并且KiKi在喝光一盒酸奶之前不会喝另一个，那么经过m分钟后还有多少盒未打开的酸奶？
输入描述：多组输入，每组输入仅一行，包括n，h和m（均为整数）。输入数据保证m <= n * h。
输出描述：针对每组输入，输出也仅一行，剩下的未打开的酸奶盒数。
示例：
- 输入：8 5 16
- 输出：4
代码实现：

//假设m能整除h，则剩下的未打开酸奶就是 n-(m/n)
//如果不能整除，有余数，此时只是打开的这一瓶没喝完而已，所以剩余瓶数得-1
#include 

int main()
{
        int n,h,m;
        scanf("%d%d%d",&n,&h,&m);

        if(m <= n * h)
        {
                if(0 == m % h)
                {
                        n = n - (m / h);
                }
                else
                {
                        n = n - (m / h) - 1;
                }
        }
        printf("%d\n",n);
        
        return 0;
}

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   \n");

        return 0;
}

31. 计算平均成绩

问题描述：从键盘输入5个学生的成绩（整数），求他们的平均成绩（浮点数，保留一位小数）。
输入描述：一行，连续输入5个整数（范围0~100），用空格分隔。
输出描述：一行，输出5个数的平均数（保留一位小数）。
示例：
- 输入：75 80 43 67 96
- 输出：72.2
代码实现：

#include 

int main()
{
        int a,b,c,d,e;
        scanf("%d%d%d%d%d",&a,&b,&c,&d,&e);

        float average = (a + b + c + d + e)/5.0;
        printf("%.1f\n",average);
        

        return 0;
}

32. 进制A+B

问题描述：输入一个十六进制数a，和一个八进制数b，输出a+b的十进制结果（范围-231~231-1）。
输入描述：一行，一个十六进制数a，和一个八进制数b，中间间隔一个空格。
输出描述：一行，a+b的十进制结果。
示例：
- 输入：0x12 05
- 输出：23
备注：十六进制Hexadecimal一般以0x开头，例如0xFF。八进制Octal，一般以0开头，例如07。
代码实现：

#include 

int main()
{
        int a,b;
        scanf("%x %o",&a,&b);

        printf("%d\n",(a + b));

        return 0;
}

33. 判断字母

问题描述：从键盘任意输入一个字符，编程判断是否是字母（包括大小写）。
输入描述：输入包括一个字符。
输出描述：输出该字符是字母（YES）或不是（NO）。
示例1：
- 输入：H
- 输出：YES
示例2
- 输入：9
- 输出：NO
代码实现：

#include 

int main()
{
        char ch = getchar();

        if((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))
        {
                printf("YES\n");
        }
        else printf("NO\n");

        return 0;
}

34. 健康评估

问题描述：BMI指数（即身体质量指数）是用体重公斤数除以身高米数平方得出的数字，是目前国际上常用的衡量人体胖瘦程度以及是否健康的一个标准。例如：一个人的身高为1.75米，体重为68千克，他的BMI=68/(1.75^{2)=22.2（千克/米}2）。当BMI指数为18.5～23.9时属正常，否则表示身体存在健康风险。编程判断人体健康情况。
输入描述：一行，输入一个人的体重（千克）和身高（米），中间用一个空格分隔。
输出描述：一行，输出身体Normal(正常)或Abnormal(不正常)。
示例1：
- 输入：68 1.75
- 输出：Normal
示例2：
- 输入：67.5 1.65
- 输出：Abnormal
代码实现：

#include 
#include 

int main()
{
        float weight,high,BMI;

        scanf("%f %f",&weight,&high);

        BMI = weight / pow(high,2);

        if(18.5 <= BMI && BMI <= 23.9)
        {
                printf("Normal\n");
        }
        else
        {
                printf("Abnormal\n");
        }
        
        return 0;
}

35. 网购

问题描述：KiKi非常喜欢网购，在一家店铺他看中了一件衣服，他了解到，如果今天是“双11”（11月11日）则这件衣服打7折，“双12” （12月12日）则这件衣服打8折，如果有优惠券可以额外减50元（优惠券只能在双11或双12使用），求KiKi最终所花的钱数。
数据范围：衣服价格满足 1≤val≤100000
输入描述：一行，四个数字，第一个数表示小明看中的衣服价格，第二和第三个整数分别表示当天的月份、当天的日期、第四个整数表示是否有优惠券（有优惠券用1表示，无优惠券用0表示）。注：输入日期保证只有“双11”和“双12”。
输出描述：一行，小明实际花的钱数（保留两位小数）。（提示：不要指望商家倒找你钱）
示例1：
- 输入：1000.0 11 11 1
- 输出：650.00
示例2：
- 输入：999.8 12 12 0
- 输出：799.84
示例3：
- 输入：66.6 11 11 1
- 输出：0.00
代码实现：

int main()
{
        float price;
        int month,day,coupon;
        scanf("%f %d %d %d",&price,&month,&day,&coupon);

        if (12 == day && 12 == month)
        {
                if(coupon)      price = price * 0.8 - 50;

                else    price *= 0.8;
        }
        else if(11 == day && 11 == month)
        {
                if(coupon)      price = price * 0.7 -50;

                else    price *= 0.7;
        }

        if(price > 0)   printf("%.2f\n",price);

        else    printf("0.00\n");

        return 0;
}

36. 变种水仙花

问题描述：变种水仙花数 - Lily Number：把任意的数字，从中间拆分成两个数字，比如1461 可以拆分成（1和461）,（14和61）,（146和1),如果所有拆分后的乘积之和等于自身，则是一个Lily Number。
例如：
- 655 = 6 * 55 + 65 * 5
- 1461 = 1461 + 1461 + 146*1
- 求出 5位数中的所有 Lily Number。
输入描述：无
输出描述：一行，5位数中的所有 Lily Number，每两个数之间间隔一个空格。
代码实现：

#include 

int main()
{
        int i,j;

        for(i = 10000;i <= 99999;i++)
        {
                //判断i是否为水仙花数
                int sum = 0;
                for(j = 10;j <= 10000;j *= 10)
                {
                        sum += (i/j)*(i%j);
                }

                if(sum == i)    printf("%d ",i);
        }
        putchar('\n');

        return 0;
}

答案解析：分析题目后发现，lily数求和的每一项都是对同一个数（10/100/1000…）的取模或者整除取商。这样的话，产生10，100,1000,10000 这些数字，分别对被判断的数字取模或者取商，然后乘起来，再计算和，再判断就行。

37. 争夺前五名

问题描述：期中考试开始了，大家都想取得好成绩，争夺前五名。从键盘输入 n 个学生成绩，输出每组排在前五高的成绩。
数据范围： 5≤n≤50 ，成绩采取百分制并不会出现负数
输入描述：两行，第一行输入一个整数，表示n个学生（>=5），第二行输入n个学生成绩（整数表示，范围0~100），用空格分隔。
输出描述：一行，输出成绩最高的前五个，用空格分隔。
示例1：

输入：6
	  99 45 78 67 72 88
输出：99 88 78 72 67

示例2：

输入：5 
	 10 20 30 40 50
输出：50 40 30 20 10

代码实现1：自己排序

#include 
int main()
{
        int n,i;
        int arr[40]= {0};//存放成绩
        scanf("%d",&n);
        for(i = 0;i < n;i++)
        {
                scanf("%d",&arr[i]);
        }
        //自己排序:冒泡排序,升序后五个就是最高成绩
        for(i = 0;i < n-1;i++)//确定冒泡排序的趟数
        {
                int j;
                //一趟冒泡排序进行多少对元素的比较
                for(j = 0;j < n-i-1;j++)
                {
                        if(arr[j]> arr[j+ 1])
                        {
                                int t = arr[j];
                                arr[j] = arr[j + 1];
                                arr[j + 1]= t;
                        }
                }
        }
        //取出冒泡排序完之后的数组后五个元素
        for(i = n-1;i >= n-5;i--)
        {
                printf("%d ",arr[i]);
        }

        return 0;
}

代码实现2：qsort排序

#include 
#include 

int compare(const void* e1,const void* e2)
{
        int* pa = (int*)e1;
        int* pb = (int*)e2;

        return (*pa) - (*pb);
}

int main()
{
        int n,i;
        int arr[40]= {0};//存放成绩

        scanf("%d",&n);

        for(i = 0;i < n;i++)
        {
                scanf("%d",&arr[i]);
        }

        //qsort排序
        qsort(arr,n,4,compare);

        for(i = n-1;i >= n-5;i--)
        {
                printf("%d ",arr[i]);
        }       
        putchar('\n');
                
        return 0;
}

38. 竞选社长

问题描述：假设你们社团要竞选社长，有两名候选人分别是A和B，社团每名同学必须并且只能投一票，最终得票多的人为社长.
输入描述：一行，字符序列，包含A或B，输入以字符0结束。
输出描述：一行，一个字符，A或B或E，输出A表示A得票数多，输出B表示B得票数多，输出E表示二人得票数相等。
示例：
- 输入：ABBABBAAB0
- 输出：B
代码实现：

#include 

int main()
{
        char ch;
        int A = 0,B = 0;

        while((ch = getchar()) != '0')
        {
                if('A' == ch)	A++ ;                
                else if('B' == ch)	B++ ;                
        }

        if(A < B)       printf("B\n");
        else if(A > B)  printf("A\n");
        else            printf("E\n");
     
        return 0;
}

39. 你是天才吗？

问题描述：据说智商140以上者称为天才，KiKi想知道他自己是不是天才，请帮他编程判断。输入一个整数表示一个人的智商，如果大于等于140，则表明他是一个天才，输出“Genius”。
输入描述：多组输入，每行输入包括一个整数表示的智商。
输出描述：针对每行输入，输出“Genius”。
示例：
- 输入：160
- 输出：Genius
代码实现：

#include 

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

        if(IQ >= 140)   printf("Genius\n");

        return 0;
}

40. 完美成绩

问题描述：KiKi想知道他的考试成绩是否完美，请帮他判断。从键盘输入一个整数表示的成绩，编程判断成绩是否在90~100之间，如果是则输出“Perfect”。
输入描述：多组输入，每行输入包括一个整数表示的成绩（90~100）。
输出描述：针对每行输入，输出“Perfect”。
示例：
- 输入：98
- 输出：Perfect
代码实现：

#include 

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

        if(90 <= result && result <= 100)
        {
                printf("Perfect\n");
        }

        return 0;
}

41. 及格分数

问题描述：KiKi想知道他的考试分数是否通过，请帮他判断。从键盘任意输入一个整数表示的分数，编程判断该分数是否在及格范围内，如果及格，即：分数大于等于60分，是输出“Pass”，否则，输出“Fail”。
输入描述：多组输入，每行输入包括一个整数表示的分数（0~100）。
输出描述：针对每行输入，输出“Pass”或“Fail”。
示例1：
- 输入：94
- 输出：Pass
示例2：
- 输入：44
- 输出：Fail
代码实现：

#include 

int main()
{
        int point;
        
        while((scanf("%d",&point)) != EOF)
        {

                if(point >= 60) printf("Pass\n");

                else            printf("Fail\n");
        }

        return 0;
}

42. 判断整数奇偶性

问题描述：KiKi想知道一个整数的奇偶性，请帮他判断。从键盘任意输入一个整数（范围-231~231-1），编程判断它的奇偶性。
输入描述：多组输入，每行输入包括一个整数。
输出描述：针对每行输入，输出该数是奇数（Odd）还是偶数（Even）。
示例：

	输入：
		4
		7
	输出：
		Even
		Odd

代码实现：

#include 

int main()
{
        int n;
        while((scanf("%d",&n)) != EOF)
        {
                if(n % 2 == 0)  printf("Even\n");

                else            printf("Odd\n");
        }

        return 0;
}

43. 最高分数

问题描述：KiKi参加了语文、数学、外语的考试，请帮他判断三科中的最高分。从键盘任意输入三个整数表示的分数，编程判断其中的最高分。
数据范围： 0≤n≤100
输入描述：输入一行包括三个整数表示的分数（0~100），用空格分隔。
输出描述：输出为一行，即三个分数中的最高分。
示例1：
- 输入：94 98 99
- 输出：99
示例2：
- 输入：100 88 60
- 输出：100
代码实现：

#include 

int main()
{
        int Chinese,math,English;
        scanf("%d %d %d",&Chinese,&math,&English);

        if(Chinese > math)
        {
                if(Chinese > English)   printf("%d\n",Chinese);
                
                else                    printf("%d\n",English);
        }
        else 
        {
                if(math > English)      printf("%d\n",math);

                else                    printf("%d\n",English);
        }

        return 0;
}

44. 判断元音还是辅音

问题描述：KiKi开始学习英文字母，BoBo老师告诉他，有五个字母A(a), E(e), I(i), O(o),U(u)称为元音，其他所有字母称为辅音，请帮他编写程序判断输入的字母是元音（Vowel）还是辅音（Consonant）。
输入描述：多组输入，每行输入一个字母。
输出描述：针对每组输入，输出为一行，如果输入字母是元音（包括大小写），输出“Vowel”，如果输入字母是非元音，输出“Consonant”。
示例：

输入：
	A
	b
输出：
	Vowel
	Consonant

代码实现：

#include 

int main()
{
        char ch;

        while((scanf("%c",&ch)) != EOF)
        {
                getchar();//吸收掉换行符号
                if(ch == 'A'||ch== 'a'||ch == 'E'||ch == 'e'||ch == 'I'||ch == 'i'||ch == 'O'||ch == 'o'||ch == 'U'||ch == 'u')
                printf("Vowel\n");
                else    printf("Consonant\n");          
        }

        return 0;
}

45. 判断是不是字母

问题描述：KiKi想判断输入的字符是不是字母，请帮他编程实现。
输入描述：多组输入，每一行输入一个字符。
输出描述：针对每组输入，输出单独占一行，判断输入字符是否为字母，输出内容详见输出样例。
示例：

输入：
	A
	6
输出：
	A is an alphabet.
	6 is not an alphabet.

代码实现：

#include 

int main()
{
        char ch;

        while((ch = getchar()) != EOF)
        {
                if(('A'<= ch && ch <= 'Z')||('a' <= ch && ch <= 'z'))
                {
                        printf("%c is an alphabet.\n",ch);
                }
                else 
                {
                        printf("%c is not an alphabet.\n",ch);
                }
                getchar();
        }

        return 0;
}

46. 字母大小写转换

问题描述：KiKi想完成字母大小写转换，有一个字符，判断它是否为大写字母，如果是，将它转换成小写字母；反之则转换为大写字母。
输入描述：多组输入，每一行输入一个字母。
输出描述：针对每组输入，输出单独占一行，输出字母的对应形式。
示例：

输入：
	a
	A
	Z
输出：
	A
	a
	z

代码实现：

#include 

int main()
{
        char ch;
        while((ch = getchar()) != EOF)
        {
                if(ch >= 'A' && 'Z' >= ch)
                {
                        printf("%c\n",ch + 32);
                }
                else if(ch >= 'a' && 'z' >= ch)
                {
                        printf("%c\n",ch - 32);
                }
        }
        
        return 0;
}

47. 判断两个数的大小关系

问题描述：KiKi想知道从键盘输入的两个数的大小关系，请编程实现。
输入描述：题目有多组输入数据，每一行输入两个整数（范围-231~231-1），用空格分隔。
输出描述：针对每行输入，输出两个整数及其大小关系，数字和关系运算符之间没有空格，详见输入输出样例。
示例1：
- 输入：1 1
- 输出：1=1
示例2：
- 输入：1 0
- 输出：1>0
示例3：
- 输入：0 1
- 输出：0<1
代码实现：

#include 

int main()
{
        int a,b;
        while((scanf("%d%d",&a,&b)) != EOF)
        {
                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
输出描述：输出函数的值并换行。
示例：

输入：
		11
		0
		-11

输出：
		1
		0.5
		0

代码实现：

#include 

int main()
{
        int t;
        while((scanf("%d",&t)) != EOF)
        {
                if(t > 0)       printf("1\n")  ;
                else if(0 == t) 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!”。
示例：

输入：
		2 3 2
		3 3 3
输出：
		Isosceles triangle!
		Equilateral triangle!

代码实现：

#include 

int main()
{
        int a,b,c;

        while((scanf("%d %d %d",&a,&b,&c) != EOF))
        {
        		//任意两边之和大于第三边的就是三角形
                if(a+b>c && a+c > b && b+c > a)
                {
                        if(a == b && a == c)    
						{
								printf("Equilateral triangle!\n");
   						}
                        else if(a == b || b == c ||a == c)      
						{
								printf("Isosceles triangle!\n");
						}
                        else    
						{
								printf("Ordinary triangle!\n");
						}
                }
                else    printf("Not a triangle!\n");
        }

        return 0;
}

50. 衡量人体胖瘦程度

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

输入描述：多组输入，每一行包括两个整数，用空格隔开，分别为体重（公斤）和身高（厘米）。
输出描述：针对每行输入，输出为一行，人体胖瘦程度，即分类。
示例：

输入：
	80 170
	60 170
	90 160
	50 185
输出：
	Overweight
	Normal
	Obese
	Underweight

代码实现：

#include 
#include 

int main()
{
        int weight,hight;

        while((scanf("%d %d",&weight,&hight)) != EOF)
        {
                float BMI = weight / pow(hight/100.0,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 if(BMI > 27.9)                     printf("Obese\n");
        }

        return 0;
}

51. 计算一元二次方程

问题描述：从键盘输入a, b, c的值，编程计算并输出一元二次方程ax2 + bx + c = 0的根，当a = 0时，输出“Not quadratic equation”，当a ≠ 0时，根据△ = b2 - 4ac的三种情况计算并输出方程的根。
输入描述：多组输入，一行，包含三个浮点数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 / (2a),虚部= sqrt(-△ ) / (2a)所有实数部分要求精确到小数点后2位，数字、符号之间没有空格。
示例1：
- 输入：2.0 7.0 1.0
- 输出：x1=-3.35;x2=-0.15
示例2：
- 输入：0.0 3.0 3.0
- 输出：Not quadratic equation
示例3：
- 输入：1 2 1
- 输出：x1=x2=-1.00
示例4：
- 输入：2 2 5
- 输出：x1=-0.50-1.50i;x2=-0.50+1.50i
示例5：
- 输入：1 0 1
- 输出：x1=0.00-1.00i;x2=0.00+1.00i
代码实现：

#include
#include
int main()
{
    double a = 0.0;
    double b = 0.0;
    double c = 0.0;
    while (scanf("%lf %lf %lf", &a, &b, &c) != EOF)
    {
        if (a == 0)
        {
            printf("Not quadratic equation\n");
        }
        else
        {
            double deta = b * b - 4 * a * c;
            if (deta == 0)
            {
                if (a < 0)
                {
                    printf("x1=x2=%.2lf\n", (-b - sqrt(deta)) / (2 * a));//因为测试用例4 0 0会输出-0.00 所以加一个判断条件
                }
                else
                {
                    printf("x1=x2=%.2lf\n", (-b + sqrt(deta)) / (2 * a));
                }
            }
            else if (deta > 0)
            {
                printf("x1=%.2lf;x2=%.2lf\n", ((-b - sqrt(deta)) / (2 * a)), ((-b + sqrt(deta)) / (2 * a)));
            }
            else
            {
                double real = -b / (2 * a);
                double image = sqrt(-deta) / (2 * a);
                if (image < 0)//测试用例的 -1 5 -10 会出现 --  +- 所以加判断条件  把-号消掉
                {
                    image = (-image);
                }
                printf("x1=%.2lf-%.2lfi;x2=%.2lf+%.2lfi\n", real, image, real, image);
            }
        }
    }
    return 0;
}

52. 获取月份天数

问题描述：KiKi想获得某年某月有多少天，请帮他编程实现。输入年份和月份，计算这一年这个月有多少天。
输入描述：多组输入，一行有两个整数，分别表示年份和月份，用空格分隔。
输出描述：针对每组输入，输出为一行，一个整数，表示这一年这个月有多少天。
示例：
- 输入：2008 2
- 输出：29
代码实现：

#include 

int main()
{
        int year,month;

        while(scanf("%d %d",&year,&month) != ROF)
        {
                int month1[] = {31,29,31,30,31,30,31,31,30,31,30,31};
                int month2[] = {31,28,31,30,31,30,31,31,30,31,30,31};

                if((0 == year%4 && 0 != year%100)||(0 == year%400))
                {
                        printf("%d\n",month1[month - 1]);
                }
                else
                {
                        printf("%d\n",month2[month - 1]);
                }
        }

        return 0;
}

53. 简单计算器

问题描述：KiKi实现一个简单计算器，实现两个数的“加减乘除”运算，用户从键盘输入算式“操作数1运算符操作数2”，计算并输出表达式的值，如果输入的运算符号不包括在（+、-、*、/）范围内，输出“Invalid operation!”。当运算符为除法运算，即“/”时。如果操作数2等于0.0，则输出“Wrong!Division by zero!”
数据范围：字符串长度满足 3≤n≤50 ，保证运算符是一个char类型字符。
输入描述：输入一行字符串，操作数1+运算符+操作数2 （其中合法的运算符包括：+、-、*、/）。
输出描述：输出为一行。
- 如果操作数和运算符号均合法，则输出一个表达式，操作数1运算符操作数2=运算结果，各数小数点后均保留4位，数和符号之间没有空格。
- 如果输入的运算符号不包括在（+、-、*、/）范围内，输出“Invalid operation!”。当运算符为除法运算，即“/”时。
- 如果操作数2等于0.0，则输出“Wrong!Division by zero!”。
示例1：
- 输入：1.0+3.0
- 输出：1.0000+3.0000=4.0000
示例2：
- 输入：1.0;4.0
- 输出：Invalid operation!
示例3：
- 输入：44.0/0.0
- 输出：Wrong!Division by zero!
代码实现：

#include 

int main()
{
        double n1,n2;
        char op;

        while(scanf("%lf%c%lf",&n1,&op,&n2) != EOF)
        {
                switch(op)
                {
                        case '+':printf("%.4lf+%.4lf=%.4lf\n",n1,n2,n1+n2);break;
                        case '-':printf("%.4lf-%.4lf=%.4lf\n",n1,n2,n1-n2);break;
                        case '*':printf("%.4lf*%.4lf=%.4lf\n",n1,n2,n1*n2);break;
                        case '/':if(0.0 == n2)
                                {       
                                        printf("Wrong!Division by zero!\n");break;
                                }
                                 else
                                {
                                        printf("%.4lf/%.4lf=%.4lf\n",n1,n2,n1/n2);break;
                                }
                        default:printf("Invalid operation!\n");break;
                        
                }
        }

        return 0;
}

54. 线段图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的线段图案。
输入描述：多组输入，一个整数（1~100），表示线段长度，即“*”的数量。
输出描述：针对每行输入，输出占一行，用“*”组成的对应长度的线段。
示例：

输入：
	10
	2
输出：
	**********
	**

代码实现：

#include 

int main()
{
        int n;
        while(scanf("%d",&n) != EOF)
        {
                while(n--)      printf("*");
                putchar('\n');
        }

        return 0;
}

55. 正方形图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的正方形图案。
输入描述：多组输入，一个整数（1~20），表示正方形的长度，也表示输出行数。
输出描述：针对每行输入，输出用“”组成的对应边长的正方形，每个“”后面有一个空格。
示例1：

输入：4
输出：
	* * * *
	* * * *
	* * * *
	* * * *

示例2：

输入：5
输出：
	* * * * *
	* * * * *
	* * * * *
	* * * * *
	* * * * *

代码实现：

#include 

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

        return 0;
}

56. 直角三角形图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的直角三角形图案。
输入描述：多组输入，一个整数（2~20），表示直角三角形直角边的长度，即“*”的数量，也表示输出行数。
输出描述：针对每行输入，输出用“”组成的对应长度的直角三角形，每个“”后面有一个空格。
示例1：

输入：4
输出：
	*
	* *
	* * *
	* * * *

示例2：

输入：5
输出：
	*
	* *
	* * *
	* * * *
	* * * * *

代码实现：

#include 

int main()
{
        int n;
        while(scanf("%d",&n) != EOF)
        {
                for(int i = 0;i < n;i++)
                {
                        for(int j = 0;j <= i;j++)
                        {
                                printf("* ");
                        }
                        putchar('\n');
                }
        }

        return 0;
}

57. 翻转直角三角形图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的翻转直角三角形图案。
输入描述：多组输入，一个整数（2~20），表示翻转直角三角形直角边的长度，即“*”的数量，也表示输出行数。
输出描述：针对每行输入，输出用“”组成的对应长度的翻转直角三角形，每个“”后面有一个空格。
示例1：

输入：5
输出：
	* * * * *
	* * * *
	* * *
	* *
	*

示例2：

输入：6
输出：
	* * * * * *
	* * * * *
	* * * *
	* * *
	* *
	*

代码实现：

#include 

int main()
{
        int n;
        while(scanf("%d",&n) != EOF)
        {
                for(int i = 0;i < n;i++)
                {
                        for(int j = n;j > i;j--)
                        {
                                printf("* ");
                        }
                        putchar('\n');
                }
        }

        return 0;
}

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

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的带空格直角三角形图案。
输入描述：多组输入，一个整数（2~20），表示直角三角形直角边的长度，即“*”的数量，也表示输出行数。
输出描述：针对每行输入，输出用“”组成的对应长度的直角三角形，每个“”后面有一个空格。
示例1：

输入：5
输出：
        * 
      * * 
    * * * 
  * * * * 
* * * * *

示例2：

输入：4
输出：
      * 
    * * 
  * * * 
* * * *

代码实现：

#include 

int main()
{
        int n;
        while(scanf("%d",&n) != EOF)
        {
                for(int i = 0;i < n;i++)
                {
                        //第一行打印4对空格，第二行三对，3行两对...
                        for(int j = 0;j < n-i-1;j++)
                        {
                                printf("  ");//打印空格
                        }

                        //第1打印0+1颗*，第二行打印1+1颗*，第三行三颗*...
                        for(int j = 0;j < i + 1 ;j++)
                        {
                                printf("* ");
                        }
                        putchar('\n');
                }
        }

        return 0;
}

59. 金字塔图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的金字塔图案。
输入描述：多组输入，一个整数（2~20），表示金字塔边的长度，即“*”的数量，，也表示输出行数。
输出描述：针对每行输入，输出用“”组成的金字塔，每个“”后面有一个空格。
示例1：

输入：4
输出：
   * 
  * * 
 * * * 
* * * *

示例2：

输入：5
输出：
    * 
   * * 
  * * * 
 * * * * 
* * * * *

代码实现：

#include 

int main()
{
        int n;
        while(scanf("%d",&n) != EOF)
        {
                for(int i = 0;i < n;i++)
                {
                        for(int j = 0;j < n-i-1;j++)
                        {
                                printf(" ");
                        }
                        for(int j = 0;j <= i;j++)
                        {
                                printf("* ");
                        }
                        putchar('\n');
                }
        }

        return 0;
}

60. 翻转金字塔图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的翻转金字塔图案。
输入描述：多组输入，一个整数（2~20），表示翻转金字塔边的长度，即“*”的数量，也表示输出行数。
输出描述：针对每行输入，输出用“”组成的金字塔，每个“”后面有一个空格。
示例1：

输入：5
输出：
* * * * * 
 * * * * 
  * * * 
   * * 
    *

示例2：

输入：6
输出：
* * * * * * 
 * * * * * 
  * * * * 
   * * * 
    * * 
     *

代码实现：

#include 

int main()
{
        int n;
        while(scanf("%d",&n) != EOF)
        {
                //打印n行
                for(int i = 0;i < n;i++)
                {
                		//先根据i值来打印空格，i为0时不打印空格，i为1时打印一个空格...
                        for(int j = 0;j < i;j++)
                        {
                                printf(" ");
                        }
                        //第一行打印5组*+空格，第二行4组...
                        for(int j = 0;j <= n-i-1;j++)
                        {
                                printf("* ");
                        }
                        putchar('\n');
                }
        }

        return 0;
}

61. 菱形图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的菱形图案。
输入描述：多组输入，一个整数（2~20）。
输出描述：针对每行输入，输出用“ * ”组成的菱形，每个“ * ”后面有一个空格。
示例1：

输入：2
输出：
  * 
 * * 
* * * 
 * * 
  *

示例2：

输入：3
输出：
   * 
  * * 
 * * * 
* * * * 
 * * * 
  * * 
   *

示例3：

输入：4
输出：
    * 
   * * 
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 
   * * 
    *

代码实现：

#include 
int main()
{
        int n;

        //菱形分为两部分；
        //输入2则分成上两行下三行，输入3则上三下四行...
        while(scanf("%d",&n) != EOF)
        {
                //上半部分空格逐渐变少，*变多，打印n行
                for(int i = 0;i < n;i++)
                {
                        //每行的打印格式为：空格 + *
                        for(int j = 0;j < n-i;j++)
                        {
                                printf(" ");//每行打印n-i个空格
                        }
                        for(int j = 0;j <= i ;j++)
                        {
                                printf("* ");
                        }
                        putchar('\n');
                }

                //下半部分*逐渐变少，空格变多，答应n+1行
                for(int i = 0;i < n + 1;i++)
                {
                        //每行的打印格式为：空格 + *
                        for(int j = 0;j < i;j++)
                        {
                                printf(" ");//i是多少就在前面打印几个空格
                        }
                        for(int j = 0;j < n + 1-i;j++)
                        {
                                printf("* ");
                        }
                        putchar('\n');
                }             
        }
        return 0;
}

62. k形图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的K形图案。
输入描述：多组输入，一个整数（2~20）。
输出描述：针对每行输入，输出用“ * ”组成的 K 形，每个“ * ”后面有一个空格。
示例1：

输入：2
输出：
* * * 
* * 
* 
* * 
* * *

示例2：

输入：3
输出：
* * * * 
* * * 
* * 
* 
* * 
* * * 
* * * *

示例3：

输入：4
输出：
* * * * * 
* * * * 
* * * 
* * 
* 
* * 
* * * 
* * * * 
* * * * *

代码实现：

#include 
int main()
{
        int n;
        while(scanf("%d",&n) != EOF)
        {
                //同样分成上n行和下n+1行打印

                for(int i = 0;i < n;i++)
                {
                        //打印一行                      

                        for(int j = 0;j < n + 1-i;j++)
                        {
                                printf("* ");//打印 * + 空格
                        }
                        for(int j = 0;j < i;j++)
                        {
                                printf(" ");//打印空格
                        }
                        printf("\n");
                }
                for(int i = 0;i < n + 1;i++)
                {
                        for(int j = 0;j <= i;j++)
                        {
                                printf("* ");//* + 空格
                        }
                        for(int j = 0;j < n-i;j++)
                        {
                                printf(" ");//空格
                        }
                        putchar('\n');
                }
        }

        return 0;
}

63. 箭形图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的箭形图案。
输入描述：本题多组输入，每行一个整数（2~20）。
输出描述：针对每行输入，输出用“*”组成的箭形。
示例1：

输入：2
输出：
    *
  **
***
  **
    *

示例2：

输入：3
输出：
      *
    **
  ***
****
  ***
    **
      *

示例3：

输入：4
输出：
        *
      **
    ***
  ****
*****
  ****
    ***
      **
        *

代码实现：

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

64. 反斜线形图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的反斜线形图案。
输入描述：多组输入，一个整数（2~20），表示输出的行数，也表示组成反斜线的“ * ”的数量。
输出描述：针对每行输入，输出用“*”组成的反斜线。
示例1：

输入：4
输出：
*   
 *  
  * 
   *

示例2：

输入：5
输出：
*    
 *   
  *  
   * 
    *

代码实现：

#include 
int main()
{
        int n;
        while(scanf("%d",&n) != EOF)
        {
                for(int i = 0;i < n;i++)
                {
                        for(int j = 0;j < n;j++)
                        {
                                if(i == j)//在行列相等的地方打印*
                                {
                                        printf("*");
                                }
                                else //其余地方用空格填充
                                {
                                        printf(" ");
                                }
                        }
                        putchar('\n');
                }
        }
        return 0;
}

65. 正斜线图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的正斜线形图案。
输入描述：多组输入，一个整数（2~20），表示输出的行数，也表示组成正斜线的“ * ”的数量。
输出描述：针对每行输入，输出用“ * ”组成的正斜线。
示例1：

输入：4
输出：
   *
  * 
 *  
*

示例2：

输入：5
输出：
    *
   * 
  *  
 *   
*

代码实现：

#include 

int main()
{
        int n;
        while(scanf("%d",&n) != EOF)
        {
                for(int i = 0;i < n;i++)
                {
                        for(int j = 0;j < n;j++)
                        {
                                if(j == n-i-1)//在第n-i-1列处打印*
                                {
                                        printf("*");
                                }
                                else //其余地方用空格填充
                                {
                                        printf(" ");
                                }
                        }
                        putchar('\n');
                }
        }
        return 0;
}

66. X形图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的X形图案。
输入描述：多组输入，一个整数（2~20），表示输出的行数，也表示组成“X”的反斜线和正斜线的长度。
输出描述：针对每行输入，输出用“ * ”组成的X形图案。
示例1：

输入：5
输出：
*   *
 * * 
  *  
 * * 
*   *

示例2：

输入：6
输出：
*    *
 *  * 
  **  
  **  
 *  * 
*    *

解题思路：这题也就是把上面两题结合在一起而已。
代码实现：

#include 

int main()
{
        int n;
        while(scanf("%d",&n) != EOF)
        {
                for(int i = 0;i < n;i++)
                {
                        for(int j = 0;j < n;j++)
                        {
                                if(j == i || j == n-i-1)
                                {
                                        printf("*");
                                }
                                else
                                {
                                        printf(" ");
                                }
                        }
                        putchar('\n');
                }
        }
        return 0;
}

67. 空心正方形图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的“空心”正方形图案。
输入描述：多组输入，一个整数（3~20），表示输出的行数，也表示组成正方形边的“ * ”的数量。
输出描述：针对每行输入，输出用“*”组成的“空心”正方形，每个“ * ”后面有一个空格。
示例1：

输入：4
输出：
* * * * 
*     * 
*     * 
* * * *

示例2：

输入：5
输出：
* * * * * 
*       * 
*       * 
*       * 
* * * * *

代码实现：

#include 

int main()
{
    int n;
    while(scanf("%d",&n) != EOF)
    {
        for(int i = 0;i < n;i++)
        {
            for(int j = 0;j < n;j++)
            {
                if(0 == i || i == n-1)
                {
                    printf("* ");
                }
                else if(0 == j || j == n-1)
                {
                    printf("* ");
                }
                else {
                    printf("  ");//双空格
                }
            }
            putchar('\n');
        }
    }
    return 0;
}

68. 空心三角形图案

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的“空心”三角形图案。
输入描述：多组输入，一个整数（3~20），表示输出的行数，也表示组成三角形边的“ * ”的数量。
输出描述：针对每行输入，输出用“”组成的“空心”三角形，每个“”后面有一个空格。
示例1：

输入：4
输出：
*       
* *     
*   *   
* * * *

示例2：

输入：5
输出：
*         
* *       
*   *     
*     *   
* * * * *

解题思路：第一列和最后一行都打印满，以及行列相同时则打印 *+空格，其余情况打印双空格。
代码实现：

#include 

int main()
{
    int n;
    while(scanf("%d",&n) != EOF)
    {
        for(int i = 0;i < n;i++)
        {
            for(int j = 0;j <= i;j++)
            {
                if(j == 0 || i == n-1 || i == j)
                {
                    printf("* ");
                }
                else {
                    printf("  ");//双空格
                }
            }
            putchar('\n');
        }
    }
    return 0;
}

69. 新年快乐

问题描述：新年到来，输出信息迎接新年。
输入描述：无
输出描述：Happy New Year2019
代码实现：

#include 

int main()
{
        printf("Happy New Year*2019*\n");

        return 0;
}

70. 平均身高

问题描述：从键盘输入5个人的身高（米），求他们的平均身高（米）。
输入描述：一行，连续输入5个身高（范围0.00~2.00），用空格分隔。
输出描述：一行，输出平均身高，保留两位小数。
示例：
- 输入：1.68 1.75 1.82 1.60 1.92
- 输出：1.75
代码实现：

#include 

int main()
{
        float arr[5] = {0};
        float sum = 0;
        for(int i = 0;i < 5;i++)
        {
                scanf("%f ",&arr[i]);
                sum += arr[i];
        }
        printf("%.2f\n",sum / 5);
        return 0;
}

71. 挂科危险

问题描述：KiKi想知道这学期他的学习情况，BoBo老师告诉他这学期挂的科目累计的学分，根据所挂学分，判断KiKi学习情况，10分以上：很危险(Danger++)，4~9分：危险(Danger)，0 ~ 3:Good。
输入描述：一行，一个整数（0~30），表示KiKi挂的科目累计的学分。
输出描述：一行，根据输入的挂科学分，输出相应学习情况（Danger++，Danger，Good）。
示例1：
- 输入：14
- 输出：Danger++
示例2：
- 输入：9
- 输出：Danger
示例3：
- 输入：1
- 输出：Good
代码实现：

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

    if (a >= 10)
        printf("Danger++\n");
    else if (a >= 4 && a <= 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

示例：
- 输入：200
- 输出：OK
代码实现：

#include 

int main()
{
        int HTTP;
        while(scanf("%d",&HTTP) != EOF)
        {
                switch(HTTP)
                {
                        case 200:printf("OK\n");break;
                        case 202:printf("Accepted\n");break;
                        case 400:printf("Bad Request\n");break;
                        case 403:printf("Forbidden\n");break;
                        case 404:printf("Not Found\n");break;
                        case 500:printf("Internal Server Error\n");break;
                        case 502:printf("Bad Gateway\n");break;
                }
        }
        return 0;
}

73. 数字三角形

问题描述：KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用数字组成的数字三角形图案。
输入描述：多组输入，一个整数（3~20），表示数字三角形边的长度，即数字的数量，也表示输出行数。
输出描述：针对每行输入，输出用数字组成的对应长度的数字三角形，每个数字后面有一个空格。
示例1：

输入：4
输出：
1
1 2
1 2 3
1 2 3 4

示例2：

代码实现：

#include 
 
int main()
{
    int n;
    while(scanf("%d",&n) != EOF)
    {
        for(int i = 1;i <= n;i++)
        {
            for(int j = 1;j <= i;j++)//i行就打印i列
            {
                printf("%d ",j);              
            }
            putchar('\n');
        }
    }
    return 0;
}

74. 公务员面试

问题描述：公务员面试现场打分。有7位考官，从键盘输入若干组成绩，每组7个分数（百分制），去掉一个最高分和一个最低分，输出每组的平均成绩。
（注：本题有多组输入）
输入描述：每一行，输入7个整数（0~100），代表7个成绩，用空格分隔。
输出描述：每一行，输出去掉最高分和最低分的平均成绩，小数点后保留2位，每行输出后换行。
示例：
- 输入：99 45 78 67 72 88 60
- 输出：73.00
解题思路：一边输入，一边求和，一边求最大最小值，最后求平均值。
代码实现：

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

75. 有序序列插入一个数

问题描述：有一个有序数字序列，从小到大排序，将一个新输入的数插入到序列中，保证插入新数后，序列仍然是升序。
输入描述：
- 第一行输入一个整数(0≤N≤50)。
- 第二行输入N个升序排列的整数，输入用空格分隔的N个整数。
- 第三行输入想要进行插入的一个整数。
输出描述：输出为一行，N+1个有序排列的整数。
示例：

输入：
	5
	1 6 9 22 30
	8
输出：1 6 8 9 22 30

解题思路：从后往前比较一定数字找到合适的位置，就可以插入数字了，但是如果插入的数字比所有的元素都小，那就插入到第一个位置上。
代码实现：

#include 
int main()
{
        int n,i;
        int arr[51] = {0};
        int m;//要插入的数字

        scanf("%d",&n);//输入个数

        for(i = 0;i < n;i++)//输入有序的数字
        {
                scanf("%d",&arr[i]);
        }

        scanf("%d",&m);//输入要插入的数字

        //从后往前一个一个的找，
        //找到第一个比m小的数则将m放在它后面
        for(i = n-1;i >= 0;i--)
        {
                if(m < arr[i])
                {
                        arr[i + 1] = arr[i];//将比m大的数往后移动
                }
                else
                {
                        arr[i + 1] = m;//插在比m小的数字后面
                        break;
                }
        }
        if(i < 0)//数组中所有元素都比m大
        {
                arr[0] = m;//将m放到第一个位置
        }
        for(i = 0;i < n+1;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 的个数。每行输出后换行。
示例：

输入：20
输出：2 3 5 7 11 13 17 19
	 11

代码实现：

#include 
int main()
{
        int n;
        while(scanf("%d",&n) != EOF)
        {
                int i,arr[101];
                for(i = 2;i <= n;i++)//将2到n之间的数存起来
                {
                        arr[i] = i;
                }
                int j;
                for(j = 2;j <= n;j++)//列举所有的除数：2～n
                {
                        int k;
                        //用j之后的数来除j
                        for(k = j + 1;k <= n;k++)
                        {
                                //j之后的数 % j如果等于0，则将其置为0
                                if(0 == arr[k] % j)
                                {
                                        arr[k] = 0;
                                }
                        }
                }
                int count = 0;
                //输出并记录
                for(i = 2;i <= n;i++)
                {
                        if(arr[i] != 0)//这就是筛选出来的素数
                        {
                                printf("%d ",arr[i]);
                        }
                        else    count++ ;
                }
                printf("\n%d\n",count);//在第二行打印被清零的数的个数
        }
        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,n;
        int arr1[100][100] = {0};//m 和n最大取值都是100
        int arr2[100][100] = {0};
        int count = 0;//统计有多少个位置上的数相等      

        scanf("%d %d",&m,&n);
        int i,j;
        for(i = 0;i < m;i++)//m行
        {
                for(j = 0;j < n;j++)//n列
                {
                        scanf("%d",&arr1[i][j]);
                }
        }
        for(i = 0;i < m;i++)//m行
        {
                for(j = 0;j < n;j++)//n列
                {
                        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\n",100.0 * count / (m * n));
        return 0;
}

78. 登录验证

问题描述：有个软件系统登录的用户名和密码为（用户名：admin，密码：admin），用户输入用户名和密码，判断是否登录成功。
输入描述：多组测试数据，每行有两个用空格分开的字符串，第一个为用户名，第二个为密码。
输出描述：针对每组输入测试数据，输出为一行，一个字符串（“Login Success!”或“Login Fail!”）。
示例1：
- 输入：admin admin
- 输出：Login Success!
示例2：
- 输入：admin abc
- 输出：Login Fail!
代码实现：

#include 
#define MAX 100
#include 

int main()
{
        char name[MAX];
        char code[MAX];

        while(scanf("%s %s",&name,&code) != EOF)
        {
                if(!strcmp(name,"admin") && !strcmp(code,"admin"))
                {
                        printf("Login Success!\n");
                }
                else
                {
                        printf("Login Fail!\n");
                }
        }

        return 0;
}

79. 学好C++

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

//学好C++

#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”的计算结果。
示例：
- 输入：1 3 2 4
- 输出：8
代码实现：

#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（结果大小写敏感）。
示例1：
- 输入：10
- 输出：YES
示例2：
- 输入：9
- 输出：NO
代码实现：

#include 

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

        if(0 == n % 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的值。
示例1：
- 输入：10
- 输出：-1
示例2：
- 输入：-10
- 输出：1
代码实现：

#include 
int main()
{
        int x,y;
        scanf("%d",&x);

        if(x < 0)       y = 1;
        
        else if(x > 0)  y = -1;
        
        else            y = 0;

        printf("%d\n",y);

        return 0;
}

83. 包含数字9的数

问题描述：今年是2019年，KiKi想知道1~2019中有多少个包含数字9的数。包含数字的数是指有某一位是“9”的数，例如“2019”、“199”等。
输入描述：无
输出描述：一行，一个整数，表示1~2019中共有多少个数包含数字9。
代码实现：

#include 
int main()
{
        int count = 0;
        for(int i = 1;i <= 2019;i++ )
        {
                int m = i;
                while(m)
                {
                		//不停地取出个十百千位上的数判断是否为9
                        if(9 == m % 10)
                        {
                                count++ ;
                                break;
                        }
                        m /= 10;
                }
        }
        printf("%d\n",count);
        return 0;
}

84. 奇偶统计

问题描述：任意输入一个正整数N，统计1~N之间奇数的个数和偶数的个数，并输出。
输入描述：一行，一个正整数N。（1≤N≤100,000）
输出描述：一行，1~N之间奇数的个数和偶数的个数，用空格分开。
示例:
- 输入：5
- 输出：3 2
代码实现：

#include 
int main()
{
        int n,odd = 0,even = 0;
        scanf("%d",&n);

        for(int i = 1;i <= n;i++)
        {
                if(0 == i % 2)  even++ ;//偶数

                else            odd++ ;//奇数
        }
        printf("%d %d\n",odd,even);

        return 0;
}

85. 统计成绩

问题描述：输入n科成绩（浮点数表示），统计其中的最高分，最低分以及平均分。
数据范围：1≤n≤100 ，成绩使用百分制且不可能出现负数
输入描述：两行，
- 第1行，正整数n（1≤n≤100）
- 第2行，n科成绩（范围0.0~100.0），用空格分隔。
输出描述：输出一行，三个浮点数，分别表示，最高分，最低分以及平均分（小数点后保留2位），用空格分隔。
示例：

输入：
	5
	99.5 100.0 22.0 60.0 88.5
输出：
	100.00 22.00 74.00

代码实现：

#include 
int main()
{
        int n;

        scanf("%d",&n);

        float score[n];
        float sum = 0,max = 0,min = 100;

        for(int i = 0;i < n;i++)
        {
                scanf("%f",&score[i]);
                sum += score[i];
                if(score[i] > max)      max = score[i];
                if(score[i] < min)      min = score[i];                       
        }
        printf("%.2f %.2f %.2f\n",max,min,sum/n);
        return 0;
}

86. 密码验证

问题描述：用户登录网站，通常需要注册，一般需要输入两遍密码。请编程判断输入的两次密码是否一致，一致输出“same”，不一致输出“different”
输入描述：每行有两个用空格分开的字符串，第一个为密码，第二个为重复密码。
输出描述：每组输出一个字符串（“same”或“different”）。
示例：
- 输入：abc abc
- 输出：same
解题思路：用两个字符串数组存储两次密码，然后用 strcmp 函数来判断是否相等。
代码实现：

#include 
#include 
#define MAX 100

int main()
{
        char arr1[MAX];
        char arr2[MAX];

        scanf("%s %s",&arr1,&arr2);

        if(!strcmp(arr1,arr2))  printf("same\n");

        else                    printf("different\n");

        return 0;
}

87. 矩阵计算

问题描述：输入NxM矩阵，矩阵元素均为整数，计算其中大于零的元素之和。
输入描述：第一行为N M(N: 矩阵行数；M: 矩阵列数,且M,N<=10)，接下来的N行为矩阵各行。
输出描述：一行，其中大于零的元素之和。
示例：

输入：
	3 3
	2 3 4
	-5 -9 -7
	0 8 -4
输出：17

代码实现：

#include 
int main()
{
        int n,m,num,sum = 0;
        scanf("%d %d",&n,&m);

        //获取n行m列的矩阵
        for(int i = 0;i < n;i++)
        {
                for(int j = 0;j < m;j++)
                {
                        scanf("%d",&num);
                        if(num > 0)
                        {
                                sum += num;
                                //计算矩阵中大于0的元素之和
                        }
                }
        }       
        printf("%d\n",sum);     
        return 0;
}

88. 成绩输入输出问题

问题描述：输入10科成绩，换行显示输入的10科成绩。
输入描述：一行，输入10科成绩（整数表示，范围0~100），用空格分隔。
输出描述：一行，输出输入的10科成绩，用空格分隔。
示例：
- 输入：98 100 99 97 95 99 98 97 96 100
- 输出：98 100 99 97 95 99 98 97 96 100
代码实现：

#include 

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

        return 0;
}

89. 逆序输出

问题描述：输入10个整数，要求按输入时的逆序把这10个数打印出来。逆序输出，就是按照输入相反的顺序打印这10个数。
输入描述：一行，输入10个整数（范围-231~231-1），用空格分隔。
输出描述：一行，逆序输出输入的10个整数，用空格分隔。
示例：
- 输入：1 2 3 4 5 6 7 8 9 10
- 输出：10 9 8 7 6 5 4 3 2 1
代码实现：

#include 

int main()
{
        int num[10];
        for(int i = 0;i < 10;i++)
        {
                scanf("%d ",&num[i]);
        }
        for(int j = 9;j >= 0;j--)
        {
                printf("%d ",num[j]);
        }
        putchar('\n');

        return 0;
}

90. 统计数据正负个数

问题描述：输入10个整数，分别统计输出正数、负数的个数。
输入描述：输入10个整数（范围-231~231-1），用空格分隔。
输出描述：两行，第一行正数个数，第二行负数个数，具体格式见样例。
示例：

输入：
-1 2 3 -6 7 8 -1 6 8 10
输出：
positive:7
negative:3

代码实现：

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

        return 0;
}

91. N个数之和

问题描述：输入数字N，然后输入N个数，计算这N个数的和。
输入描述：第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。
输出描述：输出为一行，为第二行输入的“N个整数之和”的计算结果。
示例：

输入：
5
1 2 3 4 5
输出：
15

代码实现：

#include 
int main()
{
        int n,sum = 0;
        scanf("%d",&n);

        for(int i = 0;i < n;i++)
        {
                int num[n];
                scanf("%d ",&num[i]);
                sum += num[i];
        }
        printf("%d",sum);
        return 0;
}

92. 最高分和最低分之差

问题描述：输入n个成绩，换行输出n个成绩中最高分数和最低分数的差。
输入描述：两行，
- 第一行为n，表示n个成绩，不会大于10000。
- 第二行为n个成绩（整数表示，范围0~100），以空格隔开。
输出描述：一行，输出n个成绩中最高分数和最低分数的差。
示例：

输入：
10
98 100 99 97 95 99 98 97 96 100
输出：
5

代码实现：

#include 
int main()
{
        int n,max = 0,min = 100;
        scanf("%d",&n);

        for(int i = 0;i < n;i++)
        {
                int score[n];
                scanf("%d ",&score[i]);

                if(score[i]  > max)
                {
                        max = score[i];
                }
                if(score[i] < min)
                {
                        min = score[i];
                }
        }
        printf("%d\n",max - min);

        return 0;
}

93. 有序序列判断

问题描述：输入一个整数序列，判断是否是有序序列，有序，指序列中的整数从小到大排序或者从大到小排序(相同元素也视为有序)。
数据范围： 3≤n≤50 序列中的值都满足 1≤val≤100
输入描述：
- 第一行输入一个整数N(3≤N≤50)。
- 第二行输入N个整数，用空格分隔N个整数。
输出描述：输出为一行，如果序列有序输出sorted，否则输出unsorted。
示例1：

输入：
5
1 6 9 22 30
输出：sorted

示例2：

输入：
5
3 4 7 2 10
输出：unsorted

示例3：

输入：
5
1 1 1 1 1
输出：sorted

解题思路：如果前面出现了一组升序的数，后面的所有数都得是，升序如果出现降序则不有序，降序同理。
代码实现：

#include 
int main()
{
        int n;
        int arr[50];
        scanf("%d",&n);
        int flag1 = 0;//升序
        int flag2 = 0;//降序

        for(int i = 0;i < n;i++)
        {
                scanf("%d ",&arr[i]);

                if(i > 0)//表示数组当前有两个元素
                {
                        if(arr[i]> arr[i-1])
                        {
                                flag1 = 1;//升序
                        }
                        else
                        {
                                flag2 = 1;//降序
                        }
                }
        }
        //如果前面出现了升序flag变成1，后面又出现降序flag也成了1
        //所以就需要判断相加是否等于1了
        if(1 == flag1 + flag2)  printf("sorted\n");
        
        else    printf("unsorted\n");

        return 0;
}

94. 序列中删除指定数字

问题描述：有一个整数序列（可能有重复的整数），现删除指定的某一个整数，输出删除指定数字之后的序列，序列中未被删除数字的前后位置没有发生改变。
数据范围：序列长度和序列中的值都满足 1≤n≤50
输入描述：
- 第一行输入一个整数(0≤N≤50)。
- 第二行输入N个整数，输入用空格分隔的N个整数。
- 第三行输入想要进行删除的一个整数。
输出描述：输出为一行，删除指定数字之后的序列。
示例1：

输入：
6
1 2 3 4 5 9
4
输出：
1 2 3 5 9

示例2：

代码实现：

#include 
int main()
{
        int n = 0;
        int arr[50] = {0};
        int m = 0;
        //输入数据

        scanf("%d",&n);
        int i = 0;
        int j = 0;
        for(i = 0;i < n;i++)
        {
                scanf("%d",&arr[i]);
        }
        scanf("%d",&m);

        //i用来遍历数组，
        //j用来记录存放数据位置的下标
        for(i = 0;i < n;i++)
        {
                if(arr[i]!= m)
                {
                        arr[j++] = arr[i];
                }
        }

        //此时j中存放着未被删除的其余元素下标
        for(i= 0;i< j;i++)
        {
                printf("%d ",arr[i]);
        }
        return 0;
}

95. 序列中整数去重

问题描述：输入n个整数的序列，要求对这个序列进行去重操作。所谓去重，是指对这个序列中每个重复出现的整数，只保留该数第一次出现的位置，删除其余位置。
输入描述：输入包含两行，第一行包含一个正整数n（1 ≤ n ≤ 1000），表示第二行序列中数字的个数；第二行包含n个整数（范围1~5000），用空格分隔。
输出描述：输出为一行，按照输入的顺序输出去重之后的数字，用空格分隔。
示例：

输入：
	5
	10 12 93 12 75
输出：
	10 12 93 75

解题思路：让每一个数字和后面所有元素比较；
- 如果出现相等，则将相等的元素后面的元素往前挪，覆盖重复元素。
代码实现：

#include 

int main()
{
        int n,i,j;
        int arr[1000];
        scanf("%d",&n);

        for(i = 0;i < n;i++)
        {
                scanf("%d",&arr[i]);
        }

        //去重
        for(i = 0;i < n;i++)
        {
                //判断arr[i]是否在后面出现
                for(j = i + 1;j < n;j++)
                {
                        if(arr[i] == arr[j])
                        {
                                //去重
                                //将重复元素后面的元素往前覆盖
                                int k;
                                for(k = j;k < n - 1;k++)
                                {
                                        arr[k] = arr[k + 1];
                                }
                                n--;//删了一个重复元素
                                j--;
                                //如果去重了arr[j]
                                //把下一个位置的数字arr[j+1]，放在新的arr[j]上
                                //恰好又和arr[i]相同,所以也要再判断
                        }
                }
        }
        //打印剩下的元素
        for(i = 0;i < n;i++)
        {
                printf("%d ",arr[i]);
        }
        return 0;
}

96. 有序序列合并

问题描述：输入两个升序排列的序列，将两个序列合并为一个有序序列并输出。
数据范围：1≤n,m≤1000 ，序列中的值满足 0≤val≤30000
输入描述：输入包含三行，
- 第一行包含两个正整数n, m，用空格分隔。n表示第二行第一个升序序列中数字的个数，m表示第三行第二个升序序列中数字的个数。
- 第二行包含n个整数，用空格分隔。
- 第三行包含m个整数，用空格分隔。
输出描述：输出为一行，输出长度为n+m的升序序列，即长度为n的升序序列和长度为m的升序序列中的元素重新进行升序序列排列合并。
示例：

输入：
		5 6
		1 3 7 9 22
		2 8 10 17 33 44
输出：
		1 2 3 7 8 9 10 17 22 33 44

代码实现：

#include 
int main()
{
        int n,m,arr[2000]={0};
        int i,j,tmp;
        scanf("%d %d\n",&n,&m); // 接收 n m

        for(i = 0;i < n + m;i++)//往里存n+m个数
        {     
                scanf("%d",&arr[i]);
        }
        for(i = 0;i < n + m;i++)//排序
        {         
                for(j = i + 1;j < n + m;j++)
                {
                        if(arr[i] > arr[j])
                        {
                                tmp = arr[i];
                                arr[i] = arr[j];
                                arr[j] = tmp;
                        }
        }
                printf("%d ",arr[i]);
        }
        return 0;
}

97. 班级成绩输入输出

问题描述：输入一个班级5个学生各5科成绩，输出5个学生各5科成绩及总分。
输入描述：五行，每行输入一个学生各5科成绩（浮点数表示，范围0.0~100.0），用空格分隔。
输出描述：五行，按照输入顺序每行输出一个学生的5科成绩及总分（小数点保留1位），用空格分隔。
示例：

输入：
		98.5 96.0 100 99 88
		60.5 77 88.5 99 60
		80 80.5 89 91 92
		93 94 95.5 96 97.5
		100 98 88.5 88 78.5
输出：
		98.5 96.0 100.0 99.0 88.0 481.5
		60.5 77.0 88.5 99.0 60.0 385.0
		80.0 80.5 89.0 91.0 92.0 432.5
		93.0 94.0 95.5 96.0 97.5 476.0
		100.0 98.0 88.5 88.0 78.5 453.0

代码实现：

#include 
int main()
{
        int i;
        for(i = 0;i < 5;i++)
        {
                double score,sum = 0;
                //读取一个人的五科成绩
                for(int j = 0;j < 5;j++)
                {
                        scanf("%lf",&score);
                        sum += score;
                        printf("%.1lf ",score);
                }
                
                printf("%.1lf\n",sum);
        }
        return 0;
}

98. 矩阵元素定位

问题描述：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,i,j,x,y;
        int arr[10][10];

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

        //接收矩阵数据
        for(i = 1;i <= n;i++)//n行
        {
                for(j = 1;j <= m;j++)//m列
                {
                        scanf("%d",&arr[i][j]);
                }
        }
        scanf("%d %d",&x,&y);
        printf("%d\n",arr[x][y]);
        
        return 0;
}

99. 序列重组矩阵

问题描述：KiKi现在得到一个包含nm个数的整数序列，现在他需要把这nm个数按顺序规划成一个n行m列的矩阵并输出，请你帮他完成这个任务。
输入描述：一行，输入两个整数n和m，用空格分隔，第二行包含n*m个整数（范围-231~231-1）。(1≤n≤10, 1≤m≤10)
输出描述：输出规划后n行m列的矩阵，每个数的后面有一个空格。
示例：

输入：
		2 3
		1 2 3 4 5 6
输出：
		1 2 3
		4 5 6

代码实现：

#include 
int main()
{
        int arr[10][10];
        int n,m,i,j;

        scanf("%d %d",&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(j = 0;j < m;j++)
                {
                        printf("%d ",arr[i][j]);
                }
                putchar('\n');
        }
        return 0;
}

100. 最高身高

问题描述：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,num,max = 0;
        int x,y;
        scanf("%d %d",&n,&m);

        for(i = 1;i <= n;i++)
        {
                for(j = 1;j <= m;j++)
                {
                        scanf("%d",&num);
                        if(num > max)
                        {
                                max = num;
                                x = i,y = j;
                                //找到最大值时要把坐标存起来
                        }
                }
        }
        printf("%d %d\n",x,y);
        return 0;
}

101. 矩阵相等判定

问题描述：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"并换行。
示例：

输入：
		2 2
		1 2
		3 4
		1 2
		3 4
输出：
		Yes

代码实现：

#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]);
                }
        }
        //比较两个数组对应位置的元素
        for(i = 0;i < n;i++)
        {
                for(j = 0;j < m;j++)
                {
                        if(arr1[i][j] != arr2[i][j])
                        {
                                printf("No\n");
                                return 0;
                        }
                }
        }
        printf("Yes\n");
        return 0;
}

102. 上三角矩阵判定

问题描述：KiKi想知道一个n阶方矩是否为上三角矩阵，请帮他编程判定。上三角矩阵即主对角线以下的元素都为0的矩阵，主对角线为从矩阵的左上角至右下角的连线。
输入描述：第一行包含一个整数n，表示一个方阵包含n行n列，用空格分隔。 (1≤n≤10)从2到n+1行，每行输入n个整数（范围-231~231-1），用空格分隔，共输入n*n个数。
输出描述：一行，如果输入方阵是上三角矩阵输出"YES"并换行，否则输出"NO"并换行。
示例：

输入：
		3
		1 2 3
		0 4 5
		0 0 6
输出：
		YES

解题思路：对角线以下的元素都是 0 的，则为上三角矩阵。
- 所有为 0 元素的坐标的特点是：i > j，也就是说只要判断当 i > j 时的所有元素是否为 0 即可。

代码实现：

#include 
int main()
{
	int n,i,j;
	int arr[10][10];
	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 < n;j++)
		{
			if(i > j)
			{
				if(0 != arr[i][j])
				{
					printf("NO\n");
					return 0;
				}
			}
		}
	}
	printf("YES\n");
	return 0;
}

103. 矩阵转置

问题描述：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,m,i,j;
        int arr[10][10];
        scanf("%d %d",&n,&m);

        for(i = 0;i < n;i++)
        {
                for(j = 0;j < m;j++)
                {
                        scanf("%d",&arr[i][j]);
                }
        }
        for(i = 0;i < m;i++)
        {
                for(j = 0;j < n;j++)
                {
                        printf("%d ",arr[j][i]);
                        //行变成了用j控制，列则由i控制
                }
                putchar('\n');
        }      
        return 0;
}

104. 矩阵交换

问题描述：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列，为矩阵交换后的结果。每个数后面有一个空格。
示例1：
输入：

示例2：

代码实现：

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

	int k;//操作k次	
	scanf("%d",&k);//k\n,输入k次之后敲回车还剩个\n

	char t;
	int  a,b;
	for(i = 0;i < k;i++)//每一次操作的过程
	{
		scanf(" %c %d %d",&t,&a,&b);
		//%c前多个空格能消化掉上面剩下的\n
		//不让t接收到的值变成\n

		if(t == 'r')//交换a和b行
		{
			for(j = 0;j < m;j++)
			{
				int tmp = arr[a-1][j];
				arr[a-1][j]= arr[b-1][j];
				arr[b-1][j]= tmp;
			}
		}
		else if(t == 'c')//交换a和b列
		{
			for(j = 0;j < n;j++)
			{
				int tmp = arr[j][a-1];
				arr[j][a-1]= arr[j][b-1];
				arr[j][b-1]= tmp;
			}
		}		
	}
	
	//交换完之后打印
	for(i = 0;i < n;i++)
	{
		for(j = 0;j < m;j++)
		{
			printf("%d ",arr[i][j]);
		}
		putchar('\n');
	}
	
	return 0;
}

105. 杨辉三角

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

输入：6
输出：
    1
    1    1
    1    2    1
    1    3    3    1
    1    4    6    4    1
    1    5   10   10    5    1

解题思路：
- 前提：每行端点与结尾的数为1。
- 每个数为上方的两数之和，且头两行无需计算全都是1。
- 行列相等的位置的值为1。
- 在框起来的三角形内行都是>=2的，列都是>=1的。当行列都在范围内的时候才需要去计算。

代码实现：

#include 
int main()
{
	int n,i,j;
	int arr[30][30];
	scanf("%d",&n);
	
	for(i = 0;i < n;i++)
	{
		for(j = 0;j < n;j++)
		{
			if(0 == j)//将第0列的值置为1
			{
				arr[i][j] = 1;
			}
			if(i == j)//将对角线的值置为1
			{
				arr[i][j] = 1;
			}
			if(i >= 2 && j >= 1)
			{
				arr[i][j] = arr[i-1][j-1]+ arr[i-1][j];
			}
		}
	}
	for(i = 0;i < n;i++)
	{
		//要打印三角形，i打印多少j就打印多少
		for(j = 0;j <= i;j++)
		{
			printf("%5d",arr[i][j]);
		}
		putchar('\n');
	}
	return 0;
}

106. 井字棋

问题描述：KiKi 和 BoBo 玩 “井”字棋。也就是在九宫格中，只要任意行、列，或者任意对角线上面出现三个连续相同的棋子，就能获胜。请根据棋盘状态，判断当前输赢。
输入描述：三行三列的字符元素，代表棋盘状态，字符元素用空格分开，代表当前棋盘，其中元素为K代表KiKi玩家的棋子，为O表示没有棋子，为B代表BoBo玩家的棋子。
输出描述：
- 如果KiKi获胜，输出“KiKi wins!”；
- 如果BoBo获胜，输出“BoBo wins!”；
- 如果没有获胜，输出“No winner!”。
示例：

输入：
		K O B
		O K B
		B O K
输出：KiKi wins!

解题思路：判断横3、竖3、对角线上的元素是否相等即可。
代码实现：

#include 
int main()
{
	int i,j;
	char arr[3][3];
	
	for(i = 0;i < 3;i++)
	{
		for(j = 0;j < 3;j++)
		{
			scanf(" %c",&arr[i][j]);
			//记得消化掉按下回车之后剩余的\n
		}
	}

	//判断输赢
	char flag = 'O';
	for(i = 0;i < 3;i++)
	{
		//判断某一行的三个是否相等且不为'O'
		if(arr[i][0]==arr[i][1]&&arr[i][1]==arr[i][2]&&arr[i][1]!='O')
		{
			flag = arr[i][1];
			break;
		}
		//判断某一列的三个是否相等且不为'O'
		if(arr[0][i]==arr[1][i]&&arr[1][i]==arr[2][i]&&arr[1][i]!='O')
                {
                        flag = arr[1][i];
                        break;
                }

	}
	//判断对角线上的三个是否相等
	if(arr[0][0]== arr[1][1]&&arr[1][1]==arr[2][2]&&arr[1][1]!='O')
	{
		flag = arr[1][1];
	}
	//判断另一条对角线
	if(arr[0][2]== arr[1][1]&&arr[1][1]==arr[2][0]&&arr[1][1]!='O')
        {
                flag = arr[1][1];
        }

	if('K' == flag)			printf("KiKi wins!\n");
	
	else if('B' == flag)	printf("BoBo wins!\n");
	
	else					printf("No winner!\n");

	return 0;
}

107. 小乐乐与进制转换

问题描述：小乐乐在课上学习了二进制八进制与十六进制后，对进制转换产生了浓厚的兴趣。因为他的幸运数字是6，所以他想知道一个数表示为六进制后的结果。请你帮助他解决这个问题。
输入描述：输入一个正整数n (1 ≤ n ≤ 109)
输出描述：输出一行，为正整数n表示为六进制的结果
示例1：
- 输入：6
- 输出：10
示例2：
- 输入：120
- 输出：320
解题思路：
- 先让输入的数 n % 6 得到当前数转换成六进制的最低位;
- 然后让 n / 6，用得到的结果继续 % 6 获得第二低位;
- 不停重复上述步骤，直到 n / 6 的结果为 0 为止。
- 最后将得出的结果翻转过来，就是十进制转六进制的最终结果。

代码实现：

#include 
int main()
{
        int n,i = 0;
        int arr[40];//将%6,/6后得到的结果存起来
        scanf("%d",&n);

        //转换
        while(n)//如果n不为0,说明还有能拿下来的位
        {
                arr[i] = n % 6;
                i++ ;
                n = n / 6;//去掉最低位
        }
        for(i--;i >= 0;i--)
        {
                printf("%d",arr[i]);
                //将得到的数翻转过来就是6进制
        }
        return 0;
}

108. 小乐乐求和

问题描述：小乐乐最近接触了求和符号Σ，他想计算
的结果。但是小乐乐很笨，请你帮助他解答。
输入描述：输入一个正整数n (1 ≤ n ≤ 109)
输出描述：输出一个值，为求和结果。
示例1：
- 输入：1
- 输出：1
示例2：
- 输入：10
- 输出：55
代码实现1：

#include 
int main()
{
        long long n,sum = 0;
        scanf("%lld",&n);

        for(int i = 1;i <= n;i++)
        {
                sum += i;
        }
        printf("%lld\n",sum);

        return 0;
}

代码实现2：
- 等差数列公式：(1 + n) * n / 2

#include 
int main()
{
    	long long n;    
    	scanf("%lld",&n);

    	printf("%lld\n",(1+n)*n/2);

    	return 0;
}

109. 小乐乐定闹钟

问题描述：小乐乐比较懒惰，他现在想睡觉，然后再去学习。他知道现在的时刻，以及自己要睡的时长，想设定一个闹钟叫他起床学习，但是他太笨了，不知道应该把闹钟设定在哪个时刻，请你帮助他。(只考虑时和分，不考虑日期)
输入描述：输入现在的时刻以及要睡的时长k（单位：minute），中间用空格分开。
输入格式：hour:minute k（如hour或minute的值为1，输入为1，而不是01)，(0 ≤ hour ≤ 23，0 ≤ minute ≤ 59，1 ≤ k ≤ 109)。
输出描述：对于每组输入，输出闹钟应该设定的时刻，输出格式为标准时刻表示法（即时和分都是由两位表示，位数不够用前导0补齐）。
示例1：
- 输入：0:0 100
- 输出：01:40
示例2：
- 输入：1:0 200
- 输出：04:20
解题思路：用 k / 60 得到的结果就是对应的小时数，用 k % 60 得到的结果则是对应的分钟数。
代码实现：

#include 
int main()
{
        int h,m,k;
        scanf("%d:%d %d",&h,&m,&k);

        h = (h + (m + k) / 60) % 24;//转小时转成24进制
        m = (m + k) % 60;//将分钟转成60进制

        printf("%02d:%02d\n",h,m);

        return 0;
}

110. 小乐乐排电梯

问题描述：小乐乐学校教学楼的电梯前排了很多人，他的前面有n个人在等电梯。电梯每次可以乘坐12人，每次上下需要的时间为4分钟（上需要2分钟，下需要2分钟）。请帮助小乐乐计算还需要多少分钟才能乘电梯到达楼上。（假设最初电梯在1层）
输入描述：输入包含一个整数n (0 ≤ n ≤ 109)
输出描述：输出一个整数，即小乐乐到达楼上需要的时间。
示例1：
- 输入：1
- 输出：2
示例2：
- 输入：12
- 输出：6
代码实现;

#include 
int main()
{
        int n;
        scanf("%d",&n);

        printf("%d\n",(n / 12)*4 + 2);

        //n / 12得出需要上下几趟电梯，
        //然后* 4得出轮到乐乐上电梯时的时间，
        //再加上小乐乐上去的两分钟

        return 0;
}

111. 小乐乐与欧几里得

问题描述：小乐乐最近在课上学习了如何求两个正整数的最大公约数与最小公倍数，但是他竟然不会求两个正整数的最大公约数与最小公倍数之和，请你帮助他解决这个问题。
输入描述：每组输入包含两个正整数n和m。(1 ≤ n ≤ 109，1 ≤ m ≤ 109)
输出描述：
对于每组输入，输出一个正整数，为n和m的最大公约数与最小公倍数之和。
示例1：
- 输入：10 20
- 输出：30
示例2：
- 输入：15 20
- 输出：65
解题思路：
- 最大公约数：辗转相除法，用 n % m，如果结果不等于 0 则说明没找到最大公约数，此时将 m 的值赋给 n ，然后将 n % m 得到的结果赋给 m，重复上述步骤直到 n % m 等于 0 的时候，此时 m 为最大公约数。
- 最小公倍数：n * m / 最大公约数，注意要先保留 n 和 m 的值，不然在求最大公约数的过程中就将这俩给改了。
代码实现：

#include 
int main()
{
        long long n,m,max,min,t;
        scanf("%lld %lld",&n,&m);

        long n1 = n,m1 = m;

        //最大公约数
        while(0 != (t = n % m))
        {
                n = m;
                m = t;
                //此时m为最大公约数
        }
        max = m;

        //最小公倍数
        min = n1 * m1 / max;

        printf("%lld\n",max + min);
        return 0;
}

112. 小乐乐改数字

问题描述：小乐乐喜欢数字，尤其喜欢0和1。他现在得到了一个数，想把每位的数变成0或1。如果某一位是奇数，就把它变成1，如果是偶数，那么就把它变成0。请你回答他最后得到的数是多少。
输入描述：输入包含一个整数n (0 ≤ n ≤ 109)
输出描述：输出一个整数，即小乐乐修改后得到的数字。
示例1：
- 输入：222222
- 输出：0
示例2：
- 输入：123
- 输出：101
解题思路：当拿出个十百位上得出奇偶数然后转换成0/1之后，还需要将得出的数放回原来的个十百位上。
代码实现：

#include 
#include 

int main()
{
        int n,k,i = 0,sum = 0;
        scanf("%d",&n); 

        while(n)
        {
                k = n % 10;
                if(1 == k % 2)
                {
                        k = 1;
                }
                else
                {
                        k = 0;
                }
                sum += k * pow(10,i);
                i++ ;
                n /= 10;
        }
        printf("%d\n",sum);
        return 0;
}

113. 小乐乐走台阶

问题描述：小乐乐上课需要走n阶台阶，因为他腿比较长，所以每次可以选择走一阶或者走两阶，那么他一共有多少种走法？
输入描述：输入包含一个整数n (1 ≤ n ≤ 30)
输出描述：输出一个整数，即小乐乐可以走的方法数。
示例1：
- 输入：2
- 输出：2
示例2：
- 输入：10
- 输出：89
解题思路：
1. 如果只有 1 级台阶，那么只有一种跳法。
2. 如果有 2 级台阶，那么就有 2 种跳法，一种是分 2 次跳，每次跳 1 级，另一种就是一次跳 2 级。
3. 如果台阶树大于 2，设为 n 的话，这时候把 n 级台阶时的跳法看成 n 的函数，记为 f(n)，第一次跳的时候有两种不同的选择：
  - 一是第一次跳一级，此时跳法的数目等于后面剩下的 n-1 级台阶的跳法数目，即为 f(n-1)，
  - 二是第一次跳二级，此时跳法的数目等于后面剩下的 n-2 级台阶的跳法数目，即为 f(n-2)，
- 因此 n 级台阶的不同跳法总数为：f(n) = f(n-1) + f(n-1)，瞪眼法看这就是个斐波那契数数列。

代码实现：

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

114. 小乐乐与序列

问题描述：老师给了小乐乐一个正整数序列，要求小乐乐把这个序列去重后按从小到大排序。但是老师给出的序列太长了，小乐乐没办法耐心的去重并排序，请你帮助他。
输入描述：第一行包含一个正整数n，表示老师给出的序列有n个数。接下来有n行，每行一个正整数k，为序列中每一个元素的值。(1 ≤ n ≤ 105，1 ≤ k ≤ n)
输出描述：输出一行，为去重排序后的序列，每个数后面有一个空格。
示例1：

输入：4
	2
	2
	1
	1
输出：1 2

示例2：

输入：5
	5
	4
	3
	2
	1
输出：1 2 3 4 5

解题思路：
1. 创建一个具足够带下的数组并将其完全初始化为 0。
2. 假设遇到 1，则将 1 存到下标为 1 的位置去，之后如果再遇到 1 同样是将其存进下标为 1 的位置上去，就能搞定去重了。遇到其他正整数同理。
3. 当全部存完之后，再将数组从前往后遍历，数组中非 0 的元素就是去重之后的结果。
代码实现：

#include 
#define MAX 100001

int main()
{
        int n,i,tmp;
        int arr[MAX] = {0};
        scanf("%d",&n);

        for(i = 1;i <= n;i++)
        {
                scanf("%d",&tmp);
                arr[tmp] = tmp;
        }
        for(i = 1;i <= n;i++)
        {
                if(0 != arr[i])
                {
                        printf("%d ",arr[i]);
                }
        }
        return 0;
}

115. 小乐乐与字符串

问题描述：在庆祝祖国母亲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”的数量。
示例1：
- 输入：CCHNCHN
- 输出：7
示例2：
- 输入：CCHNCHNCHNCHN
- 输出：30
解题思路：H之前出多少个C很重要，决定了会出现多少个CH，所以要先统计出现了多少个C，然后CH决定了有几个CHN会出现，所以之后要统计CH出现的次数。
代码实现：

#include 
int main()
{
        char arr[8000] = {0};
        scanf("%s",arr);

        //统计子串 CHN 的个数
        long long c = 0,ch = 0,chn = 0;
        char* p = arr;

        while(0 != *p)
        {
                if('C' == *p)
                {
                        c++ ;
                }
                else if('H' == *p)
                {
                        ch += c;
                }
                else if('N' == *p)
                {
                        chn += ch;
                }
                p++ ;
        }
        printf("%lld\n",chn);
        return 0;
}

116. 小乐乐算平均分

问题描述：小乐乐输入三科成绩，请编程帮他输出三科成绩总分及平均分。
输入描述：一行，3科成绩（浮点数），成绩之间用一个空格隔开。
输出描述：一行，总分和平均分（小数点后保留两位），用一个空格隔开。
示例：
- 输入：79.5 80.0 98.0
- 输出：257.50 85.83
代码实现：

#include 

int main()
{
        float a,b,c;
        scanf("%f %f %f",&a,&b,&c);

        printf("%.2f %.2f\n",(a+b+c),(a+b+c)/3.0);

        return 0;
}

117. 小乐乐找最大数

问题描述：小乐乐获得4个最大数，请帮他编程找到最大的数。
输入描述：一行，4个整数，用空格分开。
输出描述：一行，一个整数，为输入的4个整数中最大的整数。
示例：
- 输入：5 8 2 5
- 输出：8
代码实现：

#include 
int main()
{
        int arr[4] = {0};
        int i;
        for(i = 0;i < 4;i++)
        {
                scanf("%d",&arr[i]);
        }
        //假设arr[0]就是最大值
        int max = arr[0];
        for(i = 0;i < 4;i++)
        {
                if(arr[i] > max)
                {
                        max = arr[i];
                }
        }
        printf("%d\n",max);

        return 0;
}

118. 小乐乐是否被叫家长

问题描述：小乐乐的班级进行了一次期中考试，考试一共有3门科目：数学，语文，英语，小乐乐的班主任决定给没有通过考核的同学家长开一次家长会，考核的标准是三科平均分不低于60分，所以现在想请你帮忙算一算小乐乐会不会被叫家长。
输入描述：一行，输入三个整数（表示小乐乐的数学、语文、英语的成绩），用空格分隔。
输出描述：一行，如果小乐乐会被请家长则输出“YES”，否则输出“NO”。
示例1：
- 输入：80 60 50
- 输出：NO
示例2：
- 输入：70 55 40
- 输出：YES
代码实现：

#include 
int main()
{
        int Chinese,math,English;
        scanf("%d %d %d",&Chinese,&math,&English);
        int average = (Chinese + math + English) / 3;

        if(average >= 60)       printf("NO\n");
        else                    printf("YES\n");

        return 0;
}

119. 小乐乐转换成绩

问题描述：小乐乐输入百分制成绩，他想将成绩转换成等级制。转换规则为：90-100为’A’，80-89为’B’，70-79为’C’，60-69为’D’，59以下为’E’。如果输入的成绩不在0-100之间，输出’F’。
输入描述：一行，一个整数表示的成绩。
输出描述：一行，转换后的等级。
示例：
- 输入：78
- 输出：C
代码实现：

#include 
int main()
{
        int n;
        scanf("%d",&n);

        if(n >= 90 && n <= 100)
                printf("A\n");
        else if(n >= 80 && n <= 89)
                printf("B\n");
        else if(n >= 70 && n <= 79)
                printf("C\n");
        else if(n >= 60 && n <= 69)
                printf("D\n");
        else if(n >= 0 && n <= 59)
                printf("E\n");
        else
                printf("F\n");

        return 0;
}

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

问题描述：小乐乐的班主任想统计一下班级里一共有多少人需要被请家长，三个成绩（语文，数学，外语）平均分低于60的将被请家长，小乐乐想编程帮助班主任算一下有多少同学被叫家长。
输入描述：共n+1行第一行，输入一个数n，代表小乐乐的班级中有n个同学。
在接下来的n行中每行输入三个整数代表班级中一个同学的三科成绩（语文，数学，外语），用空格分隔。
输出描述：一行，一个整数，代表班级中需要被请家长的人数。
示例：

代码实现：

#include 
int main()
{
        int n,a,b,c;
        int count = 0;
        scanf("%d",&n);

        for(int i = 0;i < n;i++)
        {
                scanf("%d %d %d",&a,&b,&c);
                if((a + b + c) / 3 < 60)
                {
                        count++;
                }
        }
        printf("%d\n",count);

        return 0;
}

121. 小乐乐算最高分

问题描述：小乐乐的老师BoBo想知道班级中谁的数学成绩最高，请编程帮他实现。
输入描述：共两行
- 第一行输入一个数n，代表小乐乐的班级中n个同学。
- 第二行输入n个数，用空格相隔，代表班级中每个人的数学成绩。
输出描述：一个整数，代表班级中最高的数学成绩。
示例：

输入：3
	99 89 39
输出：99

代码实现：

#include 
int main()
{
        int n,score,max = 0;
        scanf("%d",&n);

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

122. 小乐乐计算求和

问题描述：小乐乐想计算一下1!+2!+3!+…+n!。
输入描述：一行，一个整数n。
输出描述：一行，一个整数，表示1!+2!+3!+…+n!的结果。
示例：
- 输入：3
- 输出：9
备注：结果范围在int类型范围之内
代码实现：

#include 
int main()
{
        int n;
        int ch = 1,sum = 0;
        scanf("%d",&n);

        for(int i = 1;i <= n;i++)
        {
                ch *= i;
                sum += ch;
        }
        printf("%d\n",sum);

        return 0;
}

123. 小乐乐计算函数

问题描述：小乐乐学会了自定义函数，BoBo老师给他出了个问题，根据以下公式计算m的值。其中 max3函数为计算三个数的最大值，如： max3(1, 2, 3) 返回结果为3。

输入描述：一行，输入三个整数，用空格隔开，分别表示a, b, c。
输出描述：一行，一个浮点数，小数点保留2位，为计算后m的值。
示例：
- 输入：1 2 3
- 输出：0.30
代码实现：

#include 
float max3(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);

        float m = max3(a+b,b,c) / (max3(a,b+c,c)+max3(a,b,b+c));
        printf("%.2f\n",m);

        return 0;
}

124. 小乐乐查找数字

问题描述：给定n个整数和一个整数x，小乐乐想从n个整数中判断x出现几次，请编程帮他实现。
输入描述：共3行
- 第一行，一个整数，表示n（1 <= n <= 100）。
- 第二行，共输入n个整数，两个整数之间用空格分隔。
- 第三行，输入一个整数，表示要查找的整数x。
输出描述：一行，表示整数x出现的次数。
示例：

输入：5
	1 1 2 1 3
	1
输出：3

代码实现：

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

        for(i = 0;i < n;i++)
        {
                if(x == arr[i])
                {
                        count++ ;
                }
        }
        printf("%d\n",count);
        return 0;
}

125. 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;
}

126. kiki算期末成绩

问题描述：KiKi这学期努力学习程序设计基础，要期末考试了，BoBo老师告诉他，总成绩包括四个部分，如下：总成绩 = 实验成绩 * 20% + 课堂表现成绩 * 10% + 过程考核成绩 * 20% + 期末上机考试成绩 * 50%，现在输入KiKi的各项成绩，请计算KiKi的总成绩。
输入描述：一行，包括四个整数（百分制），用空格分隔，分别表示实验成绩，课堂表现成绩，过程考核成绩，期末上机考试成绩。
输出描述：一行，总成绩，保留小数点一位。
示例：
- 输入：100 100 90 80
- 输出：88.0
代码实现：

#include 
int main()
{
        float sum = 0;
        int a,b,c,d;
        scanf("%d %d %d %d",&a,&b,&c,&d);
        
        sum = a*0.2 + b*0.1 + c*0.2 + d*0.5;
        printf("%.1f\n",sum);

        return 0;
}

127. kiki说祝福语

问题描述：2020年来到了，KiKi要对他的n位好朋友说n遍”Happy new year!Good luck!”的祝福语。
输入描述：输入只有一行，其中含有一个正整数 n(1≤n≤20)，代表KiKi说祝福话的遍数。
输出描述：输出 n 行"Happy new year!Good luck!"。
示例：

输入：2
输出：
	Happy new year!Good luck!
	Happy new year!Good luck!

代码实现：

#include 
int main()
{
        int n;
        scanf("%d",&n);

        for(int i = 0;i < n;i++)
        {
                printf("Happy new year!Good luck!\n");
        }
        return 0;
}

128. kiki的最高分

问题描述：KiKi知道了大一三科比较重要课程的分数，包括：程序设计基础，高数，英语，请编程帮他找到三科中的最高分。
输入描述：一行，三个整数，用空格分隔，代表三科成绩。
输出描述：一行，一个整数，代表输入三科分数中的最高分数。
示例：
- 输入：90 88 99
- 输出：99
代码实现：

#include 
int MAX3(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\n",MAX3(a,b,c));

        return 0;
}

129. 求质数的个数

问题描述：KiKi知道了什么是质数（只能被1和他自身整除的数），他现在想知道所有三位整数中，有多少个质数。
输入描述：无
输出描述：一行，一个整数，表示所有三位整数中，有多少个质数。
代码实现：

#include 

//是素数则返回1，否则返回0
int is_prime(int i)
{       
        //拿2到i-1之间的数去试除i
        for(int j = 2;j < i-1;j++)
        {
                if(0 == i % j)
                {
                        return 0;
                }
        }
        return 1;
}
int main()
{
        int count = 0;
        for(int i = 100;i <= 999;i++)
        {
                //判断i是否为素数
                if(1 == is_prime(i))
                {
                        count++ ;
                }
        }
        printf("%d\n",count);
        return 0;
}

130. kiki去重整数并排序

问题描述：给定一个整数序列，KiKi想把其中的重复的整数去掉，并将去重后的序列从小到大排序输出。
输入描述：
- 第一行，输入一个整数n，表示序列有n个整数。
- 第二行输入n个整数（每个整数大于等于1，小于等于1000），整数之间用空格分隔。
输出描述：去重并且从小到大排列的整数序列，整数之间用空格分隔。
示例：

输入：6
	5 3 3 4 2 2
输出：2 3 4 5

代码实现1：暴力求解
- 先利用冒泡排序将序列从小到大先排好序；
- 在让相邻的两个元素进行比较，如果出现重复的元素，则让后面的元素往前挪动覆盖掉重复的元素。当有n个元素的时候，要去重则最多要比较n-1对元素。

#include 
int main()
{
        int n,i;
        int arr[1000]= {0};
        scanf("%d",&n);

        for(i = 0;i < n;i++)
        {
                scanf("%d ",&arr[i]);
        }
        //先排序再去重
        for(i = 0;i < n-1;i++)//冒泡排序
        {
                for(int j = 0;j < n-i-1;j++)
                {
                        if(arr[j] > arr[j+1])
                        {
                                int t = arr[j];
                                arr[j] = arr[j+1];
                                arr[j+1]= t;
                        }
                }
        }
        //去重
        for(i = 0;i < n-1;i++)//取中最多比较的次数为n-1次
        {
                if(arr[i] == arr[i+1])
                {
                        //把从i+1往后的元素统统往前覆盖
                        for(int k = i;k < n-1;k++)
                        {
                                arr[k] = arr[k+1];
                        }
                        n--;//去重了一个元素，要少一个元素
                        i--;//让i还是保持i+1的位置
                }
        }
        //打印
        for(i = 0;i < n;i++)
        {
                printf("%d ",arr[i]);
        }
        return 0;
}

代码实现2：拿空间换时间
- 既然输入的数字不超过一千，那么就创建一个1001大小的数组（1001才有下标1000），然后将数组完全初始化为0；
- 按照输入的数字来存放进数组中，如：输入1则存在下标为1的地方，这样如果后面再出现1则继续存在下标1处，就能将重复的数字去掉了；
- 当循环结束的时候，此时不仅去完重了同时也排好序了，再从前往后将数组中非0的元素全部打印出来就搞定了。

#include 
int main()
{
        int n,i;
        int arr[1001] = {0};
        scanf("%d",&n);

        for(i = 0;i < n;i++)
        {
                int m;
                scanf("%d",&m);
                arr[m] = m;
        }
        for(i = 0;i <= 1000;i++)
        {
                if(0 != arr[i])
                {
                        printf("%d ",arr[i]);
                }
        }
        putchar('\n');
        return 0;
}

131. kiki学结构体和指针

问题描述：KiKi学习了结构体和指针，他了解了结构体类型可以定义包含多个不同类型成员，而指针本质是内存地址，是引用数据的另外一种方式。现在他想将多个输入的数据通过结构体和指针的方式连接在一起，形成一个单向链表，即：每个结点是结构体类型，包括整型数据成员（data）和结构体指针类型成员（next），每个结点的指针部分指向下一个输入的结点。具体建立过程如下：先输入n个整数，按照数据输入的顺序建立一个带头结点的单链表，再输入一个数据m,将单链表中的值为m的结点全部删除。输出删除后的单链表信息。
输入描述：包括三行：
- 第一行输入数据个数n (3≤n≤100);
- 第二行依次输入n个整数，用空格分隔;
- 第三行输入欲删除数据m。
输出描述：包括两行：
- 第一行输出完成删除后的单链表长度；
- 第二行依次输出完成删除后的单链表数据。
示例：

代码实现：

#include 
#include 

//链表结点的定义
struct Node
{
	int data;//数据域
	struct Node* next;//指针域
};

int main()
{	
	int n,i;
	scanf("%d",&n);
	struct Node* list = NULL;//指向链表的指针
	struct Node* tail = NULL;//指向链表尾部元素的指针	

	//接收n个数字,并尾部插入到单链表中	
	for(i = 0;i < n;i++)
	{
		int m = 0;
		scanf("%d",&m);
		struct Node* n = (struct Node*)malloc(sizeof(struct Node));
		n -> data = m;//往数据域存
		n -> next = NULL;

		if(NULL == list)//插入第一个元素
		{
			list = n;
			tail = list;//让尾指针指向当前结点
		}
		else//插入其他元素
		{
			tail -> next = n;//将下一个结点的地址赋尾指针的next域
			tail = tail -> next;//然后让尾指针指向下一个结点
		}
	}
	//获取要删除的元素
	int del;//要删除的元素
	scanf("%d",&del);//接收要删除的元素

	//删除链表中指定的元素
	struct Node* cur  = list;
	struct Node* prev = NULL;

	while(cur)
	{
		//找到了要删除的元素
		if(del == cur -> data)
		{
			//如果要删除的是第一个结点
			struct Node* pd = cur;//要先存着被删除的结点，防止找不到地址
			if(cur == list)
			{
				list = list -> next;//让list直接指向下一个结点
				cur = list;
			}
			else//删除的不是第一个结点
			{
				prev -> next = cur -> next;
				cur = prev -> next;
			}
			free(pd);
			n-- ;//删除了一个元素长度就变小一点
		}
		else//找不到
		{
			prev = cur;//prev始终记录cur指针的前一个结点的位置
			cur = cur -> next;
			//没找到自然是让指针指向下一个结点继续找
		}
	}
	printf("%d\n",n);//删除了结点之后的单链表长度
	
	//输出完成单链表删除操作后的单链表数据
	cur = list;//找到链表的起始位置
	while(cur)//知道cur变成空指针为止
	{
		printf("%d ",cur -> data);
		cur = cur -> next;
	}
	
	//释放链表-从头往后释放
	cur = list;
	struct Node* d = NULL;
	while(cur)
	{
		d = cur;
		cur = cur -> next;
		free(d);
	}

	list = NULL;//变成空链表了
	
	return 0;
}

132. kiki定义电子日历类

问题描述：KiKi学习了面向对象技术，学会了通过封装属性（变量）和行为（函数）定义类，现在他要设计一个电子日历类TDate。
它有3个私有数据成员：Month,Day,Year和若干个公有成员函数，要求：
1. 带有默认形参值的构造函数，默认值为0, 0, 0；
2. 输出日期函数，用“日/月/年”格式输出日期；
3. 设置日期函数，从键盘输入年、月、日。
输入描述：一行，三个整数，用空格分隔，分别表示年、月、日。
输出描述：一行，用“日/月/年”格式输出日期。
示例：
- 输入：2019 12 30
- 输出：30/12/2019
代码实现：

#include 
using namespace std;
class TDate
{
private:
    int Year;
    int Month;
    int Day;
public:
    TDate(int year=0, int month=0, int day = 0)
   {
        Year = year;
        Month = month;
        Day = day;
   }
    void Print()
   {
        cout<<Day<<"/"<<Month<<"/"<<Year<<endl;
   }
};
int main()
{
    int year = 0;
    int month = 0;
    int day = 0;
    cin>>year>>month>>day;
    TDate d(year, month, day);
    d.Print();
    return 0;
}

133. 圣诞树

问题描述：今天是圣诞节，牛牛要打印一个漂亮的圣诞树送给想象中的女朋友，请你帮助他实现梦想。
输入描述：输入圣诞树的高度h，1<=h<=100
输出描述：输出对应的圣诞树
示例1：

输入：1
输出：
  *  
 * * 
* * *
  *

说明：

示例2：

输入：2
输出：
     *     
    * *    
   * * *   
  *     *  
 * *   * * 
* * * * * *
     *
     *

说明：

示例3：

输入：3
输出：
        *  
       * * 
      * * *
     *     *  
    * *   * * 
   * * * * * *
  *     *     *  
 * *   * *   * * 
* * * * * * * * *
        *
        *
        *

说明：

代码实现：

#include 
int main()
{
    int num;
    scanf("%d",&num);
    
    for(int i = 1; i <= 3 * num; i++)
    {
        for(int j = 0; j < 3 * num - i; j++)
        {
            printf(" ");
        }
        int cnt = 0;
        for(int k = 0; k < ((i + 2) / 3); k++)
        {
            if(i % 3 == 0)
            {
                cnt = 3;
            }
            else 
            {
                cnt = i % 3;
            }
            for(int p = 0; p < cnt; p++)
            {
                printf("* ");
            }
            for(int p = 0; p < 3 - cnt; p++)
            {
                printf("  ");
            }
        }        
        printf("\n"); 
    }
    for(int i = 0; i < num; i++)
    {
        for(int j = 0; j < 3 * num - 1; j++)
        {
            printf(" ");
        }
        printf("*\n");
    }
    return 0;
}

134. 超级圣诞树

问题描述：今天是圣诞节，牛牛要打印一个漂亮的圣诞树送给想象中的女朋友，请你帮助他实现梦想。
输入描述：输入圣诞树的大小 1≤n≤8
输出描述：输出对应的圣诞树
示例1：

输入：1
输出：
  *
 * *
* * *
  *

说明：

示例2：

输入：2
输出：
     *
    * *
   * * *
  *     *
 * *   * *
* * * * * *
     *
     *

说明：

示例3：

输入：3
输出：
           *
          * *
         * * *
        *     *
       * *   * *
      * * * * * *
     *           *
    * *         * *
   * * *       * * *
  *     *     *     *
 * *   * *   * *   * *
* * * * * * * * * * * *
           *
           *
           *

说明：

示例4：

输入：4
输出：
                       *
                      * *
                     * * *
                    *     *
                   * *   * *
                  * * * * * *
                 *           *
                * *         * *
               * * *       * * *
              *     *     *     *
             * *   * *   * *   * *
            * * * * * * * * * * * *
           *                       *
          * *                     * *
         * * *                   * * *
        *     *                 *     *
       * *   * *               * *   * *
      * * * * * *             * * * * * *
     *           *           *           *
    * *         * *         * *         * *
   * * *       * * *       * * *       * * *
  *     *     *     *     *     *     *     *
 * *   * *   * *   * *   * *   * *   * *   * *
* * * * * * * * * * * * * * * * * * * * * * * *
                       *
                       *
                       *
                       *

说明：

解题思路：实在搞不定，看的题解。
1. 定义二维数组ch[最大行数][最大列数]，并初始化为n=1时的内容char ch[400][800] = {" * ", " * * ", “* * *”}，还有现在三角的行数row=3，列数col=5
2. 最外层循环 n-1 次。
3. 将现在的三角复制到左下角和右下角。
4. 清除原来左上角的三角。
5. 将左下角的三角复制到上一层的中间位置。
6. 设置新三角的行数row=row*2，列数col=col*2+1，完成了一次循环，跳到第2步。
7. 根据row和col打印出来。
8. 打印树干。
代码实现：

#include 
int main() {
    int n;
    scanf("%d", &n);
    int i, j, k;
    int row = 3;
    int col = 5;
    // 行数 = 3 * pow(2,n-1) 列数 = 5 * pow(2,n-1)
    char ch[400][800] = {"  *  ", " * * ", "* * *"};
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < row; j++) {
            for (k = 0; k < col; k++) {
                ch[j + row][k] = ch[j][k]; // 左下角的图形复制
                ch[j + row][k + 1 + col] = ch[j][k];
            }
        }
        // 清空原来的三角位置
        for (j = 0; j < row; j++) {
            for (k = 0; k < col; k++)
                ch[j][k] = ' ';
        }
        // 将左下角的三角复制到两个中间去
        for (j = 0; j < row; j++) {
            for (k = 0; k < col; k++)
                ch[j][k + row] = ch[j + row][k];
        }
        row *= 2;           // 当前的行数
        col = col * 2 + 1;  // 当前的列数
    }
    // 打印出来
    for (j = 0; j < row; j++) {
        for (k = 0; k < col; k++) {
            if (ch[j][k] == '*')
                printf("%c", ch[j][k]);
            else
                printf(" ");
        }
        printf("\n");
    }
    // 打印树干
    for (j = 0; j < n; j++) {
        for (k = 0; k < row - 1; k++)
            printf(" ");
        printf("*\n");
    }
    return 0;
}