开始刷题--《C语言经典100题》

前言

国庆哪儿也没去，打算趁着这段时间好好理理、总结自己刚工作以来的问题。

工作有点恼火，没有得心应手的感觉，除了换了工作方向不适应外，就感觉自己基础不够好，刚工作，就在公司犯了一些C语言方面的错误，也被leader说了，就打算来刷刷C语言的题了，加强下自己的基础，加油！

每天至少两道题，立贴为证~~

编程环境

IDE：
Visual C++ 6.0

操作系统：
win10-64位

所编程序均已验证，能实现功能，但是否最优，尚待确认，仅作为自己的练习积累。

如有不妥，敬请指教啦~

正文

【程序1】

题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？

分析：
使用三个for循环将1,2，3,4分别填在个、十、百位上，再去掉不满足条件的即可。

程序如下：

#include 

int main(void)
{
     
	int i = 0;
	int j = 0;
	int k = 0;

	int m = 0;
	int num = 0;
	int count = 0;

	for(i=1;i<5;i++)
	{
     
		for(j=1;j<5;j++)
		{
     
			for(k=1;k<5;k++)
			{
     
				m++;
				if(i != j && j!=k && i!=k)
				{
     
					num = i*100+j*10+k;
					printf(" %d ",num);

					if(m%10 ==0)
					{
     
						printf("\r\n");
					}
					count++;
				}
				else
				{
     
				}
			}
		}
	}
	printf("\r\n count is %d \r\n",count);
	return 0;
}

运行结果：

【程序2】

题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？

分析：
多重if elseif else即可。

程序如下：

#include 

int main(void)
{
     	
	float I = 0;
	float bonus = 0;
	printf("请输入当月利润I，按Enter完成输入 \r\n");
	printf("单位:万元 \r\n ");
	printf("I: ");
	scanf("%f",&I);

	if(I>100)
	{
     
		bonus = (I-100)*0.01+40*0.015+20*0.03+20*0.05+10*0.075+10*0.1;
	}
	else if(I>60)
		{
     
			bonus = (I-60)*0.015+20*0.03+20*0.05+10*0.075+10*0.1;
		}
			else if(I>40)
			{
     
				bonus = (I-40)*0.03+20*0.05+10*0.075+10*0.1;
			}
				else if(I>20)
					{
     
						bonus = (I-20)*0.05+10*0.075+10*0.1;
					}
					else if(I>10)
						{
     
							bonus = (I-10)*0.075+10*0.1;
						}
						else
						{
     
							bonus = I*0.1;
						}

	printf("I:%f 万元, bonus:%f 万元 \r\n",I,bonus);

	return 0;
}

运行结果：

【程序3】

题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？

分析：
死循环判断是否为平方数，再加上开方后是否为整数，我这儿错误理解完全平方数的意思，我以为只是个平方数，所以我的程序求解的是平方数，并不是完全平方数。

程序如下：

#include 
#include 

int main(void)
{
     
	int a = 0;
	int b = 0;

	int i = 0;

	float c = 0;
	float d = 0;

	float diff_a = 0;
	float diff_b = 0;

	do
	{
     
		a = i+100;
		b = i+168;
		
		//使用sqrt函数计算开方后的数
		c = sqrt(a);
		d = sqrt(b);

		//判断开方后是否为整数
		diff_a = c - (int)c;
		diff_b = d - (int)d;

		if(diff_a == 0 && diff_b ==0)
		{
     
			printf("%d \r\n",i);
			break;
		}
		i++;
	}while(1);
	return 0;
}

运行结果：

【程序4】

题目：输入三个整数x,y,z，请把这三个数由小到大输出

分析：
依次两两对比，交换位置，用的是冒泡法的思路。

程序如下：

#include 

int main(void)
{
     
	int a = 0;
	int b = 0;
	int c = 0;

	int temp = 0;

	printf("请输入三个整数，以空格隔开，最后点击enter键结束！\r\n");
	scanf("%d",&a);
	scanf("%d",&b);
	scanf("%d",&c);

	if(a>b)
	{
     
		temp = a;
		a = b;
		b = temp;
	}

	if(b>c)
	{
     
		temp = b;
		b = c;
		c = temp;
	}

	if(a>b)
	{
     
		temp = a;
		a = b;
		b = temp;
	}

	printf("%d<%d<%d \r\n",a,b,c);
	return 0;
}

运行结果：

【程序5】

题目：用*号输出字母c的图案。

分析：
这个简单。

程序如下：

#include 

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

	return 0;
}

运行结果：

【程序6】

题目：输出9*9口诀

分析：
两个for循环，一个控制行的数字增大，一个控制列的数字增大。

程序如下：

#include 

int main(void)
{
     
	int  i = 0; 
	int  j = 0; 	
	
	for(i = 1;i<10;i++)
	{
     
		for(j = 1;j<10;j++)
		{
     
			printf("%d * %d = %-3d",i,j,i*j);
		}
		printf("\r\n");
	
	}
	return 0;
}

运行结果：

【程序7】

题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

分析：
这个题目比较难。

难一：正确计算每个月，兔子数量的规律，一开始我没计算对，看了下别人的思路，发现原来是斐波那契数列（Fibonacci sequence）：0、1、1、2、3、5、8、13、21、34、……，规律就是从第三个数开始，后面的数为其前两个数之和；
难二：就是实现该规律了。

认真想了下，就用数组的方式实现了，这样比较简单直接。

程序如下：

#include 

int main(void)
{
     
	int i = 0;
	long num[20] = {
     1,1};
	for(i=2;i<20;i++)
	{
     
		num[i] = num[i-1] + num[i-2];
		printf("第%d个月兔子总数为：%d对 \r\n",i+1,num[i]);
	}
	return 0;
}

运行结果：

【程序8】

题目：将一个正整数分解质因数。例如：输入90,打印出90=2 * 3 * 3 * 5。

分析：
先将该数分解，即求解质因数，最后拼凑成题目要求的，这个地方有点小技巧。

程序如下：

#include 

int main(void)
{
     
	long i = 0;
	int b[20] = {
     0};//暂定该数有20个质因数
	int j = 0;
	long a = 0;

	int k = 0;

	printf("请输入一个正整数：");
	scanf("%d",&a);
	printf("输入的正整数为：%d \r\n",a);
	
	printf("%d = ",a);
	i = 2;
	while(i<=a)
	{
     
		if(a%i == 0 )
		{
     
			a = a/i;
			b[j] = i;
			
			//得到一个约数后，要将i重置为1，重新寻找下一个约数
			i = 1;
			j++;
		}
		i++;
	}

	//打印成题目要求的格式
	for(k=0;k<j;k++)
	{
     	
		//最后一个乘数，不打印*
		if(j ==0 || k == j-1)
		{
     
			printf("%d",b[k]);
		
		}
		else
		{
     
			printf("%d*",b[k]);	
		}
	}

	printf("\r\n");

	return 0;
}

运行结果：

【程序9】

题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。

分析：
这个简单，只是要了解下条件运算符（？：）的用法。

程序如下：

#include 

int main(void)
{
     
	char g = '0';

	char A = 'A';
	char B = 'B';
	char C = 'C';

	unsigned int a = 0;
	printf("请输入成绩：");
	scanf("%d",&a);

	printf("输入的成绩为：%d \r\n",a);
	g = (a >= 90)?A:((a>=60)?B:C);
	
	printf("成绩等级为：%c \r\n",g);
	return 0;
}

运行结果：

【程序10】

题目：输入两个正整数m和n，求其最大公约数和最小公倍数。

