C语言学习记录—作业4

1. 从大到小输出
写代码将三个整数数按从大到小输出。
例如：
输入：2 3 1
输出：3 2 1

非函数版本

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

	//调整
	int tmp = 0;
	//此方法假设a最大,
	//首先用a和b c分别比较，把较大值放到a里面	
	if (a < b)//只有当a < b时才有必要交换
	{
		tmp = a;
		a = b;
		b = tmp;
	}
	if (a < c)
	{
		tmp = a;
		a = c;
		c = tmp;
	}
	//上面两个if语句找出了a b c中的最大值并放到a里面
	if (b < c)
	{
		tmp = b;
		b = c;
		c = tmp;
	}
	printf("%d %d %d", a, b, c);
	return 0;
}

函数版本

//上方一直在做的都是交换变量，故可以写一个交换变量的函数，反复调用
void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}

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

	//调整
	//此方法假设a最大,
	//首先用a和b c分别比较，把较大值放到a里面	
	if (a < b)//只有当a < b时才有必要交换
	{
		Swap(&a, &b);
	}
	if (a < c)
	{
		Swap(&a, &c);
	}
	//上面两个if语句找出了a b c中的最大值并放到a里面
	if (b < c)
	{
		Swap(&b, &c);
	}

	printf("%d %d %d", a, b, c);

	return 0;
}

2. 写一个代码打印1 - 100之间所有3的倍数的数字

int main()
{
	int i = 0;
	//for ( i = 1; i <= 100; i++)
	//{
	//	if (i % 3 == 0)
	//		printf("%d ", i);
	//}

	for ( i = 3; i < 100; i+=3)//优化版本
		printf("%d ", i);
	return 0;
}

3. 给定两个数，求这两个数的最大公约数
例如：
输入：20 40
输出：20

方法1：暴力求解法

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	//思路：暴力求解
	//找两个数的较小数(因为两个数较大数不可能是最大公约数)，
	//用较小数去试除，每次-1直到找到为止
	int min = (a < b) ? a : b;
	int m = min;
	while (1)
	{
		if (a % m == 0 && b % m == 0)
		{
			break;
		}
		m--;
	}
	printf("%d\n", m);
	return 0;
}

方法2：辗转相除法

int main()
{
	int a = 0;
	int b = 0;
	int c = 0;
	scanf("%d %d", &a, &b);
	//用a%b=c，如果c不为0，则用b%c(这里是将b赋值给a，c赋值给b)直到结果为0
	while (c = a % b)
	{
		a = b;
		b = c;
	}
	printf("%d\n", b);
	return 0;
}

4. 编写程序数一下 1到 100 的所有整数中出现多少个数字9
  9 19 29 39 49 59 69 79 89 99
90 91 92 93 94 95 96 97 98 99

int main()
{
	int i = 0;
	int count = 0;
	for ( i = 1; i <= 100; i++)
	{
		//判断个位是不是9
		if (i % 10 == 9)
			count++;
		//判断十位是不是9
		if (i / 10 == 9)
			count++;
	}	
	printf("%d\n", count);
	return 0;
}

5. 分数求和
计算1/1 - 1/2 + 1/3 - 1/4 + 1/5 …… + 1/99 - 1/100 的值，打印出结果

思路：一开始忽略正负号，先求出所有的1/1  1/2  ....  1/99  1/100，然后利用flag每次一正一负

int main()
{
	int i = 0;
	double sum = 0.0;
	int flag = 1;
	for ( i = 1; i <= 100; i++)
	{
		sum = sum + flag * (1.0 / i);
		//第一次是1，-flag就变为-1，
		//第二次-1又加了-(负号)，-(-1)又变为+1
		flag = -flag;
	}
	printf("%lf\n", sum);
	return 0;
}

6. 求10个整数中最大值

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	
	//通过输入获得10个数
	//此方法创建数组是不能写成int arr[] = { 0 },此代码等效为int arr[1] = { 0 }，是一种错误写法
	for (i = 0; i < 10; i++)//i为元素下标
	{
		scanf("%d", &arr[i]);
	}

	int sz = sizeof(arr) / sizeof(arr[0]);
	//假设第一个元素是最大值。不建议将max初始化为0，因为数组如果都是负数且没有0，那么0就是最大值
	int max = arr[0];
	for (i = 1; i < sz ; i++)//因假设了第一个元素为最大值，所以从下标为1的元素(即第二个元素)开始
	{
		if (max < arr[i])
		{
			max = arr[i];
		}
	}
	printf("%d\n", max);
	return 0;
}

7. 在屏幕上输出9 * 9乘法口诀表

i是行数，j是每行打印多少个

int main()
{
	int i = 1;
	int pro = 0;
	for (i = 1; i <= 9; i++)//打印9行
	{
		int j = 1;
		for (j = 1; j <= i; j++)
		{
			pro = i * j;
			printf("%d*%d=%-2d ", i, j, pro);//%-2d左对齐；%2d右对齐
		}
		printf("\n");
	}
	return 0;
}

8. 猜数字游戏

思路：

程序开始展示菜单，输入1是开始游戏，输入0是结束程序。此需求通过switch语句实现。同时，为了让玩家能够反复玩这个游戏，要将这个switch语句放到do while循环中。do while的判断条件和switch语句一样，都是玩家输入的选项。

游戏开始，每局生成一个随机数。并且在会提示玩家猜大猜小直到玩家猜对为止。

