编写程序, 实现矩阵（3行3列）的转置(即行列互换) 例如, 输入下面的矩阵: 100 200 300 400 500 600 700 800 900 程序输出: 100 400 700 200 500 800 300 600 900

可以使用两层循环实现矩阵转置，具体代码如下：

matrix = [[100, 200, 300], [400, 500, 600], [700, 800, 900]]
transpose = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

# 矩阵转置
for i in range(len(matrix)):
    for j in range(len(matrix[0])):
        transpose[j][i] = matrix[i][j]

# 输出转置后的矩阵
for row in transpose:
    print(row)

输出结果为：

[100, 400, 700]
[200, 500, 800]
[300, 600, 900]

相关问题

编写C语言程序, 实现矩阵（3行3列）的转置(即行列互换) 例如, 输入下面的矩阵: 100 200 300 400 500 600 700 800 900 程序输出: 100 400 700 200 500 800 300 600 900

好的，以下是实现矩阵转置的C语言程序：

#include <stdio.h>

int main() {
   int matrix[3][3] = {{100, 200, 300}, {400, 500, 600}, {700, 800, 900}};
   int row, col, temp;

   // 输出原始矩阵
   printf("原始矩阵：\n");
   for (row = 0; row < 3; row++) {
      for (col = 0; col < 3; col++) {
         printf("%d ", matrix[row][col]);
      }
      printf("\n");
   }

   // 转置矩阵
   for (row = 0; row < 3; row++) {
      for (col = row; col < 3; col++) {
         temp = matrix[row][col];
         matrix[row][col] = matrix[col][row];
         matrix[col][row] = temp;
      }
   }

   // 输出转置后的矩阵
   printf("转置后的矩阵：\n");
   for (row = 0; row < 3; row++) {
      for (col = 0; col < 3; col++) {
         printf("%d ", matrix[row][col]);
      }
      printf("\n");
   }

   return 0;
}

输出结果：

原始矩阵：
100 200 300 
400 500 600 
700 800 900 
转置后的矩阵：
100 400 700 
200 500 800 
300 600 900 

编写程序, 实现矩阵（3行3列）的转置(即行列互换)

### 回答1：
可以使用二维数组来表示矩阵，然后通过循环遍历矩阵元素，将行和列互换即可实现矩阵的转置。具体代码如下：

# 定义一个3行3列的矩阵
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 输出原始矩阵
print("原始矩阵：")
for row in matrix:
    print(row)

# 转置矩阵
for i in range(3):
    for j in range(i, 3):
        matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

# 输出转置后的矩阵
print("转置后的矩阵：")
for row in matrix:
    print(row)

输出结果如下：

原始矩阵：
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
转置后的矩阵：
[1, 4, 7]
[2, 5, 8]
[3, 6, 9]

### 回答2：
矩阵的转置是指将矩阵的行和列互换，使得原来的行变成了列，原来的列变成了行。矩阵的转置可以用程序实现。下面是一个 Python 程序示例，用来实现矩阵（3行3列）的转置：

# 定义原始矩阵
original_matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 定义转置后矩阵
transpose_matrix = [
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0]
]

# 转置矩阵
for i in range(3):
    for j in range(3):
        transpose_matrix[j][i] = original_matrix[i][j]

# 输出转置后的矩阵
print("转置后的矩阵：")
for row in transpose_matrix:
    print(row)

上面的程序首先定义了一个原始矩阵，然后定义了一个转置后的矩阵。接下来，程序使用嵌套的 for 循环遍历矩阵中的每一个元素，将它们转置到转置后矩阵对应的位置上。最后，程序输出转置后的矩阵。

当运行以上程序时，输出结果将为：

转置后的矩阵：
[1, 4, 7]
[2, 5, 8]
[3, 6, 9]

由此可以看出，程序成功实现了矩阵（3行3列）的转置，将原始矩阵的行和列互换，得到了一个新的转置后的矩阵。

### 回答3：
矩阵的转置是指将矩阵的行与列对调，形成一个新的矩阵。对于一个3行3列的矩阵，可以采用以下方式实现矩阵转置的程序：

1.定义一个两重循环，其中第一重循环用于从第一行到第三行遍历矩阵的行，第二重循环用于从第一列到第三列遍历矩阵的列。

2.当内外循环都遍历到矩阵的某个位置时，将该位置上的元素与该位置所对应的行列互换，即将矩阵元素m[i][j]与m[j][i]互换。

3.最终可以得到一个新的矩阵，其中原本的第一行变成了新矩阵的第一列，原本的第一列变成了新矩阵的第一行，其余的行列也按照相同的方式互换。

示例代码如下：

#include <iostream>
using namespace std;

int main()
{
int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int transpose[3][3];

// 行列互换
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
transpose[i][j] = matrix[j][i];
}
}

// 输出转置矩阵
cout << "原矩阵：" << endl;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
cout << matrix[i][j] << " ";
}
cout << endl;
}

cout << "转置矩阵：" << endl;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
cout << transpose[i][j] << " ";
}
cout << endl;
}

return 0;
}

在这个程序中，我们首先定义了一个3行3列的矩阵matrix，并通过两重循环将其转置成一个新的矩阵transpose。通过输出可以看到，原矩阵的第一行变为转置矩阵的第一列，原矩阵的第一列变为转置矩阵的第一行，其余的行列也按照相同的方式互换。