Làm cách nào để xoay ma trận 90 độ ngược chiều kim đồng hồ trong python?

Cho ma trận vuông, xoay ma trận 90 độ theo chiều kim đồng hồ. Việc chuyển đổi nên được thực hiện tại chỗ và trong thời gian bậc hai

Show

    Ví dụ,

    Đầu vào.
     
    1   2   3   4
    5   6   7   8
    9   10  11  12
    13  14  15  16
     
    Output:
     
    13  9   5  1
    14  10  6  2
    15  11  7  316  12  8  4

    Thực hành vấn đề này

    Ý tưởng là chuyển đổi tại chỗ ma trận thành chuyển vị của nó trước. Nếu hoán đổi cột đầu tiên với cột cuối cùng, cột thứ hai với cột cuối cùng thứ hai, v.v., chúng ta sẽ nhận được ma trận mong muốn

    Sau đây là triển khai trong C++, Java và Python dựa trên ý tưởng trên

    C++


    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    #include

    #include

    #include

    #include

    sử dụng không gian tên std;

     

    // Xoay tại chỗ 90 độ theo chiều kim đồng hồ

    khoảng trống xoay(vectơ<vector<int>> &mat)

    {

        // Ma trận `N × N`

        int N = mat.kích thước();

     

        // trường hợp cơ bản

        nếu (N == 0) {

            trả lại;

        }

     

        // Hoán vị ma trận

        cho (int i = 0; i < N; i++)

        {

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

                hoán đổi(mat[i][j], mat[j][i]);

            }

        }

     

        // hoán đổi cột

        cho (int i = 0; i < N; i++)

        {

            cho (int j = 0; j < N/2; j++) {

                hoán đổi(mat[i][j], mat[i][N - j - 1]);

            }

        }

    }

     

    //Hàm in ma trận

    void printMatrix(vectơ<vector<int>> const &mat)

    {

        cho (ô tô &row: thảm) {

            cho (ô tô &i: hàng) {

                cout << setw(3) << i;

            }

            cout << endl;

        }

        cout << endl;

    }

     

    int chính()

    {

        vectơ<vectơ<int>> mat =

        {

            { 1, 2, 3, 4 },

            { 5, 6, 7, 8 },

            { 9, 10, 11, 12 },

            { 13, 14, 15, 16 }

        };

     

        xoay(thảm);

        printMatrix(mat);

     

        return 0;

    }

    Tải xuống Chạy mã

    Đầu ra.

    13   9   5   1
    14  10   6   2
    15  11   7   3
    16  12

    Java


    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    nhập java. sử dụng. Mảng;

     

    lớp Chính

    {

        // Xoay tại chỗ 90 độ theo chiều kim đồng hồ

        công khai tĩnh vô hiệu xoay(int[][] mat)

        {

            // trường hợp cơ bản

            nếu (mat == null || thảm. độ dài == 0) {

                return;

            }

     

            // Ma trận `N × N`

            int N = mat.độ dài;

     

            // Hoán vị ma trận

            cho (int i = 0; i < N; i++)

            {

                cho (int j = 0; j < i; j++)

                {

                            int temp = mat[i][j];

                            thảm[i][j] = mat[j][i];

                            thảm[j][i] = temp;

                }

            }

     

            // hoán đổi cột

            cho (int i = 0; i < N; i++)

            {

                cho (int j = 0; j < N / 2; j++)

                {

                            int temp = mat[i][j];

                            thảm[i][j] = mat[i][N - j - 1];

                            thảm[i][N - j - 1] = temp;

                }

            }

        }

     

        công khai tĩnh vô hiệu chính(String[] args)

        {

            int[][] mat =

            {

                { 1, 2, 3, 4 },

                { 5, 6, 7, 8 },

                { 9, 10, 11, 12 },

                { 13, 14, 15, 16 }

            };

     

            xoay(thảm);

     

            cho (var r: thảm) {

                Hệ thống. ra. println(Mảng. toString(r));

            }

        }

    }

    Tải xuống Chạy mã

    Đầu ra.

    [13, 9, 5, 1]
    [14, 10, 6, 2]
    [15, 11,
    [16, 12, 8, 4]

    con trăn


    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    # Xoay tại chỗ 90 độ theo chiều kim đồng hồ

    def xoay(mat):

     

        # trường hợp cơ bản

        nếu không thảm hoặc not len(mat):

            trả lại

     

        # `N × N` ma trận

        N = len(mat)

     

        # Hoán vị ma trận

        cho i trong phạm vi(N):

            cho j trong phạm vi(i):

                nhiệt độ = mat[i][j]

                mat[i][j] = mat[j][i]

                mat[j][i] = temp

     

        # hoán đổi cột

        cho i trong phạm vi(N):

            cho j trong phạm vi(N // 2):

                nhiệt độ = mat[i][j]

                mat[i][j] = mat[i][N - j - 1]

                mat[i][N - j - 1] = temp

     

     

    if __name__ == '__main__'.

     

        mat = [

            [1, 2, 3, 4],

            [5, 6, 7, 8],

            [9, 10, 11, 12],

            [13, 14, 15, 16]

        ]

     

        xoay(thảm)

     

        cho r trong mat:

            in(r)

     

    Tải xuống Chạy mã

    Đầu ra.

    [13, 9, 5, 1]
    [14, 10, 6, 2]
    [15, 11,
    [16, 12, 8, 4]

    Nếu chúng ta được yêu cầu xoay ma trận ngược chiều kim đồng hồ, chúng ta cũng có thể dễ dàng làm điều đó, sử dụng logic tương tự. Điểm khác biệt duy nhất là thay vì hoán đổi cột, chúng ta hoán đổi hàng