Trong phần này, chúng ta sẽ thảo luận về cách xoay ma trận 180 độ trong Java. Trong bài toán này, một ma trận vuông được đưa ra và chúng ta phải xoay nó 1800
ví dụ 1
Đầu vào
4 6 7 8
9 3 2 1
9 0 4 5
8 0 3 2
đầu ra
2 3 0 8
5 4 0 9
1 2 3 9
8 7 6 4
Phương pháp xoay ma trận 180 độ
Có nhiều cách tiếp cận khác nhau để giải quyết vấn đề, nhưng trong phần này, chúng ta sẽ thảo luận về các cách tiếp cận sau
- Cách tiếp cận ngây thơ
- Sử dụng ma trận chuyển vị
- Bằng cách hoán đổi vị trí
Trước tiên hãy bắt đầu với cách tiếp cận đơn giản nhất
Cách tiếp cận ngây thơ
Xem xét các ví dụ trên. Chúng tôi quan sát thấy rằng chúng tôi đang in các hàng của ma trận đầu vào theo thứ tự ngược lại bắt đầu từ hàng dưới cùng và đi lên
Ví dụ: nếu một mảng đầu vào có 5 hàng thì hàng thứ 5 được in trước. Sau đó, hàng thứ 4 được in, rồi hàng thứ 3 được in, v.v.
Hãy xem việc thực hiện phương pháp đơn giản nhất
Tên tệp. XoayMatrix. java
đầu ra
For the following matrix: 4 6 7 8 9 3 2 1 9 0 4 5 8 0 3 2 The rotated matrix at 180 degree is: 2 3 0 8 5 4 0 9 1 2 3 9 8 7 6 4 For the following matrix: 4 7 8 6 7 9 2 1 9 1 9 0 5 4 3 5 6 7 2 1 8 9 0 5 1 The rotated matrix at 180 degree is: 1 5 0 9 8 1 2 7 6 5 3 4 5 0 9 1 9 1 2 9 7 6 8 7 4
Sử dụng ma trận chuyển vị
Thuật toán sau mô tả cách một người có thể sử dụng khái niệm chuyển vị của ma trận để giải quyết vấn đề
Bước 1. Tính chuyển vị của ma trận đã cho
Bước 2. Đảo ngược cột của ma trận chuyển vị
Bước 3. Sau khi đảo cột ở bước trước, tìm lại chuyển vị của ma trận
Bước 4. Đảo ngược cột của ma trận được tìm thấy trong bước 3
Ví dụ: nếu chúng ta có một ma trận đầu vào là
14 27 38 46 57
79 52 31 39 11
99 80 15 24 43
45 56 97 82 51
78 79 60 25 41
Sau đó, chuyển vị của nó sẽ là
14 79 99 45 78
27 52 80 56 79
38 31 15 97 60
46 39 24 82 25
57 11 43 51 41
Bây giờ, chúng ta sẽ đảo ngược các cột của nó
57 11 43 51 41
46 39 24 82 25
38 31 15 97 60
27 52 80 56 79
14 79 99 45 78
Một lần nữa, chúng ta sẽ hoán vị ma trận
57 46 38 27 14
11 39 31 52 79
43 24 15 80 99
51 82 97 56 45
41 25 60 79 78
Một lần nữa, chúng tôi sẽ đảo ngược các cột của nó
41 25 60 79 78
51 82 97 56 45
43 24 15 80 99
11 39 31 52 79
57 46 38 27 14
Chương trình sau đây mô tả việc thực hiện phương pháp trên
Tên tệp. XoayMatrix1. java
đầu ra
For the following matrix: 4 6 7 8 9 3 2 1 9 0 4 5 8 0 3 2 The rotated matrix at 180 degree is: 2 3 0 8 5 4 0 9 1 2 3 9 8 7 6 4 For the following matrix: 4 7 8 6 7 9 2 1 9 1 9 0 5 4 3 5 6 7 2 1 8 9 0 5 1 The rotated matrix at 180 degree is: 1 5 0 9 8 1 2 7 6 5 3 4 5 0 9 1 9 1 2 9 7 6 8 7 4
Bằng cách hoán đổi vị trí
Như chúng ta có thể thấy trong cách tiếp cận trên, chuyển vị của ma trận phải được tìm thấy hai lần. Ngoài ra, sự đảo ngược của các cột phải được tìm thấy hai lần. Do đó, chúng ta có thể thực hiện một số tối ưu hóa để có giải pháp tốt hơn
Trong cách tiếp cận này, chúng tôi sẽ hoán đổi các giá trị ở các vị trí khác nhau. Quan sát đoạn chương trình sau
Tên tệp. XoayMatrix2. java
đầu ra
For the following matrix: 4 6 7 8 9 3 2 1 9 0 4 5 8 0 3 2 The rotated matrix at 180 degree is: 2 3 0 8 5 4 0 9 1 2 3 9 8 7 6 4 For the following matrix: 4 7 8 6 7 9 2 1 9 1 9 0 5 4 3 5 6 7 2 1 8 9 0 5 1 The rotated matrix at 180 degree is: 1 5 0 9 8 1 2 7 6 5 3 4 5 0 9 1 9 1 2 9 7 6 8 7 4
Phân tích độ phức tạp
Trong các chương trình trên, chúng tôi đang duyệt qua từng hàng và cột của ma trận. Nó dẫn đến độ phức tạp thời gian là O[R * C], trong đó R là kích thước hàng của ma trận đầu vào và C là kích thước cột của ma trận đầu vào
Lưu ý rằng chúng tôi không sử dụng bất kỳ không gian phụ trợ nào để lưu trữ dữ liệu;
Chỉ định
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
import numpy as np
a_2d = np.arange[6].reshape[2, 3]
print[a_2d]
# [[0 1 2]
# [3 4 5]]
a_2d_rot = np.rot90[a_2d]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
nguồn.
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
nguồn.
Nếu bạn muốn xử lý dưới dạng dữ liệu riêng biệt, hãy sử dụng
a_2d_rot_copy = np.rot90[a_2d].copy[]
print[a_2d_rot_copy]
# [[2 5]
# [1 4]
# [0 3]]
print[np.shares_memory[a_2d, a_2d_rot_copy]]
# False
________số 8_______
nguồn.
Chỉ định số lần quay. k
Chỉ định một giá trị số nguyên cho đối số thứ hai
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
print[np.rot90[a_2d, 2]]
# [[5 4 3]
# [2 1 0]]
print[np.rot90[a_2d, 3]]
# [[3 0]
# [4 1]
# [5 2]]
print[np.rot90[a_2d, 4]]
# [[0 1 2]
# [3 4 5]]
print[np.rot90[a_2d, 100]]
# [[0 1 2]
# [3 4 5]]
nguồn.
Trong trường hợp giá trị âm, hướng quay theo chiều kim đồng hồ
print[np.rot90[a_2d, -1]]
# [[3 0]
# [4 1]
# [5 2]]
print[np.rot90[a_2d, -2]]
# [[5 4 3]
# [2 1 0]]
nguồn.
Đối với mảng một chiều
Mảng một chiều không xoay được
a_1d = np.arange[3]
print[a_1d]
# [0 1 2]
# print[np.rot90[a_1d]]
# ValueError: Axes must be different.
nguồn.
Nó có thể được xoay nếu được định nghĩa là một mảng hai chiều chỉ có một hàng
a_2d_row = np.arange[3].reshape[1, 3]
print[a_2d_row]
# [[0 1 2]]
print[np.rot90[a_2d_row]]
# [[2]
# [1]
# [0]]
nguồn.
Liên kết được tài trợ
Đối với mảng nhiều chiều
Các mảng đa chiều có ba chiều trở lên cũng có thể được xoay
hành vi mặc định
Theo mặc định, nó được xoay như sau
a_3d = np.arange[24].reshape[2, 3, 4]
print[a_3d]
# [[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]]
print[a_3d.shape]
# [2, 3, 4]
print[np.rot90[a_3d]]
# [[[ 8 9 10 11]
# [20 21 22 23]]
#
# [[ 4 5 6 7]
# [16 17 18 19]]
#
# [[ 0 1 2 3]
# [12 13 14 15]]]
print[np.rot90[a_3d].shape]
# [3, 2, 4]
nguồn.
Nó được quay trong một mặt phẳng bao gồm hai trục [kích thước] đầu tiên
print[a_3d[:, :, 0]]
# [[ 0 4 8]
# [12 16 20]]
print[np.rot90[a_3d][:, :, 0]]
# [[ 8 20]
# [ 4 16]
# [ 0 12]]
nguồn.
Chỉ định mặt phẳng để xoay. trục
Đối với mảng nhiều chiều, đối số thứ ba
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
Giá trị mặc định là
a_2d_rot_copy = np.rot90[a_2d].copy[]
print[a_2d_rot_copy]
# [[2 5]
# [1 4]
# [0 3]]
print[np.shares_memory[a_2d, a_2d_rot_copy]]
# False
print[np.rot90[a_3d, axes=[0, 1]]]
# [[[ 8 9 10 11]
# [20 21 22 23]]
#
# [[ 4 5 6 7]
# [16 17 18 19]]
#
# [[ 0 1 2 3]
# [12 13 14 15]]]
nguồn.
Một ví dụ về quay trong một mặt phẳng khác như sau. Nếu thứ tự của các trục được chỉ định trong
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
nguồn.
Nó cũng có thể được chỉ định cùng với đối số thứ hai
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
nguồn.
Xoay hình ảnh
Các tệp hình ảnh có thể được đọc dưới dạng mảng NumPy
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]
- Xử lý ảnh với Python, NumPy
- Đọc và lưu file ảnh với Python, OpenCV [imread, imwrite]
Có thể xoay hình ảnh bằng cách sử dụng
print[np.shares_memory[a_2d, a_2d_rot]]
# True
a_2d_rot[0, 0] = 100
print[a_2d_rot]
# [[100 5]
# [ 1 4]
# [ 0 3]]
print[a_2d]
# [[ 0 1 100]
# [ 3 4 5]]
a_2d[0, 2] = 2
print[a_2d]
# [[0 1 2]
# [3 4 5]]
print[a_2d_rot]
# [[2 5]
# [1 4]
# [0 3]]