Xoay vòng theo chu kỳ của mảng python theo k

Trong hướng dẫn này, chúng ta sẽ học cách viết một hàm cho Xoay mảng. Người dùng sẽ cung cấp một đầu vào d mà theo đó các phần tử của mảng sẽ được xoay

Mảng Python là cấu trúc dữ liệu lưu trữ dữ liệu đồng nhất. Mảng lưu trữ các đối tượng có cùng kiểu dữ liệu. Mảng có thể thay đổi, nghĩa là dữ liệu trong một mảng có thể được thay đổi và lặp đi lặp lại, nghĩa là mỗi phần tử trong một mảng có thể được truy cập từng phần tử một

Giả sử một mảng a[ ] có các phần tử sau,

Nó phải được xoay 2 thì mảng kết quả sẽ là,

Chương trình của chúng tôi sẽ cung cấp đầu ra như sau

Đầu vào-[1, 2, 3, 4, 5, 6]

Mảng xoay đầu ra là [3, 4, 5, 6, 1, 2]

Để thực hiện nhiệm vụ này, chúng tôi sẽ làm theo các phương pháp sau

1. Sử dụng một mảng tạm thời sẽ lưu trữ các phần tử đã dịch chuyển
2. Cắt mảng

Cách tiếp cận 1. Bằng cách sử dụng một mảng tạm thời

Trong phương pháp này, chúng tôi sẽ khai báo một mảng tạm thời sẽ lưu trữ các phần tử mảng theo thứ tự thay đổi

Input arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2, n =7

1] Store all the elements in the index range d to n in a temp array
   temp[] = [3, 4, 5, 6, 7]
2] Add all the elements in the index range 0 to d in the temp array
   arr[] = [3, 4, 5, 6, 7, 1, 2]
3] Copy the temp array to arr[]
   arr[] = [3, 4, 5, 6, 7, 1, 2]

thuật toán

Bước 1- Định nghĩa hàm xoay mảng

Bước 2- Khai báo biến tạm thời

Bước 3- Sử dụng len[] để tính độ dài của mảng và lưu nó vào một biến

Bước 4- Chạy một vòng lặp từ d đến n và lưu trữ các phần tử tại mỗi chỉ mục trong mảng tạm thời

Bước 5- Chạy một vòng lặp khác để thêm các phần tử còn lại vào mảng tạm thời

Bước 6- Sao chép mảng tạm thời sang mảng ban đầu

Bước 7- Trả về mảng

Chương trình Python 1

Nhìn vào chương trình để hiểu việc thực hiện phương pháp nêu trên

def rotateArray[a,d]:
    temp = []
    n=len[a]
    for i in range[d,n]:
        temp.append[a[i]]
    i = 0
    for i in range [0,d]:
        temp.append[a[i]]
    a=temp.copy[]
    return a
 
arr = [1, 2, 3, 4, 5, 6, 7]
print["Array after left rotation is: ", end=' ']
print[rotateArray[arr, 2]]

Mảng sau khi xoay trái là. [3, 4, 5, 6, 7, 1, 2]

Cách tiếp cận 2. cắt lát

Trong cách tiếp cận này, chúng ta sẽ sử dụng khái niệm cắt lát. Vì mảng là một kiểu danh sách với các phần tử cùng kiểu dữ liệu nên chúng ta có thể sử dụng khái niệm cắt danh sách ở đây. Thông qua việc cắt, chúng ta có thể truy cập bất kỳ phần nào của mảng

thuật toán

Bước 1- Định nghĩa hàm xoay phần tử trong danh sách mảng

Bước 2- Xác định độ dài của một mảng bằng len[]

Bước 3- Sử dụng toán tử nối [. ] để lưu trữ các phần tử từ d đến n và 0 đến d

Bước 4- Sử dụng dấu [+] để nối cả hai mảng

Bước 5- Trả về mảng

Chương trình Python 2

Nhìn vào chương trình để hiểu việc thực hiện phương pháp nêu trên

# List slicing approch to rotate the array
def rotateArray[a,d]:
    n=len[a]
    a[:]=a[d:n]+a[0:d]
    return a

arr = [1, 2, 3, 4, 5, 6]

print["Rotated list is"]
print[rotateArray[arr,2]] 

Danh sách đã xoay là
[3, 4, 5, 6, 1, 2]

Phần kết luận

Trong hướng dẫn này, chúng ta đã học được hai cách tiếp cận mà chúng ta có thể thực hiện để xoay các phần tử trong một mảng. Chúng tôi đã sử dụng khái niệm cắt lát trong hướng dẫn của mình. Chúng ta cũng có thể khai báo một mảng tạm thời sẽ lưu trữ các phần tử theo thứ tự đã dịch chuyển. Để thêm dữ liệu vào mảng tạm thời, chúng tôi đã sử dụng append[] và để sao chép mảng tạm thời vào mảng ban đầu, chúng tôi đã sử dụng copy[] trong chương trình của mình

Trong bài đăng này, chúng ta sẽ xem cách xoay phải một mảng theo các vị trí đã chỉ định. Ví dụ, xoay phải mảng { 1, 2, 3, 4, 5, 6, 7 } ba lần sẽ cho kết quả là mảng { 5, 6, 7, 1, 2, 3, 4 }

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

1. Xoay k lần

Ý tưởng là xoay phải tất cả các phần tử mảng theo một vị trí k lần, trong đó k là số lần xoay đã cho. Cách tiếp cận này được trình bày dưới đây trong C, Java và Python

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

#include

// Hàm xoay phải một mảng theo một vị trí

void rightRotateByOne[int A[], int n]

{

    int last = A[n - 1];

    cho [int i = n - 2; i >= 0; i--] {

        A[i + 1] = A[i];

    }

    A[0] = last;

}

// Hàm xoay phải một mảng theo vị trí `k`

void xoay phải[int A[], int k, int n]

{

   // trường hợp cơ bản. đầu vào không hợp lệ

    nếu [k = n] {

        trả lại;

    }

    cho [int i = 0; i