1.给定秒数 seconds ，把秒转化成小时、分钟和秒。
描述
给定秒数 seconds ，把秒转化成小时、分钟和秒。
数据范围：0< seconds<100000000
输入描述：
一行，包括一个整数，即给定的秒数。
输出描述：
一行，包含三个整数，依次为输入整数对应的小时数、分钟数和秒数（可能为零），中间用一个空格隔开。
我的代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
int a = 0;
int x = 0;
int y = 0;
int z = 0;
scanf("%d", &a);
x = a / 3600;
y = (a - 3600 * x) / 60;
z = a - 3600 * x - 60 * y;
printf("%d %d %d\n", x, y, z);
return 0;
}代码：
2.输入5个学生的成绩，求他们的平均成绩。
描述：
从键盘输入5个学生的成绩（整数），求他们的平均成绩（浮点数，保留一位小数）。
输入描述：
一行，连续输入5个整数（范围0~100），用空格分隔。
输出描述：
一行，输出5个数的平均数（保留一位小数）。
我的代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
int a = 0;
int b = 0;
int c = 0;
int d = 0;
int e = 0;
float x = 0;
scanf("%d %d %d %d %d", &a, &b, &c, &d, &e);
x = (a + b + c + d + e) / 5.0;
printf("%.1f\n", x);
return 0;
}代码1：
代码2（改进版）：
3.将一个四位数，反向输出。
描述：
将一个四位数，反向输出。
输入描述：
一行，输入一个整数n（1000 <= n <= 9999）。
输出描述：
针对每组输入，反向输出对应四位数。
我的代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
int x = 0;
int a = 0;
int b = 0;
int c = 0;
int d = 0;
scanf("%d", &x);
a = x % 10;
b = (x / 10) % 10;
c = (x / 100) % 10;
d = x / 1000;
printf("%d%d%d%d\n",a,b,c,d);
return 0;
}代码1：
代码2（钻题目空子版）：
4.将三个整数按从大到小输出。
描述：
写代码将三个整数数按从大到小输出。
我的代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
int a = 0;
int b = 0;
int c = 0;
int d = 0;
scanf("%d %d %d", &a, &b, &c);
if (a > b)
{
if (a > c)
{
if (b > c)
{
printf("%d %d %d\n", a, b, c);
}
else
{
printf("%d %d %d\n", a, c, b);
}
}
else
{
printf("%d %d %d\n", c, a, b);
}
}
else
{
if (b > c)
{
if(a>c)
{
printf("%d %d %d\n", b, a, c);
}
else
{
printf("%d %d %d\n", b, c, a);
}
}
else
{
printf("%d %d %d\n", c, b, a);
}
}
return 0;
}代码1：
5.最大公约数（最小公倍数）
描述：
给定两个数，求这两个数的最大公约数
我的代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
int a = 0;
int b = 0;
int i = 0;
scanf("%d %d", &a, &b);
if (a > b)
{
i = b;
while(i>=1)
{
if (a % i == 0 && b % i == 0)
{
printf("%d\n", i);
break;
}
i--;
}
}
else
{
i = a;
while (i >= 1)
{
if (a % i == 0 && b % i == 0)
{
printf("%d\n", i);
break;
}
i--;
}
}
return 0;
}代码1：
代码2（辗转相除法）：
算最小公倍数方法：
1.从两个数较大的值开始往上加一，直到有数可以将他俩整除。
2.先求出最大公约数，最小公倍数就是这两个数相乘再除以最大公约数。
6.打印闰年
描述：
打印1000年到2000年之间的闰年
我的代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
int i = 1000;
while (i <= 2000)
{
if (i % 4 == 0 && i % 100 != 0)
{
printf("%d ", i);
}
else if (i % 400==0)
{
printf("%d ", i);
}
else
{
;
}
i++;
}
return 0;
}
代码1：
代码2：
7.打印素数
描述：
写一个代码：打印100~200之间的素数
我的代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
int i = 100;
int a = 2;
while (i <= 200)
{
while (a < i)
{
if (a == i - 1)
{
printf("%d ", i);
a = 2;
i++;
break;
}
if (i % a != 0)
{
a++;
continue;
}
if (i % a == 0)
{
i++;
a = 2;
break;
}
}
}
return 0;
}
代码1：
代码2（改进版）：
代码3（超级改进版）：
8.数9的个数
描述：
编写程序数一下 1到 100 的所有整数中出现多少个数字9
我的代码：（错误）
纠错： 应将a%9==0和b%9==0改成a=9和b=9，因为0%9也为0，不符合条件。
代码1：
答案：
9.分数求和
描述：
计算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值，打印出结果
我的代码：（错误）
纠错：
1.算分数，除号的两端需要有小数。
2.sum应定义成浮点数。
代码1：
答案：
10.求最大值
描述：
求10 个整数中最大值
我的代码：
代码1：
11.乘法口诀表
描述：
在屏幕上输出9*9乘法口诀表
我的代码：
代码1：（有问题）
运行结果1：
注：此处打印有些地方没有对齐，因为有的地方打印一位，有的地方打印两位。解决方法：将%d改成%2d即可，%2d就是我们打印某些数字的时候需要两位，如果不够两位的话会拿空格来填充，此时数字位靠右，如果改成%-2d的话，如果不够两位也会拿空格填充，数字位为靠左，如下代码2和代码3。
代码2：
运行结果2：
代码3：
运行结果3：
12. 一个代码的讲解
注：
1. 数组传参的时候传的是首元素的地址，写arr[0]其实是通过这个地址找到第一个元素的地址。
也就是说在主函数中，函数名既可表示该数组，也是首元素地址的意思。而在函数调用数组时，不管形参是以指针形式接收还是以arr[ ]数组这种形式接收（这两种形式意思和功能完全一样），接收的都只是数组首元素的地址，只不过在函数中可以通过数组首元素地址找到arr[1]等元素的地址，因此在函数中也可以使用arr[1]等。
2.数组名相当于是地址，因此传的时候是地址，相当于传址调用。
13.写函数打印乘法口诀表
描述：
实现一个函数，打印乘法口诀表，口诀表的行数和列数自己指定
如：输入9，输出9*9口诀表，输出12，输出12*12的乘法口诀表。
我的代码：
代码1：
14.字符串逆序（递归实现）
描述：
编写一个函数 reverse_string(char * string)（递归实现）
实现：将参数字符串中的字符反向排列，不是逆序打印。
要求：不能使用C函数库中的字符串操作函数。
比如:
char arr[] = "abcdef";逆序之后数组的内容变成：fedcba
代码1：（循环实现，参数用数组形式）
代码2 ：（循环实现，参数用指针形式）
代码3：（递归实现，参数用指针形式）
15.计算一个数的每位之和（递归实现）
描述：
写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和
例如，调用DigitSum(1729)，则应该返回1+7+2+9，它的和是19
输入：1729，输出：19
代码：
16.递归实现n的k次方
描述：
编写一个函数实现n的k次方，使用递归实现。
代码：
17、下面代码的结果是
#include <stdio.h>
int main()
{
int a, b, c;
a = 5;
c = ++a;
b = ++c, c++, ++a, a++;
b += a++ + c;
printf("a = %d b = %d c = %d\n:", a, b, c);
return 0;
}答案：
18、统计二进制中1的个数
描述：
写一个函数返回参数二进制中 1 的个数。（n放在内存中的补码的2进制中1的个数）
比如： 15 0000 1111 4 个 1
我的代码：
#include<stdio.h>
int one_point(int n)
{
int i = 0;
int count = 0;
for (i = 0; i < 32; i++)
{
if (((n >> i) & 1) == 1)
{
count++;
}
}
return count;
}
int main()
{
int n = 0;
scanf("%d", &n);
int s=one_point(n);
printf("%d\n", s);
return 0;
}
代码1：（错误，只能算正数，负数内存中存的是补码，无法计算）
代码2：（正确）
代码3：（正确）
代码4：（正确）（有几个1循环几次，代码更高效）
注：
1.代码1，m=15
m=15的二进制：00000000000000000000000000001111
得到最后一位的1（15%2=1），然后把最后一位的1去掉（15/2=7）（与十进制同理）
15%2=1：00000000000000000000000000000001
15/2=7：00000000000000000000000000000111
2.代码2，n=-1传过去后为无符号整形，程序会把-1的补码翻译成一个整数，进行计算
3.代码3，m=-1
m=-1的原码：10000000000000000000000000000001
m=-1的反码：11111111111111111111111111111110
m=-1的补码：11111111111111111111111111111111
想找到最低为的1（m&1），不要这个1（m>>=1）
4.代码4,m=15
m=m&(m-1)，解析如下
m: 001111
m-1: 001110
m=m&(m-1): 001110
m-1：001101
m=m&(m-1): 001100
m-1：001011
m=m&(m-1):001000
m-1：000111
m=m&(m-1):000000
m=m&(m-1)这个表达式会把m的二进制序列中最右边的1去掉，m=m&(m-1)执行了几次，就说明该数值里面有几个1。
该表达式可以判断一个数是否为2的k次方（m=m&(m-1)若该表达式算出来的数等于0，则该数就是2的k次方）
19、求两个数二进制中不同位的个数
描述：
编程实现：两个int（32位）整数m和n的二进制表达中，有多少个位(bit)不同？
输入例子:
1999 2299
输出例子:7
我的代码：
#include<stdio.h>
int main()
{
int x = 0;
int y = 0;
scanf("%d %d", &x, &y);
int z = x ^ y;
int i = 0;
int count = 0;
for (i = 0; i < 32; i++)
{
if (z & 1 == 1)
{
count++;
}
z = z >> 1;
}
printf("%d\n", count);
return 0;
}
代码1：
代码2：
注：异或操作符，相同为0，相异为1
20、打印整数二进制的奇数位和偶数位
描述：
获取一个整数二进制序列中所有的偶数位和奇数位，分别打印出二进制序列
我的代码：
#include<stdio.h>
void print(int n)
{
int i = 0;
//打印奇数位
printf("奇数位： ");
for (i = 30; i >= 0; i -= 2)
{
printf("%d ", (n >> i) & 1);
}
printf("\n");
//打印偶数
printf("偶数位： ");
for (i = 31; i >= 1; i -= 2)
{
printf("%d ", (n >> i) & 1);
}
}
int main()
{
int n = 0;
scanf("%d", &n);
print(n);
return 0;
}
代码1：
答案：
21、下面代码运行的结果
#include <stdio.h>
int i;
int main()
{
i--;
if (i > sizeof(i))
{
printf(">\n");
}
else
{
printf("<\n");
}
return 0;
}运行结果：
注：
1.一个全局变量不初始化的话，默认为0
2.sizeof操作符计算的结果的类型是size_t，是无符号整型，有符号整型和无符号整型在计算时，会把有符号整型转化为无符号整型
-1的二进制原码：10000000000000000000000000000001
-1的二进制反码：11111111111111111111111111111110
-1的补码：11111111111111111111111111111111
此时如果类型为int系统会将-1的补码转变为原码进行输出，而如果类型发生变化变成无符号数，则该数认为是一个正数，原码反码补码相同，此时11111111111111111111111111111111十进制就是4294967295.
22、判断整数奇偶性
描述：
KiKi想知道一个整数的奇偶性，请帮他判断。从键盘任意输入一个整数
（范围-231~231-1），编程判断它的奇偶性。
输入描述：
多组输入，每行输入包括一个整数。
输出描述：
针对每行输入，输出该数是奇数（Odd）还是偶数（Even）。
代码1：
代码2：
注：
1.EOF：end of file，是文件结束标志，一般放在文件的末尾，而scanf一般读取失败或者遇到文件结束的字符时，会返回一个EOF。
2.EOF其实是返回一个-1，-1在内存中的补码为11111111111111111111111111111111，若scanf("%d", &n)返回的值为EOF，此时对其取反~scanf("%d", &n)，返回的~EOF就是00000000000000000000000000000000，也就是0，判断为假跳出循环。
23、判断是元音还是辅音
描述：
KiKi开始学习英文字母，BoBo老师告诉他，有五个字母A(a), E(e), I(i), O(o),U(u)称为元音，其他所有字母称为辅音，请帮他编写程序判断输入的字母是元音（Vowel）还是辅音（Consonant）。
输入描述：
多组输入，每行输入一个字母。
输出描述：
针对每组输入，输出为一行，如果输入字母是元音（包括大小写），输出“Vowel”，如果输入字母是非元音，输出“Consonant”。
示例：
输入：
A
b输出：
Vowel
Consonant
代码1：
代码2：
代码3：
注：
1.当多次输入的值是字符时，需要清理缓冲区
2.%c是从缓冲区拿走一个字符，后面如果有\n，scanf会把后面的\n也拿走（规定）
（%d后面+\n可能是不起效果的）
3.在%c前面加空格，会跳过空白字符(\n就是空白字符)
24、代码的运行结果
下面代码的结果是
#include <stdio.h>
int main()
{
int arr[] = {1,2,3,4,5};
short *p = (short*)arr;
int i = 0;
for(i=0; i<4; i++)
{
*(p+i) = 0;
}
for(i=0; i<5; i++)
{
printf("%d ", arr[i]);
}
return 0;
}运行结果：
注：
1.arr数组内存里数据存放如下图 （小端存储）
| 01 00 00 00 | 02 00 00 00 | 03 00 00 00 | 04 00 00 00 | 05 00 00 00 |
2.short类型指针进行解引用一次访问两个字节 ，第一个for循环执行完后，改变了前八个字节
| 00 00 00 00 | 00 00 00 00 | 03 00 00 00 | 04 00 00 00 | 05 00 00 00 |
25、代码的运行结果
下面代码的结果是
#include <stdio.h>
int main()
{
unsigned long pulArray[] = { 6,7,8,9,10 };
unsigned long* pulPtr;
pulPtr = pulArray;
*(pulPtr + 3) += 3;
printf("%d,%d\n", *pulPtr, *(pulPtr + 3));
return 0;
}运行结果：
注：
pulArray数组如下
| 6 | 7 | 8 | 9 | 10 |
| pulArray | pulArray+3 |
26、代码的运行结果
下面代码的结果是
#include <stdio.h>
int main()
{
int a = 0x11223344;
char *pc = (char*)&a;
*pc = 0;
printf("%x\n", a);
return 0;
}运行结果：
注:
1.a在内存中的情况如下
| 44 | 33 | 22 | 11 |
pc是字符型指针，*pc=0后，a在内存中的情况如下
| 00 | 33 | 22 | 11 |
此时a的十六进制表示为：0x11223300
2.%x是用十六进制进行打印
27、下列程序执行后，输出的结果为
描述：
下列程序执行后，输出的结果为
注：
28、以下程序的k最终值是
描述：
以下程序的k最终值是
注：+的优先级大于*=，所以先算i+j，再计算k=k*（i+j）
29、以下程序的最终的输出结果为
描述：
以下程序的最终的输出结果为
注：
1.一个是全局的a变量，一个是局部的a变量，两个变量不是同一个a变量
2.全局变量和局部变量冲突的时候，局部变量优先，因此a+=1是给局部变量a加上1
3.出了函数，局部变量a空间被释放，打印出来的是全局变量的a值
30、不能使变量year中的值增至1010的语句是
描述：
若有定义语句：int year=1009,int *p=&year;以下不能使变量year中的值增至1010的语句是
注：
1. *的优先级高于+=，A可以
2. ++的优先级高于*，这里面先执行++再执行*p，而++是后置++，但是其先执行，针对的是p指针变量而不是*p，所以是解引用然后对p指针变量++，p指向内存中year后面一个整型变量地址。D选项错误。与*dest++=*src++类似，该代码可分为三步：1.*dest=*src 2.dest++ 3.src++
31、选择表达式11|10的结果
描述：
选择表达式11|10的结果（本题数值均为十进制）
注：
1.一个|是按位或运算
2.11的二进制：1011
10的二进制：1010
11|10的二进制：1011 此值十进制为11
32、求两个数的最小公倍数
描述：
输入两个数，求两个数的最小公倍数
代码1：
代码2：
代码3：
33、倒置字符串
描述：
将一句话的单词进行倒置，标点不倒置。
比如：I like beijing.经过函数变为beijing. like I
输入描述：
每个测试输入包含一个测试用例：I like beijing.输入用例长度不超过100
输出描述：
依次输出倒置之后的字符串，以空格分隔
我的代码：
#include<stdio.h>
#include<string.h>
int main()
{
char arr[101] = { 0 };
gets(arr);
int left = 0;
int right = strlen(arr) - 1;
int ch = 0;
int i = 0;
int j = 0;
arr[right + 1] = '\0';
//将整个字符串逆序
while (right > left)
{
ch = arr[right];
arr[right] = arr[left];
arr[left] = ch;
left++;
right--;
}
//将每个单词进行逆序
while (arr[i] != '\0')
{
left = i;
while (arr[i] != ' ' && arr[i] != '\0')
{
i++;
}
right = i - 1;
while (right > left)
{
ch = arr[right];
arr[right] = arr[left];
arr[left] = ch;
left++;
right--;
}
i++;
}
printf("%s\n", arr);
return 0;
}代码：
注：
1.思路：先将每个单词进行逆序，如：I ekil .gnijieb
然后将整个字符串逆序，如：beijing. like I
2.gets函数的原型为：
# include <stdio.h>
char *gets(char *str);
这个函数很简单，只有一个参数。参数类型为 char* 型，即 str 可以是一个字符指针变量名，也可以是一个字符数组名
gets() 函数的功能是从输入缓冲区中读取一个字符串存储到字符指针变量 str 所指向的内存空间
gets() 函数不仅比 scanf 简洁，而且可以直接输入带空格的字符串
使用 gets() 函数需要注意：使用 gets() 时，系统会将最后“敲”的换行符从缓冲区中取出来，然后丢弃，所以缓冲区中不会遗留换行符。这就意味着，如果前面使用过 gets()，而后面又要从键盘给字符变量赋值的话就不需要吸收回车清空缓冲区了，因为缓冲区的回车已经被 gets() 取出来扔掉了
33、使用指针打印数组内容
描述：
写一个函数打印arr数组的内容，不使用数组下标，使用指针。
arr是一个整形一维数组。
代码1：（不符合题意）
代码2：
代码3：（代码二简化）
34、字符逆序
描述：
将一个字符串str的内容颠倒过来，并输出。
数据范围：1<=len（str）<=10000
输入描述:
输入一个字符串，可以有空格
输出描述:
输出逆序的字符串
示例1
输入
I am a student输出
tneduts a ma I示例2
输入
nowcoder输出
redocwon
代码：
注：
系统会报gets不安全，其实还有很多函数会报不安全，比如scanf、gets、strcpy、strcat、strcmp等，这些只是相对不安全，报不安全是因为这些函数不关心数组内存能不能放得下，可能越界修改内存，如下图 （修改了内存之后系统才检测出越界访问了）
35、计算求和
描述：
求Sn=a+aa+aaa+aaaa+aaaaa+...... 的前n项之和，其中a是一个数字，
例如：S5=2+22+222+2222+22222
代码：
36、打印水仙花数
描述：
求出0～100000之间的所有“水仙花数”并输出。
“水仙花数”是指一个n位数，其各位数字的n次方之和确好等于该数本身，如:153＝1^3＋5^3＋3^3，则153是一个“水仙花数”。
代码1：（错误代码，循环体变量i在循环体内被改变了）
代码2：
注：power函数需要加math.h头文件
37、打印菱形
描述：
用C语言在屏幕上输出以下图案：
我的代码：
#include<stdio.h>
int main()
{
int n = 0;
printf("输入行数：");
scanf("%d", &n);
int i = 0;
int j = 0;
for (i = 1; i <= n; i++)
{
for (j = 0; j < n - i; j++)
{
printf(" ");
}
for (j = 0; j < 2 * i - 1;j++)
{
printf("*");
}
printf("\n");
}
for (i = 1; i < n; i++)
{
for (j = 0; j < i; j++)
{
printf(" ");
}
for (j = 0; j < (n - i) * 2 - 1; j++)
{
printf("*");
}
printf("\n");
}
return 0;
}代码：（看我的代码）
注：（我的代码）
注：（代码）（看上面注即可）
1.以中间一行分割分为上下两部分打印，将中间一行分到上面部分，因此上面部分有line行，下半部分有line-1行。
2.上半部分打印空格：第一行打印line-1个空格，第二行line-2个空格，以此类推
3.上半部分打印*：第一行是2*0+1，第二行2*1+1，依次类推
38、喝汽水问题
描述：
喝汽水，1瓶汽水1元，2个空瓶可以换一瓶汽水，给20元，可以多少汽水（编程实现）
代码：
39、调整奇数偶数顺序
描述：
输入一个整数数组，实现一个函数，来调整该数组中数字的顺序使得数组中所有的奇数位于数组的前半部分，所有偶数位于数组的后半部分
代码1：
#include<stdio.h>
void print(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
void move(int* arr, int sz)
{
int* left = arr;
int* right = arr + sz - 1;
int tmp = 0;
while (left < right)
{
//从左向右找一个偶数，停下来
while ((*left) % 2 == 1)
{
left++;
}
//从右向左找一个奇数，停下来
while ((*right) % 2 == 0)
{
right--;
}
if (left < right)
{
tmp = *left;
*left = *right;
*right = tmp;
}
}
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
print(arr, sz);
move(arr, sz);
print(arr, sz);
return 0;
}
代码2：
#include<stdio.h>
void print(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
void move(int* arr, int sz)
{
int* left = arr;
int* right = arr + sz - 1;
int tmp = 0;
while (left < right)
{
//从左向右找一个偶数，停下来
while ((left < right) && (*left) % 2 == 1)
{
left++;
}
//从右向左找一个奇数，停下来
while ((left < right) && (*right) % 2 == 0)
{
right--;
}
if (left < right)
{
tmp = *left;
*left = *right;
*right = tmp;
}
}
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
print(arr, sz);
move(arr, sz);
print(arr, sz);
return 0;
}
注：
1.从左向右找一个偶数，该地址给left，从右向左找一个奇数，该地址给right，两地址交换，依次类推，直到left>right为止
2.交换的时候应该有判断，left是否小于right，如果不判断，这个代码某一次循环是有可能left>right的，会把可能正确的排序进行交换导致错误。
3.如果数组内全是奇数或全是偶数的话，一直往后找或一直往前找会造成越界访问，因此我们在找的时候也应该是有条件的，如代码2所示
40、程序的执行结果为
描述：
程序的执行结果为
int main()
{
unsigned char a = 200;
unsigned char b = 100;
unsigned char c = 0;
c = a + b;
printf(“%d %d”, a+b,c);
return 0;
}运行结果：
注：
1.200的二进制序列：00000000000000000000000011001000
a中存储的数据：11001000
100的二进制序列：00000000000000000000000001100100
b中存储的数据：01100100
2.c=a+b，a+b时进行整型提升（ab都是无符号的变量，因此整型提升补0）
a经过整型提升后：00000000000000000000000011001000
b经过整型提升后：00000000000000000000000001100100
a+b：00000000 00000000 00000001 00101100 该数值是正数，原反补相同，数值为300
c=a+b（c是unsigned char类型），变量c：00101100
%d打印，c符号位为0认为是正数，补0为 00000000000000000000000000101100，该数值是正数，原反补相同，数值为44
41、杨辉三角
描述：
在屏幕上打印杨辉三角
1
1 1
1 2 1
1 3 3 1
……
我的代码：
#include<stdio.h>
int main()
{
int arr[10][10] = { 0 };
int i = 0;
int j = 0;
arr[0][0] = 1;
arr[1][0] = 1;
arr[1][1] = 1;
for (i = 0; i < 10; i++)
{
for (j = 0; j <= i; j++)
{
if (j == 0)
{
arr[i][j] = 1;
}
if (i >= 2 && j > 0)
{
arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
}
printf("%-4d", arr[i][j]);
}
printf("\n");
}
return 0;
}
代码：
42、猜凶手
描述：
日本某地发生了一件谋杀案，警察通过排查确定杀人凶手必为4个嫌疑犯的一个。
以下为4个嫌疑犯的供词:
A说：不是我。
B说：是C。
C说：是D。
D说：C在胡说
已知3个人说了真话，1个人说的是假话。
现在请根据这些信息，写一个程序来确定到底谁是凶手。
代码：
注：依次假设abcd为凶手，从a开始往后进行验证，如过是三个真话一个假话，那么凶手就是此时正在验证的人
43、猜名次
描述：
5位运动员参加了10米台跳水比赛，有人让他们预测比赛结果：
A选手说：B第二，我第三；
B选手说：我第二，E第四；
C选手说：我第一，D第二；
D选手说：C最后，我第三；
E选手说：我第四，A第一；
比赛结束后，每位选手都说对了一半，请编程确定比赛的名次。
我的代码：
#include<stdio.h>
int main()
{
int a = 0;
int b = 0;
int c = 0;
int d = 0;
int e = 0;
for (a = 1; a <= 5; a++)
{
for (b = 1; b <= 5; b++)
{
for (c = 1; c <= 5; c++)
{
for (d = 1; d <= 5; d++)
{
for (e = 1; e <= 5; e++)
{
if (((b == 2) + (a == 3) == 1) && ((b == 2) + (e == 4) == 1) && ((c == 1) + (d == 2) == 1) && ((c == 5) + (d == 3) == 1) && ((e == 4) + (a == 1) == 1) && a * b * c * d * e == 120)
{
printf("a=%d,b=%d,c=%d,d=%d,e=%d\n", a, b, c, d, e);
}
}
}
}
}
}
return 0;
}代码：
注：上述条件都满足的情况下直接进行输出会有很多重复名次，比如a=3,b=3,c=1,d=3,e=4等，此时需要对满足条件的这些结果进行筛选，也就是1到5名词都得有，就用表达式a*b*c*d*e==120来筛选
44、把一个数每一位的奇数改为1偶数改为0
描述：
小乐乐喜欢数字，尤其喜欢0和1。他现在得到了一个数，想把每位的数变成0或1。如果某一位是奇数，就把它变成1，如果是偶数，那么就把它变成0。请你回答他最后得到的数是多少。
输入描述：
输入包含一个整数n (0 ≤ n ≤ 109)
输出描述：
输出一个整数，即小乐乐修改后得到的数字。
示例1：
输入：222222
输出：0
示例2：
输入：123
输出：101
我的代码：
#include<stdio.h>
#include<math.h>
int main()
{
int n = 0;
scanf("%d", &n);
int arr[100] = { 0 };
int i = 0;
int j = 0;
int s = 0;
int sum = 0;
//将n的每一位存入数组arr中，其中arr[0]存个位，arr[1]存十位 ...... arr[i]存最后一位
while (n)
{
arr[i] = n % 10;
n = n / 10;
i++;
}
//利用j从0访问arr数组一直到i，分别拿出其中的数字，用 1/0 乘上对应的权数后存在sum中
for (j = 0; j <= i; j++)
{
if (arr[j] % 2 == 0)
{
s = 0 * (int)pow(10, j);
}
else
{
s = 1 * (int)pow(10, j);
}
sum = sum + s;
}
printf("%d\n", sum);
return 0;
}代码：
45、n个台阶，一次走1或2阶，有多少种走法
描述：
小乐乐上课需要走n阶台阶，因为他腿比较长，所以每次可以选择走一阶或者走两阶，那么他一共有多少种走法？
输入描述：
输入包含一个整数n (1 ≤ n ≤ 30)
输出描述：
输出一个整数，即小乐乐可以走的方法数。
我的代码1：
#include<stdio.h>
int zoutaijie(int n)
{
if (n == 1)
{
return 1;
}
else if (n == 2)
{
return 2;
}
else
{
return zoutaijie(n - 1) + zoutaijie(n - 2);
}
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = zoutaijie(n);
printf("%d\n", ret);
return 0;
}我的代码2：
#include<stdio.h>
int zoutaijie(int n)
{
int a = 1;
int b = 2;
int c = 0;
if (n == 1)
{
return 1;
}
if (n == 2)
{
return 2;
}
while (n > 2)
{
c = a + b;
a = b;
b = c;
n--;
}
return c;
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = zoutaijie(n);
printf("%d\n", ret);
return 0;
}代码：
46、输入一串数字，去重并从小到大输出
描述：
老师给了小乐乐一个正整数序列，要求小乐乐把这个序列去重后按从小到大排序。但是老师给出的序列太长了，小乐乐没办法耐心的去重并排序，请你帮助他。
输入描述：
第一行包含一个正整数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
我的代码：（有问题，提示：运行超时或数组越界）
#include<stdio.h>
int main()
{
int n = 0;
scanf("%d", &n);
int p = n;
int arr[100000] = { 0 };
int i = 0;
int j = 0;
int exp = 0;
//将所有输入的数存入数组arr中
while ((scanf("%d", &arr[p - 1])) != EOF)
{
p--;
}
//将数组中数字按从小到大排序
for (i = 0; i < n - 1; i++)
{
for (j = 0; j < n - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
exp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = exp;
}
}
}
//打印数组中元素，后一个若与前一个相同则不打印
printf("%d ", arr[0]);
for (i = 1; i < n; i++)
{
if (arr[i] != arr[i - 1])
{
printf("%d ", arr[i]);
}
}
return 0;
}
代码：
47、矩阵转置
描述：
KiKi有一个矩阵，他想知道转置后的矩阵（将矩阵的行列互换得到的新矩阵称为转置矩阵），请编程帮他解答。
输入描述：
第一行包含两个整数n和m，表示一个矩阵包含n行m列，用空格分隔。 (1≤n≤10,1≤m≤10)
从2到n+1行，每行输入m个整数（范围-231~231-1），用空格分隔，共输入n*m个数，表示第一个矩阵中的元素。
输出描述：
输出m行n列，为矩阵转置后的结果。每个数后面有一个空格。
示例1：
输入：2 3
1 2 3
4 5 6输出：1 4
2 5
3 6
我的代码：
#include<stdio.h>
int main()
{
int n = 0;
int m = 0;
scanf("%d %d", &n, &m);
int i = 0;
int j = 0;
int arr[10][10] = { 0 };
//输入数组各元素，存在arr[10][10]中
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]);
}
printf("\n");
}
return 0;
}
代码：
48、序列中删除指定数字
描述：
有一个整数序列（可能有重复的整数），现删除指定的某一个整数，输出删除指定数字之后的序列，序列中未被删除数字的前后位置没有发生改变。
数据范围：序列长度和序列中的值都满足 1 \le n \le 501≤n≤50
输入描述：
第一行输入一个整数(0≤N≤50)。
第二行输入N个整数，输入用空格分隔的N个整数。
第三行输入想要进行删除的一个整数。
输出描述：
输出为一行，删除指定数字之后的序列。
示例1：
输入：6
1 2 3 4 5 9
4输出：1 2 3 5 9
示例2：
输入：5
1 2 3 4 6
5输出：1 2 3 4 6
我的代码：
#include<stdio.h>
int main()
{
int n = 0;
scanf("%d", &n);
int arr[60] = { 0 };
int i = 0;
int k = 0;
//将输入的数存在arr数组中
for (i = 0; i < n; i++)
{
scanf("%d", &arr[i]);
}
//输入要删除的数字
scanf("%d", &k);
//数组中不等于该数字的数进行输出
for (i = 0; i < n; i++)
{
if (arr[i] != k)
{
printf("%d ", arr[i]);
}
}
return 0;
}代码：
注：
代码中i变量是遍历数组中元素的，j变量是记录应该存在哪里。
49、带空格直角三角形图案
描述：
KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的带空格直角三角形图案。
输入描述：
多组输入，一个整数（2~20），表示直角三角形直角边的长度，即“*”的数量，也表示输出行数。
输出描述：
针对每行输入，输出用“*”组成的对应长度的直角三角形，每个“*”后面有一个空格。
示例1：
输入：5
输出：
示例2：
输入：4
输出：
我的代码：
#include<stdio.h>
int main()
{
int n = 0;
int i = 0;
int j = 0;
while (scanf("%d", &n) != EOF)
{
for (i = 1; i <= n; i++)
{
for (j = 0; j < (n - i) * 2; j++)
{
printf(" ");
}
for (j = 0; j < i; j++)
{
printf("* ");
}
printf("\n");
}
}
return 0;
}代码：
注：
1.
2.想象成一个n*n数组的正方形，其中对角线左上角的元素打印两个空格，其余元素打印星号+空格即可。
3.与副对角线平行的各个对角线中元素具有相同的性质：它们的横纵坐标相加是一个相等的数。
50、空心三角形图案
描述：
KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的“空心”三角形图案。
输入描述：
多组输入，一个整数（3~20），表示输出的行数，也表示组成三角形边的“*”的数量。
输出描述：
针对每行输入，输出用“*”组成的“空心”三角形，每个“*”后面有一个空格。
示例1：
输入：4
输出：
示例2：
输入：5
输出：
我的代码：
#include<stdio.h>
int main()
{
int n = 0;
int i = 0;
int j = 0;
while (scanf("%d", &n) != EOF)
{
//打印前两行
printf("* ");
printf("\n");
printf("* * ");
printf("\n");
//打印中间行（中间行共n-3行，行数i从1开始到n-3，每一行首尾是* ，中间是行数i*2个空格）
for (i = 1; i <= n - 3; i++)
{
printf("* ");
for (j = 0; j < 2 * i; j++)
{
printf(" ");
}
printf("* ");
printf("\n");
}
//打印最后一行（n个* ）
for (i = 0; i < n; i++)
{
printf("* ");
}
printf("\n");
}
return 0;
}代码：
注：
1.
2.想象成一个n*n数组的正方形，其中第一列元素、对角线元素、最后一行元素打印星号+空格，其他元素都打印两个空格即可。
2123
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
