MATLAB--Matrix Manipulation II

例1.Problem 1167. matrix zigzag

Unfold a 2-D matrix to a 1-D array in zig-zag order, e.g., for matrix（将一个二维矩阵按蛇形顺序展开成一维数组，例如，对于矩阵：）
复制代码
 [ 1 2 3 ;
   4 5 6 ;
   7 8 9 ] 
the resulting 1-D array should be（得到的一维数组应该是）
复制代码
 [ 1 2 4 7 5 3 6 8 9 ]

在MATLAB中，你可以使用以下代码将一个二维矩阵按蛇形顺序展开成一维数组：

Matlab 复制代码

function result = zigzag(matrix)
    [rows, cols] = size(matrix);
    result = zeros(1, rows * cols);
    idx = 1;
    for sumIndex = 1:rows+cols-1
        if mod(sumIndex, 2) == 0
            if sumIndex <= rows
                row = sumIndex;
                col = 1;
            else
                row = rows;
                col = sumIndex - rows;
            end
            while row >= 1 && col <= cols
                result(idx) = matrix(row, col);
                idx = idx + 1;
                row = row - 1;
                col = col + 1;
            end
        else
            if sumIndex <= cols
                row = 1;
                col = sumIndex;
            else
                row = sumIndex - cols;
                col = cols;
            end
            while row <= rows && col >= 1
                result(idx) = matrix(row, col);
                idx = idx + 1;
                row = row + 1;
                col = col - 1;
            end
        end
    end
end

可以调用这个函数并传入你的矩阵作为参数，然后它会返回按蛇形顺序展开的一维数组。例如：

Matlab 复制代码

matrix = [1, 2, 3; 4, 5, 6; 7, 8, 9];
result = zigzag(matrix);
disp(result);

这将输出：

Matlab 复制代码

1     2     4     7     5     3     6     8     9

例2. Problem 1321. Given a matrix, swap the 2nd & 3rd columns

If

a = [1 2 3 4;

1 2 3 4;

1 2 3 4;

1 2 3 4];

then the result is

ans = [1 3 2 4

1 3 2 4

1 3 2 4

1 3 2 4];

by swapping columns 2 and 3.

(通过交换第2列和第3列。)

可以使用MATLAB中的以下代码来实现对矩阵列的交换：

Matlab 复制代码

% 定义矩阵
a = [1 2 3 4;
     1 2 3 4;
     1 2 3 4;
     1 2 3 4];

% 交换第2列和第3列
temp = a(:, 2);
a(:, 2) = a(:, 3);
a(:, 3) = temp;

% 显示结果
disp('结果是：');
disp(a);

这段代码将输出：

Matlab 复制代码

结果是：
     1     3     2     4
     1     3     2     4
     1     3     2     4
     1     3     2     4

这就是通过交换第2列和第3列得到的结果矩阵。

例3.Problem 3075. Matrix of Multiplication Facts

This is James's daughter again, sneaking into his Cody account. Thanks to your help in my math class last year, I did great! But now they're giving me even harder problems. This time, they're giving me a 2x2 matrix of numbers, and asking me to make it a 3x3 matrix so the center numbers on each side multiply to the numbers in the corner. It's kinda hard to explain, so I'll just give you the example our teacher gave us in class.

The matrix we were given is:

21 6

35 10

The correct answer is:

21 3 6

7 0 2

35 5 10

The two numbers touching the 21 are 7 and 3, and 7x3=21.

The two numbers touching the 35 are 7 and 5, and 7x5=35.

The two numbers touching the 6 are 2 and 3, and 2x3=6.

The two numbers touching the 10 are 2 and 5, and 2x5=10.

The zero in the middle doesn't really matter, so I don't care what number you put in there. Some of the problems might have more than one answer, but as long as the numbers multiply out correctly, it's a good answer. All of the numbers have to be integers, though. Thanks again for your help!

这是詹姆斯的女儿，又一次悄悄地用他的Cody账号登录了。去年在数学课上得到你的帮助后，我的成绩一直很好！但是现在他们给我的问题更难了。这一次，他们给了我一个2x2的数字矩阵，并要求我将其变成一个3x3的矩阵，使得每一边的中心数字与角落的数字相乘。有点难以解释，所以我会给你我们老师在课上给我们的例子。

我们收到的矩阵是：

[ \begin{bmatrix} 21 & 6 \ 35 & 10 \ \end{bmatrix} ]

正确答案是： [ \begin{bmatrix} 21 & 3 & 6 \ 7 & 0 & 2 \ 35 & 5 & 10 \ \end{bmatrix} ]

接触到21的两个数字是7和3，而7x3=21。接触到35的两个数字是7和5，而7x5=35。接触到6的两个数字是2和3，而2x3=6。接触到10的两个数字是2和5，而2x5=10。中间的零并不真的重要，所以我不在意你在那里放什么数字。有些问题可能会有多个答案，但只要数字相乘正确，就是一个好答案。不过，所有的数字都必须是整数。再次感谢你的帮助！

以下是MATLAB代码，用于将给定的2x2矩阵扩展为一个3x3矩阵，满足要求：

Matlab 复制代码

% 给定的2x2矩阵
A = [21, 6; 35, 10];

% 扩展为3x3矩阵
B = zeros(3);
B(1:2, 1:2) = A;

% 计算中心元素与角落元素的乘积
B(1, 2) = B(1, 1) * B(1, 3) / B(2, 1);
B(2, 3) = B(1, 3) * B(3, 3) / B(3, 2);
B(3, 2) = B(3, 1) * B(3, 3) / B(2, 3);
B(2, 1) = B(1, 1) * B(3, 1) / B(2, 3);

% 显示结果
disp('正确答案是：');
disp(B);

这段代码会输出正确的3x3矩阵，满足你描述的条件。

例4.Problem 1286. MatCAT - Reconstruct X from Its X-rays

Consider a matrix x
复制代码
 x = [ 1 2 0
       0 5 0 
       3 0 8 ]
If we sum x along the rows we get
复制代码
 row_sums = [3 5 11]
Summing along the columns gives
复制代码
 col_sums = [4 7 8]
Metaphorically, we might call these sums "x-rays". Your job is to take these x-rays and reconstruct the matrix x being x-rayed, in the fashion of a CAT scan. Can you put all the bones in the right place?

All matrix elements must be non-negative integers. There is no guarantee of a unique answer. I will only check that the row and column sums match the supplied matrix, and that your elements are non-negative integers.

Bonus question: Under what circumstances does the answer become unique? Discuss.

考虑一个矩阵 x

x = [ 1 2 0 0 5 0 3 0 8 ] 如果我们沿着行求和，我们得到

row_sums = [3 5 11] 沿着列求和则得到

col_sums = [4 7 8] 比喻地说，我们可以称这些和为"X光"。你的任务是根据这些X光重新构建被X光扫描的矩阵 x，就像进行CT扫描一样。你能把所有的骨头放在正确的位置吗？

所有矩阵元素必须是非负整数。并不保证答案是唯一的。我只会检查行和列的和是否与提供的矩阵匹配，以及你的元素是否为非负整数。

奖励问题：在什么情况下答案变得唯一？讨论。

以下是MATLAB代码，用于根据给定的行和列求和重新构建矩阵x：

Matlab 复制代码

% 给定的行和列求和
row_sums = [3 5 11];
col_sums = [4 7 8];

% 初始化一个3x3的零矩阵
x_reconstructed = zeros(3);

% 重新构建矩阵x
for i = 1:3
    for j = 1:3
        % 在保证非负整数的情况下，计算矩阵元素
        x_reconstructed(i, j) = max(0, min(row_sums(i), col_sums(j)));
        % 更新行和列的和
        row_sums(i) = row_sums(i) - x_reconstructed(i, j);
        col_sums(j) = col_sums(j) - x_reconstructed(i, j);
    end
end

% 显示重建后的矩阵
disp('重建后的矩阵 x 是：');
disp(x_reconstructed);

关于奖励问题：当给定的行和列求和能够唯一确定矩阵x时，答案就会变得唯一。这种情况发生在矩阵x的每一行和每一列的和都不相等且非负整数，并且不存在其他满足条件的矩阵x的情况下。

例5.Problem 1421. subtract central cross

Given an n-by-n square matrix, where n is an odd number, return the matrix without the central row and the central column.

给定一个 n × n 的方阵，其中 n 是一个奇数，返回删除中心行和中心列后的矩阵。

以下是MATLAB代码，用于删除给定奇数阶方阵的中心行和中心列：

Matlab 复制代码

function result = remove_center_row_column(matrix)
    % 确定矩阵的大小
    [n, ~] = size(matrix);
    
    % 确保n是奇数
    if mod(n, 2) == 0
        error('输入的矩阵的大小必须是奇数.');
    end
    
    % 计算中心行和列的索引
    center_index = ceil(n / 2);
    
    % 删除中心行和中心列
    result = matrix;
    result(center_index, :) = [];
    result(:, center_index) = [];
end

你可以将这个函数应用于任何奇数阶的方阵，以删除中心行和中心列。

例6.Problem 1422. frame of the matrix

Given the matrix M, return M without the external frame.

给定矩阵 M，返回去除外部边框后的 M。

以下是MATLAB代码，用于去除给定矩阵的外部边框：

Matlab 复制代码

function result = remove_external_frame(M)
    % 获取矩阵的大小
    [rows, cols] = size(M);
    
    % 确保矩阵至少是3x3的大小，否则无法去除外部边框
    if rows < 3 || cols < 3
        error('矩阵的大小必须至少为3x3.');
    end
    
    % 去除外部边框
    result = M(2:end-1, 2:end-1);
end

这个函数可以应用于任何至少大小为3x3的矩阵，以去除其外部边框。

例7.Problem 1429. Remove entire row and column in the matrix containing the input values

Remove the entire row and column from the matrix containing specific values. The specified value can be a scalar or a vector. For example x is given by x =

从包含特定值的矩阵中移除整行和整列。指定的值可以是标量或向量。例如，给定矩阵 x 为：
复制代码
     8     1     6
     3     5     7
     4     9     2
and I specify an input value of n=3. The value 3 is in 2nd row and 1st column. So the output matrix should remove entire 2nd row and 3rd column. Output:[ 1 6; 9 2]

如果我指定输入值 n=3，值 3 在第2行第1列。因此，输出矩阵应该移除整个第2行和第3列。输出结果为：

remember the input value can be vector too !（请记住，输入值也可以是向量！）

以下是MATLAB代码，用于从包含特定值的矩阵中移除整行和整列：

Matlab 复制代码

function result = remove_row_column_containing_value(matrix, value)
    % 寻找值在矩阵中的位置
    [rows, cols] = find(matrix == value);
    
    % 移除包含指定值的整行和整列
    rows = unique(rows);
    cols = unique(cols);
    result = matrix;
    result(rows, :) = [];
    result(:, cols) = [];
end

你可以将这个函数应用于任何给定矩阵，并指定要移除的值，它会返回移除整行和整列后的结果矩阵。

例8.Problem 1853. Enlarge array

Given an m-by-n numeric array (A) and a 1-by-2 vector (sz) indicating the dimensions [p q] to enlarge each element, return an (m*p)-by-(n*q) array (B) in which each element of A has been replicated in p rows and q columns.

给定一个 m 行 n 列的数字数组 ( A ) 和一个 1 行 2 列的向量 ( sz )，指示要放大每个元素的维度 [p q]，返回一个 (mp) 行 (nq) 列的数组 ( B )，其中 ( A ) 的每个元素在 ( p ) 行 ( q ) 列中被复制。

Example

If
复制代码
A = [1 2 3
     4 5 6
     7 8 9]
sz = [3 2]
then
复制代码
B = [1 1 2 2 3 3
     1 1 2 2 3 3
     1 1 2 2 3 3
     4 4 5 5 6 6
     4 4 5 5 6 6
     4 4 5 5 6 6
     7 7 8 8 9 9
     7 7 8 8 9 9
     7 7 8 8 9 9]

以下是MATLAB代码，实现了你描述的功能：

Matlab 复制代码

function B = replicate_elements(A, sz)
    % 获取输入数组 A 的大小
    [m, n] = size(A);
    
    % 获取放大因子 p 和 q
    p = sz(1);
    q = sz(2);
    
    % 初始化放大后的数组 B
    B = zeros(m*p, n*q);
    
    % 遍历数组 A 中的每个元素
    for i = 1:m
        for j = 1:n
            % 获取当前元素的值
            value = A(i, j);
            
            % 在放大后的数组 B 中复制当前元素的值
            % 每个元素在 p 行 q 列中被复制
            B((i-1)*p+1:i*p, (j-1)*q+1:j*q) = value;
        end
    end