分析：
这个题目比较难，最大公约数、最小公倍数的计算算法，怎么计算不知道，然后我查了下，最大公约数有好几种算法，我喜欢用辗除法，比较好理解。
辗除法：
a%b =c,
b%c =d，
c%d =e,
…,
一直循环，直至结果为0，得到的除数即为最大公约数。
然后，求出了最大公约数后，最小公倍数就好求了，将两数乘积再除以最大公约数就可以得到了。

程序如下：

#include 

int main(void)
{
     	
	//定义输入的两个正整数
	int a = 0;
	int b = 0;
	int temp = 0;
	
	//打印时使用
	int c = 0;
	int d = 0;
	
	//定义最大公约数
	int maxCommonNumber = 0;

	//定义最小公倍数
	int minCommonNumber = 0;

	printf("请输入两个正整数，以空格隔开：");
	scanf("%d%d",&a,&b);

	printf("\r\n");

	//保证a>b
	if(a>b)
	{
     }
	else
	{
     
		temp = a;
		a = b;
		b = temp;
	}
	
	//打印赋值，方便打印
	c = a;
	d = b;

	//辗除法。
	//思路：a%b =c,b%c =d，...,一直循环，直至为0
	do
	{
     
		if(b!=0)
		{
     
			a = a%b;

			if(a!=0)
			{
     
				b = b%a;
			}
		}
	}while(a!=0 && b!=0);
	
	//最大公约数为a,b中非零的
	maxCommonNumber = (a==0)?b:a;

	//最大公倍数为二者相乘，再除以最大公约数
	minCommonNumber = c*d/maxCommonNumber;

	printf("%d %d的最大公约数为：%d \r\n",c,d,maxCommonNumber);
	printf("\r\n");
	printf("最小公倍数为：%d \r\n",minCommonNumber);
	return 0;
}

运行结果：

【程序11】

题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

分析：
思路如下：
将输入的字符分为四类：中英文字母、空格、数字、其他字符。

然后，还需要知道每个字符的ASCII值，查了下ASCII表：
a-z：97-122；A-Z：65-90；（十进制）
空格：32；
0-9：48-57；
剩下的就是其他字符了。

判断输入字符串中每个字符的ASCII值即可。

最后还需要注意的两个点就是，

• 两种字符串指针的读写问题：
  char * txt = “0” 只读
  char txt[] = “0” 可读可写（要用这个）
• scanf函数
  scanf函数读取字符串时以空格为分隔，遇到空格就认为当前字符串结束了，所以scanf函数无法读取含有空格的字符串，所以在本例读取输入时（涉及空格），要改用gets（p）函数，读取的字符串存入字符串指针p中。

注意点参考来源

程序如下：

#include 

int main(void)
{
     
	
	char txt[] = "0"; //char * txt = "0" 只读  char txt[] = "0"可读可写
	int num = 0; 
	int i = 0;
	int j = 0;
	
	int LetCount = 0;
	int spaCount = 0;
	int numCount = 0;
	int othCount = 0;

	printf("请输入一行字符：");
	gets(txt);

	while(txt[i] != '\0')
	{
     
		num = txt[i] + 0;//字符类型转数字类型

		if(num >= 97 && num <= 122)
		{
     
			LetCount++;
		}
		else if(num >= 65 && num <= 90)
			{
     
				LetCount++;
			}
			else if(num == 32)
				{
     
					spaCount++;
				}
				else if(num >= 48 && num <= 57)
					{
     
						numCount++;
					}
					else
					{
     
						othCount++;
					}
		i++;
	}

	printf("输入的字符为：");
	for(j=0;j<i;j++)
	{
     
		printf("%c",txt[j]);
	}
	printf("\r\n其中，中英文字母个数为： %d \r\n",LetCount);
	printf("      空格个数为： %d \r\n",spaCount);
	printf("      数字个数为： %d \r\n",numCount);
	printf("      其他字符个数为： %d \r\n",othCount);

	return 0;
}

运行结果：

——————2020-10-07——————

【程序12】

题目：求s=a+aa+aaa+aaaa+aa…a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。

分析：
22222 = 2 * 10⁰+ 2 * 10¹+ 2 * 10²+ 2 * 10³+ 2 * 10⁴
其他依次类推
然后，接下来就是怎么写10的几次方的问题，这儿我用的是pow(a,b)函数，表示a^b，但要包含math.h，直接用10相乘的办法好像不好弄，先凑合着用。

程序如下：
有个小疑问，若定义为sNumber[]，则数组成员不能超过3个，这儿有点没搞明白，因此暂定10个数相加为上限，可修改。

#include 
#include 

int main(void)
{
     
	unsigned int a = 0;
	unsigned int times = 0;
	
	long s = 0;
	long sNumber[10] = {
     0};//暂定10个，若定义为sNumber[]，则不能超过3个
	long f = 0;

	int i = 0;
	int j = 0;
	
	printf("请输入0-9中的一个数字：");
	scanf("%d",&a);
	printf("\r\n");
	printf("请输入相加的次数：");
	scanf("%d",&times);

	for(i=0;i<times;i++)
	{
     
		s = s + a*pow(10.0,i);//求取每个加数
		sNumber[i] = s;//保存每个加数到数组中
	}
	//打印对应的格式
	printf(" s = ");
	for(j=0;j<times;j++)
	{
     
		f = f + sNumber[j];//求和
	
		if(j == times-1)
		{
     
			printf("%d",sNumber[j]);
		}
		else
		{
     
			printf("%d+",sNumber[j]);
		}
	}
	printf("\r\n s = %d \r\n",f);
}

运行结果：

【程序13】

题目：一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3.编程找出1000以内的所有完数。

分析：
这个题目不难，但是要理解请题目的意思：6=1＋2＋3，我一开始以为是6等于它的质因子之和，然后写了相应的程序，结果打印出来，1000以内只有6，觉得不对啊，然后去百度了一下完数有哪些：“第一个完全数是6，第二个完全数是28，第三个完全数是496，后面的完全数还有8128、33550336等等”，然后才发现，完数的准确定义：一个数若等于除去自身之外的约数之和，则称为完数，再举例：28=1+2+4+7+14，题目再多举个例子嘛！（那我就不会理解错了，搞得我调试了很久= =）

明白了这个就简单了，也就是求一个数的所有约数（除本身），再求和判断了。

程序如下：

#include 

int main(void)
{
     
	int a = 0;

	int i = 0;
	int j = 0;
	int k = 0;

	int sum = 0;

	int c[100] = {
     0};//约数个数上限暂定100

	j = 0;
	for(a=1;a<1000+1;a++)
	{
     
		j = 0;
		i = 1;
		
		//求取所有约数
		while(i<a)
		{
     
			if(a%i == 0)
			{
     
				c[j] = i;
				j++;

			}
			i++;
		}
		
		//求和判断
		sum = 0;
		if(j>0)
		{
     
			for(k=0;k<j;k++)
			{
     
				sum = sum + c[k];
			}

			if(sum == a)
			{
     
				printf(" %d ",a);
			}
		}
	}
	printf("\r\n");
	return 0;
}

运行结果：

【程序14】

题目：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

分析：
这题比较简单，但是要注意计算第10次共经过多少米时，需要减去第10次反弹的高度。

程序如下：

#include 

int main(void)
{
     
	double high = 100;
	double sum = 0;
	int i = 0;

	for(i=0;i<10;i++)
	{
     
		sum = sum + high + 0.5*high;
		high = 0.5*high;
	}
	
	//减去第10次反弹的高度
	sum -= high;
	printf("第10次落地共经过：%f 米 \r\n",sum);
	printf("第10次反弹高度为：%f 米 \r\n",high);

	return 0;
}

运行结果：

——————2020-10-08——————

