programming php

Làm cách nào để so sánh hai mảng bằng nhau trong php?

Bây giờ bạn có thể cố gắng giải quyết vấn đề này từ đây. bằng cách áp dụng hai cách tiếp cận trên. Nếu bị mắc kẹt, sau đó bạn có thể tìm thấy giải pháp dưới đây

1. Sắp xếp mảng

Để kiểm tra xem hai mảng có bằng nhau hay không, chúng ta phải so sánh sự xuất hiện chính xác của từng phần tử trong cả hai mảng có giống nhau không

Tuy nhiên, vấn đề là các giá trị của các mảng có thể ở bất kỳ hoán vị nào không phụ thuộc vào nhau

Nếu chúng tôi có thể sắp xếp chúng theo bất kỳ cách nào, thì chúng tôi sẽ dễ dàng kiểm tra số lần xuất hiện của chúng. Vì vậy, chúng tôi sẽ sắp xếp cả hai mảng và duyệt tuyến tính trên nó trong khi so sánh từng phần tử của mảng. Nếu tại bất kỳ chỉ số nào sau khi sắp xếp chúng không khớp thì chúng tôi có thể trả lại

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

6 từ đó nếu không, chúng tôi sẽ trả lại

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

Các bước giải pháp

So sánh độ dài của

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

8 và

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

9. Nếu chúng bằng nhau, thì chúng tôi sẽ tiếp tục nếu không thì trả lại

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

Sắp xếp

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

8 và

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

9 theo thứ tự tăng dần hoặc giảm dần

Đối với mỗi chỉ số

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

3 của mảng, hãy so sánh

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

4 và

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

5 bằng nhau

Nếu tại bất kỳ thời điểm nào điều kiện không thành công, thì trả về
```
Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1
```
6 nếu không, khi kết thúc so sánh, trả về
```
Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1
```
7

Mã giả

bool twoArrEqual[int arr1[], int arr2[]] 
{ 
    // If lengths of array are not equal means 
    // array are not equal 
    if [arr1.length != arr2.length] 
        return false
  
    // Sort both arrays 
    sort[arr1]
    sort[arr2]
  
    // Linearly compare elements 
    for [int i = 0 to i < arr1.length] 
        if [arr1[i] != arr2[i]] 
            return false
  
    // If all elements were same. 
    return true
}

Phân tích độ phức tạp

Thời gian phức tạp. O[n log n] sử dụng sắp xếp hợp nhất. Sử dụng một thuật toán sắp xếp bậc hai khác sẽ làm cho độ phức tạp thời gian O[n²]

Độ phức tạp không gian. Ô[1]

Ý tưởng quan trọng để suy nghĩ

Bạn có nghĩ rằng có thể có một cách tiếp cận khác trong đó chúng ta sẽ lấy từng hoán vị của các phần tử trong mảng đầu tiên và so sánh nó với mảng thứ hai không?
Thuật toán sắp xếp nào nên được sử dụng ở đây để sắp xếp các mảng? [bình luận bên dưới]
Bạn có thể tối ưu hóa độ phức tạp của thời gian không?

2. Sử dụng hàm băm

Nếu chúng ta suy nghĩ lại, chúng ta có thể tối ưu hóa hơn nữa độ phức tạp về thời gian của phương pháp trước đó, nếu bạn nhận thấy rằng chỉ có số lần xuất hiện của mỗi phần tử là có liên quan đến chúng ta để kiểm tra sự bằng nhau của hai mảng

Vì vậy, nếu tồn tại một giá trị trong

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

8 thì nó phải tồn tại trong

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

9 với cùng số lần xuất hiện trong mỗi giá trị đó

Điều này làm tôi nhớ đến một cấu trúc dữ liệu có tên là

Input: A[] = [1, 2, 2, 7, 1] , B[] = [2, 1, 2, 7, 5] 
Output: 0

0 còn được gọi là

Input: A[] = [1, 2, 2, 7, 1] , B[] = [2, 1, 2, 7, 5] 
Output: 0

