Kiểm tra xoay mảng trong Python

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

Giả sử chúng ta có một mảng gồm n giá trị duy nhất. Chúng ta phải kiểm tra xem mảng này có được sắp xếp và xoay ngược chiều kim đồng hồ không. Ở đây cần ít nhất một phép quay để một mảng được sắp xếp đầy đủ không được coi là đã sắp xếp và xoay

Vì vậy, nếu đầu vào là nums = [4,5,6,8,1,3], thì đầu ra sẽ là True vì chúng ta có thể xoay hai lần theo chiều kim đồng hồ thì nó sẽ được sắp xếp như [1, 3,

Để giải quyết vấn đề này, chúng tôi sẽ làm theo các bước sau -

• min_element. = số tối thiểu
• min_index. = chỉ số của min_element tính bằng số
• before_sorted. = Đúng
• đối với tôi trong khoảng từ 1 đến min_index - 1, hãy làm
  • nếu nums[i] < nums[i - 1] thì
    • before_sorted. = Sai
    • đi ra khỏi vòng lặp
• after_sorted. = Đúng
• đối với tôi trong phạm vi min_index + 1 đến kích thước của nums - 1, hãy làm
  • nếu nums[i] < nums[i - 1] thì
    • after_sorted. = Sai
    • đi ra khỏi vòng lặp
• nếu before_sorted và after_sorted là đúng và là phần tử cuối cùng của nums < nums[0], thì
• nếu không thì,

Chúng ta hãy xem triển khai sau đây để hiểu rõ hơn -

Thí dụ

Bản thử trực tiếp

def solve(nums):
   min_element = 999999
   min_index = -1
   min_element = min(nums)
   min_index = nums.index(min_element) before_sorted = True
   for i in range(1, min_index):
      if nums[i] < nums[i - 1]:
         before_sorted = False
         break
   after_sorted = True
   for i in range(min_index + 1, len(nums)):
      if nums[i] < nums[i - 1]:
         after_sorted = False
         break
   if before_sorted and after_sorted and nums[-1] < nums[0]:
      return True
   else:
      return False
nums = [4,5,6,8,1,3]
print(solve(nums))

Đầu vào

[4,5,6,8,1,3]

đầu ra

True