doantuong.linh
New member
#4sum #LeetCode #Python #Array #AlGorithM
** 4 tổng trong LeetCode với Python **
Vấn đề 4 tổng là một vấn đề kinh điển trong khoa học máy tính.Đưa ra một loạt các số nguyên, tìm tất cả bốn số nguyên trong mảng tổng hợp thành một mục tiêu nhất định.Vấn đề không đơn giản như nó có vẻ, và có một số cách khác nhau để giải quyết nó.Trong bài viết này, chúng tôi sẽ chỉ cho bạn cách giải quyết vấn đề 4 tổng bằng cách sử dụng Python.
## Giải pháp lực lượng vũ phu
Giải pháp đơn giản nhất cho vấn đề tổng số 4 là đơn giản là lặp lại thông qua tất cả các kết hợp có thể có của bốn số nguyên trong mảng.Đối với mỗi kết hợp, chúng tôi kiểm tra xem tổng của bốn số nguyên bằng với mục tiêu.Nếu có, chúng tôi thêm sự kết hợp vào câu trả lời của chúng tôi.
Độ phức tạp thời gian của giải pháp này là O (n^4), trong đó n là chiều dài của mảng.Điều này là do chúng ta cần lặp lại thông qua tất cả các kết hợp có thể của bốn số nguyên trong mảng.
`` `Python
Def Four_sum (Nums, Target):
"" "
Tìm tất cả bốn số nguyên trong mảng tổng hợp cho một mục tiêu nhất định.
Thông số:
Nums: Một mảng số nguyên.
Mục tiêu: Tổng mục tiêu.
Trả lại:
Một danh sách của tất cả bốn bộ phận tổng hợp cho mục tiêu.
"" "
Kết quả = []
Đối với I trong phạm vi (Len (nums)):
Đối với J trong phạm vi (i + 1, len (nums)):
Đối với k trong phạm vi (j + 1, len (nums)):
Đối với l trong phạm vi (k + 1, len (nums)):
Nếu nums + nums [j] + nums [k] + nums [l] == Target:
results.append ((nums , nums [j], nums [k], nums [l])))
Kết quả trả lại
`` `
## Giải pháp tối ưu hóa
Giải pháp vũ phu không hiệu quả lắm, vì nó có độ phức tạp về thời gian của O (n^4).Chúng ta có thể cải thiện hiệu quả của giải pháp bằng cách sử dụng bảng băm.
Ý tưởng là sử dụng bảng băm để lưu trữ tất cả hai phần trong mảng.Khi chúng ta có hai tổng, chúng ta có thể lặp đi lặp lại thông qua chúng và tìm thấy tất cả các bộ ba tổng hợp cho mục tiêu.
Độ phức tạp về thời gian của giải pháp này là O (n^2), đây là một sự cải thiện đáng kể so với giải pháp lực lượng vũ phu.
`` `Python
Def Four_sum (Nums, Target):
"" "
Tìm tất cả bốn số nguyên trong mảng tổng hợp cho một mục tiêu nhất định.
Thông số:
Nums: Một mảng số nguyên.
Mục tiêu: Tổng mục tiêu.
Trả lại:
Một danh sách của tất cả bốn bộ phận tổng hợp cho mục tiêu.
"" "
Kết quả = []
nums.sort ()
# Tạo bảng băm để lưu trữ tất cả hai phần trong mảng.
Two_sums = {}
Đối với I trong phạm vi (Len (nums)):
Đối với J trong phạm vi (i + 1, len (nums)):
hai_sum = nums + nums [j]
Nếu hai_sum trong Two_sums:
results.append ((hai_sums [hai_sum] [0], hai_sums [hai_sum] [1], nums , nums [j]))
khác:
Two_sums [Two_sum] = (i, j)
# Lặp lại thông qua hai phần và tìm thấy tất cả các bộ ba tổng hợp cho mục tiêu.
Đối với I trong phạm vi (Len (nums)):
Đối với J trong phạm vi (i + 1, len (nums)):
Đối với k trong phạm vi (j + 1, len (nums)):
target_sum = target - nums - nums [j] -
=======================================
#4sum #LeetCode #Python #Array #AlGorithM
**4 Sum in Leetcode with Python**
The 4 sum problem is a classic problem in computer science. Given an array of integers, find all four integers in the array that sum to a given target. The problem is not as simple as it seems, and there are a number of different ways to solve it. In this article, we will show you how to solve the 4 sum problem using Python.
## Brute Force Solution
The simplest solution to the 4 sum problem is to simply iterate through all possible combinations of four integers in the array. For each combination, we check if the sum of the four integers is equal to the target. If it is, we add the combination to our answer.
The time complexity of this solution is O(n^4), where n is the length of the array. This is because we need to iterate through all possible combinations of four integers in the array.
```python
def four_sum(nums, target):
"""
Finds all four integers in the array that sum to a given target.
Parameters:
nums: An array of integers.
target: The target sum.
Returns:
A list of all four-tuples that sum to the target.
"""
results = []
for i in range(len(nums)):
for j in range(i + 1, len(nums)):
for k in range(j + 1, len(nums)):
for l in range(k + 1, len(nums)):
if nums + nums[j] + nums[k] + nums[l] == target:
results.append((nums, nums[j], nums[k], nums[l]))
return results
```
## Optimized Solution
The brute force solution is not very efficient, as it has a time complexity of O(n^4). We can improve the efficiency of the solution by using a hash table.
The idea is to use a hash table to store all of the two-sums in the array. Once we have the two-sums, we can iterate through them and find all of the four-tuples that sum to the target.
The time complexity of this solution is O(n^2), which is a significant improvement over the brute force solution.
```python
def four_sum(nums, target):
"""
Finds all four integers in the array that sum to a given target.
Parameters:
nums: An array of integers.
target: The target sum.
Returns:
A list of all four-tuples that sum to the target.
"""
results = []
nums.sort()
# Create a hash table to store all of the two-sums in the array.
two_sums = {}
for i in range(len(nums)):
for j in range(i + 1, len(nums)):
two_sum = nums + nums[j]
if two_sum in two_sums:
results.append((two_sums[two_sum][0], two_sums[two_sum][1], nums, nums[j]))
else:
two_sums[two_sum] = (i, j)
# Iterate through the two-sums and find all of the four-tuples that sum to the target.
for i in range(len(nums)):
for j in range(i + 1, len(nums)):
for k in range(j + 1, len(nums)):
target_sum = target - nums - nums[j] -
** 4 tổng trong LeetCode với Python **
Vấn đề 4 tổng là một vấn đề kinh điển trong khoa học máy tính.Đưa ra một loạt các số nguyên, tìm tất cả bốn số nguyên trong mảng tổng hợp thành một mục tiêu nhất định.Vấn đề không đơn giản như nó có vẻ, và có một số cách khác nhau để giải quyết nó.Trong bài viết này, chúng tôi sẽ chỉ cho bạn cách giải quyết vấn đề 4 tổng bằng cách sử dụng Python.
## Giải pháp lực lượng vũ phu
Giải pháp đơn giản nhất cho vấn đề tổng số 4 là đơn giản là lặp lại thông qua tất cả các kết hợp có thể có của bốn số nguyên trong mảng.Đối với mỗi kết hợp, chúng tôi kiểm tra xem tổng của bốn số nguyên bằng với mục tiêu.Nếu có, chúng tôi thêm sự kết hợp vào câu trả lời của chúng tôi.
Độ phức tạp thời gian của giải pháp này là O (n^4), trong đó n là chiều dài của mảng.Điều này là do chúng ta cần lặp lại thông qua tất cả các kết hợp có thể của bốn số nguyên trong mảng.
`` `Python
Def Four_sum (Nums, Target):
"" "
Tìm tất cả bốn số nguyên trong mảng tổng hợp cho một mục tiêu nhất định.
Thông số:
Nums: Một mảng số nguyên.
Mục tiêu: Tổng mục tiêu.
Trả lại:
Một danh sách của tất cả bốn bộ phận tổng hợp cho mục tiêu.
"" "
Kết quả = []
Đối với I trong phạm vi (Len (nums)):
Đối với J trong phạm vi (i + 1, len (nums)):
Đối với k trong phạm vi (j + 1, len (nums)):
Đối với l trong phạm vi (k + 1, len (nums)):
Nếu nums + nums [j] + nums [k] + nums [l] == Target:
results.append ((nums , nums [j], nums [k], nums [l])))
Kết quả trả lại
`` `
## Giải pháp tối ưu hóa
Giải pháp vũ phu không hiệu quả lắm, vì nó có độ phức tạp về thời gian của O (n^4).Chúng ta có thể cải thiện hiệu quả của giải pháp bằng cách sử dụng bảng băm.
Ý tưởng là sử dụng bảng băm để lưu trữ tất cả hai phần trong mảng.Khi chúng ta có hai tổng, chúng ta có thể lặp đi lặp lại thông qua chúng và tìm thấy tất cả các bộ ba tổng hợp cho mục tiêu.
Độ phức tạp về thời gian của giải pháp này là O (n^2), đây là một sự cải thiện đáng kể so với giải pháp lực lượng vũ phu.
`` `Python
Def Four_sum (Nums, Target):
"" "
Tìm tất cả bốn số nguyên trong mảng tổng hợp cho một mục tiêu nhất định.
Thông số:
Nums: Một mảng số nguyên.
Mục tiêu: Tổng mục tiêu.
Trả lại:
Một danh sách của tất cả bốn bộ phận tổng hợp cho mục tiêu.
"" "
Kết quả = []
nums.sort ()
# Tạo bảng băm để lưu trữ tất cả hai phần trong mảng.
Two_sums = {}
Đối với I trong phạm vi (Len (nums)):
Đối với J trong phạm vi (i + 1, len (nums)):
hai_sum = nums + nums [j]
Nếu hai_sum trong Two_sums:
results.append ((hai_sums [hai_sum] [0], hai_sums [hai_sum] [1], nums , nums [j]))
khác:
Two_sums [Two_sum] = (i, j)
# Lặp lại thông qua hai phần và tìm thấy tất cả các bộ ba tổng hợp cho mục tiêu.
Đối với I trong phạm vi (Len (nums)):
Đối với J trong phạm vi (i + 1, len (nums)):
Đối với k trong phạm vi (j + 1, len (nums)):
target_sum = target - nums - nums [j] -
=======================================
#4sum #LeetCode #Python #Array #AlGorithM
**4 Sum in Leetcode with Python**
The 4 sum problem is a classic problem in computer science. Given an array of integers, find all four integers in the array that sum to a given target. The problem is not as simple as it seems, and there are a number of different ways to solve it. In this article, we will show you how to solve the 4 sum problem using Python.
## Brute Force Solution
The simplest solution to the 4 sum problem is to simply iterate through all possible combinations of four integers in the array. For each combination, we check if the sum of the four integers is equal to the target. If it is, we add the combination to our answer.
The time complexity of this solution is O(n^4), where n is the length of the array. This is because we need to iterate through all possible combinations of four integers in the array.
```python
def four_sum(nums, target):
"""
Finds all four integers in the array that sum to a given target.
Parameters:
nums: An array of integers.
target: The target sum.
Returns:
A list of all four-tuples that sum to the target.
"""
results = []
for i in range(len(nums)):
for j in range(i + 1, len(nums)):
for k in range(j + 1, len(nums)):
for l in range(k + 1, len(nums)):
if nums + nums[j] + nums[k] + nums[l] == target:
results.append((nums, nums[j], nums[k], nums[l]))
return results
```
## Optimized Solution
The brute force solution is not very efficient, as it has a time complexity of O(n^4). We can improve the efficiency of the solution by using a hash table.
The idea is to use a hash table to store all of the two-sums in the array. Once we have the two-sums, we can iterate through them and find all of the four-tuples that sum to the target.
The time complexity of this solution is O(n^2), which is a significant improvement over the brute force solution.
```python
def four_sum(nums, target):
"""
Finds all four integers in the array that sum to a given target.
Parameters:
nums: An array of integers.
target: The target sum.
Returns:
A list of all four-tuples that sum to the target.
"""
results = []
nums.sort()
# Create a hash table to store all of the two-sums in the array.
two_sums = {}
for i in range(len(nums)):
for j in range(i + 1, len(nums)):
two_sum = nums + nums[j]
if two_sum in two_sums:
results.append((two_sums[two_sum][0], two_sums[two_sum][1], nums, nums[j]))
else:
two_sums[two_sum] = (i, j)
# Iterate through the two-sums and find all of the four-tuples that sum to the target.
for i in range(len(nums)):
for j in range(i + 1, len(nums)):
for k in range(j + 1, len(nums)):
target_sum = target - nums - nums[j] -
