c语言实验五

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

#include
int main()
{
	int b = 1;					//最后一天的桃数
	for (int i = 9; i > 0; i--)//天数递减（倒推计算）
	{
		b = 2 * (b + 1);//计算每一天的吃桃数
	}
	printf("一共摘了%d", b);
	return 0;
}

程序运行后，会输出第一天猴子摘了多少桃子。这个数值是通过从第10天开始逆推计算得出的。每一天的桃子数量是后一天的两倍再加2（因为后一天猴子会吃掉一半再加一个）。通过这样的计算，我们可以找出第一天猴子摘了多少桃子。 

实验2：百马百担问题：100匹马，驮100担货，大马3担，中马2担，两匹小马驮一担，问共有大、中、小马各多少？   

#include 
/*百马百担问题：100匹马，驮100担货，大马3担，中马2担，两匹小马驮一担，
问共有大、中、小马各多少？*/
int main() {

	int x, y, j; //大马，中马，小马
	for (x = 0; x <= 33; x++) { //大马<100/3
		for (y = 0; y <= 50; y++) { //中马<100/2
			j = 100 - x - y; //小马100-大马-中马
			if (3 * x + 2 * y + j * 1.0 / 2 == 100) 
				printf("大马=%d 中马=%d 小马=%d\n", x, y, j);
		}
	}

	return 0;

}

代码分析如下：

1. 首先，定义了三个整数变量 x, y, j，分别代表大马、中马和小马的数量。
2. 使用两层嵌套的 for 循环来遍历可能的大马和中马的数量。大马的数量从0到33（因为大马最多能驮3担，所以最大数量是100/3=33），中马的数量从0到50（因为中马最多能驮2担，所以最大数量是100/2=50）。
3. 在循环内部，通过计算 j = 100 - x - y 来得到小马的数量。这里假设总共有100匹马，所以小马的数量就是总数减去大马和中马的数量。
4. 接下来，使用 if 语句来检查当前的马匹数量组合是否满足条件：大马驮3担，中马驮2担，两匹小马驮1担，总共要驮100担。这个条件用数学表达式表示为 3 * x + 2 * y + j * 1.0 / 2 == 100。
5. 如果满足条件，就使用 printf 函数输出当前的大马、中马和小马的数量。
6. 最后，程序返回0，表示正常结束。

这个代码通过暴力枚举所有可能的大马和中马的数量组合，然后计算对应的小马数量，并检查是否满足条件，从而找出所有可能的解。这是一个简单但有效的方法来解决这个问题。

 

实验3：输出以下的杨辉三角形（要求输出10行）

               1

               1    1

               1    2    1

               1    3    3    1

               1    4    6    4    1

               1    5    10   10   5   1

               ......  

#include 

#define numRows 10

int main() {
	int triangle[numRows][numRows];	//定义一个二维数组，存储杨辉三角的数值

	//初始化第一列和对角线上的值为1
	for (int i = 0; i < numRows; i++) {
		triangle[i][0] = 1;	//初始化每行的第一个元素为1
		triangle[i][i] = 1;	//初始化对角线元素为1
	}

	//计算其他元素
	for (int i = 2; i < numRows; i++) { //外循环从第二行开始，因为第一行及对角线初始化为1
		for (int j = 1; j < i; j++) {
			//内循环，遍历当前行的非边界元素
			triangle[i][j] = triangle[i - 1][j] + triangle[i - 1][j - 1]; 
			//上一行两个元素相加计算出当前元素
		}
	}

	//输出杨辉三角形
	for (int i = 0; i < numRows; i++) { //外循环，遍历每一行
		for (int j = 0; j <= i; j++) {	//内循环 ，遍历当前行的所有元素
			printf("%d ", triangle[i][j]);
		}
		printf("\n");
	}
	return 0;
}

在提供的代码片段 for (int j = 0; j <= i; j++) 中，使用 j <= i 是为了确保循环在达到第 i 个元素时仍然执行。这种循环结构通常用于处理二维数组或类似结构，其中 i 表示当前行，j 表示当前列。

假设我们在处理一个与杨辉三角相关的问题，或者任何需要逐行处理的问题。在这种情况下，每一行的元素数量与其行号 i 相关。第 0 行有 1 个元素，第 1 行有 2 个元素，第 2 行有 3 个元素，以此类推。为了确保我们能访问和处理到每一行的最后一个元素，我们需要使用 j <= i。

下面是一个简单的例子，说明为什么使用 j <= i 是必要的：

	for (int i = 0; i < numRows; i++) 
    { 

	    for (int j = 0; j <= i; j++) 
        { 

	    // 在这里处理杨辉三角的第 i 行，第 j 列的元素 

	    // 如果使用 j < i，则会错过每一行的最后一个元素 

	    } 

	}

在这个例子中，外部循环控制行数，内部循环控制列数。因为每一行的列数比行数多一（从 0 开始计数），所以我们需要使用 j <= i 来确保正确处理每一行的所有列。如果我们使用 j < i，那么我们会错过每一行的最后一个元素。

实验4：