1 hoặc

Input: A[] = [1, 2, 2, 7, 1] , B[] = [2, 1, 2, 7, 5] 
Output: 0

2. Chúng ta có thể sử dụng HashMap để lưu trữ các phần tử và sự xuất hiện của chúng. Bây giờ chúng ta có thể chỉ cần lặp lại mảng thứ hai và giảm số lượng xuống một cho mỗi phần tử

các bước giải quyết

Kiểm tra kích thước của cả hai mảng
Tạo HashMap cho
```
Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1
```
8 và lưu trữ số lượng cho từng phần tử
Lặp lại trên
```
Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1
```
9 và kiểm tra từng phần tử trong
```
Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1
```
9 phải có một khóa trong HashMap và giá trị của nó tương ứng với khóa phải lớn hơn 0
Nếu khóa đó tồn tại, thì hãy giảm số đếm xuống một cho khóa đó trong lần lặp cụ thể đó
Nếu giá trị của khóa không lớn hơn 0, hãy trả về
```
Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1
```
6

Khi kết thúc mã trả về

Input: A[] = [1, 2, 2, 7, 1] , B[] = [2, 1, 2, 7, 5] 
Output: 0

Mã giả

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

Phân tích độ phức tạp

Thời gian phức tạp. Trên]. Bạn có thể sử dụng bản đồ không có thứ tự. Sử dụng Bản đồ được sắp xếp có thể hạ độ phức tạp thời gian thành O[n log n] đối với các giá trị lớn của n

Độ phức tạp không gian. Trên]

Ý tưởng quan trọng để suy nghĩ

Nếu một phần tử của
```
Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1
```
8 xuất hiện nhiều hơn phần tử đó trong
```
Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1
```
9 thì bạn có nghĩ rằng thuật toán này sẽ hoạt động không?

Bạn có thể nghĩ về trường hợp khi

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

30 trở thành

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

31 cho bất kỳ

Input: A[] = [1, 2, 5, 2, 1] , B[] = [2, 1, 2, 1, 5] 
Output: 1

3 nào không?

Thay vì sắp xếp và sử dụng không gian phụ trợ, bạn có thể nghĩ ra cách tiếp cận nào khác với độ phức tạp thời gian O[n²] không?

So sánh các phương pháp tiếp cận khác nhau

Các vấn đề được đề xuất để giải quyết

Kiểm tra xem có thể làm cho cả hai mảng bằng nhau bằng cách sửa đổi một phần tử không
Tìm các mảng con từ hai mảng đã cho sao cho chúng có tổng bằng nhau
Đếm các mảng con có các phần tử nhỏ hơn hoặc bằng X
Đếm các cặp từ hai mảng đã sắp xếp có tổng bằng một giá trị x đã cho

Nếu bạn có thêm bất kỳ cách tiếp cận nào hoặc bạn tìm thấy lỗi/lỗi trong các giải pháp trên, vui lòng bình luận xuống bên dưới

Làm cách nào để khớp hai mảng trong PHP?

Hàm array_intersect[] so sánh giá trị của hai [hoặc nhiều] mảng và trả về kết quả khớp. Hàm này so sánh các giá trị của hai hoặc nhiều mảng và trả về một mảng chứa các mục từ mảng1 có trong mảng2, mảng3, v.v.

Làm cách nào để kiểm tra các giá trị mảng bằng nhau trong PHP?

Hàm array_unique[] "lấy một mảng đầu vào và trả về một mảng mới không có giá trị trùng lặp. " Không, 1 sẽ được trả về nếu TẤT CẢ giá trị trong mảng giống nhau.

1. Sắp xếp mảng

2. Sử dụng hàm băm

So sánh các phương pháp tiếp cận khác nhau

Các vấn đề được đề xuất để giải quyết

Làm cách nào để khớp hai mảng trong PHP?

Làm cách nào để kiểm tra các giá trị mảng bằng nhau trong PHP?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề