函数调用问题

1215787625

题目描述
给定m行n列的图像各像素点灰度值，对其依次进行一系列操作后，求最终图像。
其中，可能的操作及对应字符有如下四种：
A：顺时针旋转90度；
B：逆时针旋转90度；
C：左右翻转；
D：上下翻转。

输入
第一行包含两个正整数m和n，表示图像的行数和列数，中间用单个空格隔开。1 <= m <= 100, 1 <= n <= 100。
接下来m行，每行n个整数，表示图像中每个像素点的灰度值，相邻两个数之间用单个空格隔开。灰度值范围在0到255之间。
接下来一行，包含由A、B、C、D组成的字符串s，表示需要按顺序执行的操作序列。s的长度在1到100之间。
输出
m'行，每行包含n'个整数，为最终图像各像素点的灰度值。其中m'为最终图像的行数，n'为最终图像的列数。相邻两个整数之间用单个空格隔开。
样例输入 复制
2 3
10 0 10
100 100 10
AC
样例输出 复制
10 100
0 100
10 10
#include <stdio.h>
#include <string.h>
#pragma warning(disable:4996)
int m, n, i, j;
int dig[100][100],a[100][100];
char move[100];
void operate(char c);
int main(void)
{
        scanf("%d%d", &m, &n);//获取行列

        for (i = 0; i < m; i++) {//输入行列
                for (j = 0; j < n; j++) {
                        scanf("%d", &dig[i][j]);
                }
        }

        scanf("%s", move);//输入操作
        for (i = 0; i < strlen(move); i++) {//开始操作
                operate(move[i]);
        }

        for (i = 0; i < m; i++) {//输出
                for (j = 0; j < n; j++) {
                        printf(j == 0 ? "%d" : " %d", dig[i][j]);
                }
                putchar('\n');
        }

        return 0;
}
void operate(char c)
{
        for (i = 0; i < m; i++) {//转换
                for (j = 0; j < n; j++) {
                        switch (c) {
                        case 'A':
                                a[j][m - 1 - i] = dig[i][j];       
                                break;
                        case 'B':
                                a[m - 1 - j][i] = dig[i][j];       
                                break;
                        case 'C':
                                a[i][n - 1 - j] = dig[i][j];       
                                break;
                        case 'D':
                                a[n - 1 - i][j] = dig[i][j];       
                                break;
                        }
                }
        }

        if (c == 'A' || c == 'B') {//交换行列
                int tmp = m;
                m = n;
                n = tmp;
        }
       
        for (i = 0; i < m; i++) {//复制
                for (j = 0; j < n; j++) {
                        dig[i][j] = a[i][j];
                }
        }
}
请问为什么我的operate函数在main函数中只调用了一次，不应该是两次吗？

FishC_GPT

首先，我们需要先读取输入的m和n，并创建一个大小为m×n的二维数组来表示图像。

1. m, n = map(int, input().split())
2. image = [[0] * n for _ in range(m)]

复制代码

接下来，我们需要读取每个像素点的灰度值，并将其存储到相应的位置上。

1. for i in range(m):
2.     row = list(map(int, input().split()))
3.     for j in range(n):
4.         image[i][j] = row[j]

复制代码

然后，我们需要依次执行给定的操作。对于每个操作，我们可以使用循环遍历图像的每个像素点，并根据操作类型进行相应的处理。

1. operations = input().strip()
2. for op in operations:
3.     if op == 'A':
4.         # 顺时针旋转90度
5.         rotated = [[0] * m for _ in range(n)]
6.         for i in range(m):
7.             for j in range(n):
8.                 rotated[j][m - i - 1] = image[i][j]
9.         image = rotated
10.         m, n = n, m
11.     elif op == 'B':
12.         # 逆时针旋转90度
13.         rotated = [[0] * m for _ in range(n)]
14.         for i in range(m):
15.             for j in range(n):
16.                 rotated[n - j - 1][i] = image[i][j]
17.         image = rotated
18.         m, n = n, m
19.     elif op == 'C':
20.         # 左右翻转
21.         flipped = [[0] * n for _ in range(m)]
22.         for i in range(m):
23.             for j in range(n):
24.                 flipped[i][n - j - 1] = image[i][j]
25.         image = flipped
26.     elif op == 'D':
27.         # 上下翻转
28.         flipped = [[0] * n for _ in range(m)]
29.         for i in range(m):
30.             for j in range(n):
31.                 flipped[m - i - 1][j] = image[i][j]
32.         image = flipped

复制代码

最后，我们需要输出最终图像的灰度值。

1. for i in range(m):
2.     for j in range(n):
3.         print(image[i][j], end=' ')
4.     print()

复制代码

完整代码如下：

1. m, n = map(int, input().split())
2. image = [[0] * n for _ in range(m)]
4. for i in range(m):
5.     row = list(map(int, input().split()))
6.     for j in range(n):
7.         image[i][j] = row[j]
9. operations = input().strip()
10. for op in operations:
11.     if op == 'A':
12.         rotated = [[0] * m for _ in range(n)]
13.         for i in range(m):
14.             for j in range(n):
15.                 rotated[j][m - i - 1] = image[i][j]
16.         image = rotated
17.         m, n = n, m
18.     elif op == 'B':
19.         rotated = [[0] * m for _ in range(n)]
20.         for i in range(m):
21.             for j in range(n):
22.                 rotated[n - j - 1][i] = image[i][j]
23.         image = rotated
24.         m, n = n, m
25.     elif op == 'C':
26.         flipped = [[0] * n for _ in range(m)]
27.         for i in range(m):
28.             for j in range(n):
29.                 flipped[i][n - j - 1] = image[i][j]
30.         image = flipped
31.     elif op == 'D':
32.         flipped = [[0] * n for _ in range(m)]
33.         for i in range(m):
34.             for j in range(n):
35.                 flipped[m - i - 1][j] = image[i][j]
36.         image = flipped
38. for i in range(m):
39.     for j in range(n):
40.         print(image[i][j], end=' ')
41.     print()

复制代码

希望我对问题的解答能够帮到你。如果你还有其他问题，请随时提问。

以上回复来自 -- ChatGPT（FishC官方接口），如未能正确解答您的问题，请继续追问。

1215787625

FishC_GPT 发表于 2023-12-3 08:26
首先，我们需要先读取输入的m和n，并创建一个大小为m×n的二维数组来表示图像。

我问的不是这个问题

FishC_GPT

1215787625 发表于 2023-12-03 08:42
我问的不是这个问题

非常抱歉，可能是我理解错了您的问题。那么请您重新描述一下您遇到的函数调用问题，我会尽力帮助您解答。

以上回复来自 -- ChatGPT（FishC官方接口），如未能正确解答您的问题，请继续追问。

1215787625

FishC_GPT 发表于 2023-12-3 08:42
非常抱歉，可能是我理解错了您的问题。那么请您重新描述一下您遇到的函数调用问题，我会尽力帮助您解答。 ...

为什么在//开始操作中move数组的值会被修改

FishC_GPT

1215787625 发表于 2023-12-03 08:42
为什么在//开始操作中move数组的值会被修改

在Python中，函数参数传递方式有两种：值传递和引用传递。对于不可变对象（如数值、字符串、元组），采用的是值传递方式；而对于可变对象（如列表、字典），则采用的是引用传递方式。

当您在函数中修改一个可变对象时，会直接修改原始对象的值，因为传递的是对象的引用。这意味着在函数内部对该对象的任何修改都会反映到原始对象上。

以下是一个示例代码解释了这个问题：

1. def modify_list(lst):
2.     lst.append(4)
3.     print("Inside function: ", lst)
5. my_list = [1, 2, 3]
6. print("Before function: ", my_list)
7. modify_list(my_list)
8. print("After function: ", my_list)

复制代码

输出结果为：

1. Before function:  [1, 2, 3]
2. Inside function:  [1, 2, 3, 4]
3. After function:  [1, 2, 3, 4]

复制代码

从输出结果可以看到，函数内部对`lst`进行的修改同样反映在原始列表`my_list`上。

因此，在您提到的操作中，如果`move`数组是一个可变对象（如列表），则对其进行的操作可能会修改其原始值。如果您希望避免修改原始数组的值，可以在函数内部创建一个副本进行操作。例如：

1. def process_moves(move):
2.     move_copy = move.copy()  # 创建move数组的副本
3.     # 对move_copy进行操作
4.     # ...
6. my_move = [1, 2, 3]
7. process_moves(my_move)

复制代码

通过在函数内部创建`move`的副本`move_copy`，您可以确保原始的`move`数组不会被修改。

以上回复来自 -- ChatGPT（FishC官方接口），如未能正确解答您的问题，请继续追问。

1215787625

FishC_GPT 发表于 2023-12-3 08:43
在Python中，函数参数传递方式有两种：值传递和引用传递。对于不可变对象（如数值、字符串、元组），采用 ...

我这是C语言

FishC_GPT

1215787625 发表于 2023-12-03 08:43
我这是C语言

非常抱歉，我误解了你的问题。以下是关于C语言中的函数参数传递方式的解释。

在C语言中，函数参数传递有两种方式：按值传递和按引用传递（指针传递）。

1. 按值传递：将函数参数的值复制一份给形参，在函数内部对形参的修改不会影响实参的值。这意味着，如果你在函数中修改了一个变量的值，实际上是在修改该变量的副本。
2. 按引用传递（指针传递）：传递参数的地址给函数，在函数内部可以通过指针访问和修改原始数据。这样，对形参的任何修改都会影响到实参的值。

举个例子：

1. #include<stdio.h>
3. void modify_int(int num) {
4.     num = 10; // 修改形参的值
5. }
7. void modify_array(int arr[], int length) {
8.     for (int i = 0; i < length; i++) {
9.         arr[i] = i * 2; // 修改数组元素的值
10.     }
11. }
13. int main() {
14.     int num = 5;
15.     printf("Before modify_int: %d\n", num);
16.     modify_int(num);
17.     printf("After modify_int: %d\n", num); // 这里输出仍然是5，因为modify_int函数中的修改只影响到了形参的副本
19.     int arr[] = {1, 2, 3, 4, 5};
20.     int length = sizeof(arr) / sizeof(arr[0]);
21.     printf("Before modify_array: ");
22.     for (int i = 0; i < length; i++) {
23.         printf("%d ", arr[i]);
24.     }
25.     printf("\n");
26.     modify_array(arr, length);
27.     printf("After modify_array: ");
28.     for (int i = 0; i < length; i++) {
29.         printf("%d ", arr[i]); // 这里输出是：0 2 4 6 8，因为modify_array函数中修改了原始数组的值
30.     }
31.     printf("\n");
33.     return 0;
34. }

复制代码

在上面的例子中，`modify_int`和`modify_array`函数分别按值传递一个整数和一个整数数组。在`modify_int`函数中，修改形参`num`的值并不会影响到实参`num`的值。而在`modify_array`函数中，通过修改数组元素的值，直接影响到了原始数组。

希望这次回答能够帮到你。如果你还有其他问题，请随时提问。

以上回复来自 -- ChatGPT（FishC官方接口），如未能正确解答您的问题，请继续追问。