找出一个二维数组的“鞍点”，输出该点的值和所在的行和列。“鞍点”即该位置上的元素在该行上最大，在该列上最小。也有可能没有鞍点。（要求：至少准备两组测试数据）

（1）有鞍点：

           9   80   205   40

          90  -60   96    1

         210  -3    101   89

（2）没有鞍点：

          9    80   205   40

          90  -60   196    1

        210  -3    101   89

          45   54   156   7

 

#include 

//定义一个函数FindSaddlePoint，它接受一个二维数组matrix，行数rows与列数cols作为参数
void FindSaddlePoint(int matrix[100][100], int rows, int cols) {
	//定义一个变量saddle_found,用于标记是否找到鞍点
	int saddle_found = 0;

	//遍历每一行
	for (int i = 0; i < rows; i++) {
		//假设第一个元素为当前行的最大值
		int row_max = matrix[i][0];
		//记录当前行最大值所在列的索引
		int col_index = 0;

		//找出当前行的最大值及其所在列的索引
		for (int j = 1; j < cols; j++) {
			//如果当前元素大于当前行的最大值，则更新最大值和索引
			if (matrix[i][j] > row_max) {
				row_max = matrix[i][j];
				col_index = j;
			}
		}

		//定义一个变量valid,用于标记当前列是否满足最小值的条件
		int valid = 1;

		//检查当前列是否满足最小值条件
		for (int k = 0; k < rows; k++) {
			//如果当前列的元素小于当前行的最大值，则不满足最小值条件，将valid设为0且跳出循环
			if (matrix[k][col_index] < row_max) {
				valid = 0;
				break;
			}
		}

		//如果满足最小值条件，则找到了鞍点，输出鞍点及其位置信息，并将saddle_found设为1
		if (valid) {
			printf("鞍点的值：%d\n", row_max);
			printf("所在行：%d\n", i + 1);
			printf("所在列：%d\n", col_index + 1);

			saddle_found = 1;
		}
	}

	//如果没有找到鞍点，则输出提示信息
	if (!saddle_found) {
		printf("没有找到鞍点!\n");
	}
}

//主函数
int main() {
	//定义一个二维数组
	int matrix[100][100];
	//定义行列
	int rows, cols;

	//输入行数与列数
	printf("请输入数组的行数：");
	scanf("%d", &rows);
	printf("请输入数组的列数：");
	scanf("%d", &cols);

	//提示用户输入数组元素且存储到matrix数组中
	printf("请输入数组元素：\n");
	for (int i = 0; i < rows; i++) {
		for (int j = 0; j < cols; j++) {
			scanf("%d", &matrix[i][j]);
		}
	}

	//输出用户输入数组的内容
	printf("\n输入数组为：\n");
	for (int i = 0; i < rows; i++) {
		for (int j = 0; j < cols; j++) {
			printf("%d ", matrix[i][j]);
		}
		printf("\n");
	}

	//调用FindeSaddlePoint函数查找鞍点，并且输出结果
	printf("\n查找鞍点...\n");
	FindSaddlePoint(matrix, rows, cols);

	return 0;
}

 

 

这段代码是用于查找二维数组中的鞍点的。鞍点是一个元素，它在其所在行中是最大的，而在其所在列中是最小的。以下是代码的分析和需要注意的地方：

1. 函数定义和变量声明:

   • 函数FindSaddlePoint被定义为一个接受二维数组、行数和列数的函数。
   • 变量saddle_found用于标记是否找到了鞍点。
   • 变量row_max和col_index分别用于存储当前行的最大值和其索引。
   • 变量valid用于标记当前列是否满足最小值条件。

2. 查找最大值和其索引:

   • 通过一个内部循环遍历每一行，找到每一行的最大值及其索引。

3. 检查最小值条件:

   • 使用另一个内部循环遍历当前列的每一行，检查是否满足最小值条件。
   • 如果当前列的任何元素小于当前行的最大值，则不满足最小值条件，将valid设为0并跳出循环。

4. 输出结果:

   • 如果满足最小值条件，则输出鞍点及其位置信息。
   • 如果不满足最小值条件或没有找到鞍点，则输出相应的提示信息。

5. 输入和输出:

   • 使用scanf函数从用户那里获取行数和列数。
   • 使用嵌套的循环结构获取用户输入的数组元素。
   • 使用嵌套的循环结构输出用户输入的数组内容。

6. 需要注意的地方:

   • 代码没有处理数组越界的情况，即当输入的行数或列数超过100时。
   • 代码没有处理非整数输入的情况，这可能导致未定义的行为。
   • 代码没有进行错误检查，例如确保输入的行数和列数大于0。
   • 如果在数组中找不到鞍点，程序将输出"没有找到鞍点!"，但没有提示用户这是否是预期的行为。

7. 优化建议:

   • 可以考虑使用动态内存分配来使代码更加灵活，例如使用malloc和free来分配和释放内存。
   • 可以考虑使用更高效的算法来查找鞍点，例如使用哈希表或二分查找。
   • 可以添加更多的错误检查和边界检查来增强代码的健壮性。