【程序15】

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

分析：
这个题目要知道每天桃子数的规律，如下：
第10天，1
第9天，4
第8天，10
第7天，22
…
依次类推，可以看出，规律是在前一天的桃子数*2+2的关系。

程序如下：

#include 

int main(void)
{
     
	int i = 0;
	int peach = 0;

	peach = 1;
	for(i = 1;i<10;i++)
	{
     
		peach = (peach*2+2);
		printf(" 第%d天的桃子数为：%d \r\n",10-i,peach);
	}	
	return 0;
}

运行结果：

【程序16】

题目：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。

分析：
这个题目本身不难，但是要把题目的意思转换成为程序，有点难度，现在人数少，口算都能想到赛手名单，但是如果人数再多点，限制条件再多点，该怎么编写程序呢。于是我想到了以下程序，如果人数、“比赛制度”变得更复杂了，也只需要在if的限制条件加上就行了。

程序如下：

#include 

int main(void)
{
     
	int temp = 0;
	//将x,y,z编号
	int x = 1;
	int y = 2;
	int z = 3;

	int a = 0;
	int b = 0;
	int c = 0;

	printf("x的编号为：%d \r\n",x);
	printf("y的编号为：%d \r\n",y);	
	printf("z的编号为：%d \r\n",z);

	for(temp=1;temp<=3;temp++)
	{
     
		if(temp!=x && temp!=z)
		{
     
			c = temp;
		}
	}
	//a的对手不会是c的对手
	for(temp=1;temp<=3;temp++)
	{
     
		if(temp!=x && temp!=c)
		{
     
			a = temp;
		}
	}
	//b的对手不会是a、c的对手
	for(temp=1;temp<=3;temp++)
	{
     
		if(temp!=a && temp!=c)
		{
     
			b = temp;
		}
	}
	printf("\r\n");
	printf("a的对手编号为：%d \r\n",a);
	printf("b的对手编号为：%d \r\n",b);	
	printf("c的对手编号为：%d \r\n",c);

	return 0;
}

运行结果：

【程序17】

题目：打印出如下图案（菱形）

分析：
需要分析星号出现的位置规律，将行、列编号为：
1 2 3 4 3 2 1
1
2
3
4
3
2
1
然后，填入星号和空格，可知，当行、列号之和大于等于5时，需要打印星号，就可以打印出菱形星号了。

程序如下：

#include 

int main(void)
{
     
	int i = 0;
	int j = 0;
	int sum = 0;
	
	//临时变量，因为不能直接修改i,j的值，会死循环（调试出现）
	int m = 0;
	int n = 0;

	for(i=1;i<7+1;i++)
	{
     
		for(j=1;j<7+1;j++)
		{
     
			m = i;
			n = j;

			if(m>4)
			{
     
				m = 8-m;
			}
			if(n>4)
			{
     
				n = 8-n;
			}
			
			sum = m+n;

			if(sum>=5)
			{
     
				printf("*");
			}
			else
			{
     
				printf(" ");
			}
		}
		printf("\r\n");
	}
	return 0;
}

运行结果：

——————2020-10-09——————

【程序18】

题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。

分析：
题目不难，需要分析分子、分母的规律。
可以看出，分子的规律是从第3项开始，每项均为前两项之和，跟斐波那契数列有点像哈。分母的规律的规律更简单，分母是前项分数的分子项。

然后要注意，变量类型的定义，具体见程序。

程序如下：

#include 

int main(void)
{
     
	float a[20] = {
     2,3};//只初始化前两项即可
	float b[20] = {
     1,2};

	int i = 0;
	int j = 0;
	
	float temp = 0;
	float sum = 0;

	printf("\r\n该数列的前20项为：\r\n");
	for(i=2;i<20;i++)
	{
     
		a[i] = a[i-1]+a[i-2];//分子规律
		b[i] = a[i-1];//分母规律
	}
	
	for(j=0;j<20;j++)
	{
     
		printf("%.f",a[j]);//打印整数浮点数，但是不打印小数点出来
		printf("/");
		printf("%.f ",b[j]);
		//打印换行，每5项换行
		if((j+1)%5 ==0)
		{
     
			printf("\r\n");
		}
		//涉及到相除，所以不光temp要设置为浮点型，a[j]、b[j]也要设置为浮点型
		temp = a[j]/b[j];
		sum += temp;//求和
	}

	printf("\r\n该数列的前20项之和为：%f \r\n",sum);
	return 0;
}

运行结果：

【程序19】

题目：求1+2!+3!+…+20!的和

分析：
同样是找规律，1+1 * 2+1 * 2 * 3+1 * 2 * 3 * 4+…，以此类推，这样就知道程序怎么写了，每项再比前一项多乘一个数。
然后要注意两点：

• 类型的定义，20！是天文数字，在VC++6.0，没有long long int类型（声明会报错），但可以声明_int64，
• 然后打印的时候也要注意，不能直接打印%d，要打印成%I64d，具体见程序。

注意点参考来源

程序如下：

#include 

int main(void)
{
     
	_int64 a[20] = {
     1};//只初始化首项为1，其他为0即可
	int i = 0;
	int j = 0;
	_int64 sum = 0; //注意类型定义

	for(i=1;i<20;i++)
	{
     
		a[i] = a[i-1]*(i+1);	
	}

	for(j=0;j<20;j++)
	{
     	
		printf(" %I64d ",a[j]);//注意打印格式
		sum += a[j];
		
		if((j+1)%5 == 0)
		{
     
			printf("\r\n");
		}
	}
	printf("\r\n 1+2!+3!+...+20!的和为：%I64d \r\n",sum);//注意打印格式
	
	return 0;
}

运行结果：

——————2020-10-11——————
先补上昨天的两道题，昨天着实太累，下班回来就不想动弹了，只想坐着歇会儿。

【程序20】

题目：利用递归方法求5!

分析：
需要了解下函数的递归，函数递归就是自己调用自己了，注意要设置停止条件（每次递归都要判断的条件）。

程序如下：

#include 

int multiply(int n);

int main(void)
{
     
	int a =5;
	int b = 0;
	b = multiply(a);
	printf("=%d \r\n",b);

}

//递归函数
int multiply(int n)
{
     
	int s = 0;
	//递归的判断停止条件
	if(n > 0)
	{
     
		s = n*multiply(n-1);
		//设置打印格式，为了好看点
		if(n!=5)
		{
     
			printf("%d*",n);
		}
		else
		{
     
			printf("%d",n);
		}	
	}
	else
	{
     
		s = 1;
	}
	return s;
}

运行结果：

【程序21】

题目：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。

分析：
有了上一题的基础，做这道题就不难了。我的程序实现的是输入一串字符，不限定于5个，但好像有数组越界的问题，但因为能实现功能，所以就先不管了。对这方面有要求的，注意下，我是做练习，所以先没管这些细节了。

程序如下：

#include 

void contra_print(char * a);

int main(void)
{
     
	char a[] = "0";
	int i = 0;
	
	printf("请输入一串字符（不含空格）：");
	scanf("%s",a);

	printf("\r\n输入的一串字符为：");
	while(a[i] != '\0')
	{
     
		printf("%c",a[i]);
		i++;
	}

	printf("\r\n逆序输出为：");
	contra_print(&a[i-1]);
	printf("\r\n");
	return 0;
}

void contra_print(char * a)
{
     
	if(*a!='\0')
	{
     
		printf("%c",*a);
		a--;
		contra_print(a);
	}
	else
	{
     
		printf(" ");
	}

}

运行结果：

【程序22】

题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？

分析：
除了用以前的“a[i] = a[i-1]+2”的方式来做外，还可以用刚学的递归，这个递归比较简单。

程序如下：

#include 

int age(int n);

int main(void)
{
     
	int a = 0;
	a  = age(5);
	printf("第5个人的年龄为：%d\r\n",a);

	return 0;
}

int age(int n)
{
     
	if(n==1)
	{
     
		return 10;
	}
	else
	{
     
		return (age(n-1)+2);
	}
}

运行结果：

【程序23】

题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。

分析：
这个比较简单，只是要想明白如何得到一个正整数的个、十、百、千、万位，具体见程序。

程序如下：

#include 
#include 

int main(void)
{
     
	int a = 0;
	int b[5] = {
     0};
	int i,j;
	
	printf("请输入一个不多于5位的正整数：\n");
	do
	{
     
		scanf("%d",&a);
		if(a <= 0 || a>= 100000)
		{
     
			printf("输入不合法,请输入一个不多于5位的正整数：\n");
		}
	}while(a <= 0 || a>= 100000);

	printf("输入的正整数为：%d \r\n",a);

	//判断是几位数
	for(i=0;i<5;i++)
	{
     
		if(a >= pow(10.0,i))//pow(a,b),表示a^b
			continue;
		else
			break;
	}

	b[0] = a%10; //个
	b[1] = a%100/10;//十
	b[2] = a%1000/100;//百
	b[3] = a%10000/1000;//千
	b[4] = a/10000;//万

	printf("它是%d位数\r\n",i);
	printf("逆序输出各位数字：");
	//逆序输出
	for(j=0;j<i;j++)
	{
     
		printf("%d",b[j]);
	}
	printf("\r\n");
	return 0;
}

运行结果：

——————2020-10-12——————

【程序24】

题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。

分析：
有了上一题的基础，这题就很简单了，只需判断个位与万位是否，并且十位与千位是否相同即可。

程序如下：

#include 

int main(void)
{
     
	int a = 0;
	int b[5] = {
     0};
	int i = 0;

	printf("请输入一个5位正整数：");
	scanf("%d",&a);
	printf("输入的正整数为：%d \r\n",a);

	b[0] = a%10; //个
	b[1] = a%100/10;//十
	b[2] = a%1000/100;//百
	b[3] = a%10000/1000;//千
	b[4] = a/10000;//万

	if(b[4] != 0)
	{
     
		if(b[0] == b[4] && b[1] ==b[3])
		{
     
			printf("该数是回文数\r\n");
		}
		else
		{
     
			printf("该数不是回文数\r\n");	
		}
	}
	else
	{
     
		printf("输入的不是5位正整数，请重新输入\r\n");
	}
	return 0;
}

运行结果：

【程序25】

题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母。

分析：
这个题目意思不太清楚，所以就仁者见仁智者见智了，我通过判断输入字母的ascii值的大小确定是星期几。

程序如下：

#include 

int main(void)
{
     
	char week[2]="0";
	int a[2] = {
     0};
	int i = 0;
	printf("请输入1个或2个代表星期几的字母：");
	scanf("%s",week);
	while(week[i]!='\0')
	{
     
		a[i] = week[i]+0;//字符转整形
		i++;
	}

	if(a[0]==77 || a[0]==109)
	{
     
		printf("Monday，星期一");
	}
	else if(a[0]==84 || a[0]==116)
		{
     
			if(a[1]==72 || a[1]==104)
			{
     
				printf("Thursday，星期四");
			}
			else
			{
     
				if(a[1]==85 || a[1]==117)
				{
     
					printf("Tuessday，星期二");
				}
				else
				{
     
					printf("输入的字母对应星期几存在歧义");
				}
			}
		}
		else if(a[0]==87 || a[0]==119)
			{
     
				printf("Wednesday，星期三");
			}
			else if(a[0]==70 || a[0]==102)
				{
     
					printf("Friday，星期五");
				}	
				else if(a[0]==83 || a[0]==115)
				{
     
					if(a[1]==65 || a[1]==97)
					{
     
						printf("Saturday，星期六");
					}
					else
					{
     	
						if(a[1]==85 || a[1]==117)
						{
     
							printf("Sunday，星期天");	
						}
						else
						{
     
							printf("输入的字母对应星期几存在歧义");
						}
					}
				}
				else
				{
     
					printf("输入的字母不符要求");
				}
	printf("\r\n");
	return 0;
}

运行结果：

——————2020-10-13——————

【程序26】

题目：练习函数调用。

分析：
这个简单，之前写递归的时候就用到了，pass。

【程序27】

题目：求100之内的素数。

分析：
这个比较简单，素数就是除了1和自身，没有其他约数了。

程序如下：

#include 

int main(void)
{
     
	int i = 0;
	int j = 0;
	int count =0;

	for(i = 2;i<=100;i++)
	{
     
		for(j = 1;j<i;j++)
		{
     
			if(j!=1 && i%j == 0)
			{
     
				break;//若有约数,直接break,换下一个数
			}
			else if(j == i-1)
				{
     
					printf("%d ",i);
					count++;
					//打印换行
					if(count%5==0)
					{
     
						printf("\r\n");
					}
				}
				//啥也不做，等j++
				else
				{
     
				}
		}
	}
	printf("\r\n100以内的素数共：%d个\r\n",count);
	return 0;
}

运行结果：

——————2020-10-14——————

【程序28】

题目：对10个数进行排序

分析：
比较简单，需要了解下排序算法，我就用简单的冒泡排序，比较好理解。

程序如下：

#include 

void bubbSort(int * arr,int len);

int main(void)
{
     
	int len = 0;
	int a[10] = {
     1,3,5,2,4,22,33,10,4,8};
	int i = 0;
	int j = 0;
	printf("10个数排序前：");
	for(i=0;i<10;i++)
	{
     
		printf(" %d ",a[i]);
	}
	printf("\r\n从小到大排序后：");
	bubbSort(a,10);//冒泡排序
	for(j =0;j<10;j++)
	{
     
		printf(" %d ",a[j]);
	}
	printf("\r\n");
	return 0;
}