void menu()
{
	printf("*****************************\n");
	printf("********   1. play   ********\n");
	printf("********   0. exit   ********\n");
	printf("*****************************\n");
}
void game()
{
	int guess = 0;
	int ret = rand() % 100 + 1;
	while (1)
	{
		printf("请猜数字:>\n");
		scanf("%d", &guess);
		if (guess > ret)
		{
			printf("猜大了\n");
		}
		else if (guess < ret)
		{
			printf("猜小了\n");
		}
		else
		{
			printf("猜对了\n");
			break;
		}
	}
}
int main()
{
	int input = 1;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			break;
		default:
			printf("选择错误，重新选择\n");
			break;
		}
	} 
	while (input);
	
	return 0;
}

9. 二分查找有序数组

思路：

1. 首先获取第一个元素（left）和最后一个元素（right）的下标。

2. 然后获取中间元素下标（mid），用中间的元素和被查找数比较。

3. 如果中间元素小于被查找数，说明范围在中间元素+1的至最右边元素。此时左下标移到到中间元素+1的位置

4. 如果中间元素大于被查找数，说明范围在中间元素-1的至最左边元素；此时右下标移到到中间元素-1的位置

5. 重复步骤2、3、4，直到找到为止；或当左下标和右下标相等时还没有找到，说明没有要找的数。

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	
	int left = 0;
	int right = sz - 1;
	int k = 7;

	while (left <= right)
	{
		int mid = left + (right - left) / 2;
		if (arr[mid] < k)
		{
			left = mid + 1;
		}
		else if (arr[mid] > k)
		{
			right = mid - 1;
		}
		else
		{
			printf("找到了，下标是：%d\n", mid);
			break;
		}
	}
	if (left > right)
	{
		printf("找不到\n");
	}

	return 0;
}

10. 接受一个整型值（无符号），按照顺序打印它的每一位。
例如：输入：1234，输出 1 2 3 4

思路：因为要一位一位的打印，所以要拆分数字。每次除以10就能将数字一位一位拆分。

(1234)/10=123
(123)/10=12
(12)/10=1

当只有一位的时候开始打印，因为只打印一位，所以在用当前的数%10
1%10=1
12%10=2
123%10=3
1234%10=4

void print(unsigned int n)
{
	if (n > 9)
	{
		print(n / 10);
	}
	printf("%d ", n % 10);
}
int main()
{
	unsigned int n = 0;
	scanf("%d", &n);
	print(n);
	return 0;
}

11. 递归和非递归分别实现求n的阶乘（不考虑溢出的问题）

递归版本

思路：用递归求阶乘首先找到最简单的情况，即求1的阶乘。1的阶乘就是1。2的阶乘是用2乘以1的阶乘。那么n的阶乘就是n*（n-1）的阶乘

int factorial(int n)
{
	if (n == 1)
		return	1;
	else
		return n * factorial(n - 1);
}

非递归版本

思路：非递归版本求阶乘也是用当前的数乘以上一个数的阶乘。在程序实现上需要考虑1的阶乘情况。这里创建一个阶乘的变量，并初始化为1，这样1*1还是等于1。这样就得到了1的阶乘，并保存起来。利用for循环让数字每次+1，这样每次都是乘以上一个数的阶乘。

int factorial(int n)
{
	int i = 0;
	int fac = 1;
	for (i = 1; i <= n; i++)
	{
		fac *= i;
	}
	return fac;
}

12. strlen的模拟

非递归版本

思路：将字符数组的地址传过去，用指针变量接收。利用循环判断当前位置是否是\0，如果不是那么计数变量+1，并且让指针向后移动一位。直到遇到\0。

int my_strlen(char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abc";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

递归版本

思路：同样将字符数组传过去，用指针变量接收，判断当前位置是否为\0。如果不是那么返回1，并且继续递归。同时，让指针+1也就是让指针让后移动一位。

int my_strlen(char* str)
{
	if (*str != 0)
		return 1 + my_strlen(str + 1);
	else
		return 0;
}

13. 判断一个数是不是素数。打印100-200之间的素数

非函数版本

思路：遍历100到200之间的数，用2~n-1的数去试除，如果没有一个数能整数，则说明是素数。

在此基础上优化，首先100~200的所有偶数都不是素数，所用从101开始遍历，每次+2。

其次，一个数A能被另一个数B整除（除数B和商C不为1或它本身），也可以理解为这个数A是另外两个数B C的乘积。而这两个数B C有个特点，他们中总是有一个最大不会超过被除数A（也就是乘积）的平方根。所以在试除的时候就不需要从2~n-1，只需要尝试到被除数A的平方根即可。

然后创建一个标记变量并初始化为1。如果有数能整除，说明这个数不是素数，将标记变量改为0并跳出当前试除的循环。

如果所有的数都不能整除，则说明是素数，此时标记变量还是1，那么打印这个数。

int main()
{
	int i = 0;
	int count = 0;
	
	for (i = 101; i <= 200; i+2)
	{
		int n = 0;
		int flag = 1;

		for (n = 2; n <= sqrt(i); n++)
		{
			if (i % n == 0)
			{
				flag = 0;
				break;
			}	
		}
 
		if (flag == 1)
		{
			printf("%d ", i);
			count++;
		}		
	}
	printf("\n%d\n", count);
	return 0;
}

函数版本

思路同非函数版本一样，只是非素数return 0，是素数return 1。

int is_prime(int n)
{
	int j = 0;
	for (j = 2; j <= sqrt(n); j++)
	{
		if (n % j == 0)
		{
			return 0;
		}
	}
	return 1;
}
int main()
{
	int i = 0;
	int count = 0;

	for (i = 101; i <= 200; i+=2)
	{
		if (is_prime(i))
		{
			printf("%d ", i);
			count++;
		}
	}
	printf("\n%d\n", count);
	return 0;
}