end

可以将以上代码保存在一个名为 replicate_elements.m 的文件中，然后在MATLAB中调用该函数，并传入数组 ( A ) 和向量 ( sz ) 作为参数，即可得到结果数组 ( B )。

例9.Problem 1898. Too Many Zeros, Dump Them!

Sometimes when I create a matrix, I use this syntax:
复制代码
 a = zeros(1000,1000);
But when the function ends, I find that I don't want all those zeros. Then I need another function to dump the extra zeros located to the south-east of the matrix.

For example:
复制代码
 a1 = [1 2 0;
       0 3 0;
       0 0 0];
I want to get a new matrix ,that is:
复制代码
 b1 = [1 2;
       0 3];
Another example:
复制代码
 a2 = [1 2 0 4 0;
       2 3 0 5 0;
       3 4 0 6 0;
       1 0 0 0 0];
复制代码
 b2 = [1 2 0 4;
       2 3 0 5;
       3 4 0 6;
       1 0 0 0];
Good Luck!

Solve

有时候我创建一个矩阵时会使用这种语法：
a = zeros(1000,1000);

但是当函数结束时，我发现我并不想要所有那些零。然后我需要另一个函数来清除矩阵东南方向的多余零。

例如：
a1 = [1 2 0; 0 3 0; 0 0 0];

我想要得到一个新的矩阵，即：
b1 = [1 2; 0 3];

另一个例子：

a2 = [1 2 0 4 0; 2 3 0 5 0; 3 4 0 6 0; 1 0 0 0 0]; b2 = [1 2 0 4; 2 3 0 5; 3 4 0 6; 1 0 0 0]; 祝你好运！

以下是用MATLAB编写的函数，可以实现你描述的功能：

Matlab 复制代码

function b = remove_trailing_zeros(a)
    % 找到矩阵 a 中每行和每列最后一个非零元素的索引
    [row_idx, col_idx] = find(a ~= 0, 1, 'last');
    
    % 根据找到的索引创建新的矩阵 b
    b = a(1:row_idx, 1:col_idx);
end

你可以将以上代码保存在一个名为 remove_trailing_zeros.m 的文件中，然后在MATLAB中调用该函数，并传入需要处理的矩阵作为参数，即可得到去除了东南方向多余零的新矩阵。例如：

Matlab 复制代码

a1 = [1 2 0; 0 3 0; 0 0 0];
b1 = remove_trailing_zeros(a1); % b1 = [1 2; 0 3]