void bubbSort(int * arr,int len)
{
     
	int i =0;
	int j =0;
	int temp=0;

	for(i=0;i<len-1;i++)
	{
     
		for(j=0;j<len-1-i;j++)
		{
     
			if(arr[j]>arr[j+1])
			{
     
				temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
}

运行结果：

——————2020-10-15——————

【程序29】

题目：求一个3*3矩阵对角线元素之和。

分析：
题目的意思没表达清楚，应该是主对角线元素（左上至右下角元素）之和，我一开始还以为是两条对角线元素之和呢，那还有点麻烦，还觉得奇怪，后去扫了眼答案，原来是求主对角线元素之和，那这个比较简单。

程序如下：

#include

int main(void)
{
     
	int i = 0;
	int j = 0;
	int a[3][3] = {
     0};
	int sum = 0;
	
	printf("请依次输入3*3矩阵的元素，从上至下，从左往右：\r\n");
	for(i=0;i<3;i++)
	{
     
		for(j=0;j<3;j++)
		{
     
			scanf("%d",&a[i][j]);
			printf(" %d ",a[i][j]);
		}
		printf("\r\n");
	}
	printf("\r\n对角线元素为：\r\n");
	for(i=0;i<3;i++)
	{
     
		printf(" %d ",a[i][i]);
		sum += a[i][i];
	}
	printf("\r\n主对角线之和为：%d\r\n",sum);
	return 0;
}

运行结果：

——————2020-10-17——————

【程序30】

题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

分析：
这个题目比较麻烦，首先是数组的排序方向未知，是从大到小还是从小到大；其次，就是输入的数插入位置也要分几种情况：①等于数组中的某个数；②大于数组的最大数或小于最小数；③介于数组的两数之间。最后，确定插入位置之后，还得对其他数进行位置迁移。
细节见程序。

但想清楚后，再写代码也就不麻烦了，一定要想清楚。程序是我自己想的，感觉写的有点麻烦，仅供参考啊~

程序如下：

#include

void prtNum(int *p,int cnt);

int main(void)
{
     
	int a[5] = {
     1,3,5,7,9};
	int b[6] = {
     0};
	int i = 0;
	int j = 0;
	int temp = 0;

	printf("要插入的数组为：\r\n");
	for(i=0;i<5;i++)
	{
     
		printf("%d ",a[i]);
	}

	printf("\r\n请输入要插入的数字：\r\n");
	scanf("%d",&temp);

	//等于数组中的某个数的情况
	for(i=0;i<5;i++)
	{
     
		if(temp == a[i])
		{
     
			b[i] = a[i];
			b[i+1] = temp;
			for(j=i+2;j<6;j++)//复制后面的数
			{
     
				b[j] = a[j-1];
			}
			//打印出来
			prtNum(b,6);
		}
		else
		{
     
			b[i] = a[i];//复制前面的数
		}
	}

	//其他情况:大于最大数、小于最小数、介于两数之间
	if((b[0]-b[4]) >= 0) //数组排序从大到小
	{
     
		//大于数组中的最大数
		if(temp>b[0])
		{
     
			b[0] = temp;
			for(i=0;i<5;i++)//复制前面的数
			{
     
				b[i+1] = a[i];
			}
			//打印出来
			prtNum(b,6);
		}
		//小于数组中的最小数
		if(temp<b[4])
		{
     
			b[5] = temp;
			//打印出来
			prtNum(b,6);
		}

		//介于数组两值之间
		for(i=0;i<5;i++)
		{
     
			if(temp<b[i] && temp>b[i+1])
			{
     
				b[i+1] = temp;
				for(j=i+2;j<6;j++)//复制后面的数
				{
     
					b[j] = a[j-1];
				}
				//打印出来
				prtNum(b,6);

			}
			else
			{
     
				b[i] = a[i];//复制前面的数
			}
		}

	}
	else //数组排序从小到大
	{
     
		//大于数组中的最大数
		if(temp>b[4])
		{
     
			b[5] = temp;
			//打印出来
			prtNum(b,6);

		}
		
		//小于数组中的最小数
		if(temp<b[0])
		{
     
			b[0] = temp;
			for(i=0;i<5;i++)
			{
     
				b[i+1] = a[i];
			}
			//打印出来
			prtNum(b,6);
		}

		//介于数组两值之间
		for(i=0;i<5;i++)
		{
     
			if(temp > b[i] && temp<b[i+1])
			{
     
				b[i+1] = temp;
				for(j=i+2;j<6;j++)
				{
     
					b[j] = a[j-1];
				}
				//打印出来
				prtNum(b,6);

			}
			else
			{
     
				b[i] = a[i];
			}
		}


	}

	return 0;
}

//函数功能：打印插入数字后的数组
void prtNum(int *p,int cnt)
{
     
	int i = 0;
	printf("插入数字后，数组为：\r\n");
	if(p==NULL)
	{
     
		printf("error.");
	}

	for(i=0;i<cnt;i++)
	{
     
		printf("%d ",p[i]);
	}
	printf("\r\n");
}

运行结果：
只放了一种介于数组两数之间情况，但其他情况也是可行的。

【程序31】

题目：将一个数组逆序输出。

分析：
一种简单的方法就是，另创建个数组b[n]，令b[n-1-i] = a[i]，就好了，但这样比较赖，有点不动脑筋了，然后又想了个办法——直接数组高低位置一一交换就好了，交换次数为数组数量的一半，这样最简单，也最有效。

程序如下：

#include

int main(void)
{
     
	//inNum[]调试报错，因此输入数组个数上限暂定20
	int inNum[20] = {
     0};
	int i = 0;
	int j = 0;
	int temp = 0;

	printf("请随机输入一组数字：\r\n");
	//动态获取输入任意数量的整数
	do
	{
     
		scanf("%d",&inNum[i]);
		i++;
	}while(getchar() != '\n');
	printf("输入的数组为：\r\n");
	for(j=0;j<i;j++)
	{
     
		printf("%d ",inNum[j]);
	}
	//一一交换，最低、最高交换，次低、次高交换,...
	for(j=0;j<i/2;j++)
	{
     
		temp = inNum[j];
		inNum[j] = inNum[i-1-j];
		inNum[i-1-j] = temp;
	}
	printf("\r\n数组逆序后为：\r\n");
	for(j=0;j<i;j++)
	{
     
		printf("%d ",inNum[j]);
	}
	printf("\r\n");
	return 0;
}

运行结果：

——————2020-10-18——————

【程序32】

题目：学习static定义静态变量的用法。

分析：
static，个人理解为修饰符，可修饰变量的定义、函数的定义。

• 修饰变量，则变量由自动的auto类型变为静态变量，改变变量的生命周期由代码块（在哪儿定义）变为整个程序执行结束，改变变量的存储由堆栈变为静态存储区。
• 修饰函数，则会限制函数的使用范围，仅限于在static定义函数之后才能对函数进行调用，在定义前位置的函数不能调用（也能调用，但要加声明），其他文件更不能调用。

【程序33】

题目：学习使用auto定义变量的用法。

分析：
如前，auto是变量修饰符，定义变量时默认（缺省）就是auto，定义在函数里，则是局部变量，定义在函数外，则为全局变量。

（补上，前几天落下的题）

【程序34】

题目：学习使用static的另一用法。

分析：
static的另一用法是分别用static和auto定义同一名字的变量时，由于存储区域（static：静态存储区，auto：内存区）的关系，二者值的变化互不影响。

【程序35】

题目：学习使用external的用法。

分析：
extern和static类似，属于修饰符，可修饰变量和函数，不同的是：

• 修饰变量时，表示该变量在其他文件有定义，表引用。
• 修饰函数时，也是类似，表示其他文件有函数定义，表引用。

【程序36】

题目：学习使用register定义变量的方法。

分析：
register修饰变量时，表示该变量为寄存器变量，访问速度比一般变量较快，当对变量使用频繁时，可定义为register变量，可加快程序的执行速度。
访问速度加快的原理好像是将变量的存储位置放到了缓存了，之前好像在哪儿看到过这块知识。

——————2020-10-19——————

【程序37】

题目：宏#define命令练习(1)。

分析：
练习1是练习使用#define 替换常量，以及简单的函数，这里要注意的就是多用括号“（）”，保证运算结合正确。
也趁做这个题把#define的知识系统地看了一遍。

【程序38】

题目：宏#define命令练习(2)。

分析：
练习2是指#define可以使用换行符“\”对替换的语句进行换行。

【程序39】

题目：宏#define命令练习(3)。

分析：
练习3，想说明的是，#define可以对运算符号进行替换，“<”、“>”、“==”。

——————2020-10-21——————

【程序40】

题目：#if #ifdef和#ifndef的综合应用。

分析：
条件编译的知识，也去过一遍。

#if 1
/* code */
#endif

#if 0
/* code */
#endif

#ifdef A
/* code */
#endif

#ifndef A
/* code */
#endif

【程序41】

题目：#include 的应用练习。

分析：
C语言，文件之间函数的调用。

【程序42】

题目：学习使用按位与 & 。

分析：
按位与：&
条件逻辑的与：&&

【程序43】

题目：学习使用按位或 | 。

分析：
按位或：|
条件逻辑的或：||

【程序44】

题目：学习使用按位异或 ^ 。

分析：
按位异或^：不同为1，相同为0。
0^0 = 0
0^1 = 1
1^1 = 0

【程序45】

题目：学习使用按位取反~

分析：
按位取反运算：
~0 = 1
~1 = 0

——————2020-10-25——————

【程序46】

题目：取一个整数a从右端开始的4～7位。

分析：
这个题目没太明白什么意思，暂定为取一个数的高四位吧，其他估计也差不多的。那这个就比较简单了，直接右移再左移，简单直接，左移右移都是往对应位置补0；如果用位操作与上一个11110000的数也可以，但感觉有点麻烦。

另外，这个题目可以学学如何打印一个数的二进制形式（库函数没有）。

程序如下：

#include 

int main(void)
{
     
	int i =0;
	int n = 215;
	int m = 0;
	printf("%d的二进制形式为:",n);
	//打印一个数的二进制形式
	for(i=7;i>=0;i--)
	{
     
		printf("%1d",(n&(1<<i))?1:0);
	}

	printf("\r\n取其高四位为：");

	m = n>>4;
	m = m<<4;
	for(i=7;i>=0;i--)
	{
     
		printf("%1d",(m&(1<<i))?1:0);
	}
	printf("\r\n");

	return 0;
}

运行结果：

【程序47】

题目：打印出杨辉三角形（要求打印出10行如下图）

分析：
这个题目比较难，主要是因为第一眼看杨辉三角规律不好写程序，想了很久也不知道怎么写，于是去瞄了一眼答案的提示，看到了杨辉三角的格式如下（该格式比较好想编程逻辑，不要和我一样想成等边三角形的格式，就不好编程序了），以及要用到二维数组，知道这些后，大概就知道程序怎么写了，写完后，结果正确，然后程序和答案竟一模一样~~。

其实写程序最缺的还是思路，有思路了，剩下的就是实现问题了，就怕没有思路= =

杨辉三角格式（正方形的左下半角）：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
…（以此类推）

然后规律就是

• a[i][0] = 1，i∈[0,9]
• a[i][i] = 1, i∈[0,9]
• 中间数是上级两个数之和

程序如下：

#include 

int main(void)
{
     
	int i = 0;
	int j = 0;
	int a[10][10] = {
     0};
	//两边值的初始化
	for(i=0;i<10;i++)
	{
     
		//杨辉三角的性质：两边值都是1
		a[i][i] = 1;
		a[i][0] = 1;
	}
	//中间值的计算
	for(i=2;i<10;i++)
	{
     
		for(j=1;j<i;j++)
		{
     
			//杨辉三角的本质规律
			a[i][j] = a[i-1][j-1]+a[i-1][j];
		}
	}
	//打印出来
	for(i=0;i<10;i++)
	{
     
		for(j=0;j<i+1;j++)
		{
     
			printf("%d ",a[i][j]);
		}
		printf("\r\n");
	}
	return 0;
}

运行结果：
——————2020-10-27——————

【程序48】

题目：输入3个数a,b,c，按大小顺序输出。

分析：
这题前面做过，再重做一下。

程序如下：

#include 

int main(void)
{
     
	int a = 0;
	int b = 0;
	int c = 0;
	
	int temp = 0;

	printf("请输入3个数，以空格隔开：\r\n");
	scanf("%d",&a);
	scanf("%d",&b);
	scanf("%d",&c);

	//输出从大到小的格式：a>b>c
	if(a<=b)
	{
     
		temp = b;
		b = a;
		a = temp;
	}
	if(b<=c)
	{
     
		temp = c;
		c = b;
		b = temp;		
	}
	if(a<=b)//注意，这里是a、b比较，因为b、c的值已置换
	{
     
		temp = b;
		b = a;
		a = temp;
	}
	printf("%d>%d>%d\r\n",a,b,c);
	return 0;
}

运行结果：

——————2020-11-02——————
唉，鸽了好久，无奈工作太忙了（虽然啥也没做出来= =），回来很累都不想再动了，后面有空慢慢补吧。

【程序49】

题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

分析：
这个算比较难的，后面的交换逻辑要理清，我用的是索引法吧（自己想的），瞄了下答案，答案用的好像是指针，没细看。

用一次for循环挨个比较大小，并记录索引，分别记录较大值的索引和较小值的索引，for循环执行完后，可得最大值、最小值的索引。

最后，就是交换逻辑了，要注意下，代码注释写的很清楚，自己再举个例子就知道了。

程序如下：

#include 

int main(void)
{
     
	//inNum[]调试报错，因此输入数组个数上限暂定20
	int inNum[20] = {
     0};
	int i = 0;
	int j = 0;
	int max = 0;
	int min = 0;
	int max_inx = 0;
	int min_inx = 0;
	int temp = 0;
	
	printf("请随机输入一组数字：\r\n");
	//动态获取输入任意数量的整数
	do
	{
     
		scanf("%d",&inNum[i]);
		i++;
	}while(getchar() != '\n');
	printf("输入的数组为：\r\n");
	for(j=0;j<i;j++)
	{
     
		printf("%d ",inNum[j]);
	}	
	printf("\r\n");
	min = inNum[0];
	for(j = 0;j<i;j++)
	{
     
		if(inNum[j]>=max)
		{
     
			max = inNum[j];
			max_inx = j;
		}
		if(inNum[j]<=min)
		{
     
			min = inNum[j];
			min_inx = j;
			if(min == inNum[0])
			{
     
				min_inx = 0;
			}
		}	
	}
	printf("数组中的最大数为：%d \r\n",max);
	printf("数组中的最小数为：%d \r\n",min);

	//若第一个数是最小数，最后一个数是最大数，只交换一次即可
	if(max_inx == (i-1) && min_inx == 0)
	{
     
		temp = inNum[0];
		inNum[0] = inNum[max_inx];
		inNum[max_inx] = temp;
	}
	else if(min_inx == 0)//若只第一个数为最小数，则需要注意，最小数交换的是最大数交换后的数
		{
     
			//最大的与第一个元素交换
			temp = inNum[0];
			inNum[0] = inNum[max_inx];
			inNum[max_inx] = temp;

			//最小数与最大数的位置进行交换，因为最小数被换到最大数的位置上了
			temp = inNum[max_inx];
			inNum[max_inx] = inNum[i-1];
			inNum[i-1] = temp;
		}
		else //其余情况，正常交换两次
		{
     
			//最大的与第一个元素交换
			temp = inNum[0];
			inNum[0] = inNum[max_inx];
			inNum[max_inx] = temp;
			//最小的与最后一个元素交换
			temp = inNum[i-1];
			inNum[i-1] = inNum[min_inx];
			inNum[min_inx] = temp;			
		}
	printf("最大的与第一个元素交换，最小的与最后一个元素交换后，数组为：\r\n");
	for(j=0;j<i;j++)
	{
     
		printf("%d ",inNum[j]);
	}
	printf("\r\n");
	return 0;
}

运行结果：
这里只试了一种情况，其他情况也试过的，没贴上来。

———————2020.11.08———————————
得暂时先停更一段时间了，感觉饭碗要保不住了，所以要平时有空的话，要先看看手头上相关的东西（C语言这块儿的东西，只有过了这段时间再说了）。唉，我真的太难了。= =

———————2020.12.05———————————
昨天转正答辩了，感觉没讲好，太紧张了，但是过不过都行了，过有过的好处，不过有不过的好处，Anyway，这块石头总算是落下了。

然后，接下来还是要接着补基础，一点一点的补，每天进步一点点，慢慢开始系统地学，系统地补。

【程序50】

题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数。

分析：
这个题目，我第一眼看到，这不挺简单的嘛，直接用两个数组，根据原数组对应位置复制一份到新数组，不就好了，但我又觉得太偷懒了，我想了一些其他办法，但没跑通，然后瞄了眼答案（只看思路），但答案好像就是我第一眼想的那样，不过用的是指针，看起来更高大上一点，实质还是一样，然后我就用两种方式都实现了下，具体见代码及注释。

可以修改程序中的数组及N M的值进行测试，我随便测试了一下，都是可以的。

程序如下：

#include 

#define N     (7)
#define M     (3)

//方式2
void move(int *p, int n, int m)
{
     
	int b[256];
	int i,j,k;
	//对传入的指针进行非空检查
	if(p == NULL || (n < m))
	{
     
		printf("Wrong,p is NULL or the wrong n m.\r\n");
	}
	//复制数组
	for(i = 0;i<n;i++)
	{
     
		b[i] = *(p+i);
	}
	//交换最后面的m个数至最前面
	for(j = 0;j<m;j++)
	{
     
		*(p+j) = b[n-m+j];
	}
	//交换最前面的n-m个数至最后面
	for(k = 0;k<n-m;k++)
	{
     
		*(p+m+k) = b[k];
	}
}

int main(void)
{
     
	int a[N] = {
     1,2,3,4,5,6,7};
	int b[N] = {
     0};
	int i,j;
	
	printf("原数组为：\n");
	for(i = 0;i < N;i++)
	{
     
		printf("%d ",a[i]);
	}

	printf("\n移动后数组为：\n");

	/*方式1，使用两个数组*/
	//交换后M个数到最前面，并保存最前面的M个数至b数组
/*	for(i=0;i

	/*方式2，使用指针的方式*/
	move(a,N,M);
	for(i = 0;i < N;i++)
	{
     
		printf("%d ",a[i]);
	}
	printf("\n");

	return 0;
}

运行结果：

———————2020.12.26———————————
哇，很久没上来学习了。

转正答辩后，转正流程又走的有问题，很烦，偏偏到了我的转正流程就出问题，其他人就没事儿，于是我又得解决这个问题，终于在周四的时候，流程走完了，现在算是正式员工了。也算有了归属感，以后更要努力工作，努力学习了。

【程序51】

题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。

分析：
这道题，有点难，退出圈子的人编号没规律，所以就得“硬算”了。

大体思路是，定一个数组，一个计数值一直从1加到3，然后又是1,循环，对应数组的下标也加1，当计数为3的时候，数组对应下标的值定为0（标记为退出圈子），然后当下标计数到数组的最后一个，需重新回到数组的第一个，直至数组非零数只剩2个数，剩下的两个非零数的下标就是原来第几号的那位。

具体见程序逻辑及注释。

程序如下：

#include 

//总人数,可随意修改,用以测试程序的正确性
#define N 11

int main(void)
{
     
	int a[N] = {
     0};
	int i,k,m;

	if(N < 3)
	{
     
		printf("人数太小，无法计算。\n");
		return 0;
	}

	//给数组编号1,2,3,4,5,...,N
	for(i = 0;i<N;i++)
	{
     
		a[i] = i+1;
	}

	i = 0;
	k = 0;
	m = 0;

	while(m < (N-2))
	{
     
		//等于0,则跳过后再加1
		if(a[i] != 0)
		{
     
			k++;
		}
		//报到3的数赋值为0,复位k值,并让m计数加一,
		//当m计数为(N-2)时,即最后剩2个人时,跳出while循环
		if(k == 3)
		{
     
			k = 0;
			a[i] = 0;
			m++;
		}
	
		i++;
		//如果是最后一个数，则需要重新回到第一个数的位置
		if(i == (N-1))
		{
     
			//注意加上这段,不然是死循环
			if(a[i] != 0)
			{
     
				k++;
				if(k == 3)
				{
     
					k = 0;
					a[i] = 0;
					m++;
				}
			}
			//然后从头再1-3
			i = 0;
		}
	}
	
	printf("数组中，非零数即为最后留下的号数。\n");
	//打印出非零的数,即为最后留下的号数
	for(i = 0;i < N;i++)
	{
     
		printf("%d ",a[i]);
	}
	
	printf("\n");
	return 0;
}

运行结果：
程序中的人数N，可随意修改，进行测试。

【程序52】

题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。

分析：
巧了，这道题是我当时校招的时候，面试时面试官让我手写代码的题（写在纸上给他看），当时是让我写个计算字符串长度的函数。

比较简单啦，也是库函数strlen函数了。

程序如下：

#include 

int strlen(char *input_char)
{
     
	int len = 0;
	if(input_char == NULL)
	{
     
		printf("Error,Wrong input_char.\n");
		return 0;
	}
	
	while(input_char[len] != '\0')
	{
     
		len++;
	}
	return len;
}

//输入字符串个数的上限，暂定为100，可修改
#define NUM_INPUT_CHAR    100

int main(void)
{
     
	int len;
	int i = 0;
	//这里有点奇怪，若定义为char input_char[] = "0"，打印会有问题，很奇怪。
	//所以只能先定个输入字符串的上限了
	char input_char[NUM_INPUT_CHAR] = "0";
	printf("请输入一个字符串，字符串中间不能含有空格。\n");
	scanf("%s",input_char);

	printf("输入的字符串为：\n");
	while(input_char[i] != '\0')
	{
     
		printf("%c",input_char[i]);
		i++;
	}

	printf("\n");
	len = strlen(input_char);

	printf("输入的字符串的长度为: %d \n", len);
	return 0;
}

运行结果：

———————2021.01.17———————————
新年好！
很久没学习了，自责中…

【程序53】

题目：编写input()和output()函数输入，输出5个学生的数据记录。

分析：
这个题目有点笼统，我都没明白什么意思，只好网上看了下答案，原来是要求编写两个函数，input和output，函数功能是输入5个学生的数据，如姓名、性别、年龄，然后再输出出来。

这应该是练习结构体的使用，题目还不错。
还得注意下scanf函数的用法，&：取地址符，放进对应的地址，所以年龄要用&，其他的因为是字符数组，自带地址，所以不用，

程序如下：

#include 

typedef struct
{
     
	int age;
	char name[16];
	char sex[8];
}student;

void input(student * stu)
{
     
	int i = 0;
	for(i = 0;i < 2;i++)
	{
     
		scanf("%s%s%d",stu[i].name, stu[i].sex, &stu[i].age);
	}
	printf("\r\n");
}

void output(student * stu)
{
     
	int i = 0;
	for(i = 0;i < 2;i++)
	{
     
		printf("%s %s %d",stu[i].name, stu[i].sex, stu[i].age);
		printf("\r\n");
	}
}

int main(void)
{
     
	student stu[2];

	printf("请输入2个学生的姓名、性别、年龄，中间以空格隔开. \r\n");
	input(stu);

	printf("输入的2个学生的姓名、性别、年龄如下： \r\n");
	output(stu);

	return 0;
}

运行结果：

———————2021.06.06———————————
很久没来了，最近深知基础的重要性，之前一直只是在看primer c++，但看了很久感觉进步不大，还是得动手写代码才行，果断接着刷题了，，

【程序54】

题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+…+1/n,当输入n为奇数时，调用函数1/1+1/3+…+1/n(利用指针函数)。
分析：
题目不难，只是得看下函数指针（不是指针函数吧，题目可能有误，别处找的题目）的概念。

程序如下：

#include 

float fra(int n);//函数声明
float (*p)(int n);//函数指针

int main(void)
{
     
	int n;
	float f;

	printf("请输入一个非零整数，回车键结束.\n");
	scanf("%d",&n);
	printf("输入的数字为：%d\n", n);

	p = fra;//将函数首地址赋值给函数指针

	if(n == 0)
	{
     
		printf("输入的数字不能为0 \n");
		return 0;
	}
	
	//f = fra(n);//正常函数
	f = (*p)(n);//函数指针
	printf("其倒数之和为：%f\n", f);
	return 0;
}

float fra(int n)
{
     
	float tmp = 0;
	int i;
	//even
	if(n%2 ==0)
	{
     
		for(i = 2;i <= n;i+=2)
		{
     
			tmp += (float)1/i;
			//printf("1/%d", i);
			if(i == n)
			{
     
				printf("1/%d \n", i);
			}
			else
			{
     
				printf("1/%d+", i);
			}
		}
	}
	//odd
	else
	{
     
		for(i = 1;i <= n;i+=2)
		{
     
			tmp += (float)1/i;
			if(i == n)
			{
     
				printf("1/%d\n", i);
			}
			else
			{
     
				printf("1/%d+", i);
			}
		}
	}
	return tmp;
}

运行结果：

———————2021.08.08———————————

【程序54】

809*??=800*??+9*??+1 其中??代表的两位数,8*??的结果为两位数，9*??的结果为3位数。求??代表的两位数，及809*??后的结果。
分析：
题目可能有点问题，809*??=800*??+9*??+1，n = n + 1?这怎么可能成立，然后我网上查了下，看下面代码的意思，应该是809*??是四位数的意思，那就很简单了。

程序如下：

#include 

int main(void)
{
     
	int i;

	for(i = 10;i < 100;i++)
	{
       
		int m = 809*i;
		int n = 800*i + 9*i + 1;

		int two = 8*i;
		int three = 9*i;

		if((m > 999 && m < 10000) && two < 100 && (three > 99 && three < 1000))
		{
     
			printf("found it.\n");
			printf("i: %d \n", i);
			printf("809*%d: %d \n", i, 809*i);
		}
	}
	return 0;
}

运行结果：

【程序55】

题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？
分析：
解题思路跟上面的题类似，多弄几个for循环就好了。

程序如下：

#include 

int main(void)
{
     
	int i,j,k,m;
	for(i = 10;i < 100000;i++)
	{
     
		/*这里注意,不要直接用i去做(i-1)*4/5的操作,会产生死循环的
		  比如当i = 11的时候,(i-1)*4/5就=8,然后又++到11,然后又=8,造成死循环
		  我也是调了半天才分析出来的...
		*/
		k = i;
		m = 0;

		for(j = 0;j < 5;j++)
		{
     
			if(k % 5 ==1)
			{
     
				k = (k-1)*4/5;
				m++;
			}
		}

		if(m == 5)
		{
     
			printf("the least peach on the beach: %d \n", i);
			break;
		}
	}
	return 0;
}

运行结果：

【程序56】

题目：求0—7所能组成的奇数个数。
分析：
首先，我对这个题目的理解意思是用0-7中的数字组成奇数，且数字不能重复，所能组成的奇数的个数是多少。这样的话，就得分位数统计了。
1位数：4个；
2位数：7×4-1×4个（首位不能为0，所以是6而不是7）；
3位数：6×7×4-1×6×4个；（1×6×4为排除的首位为0的奇数）；
4位数：5×6×7×4-1×5×6×4个；（1×5×6×4为排除的首位为0的奇数）；
5位数：4×5×6×7×4-1×4×5×6×4个；（1×4×5×6×4为排除的首位为0的奇数）；
6位数：3×4×5×6×7×4-1×3×4×5×6×4个；（1×3×4×5×6×4为排除的首位为0的奇数）；
7位数：2×3×4×5×6×7×4-1×2×3×4×5×6×4个；（1×2×3×4×5×6×4为排除的首位为0的奇数）；
8位数：1×2×3×4×5×6×7×4个。
解释下，排除的首位为0的奇数的个数算法是怎么来的，以3位数为例，首位为0只有1种情况，末位数可选1,3,5，7，个数则是1×4，然后十位数可选的就只有剩下的6种了，所以是1×6×4个。其他的位数依次类推。
接下来，就是怎么实现的问题了，看到计算中有阶乘，所以用递归函数，可能会比较简单一点，具体实现见代码。

程序如下：

#include 

int func1(int n);
int func2(int n);

int main(void)
{
     
	int i = 0;
	int sum1 = 0;
	int sum2 = 0;
	
	for(i = 1;i < 9;i++)//注意这里的上下限,注意阶乘的结果
	{
     
		sum1 += func1(i);
	}

	for(i = 3;i < 8;i++)//注意这里的上下限,注意阶乘的结果
	{
     
		sum2 += func2(i);
	}

	sum1 -= sum2;

	printf("用0—7（不能重复）所能组成的奇数个数为：%d \n", sum1);

	return 0;
}


int func1(int n)
{
     
	long sum = 0;
	if(n < 8)
	{
     
		sum = n * func1(n+1);
	}
	else
	{
     
		sum = 4;
	}
	return sum;
}

int func2(int n)
{
     
	long sum = 0;
	if(n < 7)
	{
     
		sum = n * func2(n+1);
	}
	else
	{
     
		sum = 4;
	}
	return sum;
}

运行结果：

----------------------------2021-10-31----------------------

【程序57】

题目：读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的＊。
分析：
这题简单，没什么说的。

程序如下：

#include 

int main(void)
{
     
	int i, j;
	int numbers[7];
	printf("请输入范围为1-50的7个整数，输入完1个后，按Enter键再输入下1个.\n");

	for(i = 0;i < 7;i++)
	{
     
		scanf("%d", &numbers[i]);
		if(numbers[i] < 1 || numbers[i] >50)
		{
     
			printf("输入数字不合法，请重新输入1-50的整数.\n");
			i = i-1;
		}
		else
		{
     
			for(j=0;j < numbers[i];j++)
			{
     
				printf("*");
			}
			printf("\n");
		}
	}

	return 0;
}

运行结果：

----------------------------2021-11-15----------------------

【程序58】

题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。
分析：
这题比较简单吧，稍微有点难的地方可能是取一个四位数的个、十、百、千位吧。
程序如下：

#include 

int main(void)
{
     
	unsigned int num;
	unsigned short num1,num2,num3,num4;
	unsigned int encryped_num;
	
	printf("请输入一个四位整数,按Enter键结束.\n");
	do
	{
     
		scanf("%d", &num);
		if(num < 999 || num > 10000)
		{
     
			printf("输入数字不合法，请重新输入.\n");
		}
	}while(num < 999 || num > 10000);
	
	num4 = num/1000;//千
	num3 = (num/100)%10;//百
	num2 = (num/10) - (num/100)*10;//十
	num1 = num - num4*1000 - num3*100 - num2*10;//个

	printf("%d = %d*1000 + %d*100 + %d*10 + %d \n", 
		    num, num4, num3, num2, num1);
		    
	printf("num4: %d \n", num4);
	printf("num3: %d \n", num3);
	printf("num2: %d \n", num2);
	printf("num1: %d \n", num1);

	//plus 5 encry
	num4 = (num4 + 5)%10;
	num3 = (num3 + 5)%10;
	num2 = (num2 + 5)%10;
	num1 = (num1 + 5)%10;

	printf("After plus 5 encry. \n");

	printf("num4: %d \n", num4);
	printf("num3: %d \n", num3);
	printf("num2: %d \n", num2);
	printf("num1: %d \n", num1);

	//change position encryption
	encryped_num = num1*1000 + num2*100 + num3*10 + num4;
	printf("plus change position encry, %d encrypt to %d \n", num, encryped_num);
	return 0;
}

运行结果：