a2 = [1 2 0 4 0; 2 3 0 5 0; 3 4 0 6 0; 1 0 0 0 0];
b2 = remove_trailing_zeros(a2); % b2 = [1 2 0 4; 2 3 0 5; 3 4 0 6; 1 0 0 0

例10.Problem 1972. Convert matrix to 3D array of triangular matrices

Given a 2D numeric array x in which each column represents the vectorized form of an upper triangular matrix, return a 3D array y containing the concatenated triangular matrices.

If the size of the input matrix x is MxN, then the size of the output matrix y is PxPxN, where M = sum(1:P)

You may assume that P<=100

给定一个二维数值数组 x，其中每列表示一个上三角矩阵的向量化形式，返回一个三维数组 y，其中包含连接的三角形矩阵。

如果输入矩阵 x 的大小为 MxN，则输出矩阵 y 的大小为 PxPxN，其中 M = sum(1:P)。你可以假设 P<=100。

Example

If
复制代码
x = 1  7 13
    2  8 14
    3  9 15
    4 10 16
    5 11 17
    6 12 18
then
复制代码
y(:,:,1) =  1  2  4
            0  3  5
            0  0  6
复制代码
y(:,:,2) =  7  8 10
            0  9 11
            0  0 12
复制代码
y(:,:,3) = 13 14 16
            0 15 17
            0  0 18
NOTE: If you are wondering why this seems like a strange task, it is inspired by a genotype->phenotype mapping I am doing in a genetic algorithm.

注意：如果你想知道为什么这看起来像一个奇怪的任务，这是受我在遗传算法中进行的基因型到表现型映射的启发

可以使用以下 MATLAB 代码实现这个任务：

Matlab 复制代码

function y = vectorized_triangular_matrices(x)
    [M, N] = size(x);
    P = round(sqrt(2 * M + 0.25) - 0.5);
    y = zeros(P, P, N);
    idx = 1;
    for n = 1:N
        temp = zeros(P, P);
        row_idx = 1;
        col_idx = 1;
        for i = 1:P
            temp(row_idx:row_idx+i-1, col_idx:col_idx+i-1) = reshape(x(idx:idx+i*(i+1)/2-1, n), i, i);
            idx = idx + i;
            row_idx = row_idx + 1;
            col_idx = col_idx + 1;
        end
        y(:, :, n) = temp;
    end
end

可以将这个函数保存到一个名为 vectorized_triangular_matrices.m 的文件中，然后在 MATLAB 中调用它，传入你的输入矩阵 x。例如：

Matlab 复制代码

x = [1 7 13; 2 8 14; 3 9 15; 4 10 16; 5 11 17; 6 12 18];
y = vectorized_triangular_matrices(x);
disp(y);

这将输出连接的三角形矩阵 y。

例11.Problem 2063. A matrix of extroverts

Now that the introverts have had their script, the extroverts spoke up (naturally!) and demanded one as well. You will be given a matrix. Write a MATLAB script to output a new matrix consisting of the average of all four terms that are next to each other.

现在轮到外向者发言了（当然是自然而然地！），他们也要求一份脚本。你将获得一个矩阵。编写一个 MATLAB 脚本来输出一个新矩阵，其中包含相邻四个项的平均值。

If your input is magic(3)（如果你的输入是 magic(3)）
复制代码
     8     1     6
     3     5     7
     4     9     2
Your output will be:（你的输出将是：）
复制代码
4.2500    4.7500
5.2500    5.7500
The top left term (4.25) is the average of [8 1 ; 3 5]. The bottom left term is the average of [3 5 ; 4 9], and so on. You can assume that the size of each of these matrices will be at least 2x2. Good luck!（左上角的项 (4.25) 是 [8 1; 3 5] 的平均值。左下角的项是 [3 5; 4 9] 的平均值，依此类推。你可以假设每个这些矩阵的大小至少为 2x2。祝你好运！）

以下是用 MATLAB 编写的脚本，实现了你描述的功能：

Matlab 复制代码

function output_matrix = extrovert_script(input_matrix)
    [rows, cols] = size(input_matrix);
    output_matrix = zeros(rows-1, cols-1);

    for i = 1:rows-1
        for j = 1:cols-1
            % 计算相邻四个项的平均值
            avg = mean(mean(input_matrix(i:i+1, j:j+1)));
            output_matrix(i, j) = avg;
        end
    end
end

可以将这个函数保存到一个名为 extrovert_script.m 的文件中。然后，你可以像这样在 MATLAB 中使用它：

Matlab 复制代码

input_matrix = magic(3);
output_matrix = extrovert_script(input_matrix);
disp(output_matrix);

这将输出符合要求的新矩阵。

例12.Problem 2178. Matrix multiplication across rows

Given matrix m, return matrix n such that, rows of n are result of multiplication of the rows of the input matrix

给定矩阵 m，返回矩阵 n，使得 n 的行是输入矩阵的行的乘积结果。

Example
复制代码
 m = [ 1 2 3
       4 5 6
       7 8 9 ]
Then
复制代码
 n = [ 1   2    6
       4  20  120
       7  56  504 ]

以下是用 MATLAB 编写的函数，实现了你描述的功能：

Matlab 复制代码

function n = row_multiplication(m)
    [rows, cols] = size(m);
    n = zeros(rows, cols);
    
    for i = 1:rows
        row_product = prod(m(i,:)); % 计算当前行的乘积
        n(i,:) = row_product; % 将乘积赋值给新矩阵的对应行
    end
end

可以将这个函数保存到一个名为 row_multiplication.m 的文件中。然后，你可以像这样在 MATLAB 中使用它：

Matlab 复制代码

m = [1 2 3; 4 5 6; 7 8 9];
n = row_multiplication(m);
disp(n);

这将输出符合要求的新矩阵 n。

例13.Problem 2351. Replace Nonzero Numbers with 1

Given the matrix x, return the matrix y with non zero elements replaced with 1.

给定矩阵 x，返回将非零元素替换为 1 的矩阵 y。

Example:
复制代码
 Input  x =  [ 1 2 0 0 0
               0 0 5 0 0 
               2 7 0 0 0
               0 6 9 3 3 ]
复制代码
 Output y is [ 1 1 0 0 0
               0 0 1 0 0 
               1 1 0 0 0
               0 1 1 1 1 ]

以下是用 MATLAB 编写的函数，实现了你描述的功能：

Matlab 复制代码

function y = replace_nonzero_with_1(x)
    y = x ~= 0; % 将非零元素替换为 1
end

可以将这个函数保存到一个名为 replace_nonzero_with_1.m 的文件中。然后，你可以像这样在 MATLAB 中使用它：

Matlab 复制代码

x = [1 2 0 0 0; 0 0 5 0 0; 2 7 0 0 0; 0 6 9 3 3];
y = replace_nonzero_with_1(x);
disp(y);

这将输出符合要求的新矩阵 y。

例14.Problem 2442. Magnet and Iron

(Inspired from Problem 112: Remove the air bubbles)

Iron (atomic number = 26) is strongly attracted by magnet. The input matrix contains some iron elements (26). I placed two strong magnetic bars above the top row and below the bottom row. What will be state of the matrix after the iron elements have moved due to attraction? Elements equidistant from both magnets will not change their positions.

（灵感来自问题 112：去除气泡）

铁（原子序数 = 26）受磁铁的强烈吸引。输入矩阵包含一些铁元素（26）。我在顶行上方和底行下方放置了两根强磁铁条。当铁元素由于吸引而移动时，矩阵的状态会如何？与两个磁铁等距离的元素将不会改变它们的位置。

Example:
复制代码
 Input =
复制代码
       1    26
       3    26
      26    26
       0     0
     -12   NaN
      26    26
复制代码
 Output =
      26    26
       1    26
       3    26
       0     0
     -12   NaN
      26    26

以下是用 MATLAB 编写的函数，实现了你描述的功能：

Matlab 复制代码

function output = move_iron_elements(input)
    % 查找铁元素的位置
    iron_indices = find(input == 26);
    
    % 计算矩阵的行数和列数
    [rows, cols] = size(input);
    
    % 创建一个与输入矩阵相同大小的矩阵，用于存储输出
    output = input;
    
    % 遍历每个铁元素的位置
    for i = 1:length(iron_indices)
        [r, c] = ind2sub([rows, cols], iron_indices(i)); % 获取当前铁元素的行列索引
        
        % 如果铁元素在第一行或最后一行，则不进行移动
        if r == 1 || r == rows
            continue;
        end
        
        % 计算当前铁元素到两个磁铁的距离
        distance_to_top_magnet = r - 1;
        distance_to_bottom_magnet = rows - r;
        
        % 如果当前铁元素与两个磁铁的距离相等，则不进行移动
        if distance_to_top_magnet == distance_to_bottom_magnet
            continue;
        end
        
        % 移动铁元素到距离更近的磁铁位置
        if distance_to_top_magnet < distance_to_bottom_magnet
            output(r-1, c) = 26; % 移动到上方
        else
            output(r+1, c) = 26; % 移动到下方
        end
        
        % 将原位置设置为非铁元素
        output(r, c) = input(r, c) ~= 26;
    end
end

可以将这个函数保存到一个名为 move_iron_elements.m 的文件中。然后，你可以像这样在 MATLAB 中使用它：

Matlab 复制代码

input_matrix = [
    1    26
    3    26
    26    26
    0     0
    -12   NaN
    26    26
    ];

output_matrix = move_iron_elements(input_matrix);
disp(output_matrix);

这将输出符合要求的新矩阵。

例15.Problem 2493. Must be in the front row...

You are given a matrix followed by a single number. Your object is to write a script that will shift the matrix around so that the number you are given is in the (1,1) position of the matrix. For example, if you start with the magic(4) matrix:

你会得到一个矩阵，然后是一个单独的数字。你的任务是编写一个脚本，将矩阵移动，使得你得到的数字在矩阵的 (1,1) 位置。例如，如果你从 magic(4) 矩阵开始
复制代码
     16     2     3    13
      5    11    10     8
      9     7     6    12
      4    14    15     1
and the number 6, your output should be:

以及数字 6，你的输出应该是：
复制代码
     6    12     9     7
    15     1     4    14
     3    13    16     2
    10     8     5    11
If there is more than one instance of the number, use the one in the leftmost column. If there is more than one in that column, use the one in the uppermost row. If your input is a modified magic(4)

如果数字有多个实例，使用最左侧列中的那个。如果该列中有多个实例，则使用最上面的行中的那个。如果你的输入是一个修改过的 magic(4)
复制代码
    16     2     3    13
     6    11    10     8
     9     7     6    12
     6    14    15     1
and you need to put 6 in the upper left corner, your output should be:

而你需要将 6 放在左上角，你的输出应该是：
复制代码
     6    11    10     8
     9     7     6    12
     6    14    15     1
    16     2     3    13
If the input number isn't in the matrix, return the original matrix. Good luck!

如果输入的数字不在矩阵中，则返回原始矩阵。祝你好运！

以下是 MATLAB 的脚本，实现了你描述的功能：

Matlab 复制代码

function shifted_matrix = shift_matrix(matrix, number)
    [row, col] = find(matrix == number); % Find the indices of the number in the matrix
    if isempty(row) || isempty(col) % If number not found in matrix, return original matrix
        shifted_matrix = matrix;
        return;
    end
    
    % Find the index of the leftmost column and uppermost row with the number
    [~, min_col_index] = min(col);
    min_row_index = find(col == min(col), 1);
    
    % Perform circular shift to bring the number to (1,1) position
    shift_amount = [min_row_index-1, min_col_index-1];
    shifted_matrix = circshift(matrix, -shift_amount);
end

% Example usage:
original_matrix = [16, 2, 3, 13; 5, 11, 10, 8; 9, 7, 6, 12; 4, 14, 15, 1];
number = 6;
shifted_matrix = shift_matrix(original_matrix, number);
disp(shifted_matrix);

可以调用 shift_matrix 函数，并传入原始矩阵和要移动到 (1,1) 位置的数字。然后会返回移动后的矩阵。

例16.

Problem 2701. Go to the head of the class!

You're given a matrix and a single number. If that number is in the matrix, reorder the matrix so that number is in the first row and first column of the matrix, and keep all of the other numbers in the same relative position. For example, your matrix is magic(3):

你会得到一个矩阵和一个单独的数字。如果该数字在矩阵中，重新排列矩阵，使该数字位于矩阵的第一行和第一列，并保持所有其他数字的相对位置不变。例如，你的矩阵是 magic(3)：
复制代码
     8     1     6
     3     5     7
     4     9     2
and the number is nine. You want to change the matrix to

而数字是九。你希望将矩阵改为：
复制代码
     9     2     4
     1     6     8
     5     7     3
Nine is now in the (1,1) position, and all of the other numbers are in the same relative position to nine. If the number is not in the matrix, just return the original matrix. Likewise, if the number appears more than once, make sure the first instance of the number is the one that is moved to the front. Good luck!

现在九位于 (1,1) 位置，而所有其他数字相对于九仍保持相同的相对位置。如果数字不在矩阵中，只需返回原始矩阵。同样，如果数字出现多次，请确保将数字的第一个实例移动到最前面。祝你好运！

下面是MATLAB程序：

Matlab 复制代码

function max_rearranged_integer = max_rearranged_integer(x)
    % Convert x to binary string
    binary_x = dec2bin(x);
    
    % Find the length of the binary representation
    len = length(binary_x);
    
    % Initialize a binary string to store the rearranged bits
    rearranged_binary = '';
    
    % Sort the binary string in descending order
    sorted_binary = sort(binary_x, 'descend');
    
    % Pad the sorted binary string with zeros to make its length equal to the original
    sorted_binary = [sorted_binary, repmat('0', 1, len - length(sorted_binary))];
    
    % Convert the rearranged binary string to decimal
    max_rearranged_integer = bin2dec(sorted_binary);
end

使用示例：

Matlab 复制代码

x = 10;
max_rearranged_integer = max_rearranged_integer(x);
disp(max_rearranged_integer); % 输出结果

例17.Problem 3094. Hankelize a matrix

Similar to Problem 42501. Toeplitize a matrix, let's consider Hankelization of a matrix.

Given an input matrix A, convert it to a Hankel matrix B by replacing each skew-diagonal of A with its mean. For example,

类似于问题 42501. 对矩阵进行托普利兹化，我们考虑对矩阵进行汉克尔化。

给定一个输入矩阵 A，通过用其每个斜对角线的均值替换，将其转换为汉克尔矩阵 B。例如，

Input
复制代码
   A = [3     7    10     2
复制代码
        3     5     1     2
复制代码
        6     3     2     7]
Output:
复制代码
   B = [3     5     7     2 
复制代码
        5     7     2     2
复制代码
        7     2     2     7]

以下是MATLAB代码：

Matlab 复制代码

function hankel_matrix = hankelize_matrix(matrix)
    [m, n] = size(matrix);
    hankel_matrix = zeros(m, n);
    for i = 1:m
        for j = 1:n
            % Calculate the mean of the skew-diagonal elements
            diagonal_elements = diag(matrix, j-i);
            mean_diagonal = mean(diagonal_elements);
            % Assign the mean value to the corresponding element in Hankel matrix
            hankel_matrix(i, j) = mean_diagonal;
        end
    end
end

% 示例用法：
A = [3     7    10     2
     3     5     1     2
     6     3     2     7];

B = hankelize_matrix(A);
disp(B);

可以调用 hankelize_matrix 函数，并传入原始矩阵 A，然后将返回转换后的汉克尔矩阵 B。

例18.Problem 42320. Write a function man that takes a row vector v and returns a matrix H as follows..

Write a function called man that takes a row vector v as an input and returns a matrix H whose first column consist of the elements of v, whose second column consists of the squares of the elements of v, and whose third column consists of the cubes of the elements v. For example, if A = man(1:3) , then A will be [ 1 1 1; 2 4 8; 3 9 27 ].

编写一个名为 man 的函数，该函数接受一个行向量 v 作为输入，并返回一个矩阵 H，其中第一列包含 v 的元素，第二列包含 v 元素的平方，第三列包含 v 元素的立方。例如，如果 A = man(1:3)，那么 A 将是 [ 1 1 1; 2 4 8; 3 9 27 ]。

以下是MATLAB代码：

Matlab 复制代码

function H = man(v)
    % 获取向量的长度
    n = length(v);
    % 初始化矩阵 H
    H = zeros(n, 3);
    
    % 第一列为向量 v 的元素
    H(:, 1) = v;
    % 第二列为向量 v 的元素的平方
    H(:, 2) = v.^2;
    % 第三列为向量 v 的元素的立方
    H(:, 3) = v.^3;
end

% 示例用法：
A = man(1:3);
disp(A);

可以调用 man 函数，并传入行向量作为参数，它将返回符合要求的矩阵。

例19.Problem 42501. Toeplitize a matrix

Similar to Problem 3094. Hankelize a matrix, now consider Toeplitization of a matrix.

Given an input matrix A, convert it to a Toeplitz matrix B by replacing the diagonal of A with the mean of the respective diagonal. For example,

将矩阵转换为托普利茨矩阵，与问题 3094 中的汉克尔化矩阵类似。

给定一个输入矩阵 A，通过用相应对角线的均值替换 A 的对角线，将其转换为托普利茨矩阵 B。例如，

Input
复制代码
   A = [6     3     2     7
复制代码
        3     5     1     2
复制代码
        3     7    10     2]
Output:
复制代码
   B = [7     2     2     7 
复制代码
        5     7     2     2
复制代码
        3     5     7     2]

以下是MATLAB代码：

Matlab 复制代码

function B = toeplitize(A)
    % 获取矩阵 A 的大小
    [m, n] = size(A);
    
    % 初始化矩阵 B 为与 A 相同大小的零矩阵
    B = zeros(m, n);
    
    % 遍历每个对角线
    for k = 1-m : n-1
        % 计算当前对角线上的元素
        diagonal_elements = diag(A, k);
        % 计算当前对角线上的均值
        mean_value = mean(diagonal_elements);
        % 将对角线上的元素替换为均值
        B = B + diag(mean_value * ones(1, length(diagonal_elements)), k);
    end
end
% 示例用法：
A = [6     3     2     7
     3     5     1     2
     3     7    10     2];

B = toeplitize(A);
disp(B);

你可以调用 toeplitize 函数，并传入矩阵 A 作为参数，它将返回转换后的托普利茨矩阵 B。