查找數組中兩個數字的總和是否等於 k

Question

我正在嘗試解決：

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:
Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

這是我的解決方案：

def twoSum(nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """

        hash_table = {}
        k = target

        for i, x in enumerate(nums):
            if x not in hash_table:
                hash_table[x] = i

        for x in nums:
            if k-x in hash_table:
                if hash_table[k-x]!= hash_table[x]:
                    return [hash_table[x], hash_table[k-x]] 

現在解決方案不正確，因為它沒有通過像 [3,3], 6 這樣的測試用例。現在兩個 3 都作為預期的一個條目存儲在哈希表中，因此哈希表中只記錄了一個索引 3 和我的解決方案不起作用。

所以，我認為解決方案可能不是哈希表。 但正確的解決方案是：

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        map.put(nums[i], i);
    }
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement) && map.get(complement) != i) {
            return new int[] { i, map.get(complement) };
        }
    }
    throw new IllegalArgumentException("No two sum solution");
}

現在，這在 Java 中基本上是相同的解決方案，並且它被稱為正確的解決方案。

所以，我的問題是：

1. 如何在 Python 中更改我的解決方案以使其正常工作而不會使測試用例失敗？
2. Java 解決方案有何不同，它的哈希表是否有其他行為？

謝謝你的幫助。

Answer 1

Java 解決方案有一個檢查兩個相等的元素：

if (map.containsKey(complement) && map.get(complement) != i)

此條件的第一部分 - map.containsKey(complement) - 表示complement存在於Map中，而第二部分 - map.get(complement) != i) - 表示complement的索引存儲在map 與索引i不同。 這意味着如果complement == nums[i] ，則輸入數組中有兩個相同的數字。

我不知道 Python，但看起來你的代碼失敗了，因為

if hash_table[k-x]!= hash_table[x]

當kx == x時總是返回 false。 您需要將hash_table[kx]與輸入數組的當前索引進行比較。

根據您的第一個 Python 循環，我假設第二個循環應如下所示：

    for i, x in enumerate(nums):
        if k-x in hash_table:
            if hash_table[k-x]!= i:
                return [i, hash_table[k-x]] 

Answer 2

為什么不使用簡單的東西：

def twoSum(nums, target):
    for i, num1 in enumerate(nums):
        for j, num2 in enumerate(nums):
            if num1 + num2 == target and i != j:
                return [i, j]
    return [-1, -1] # or whaterver you want to say "no solution found"

這會產生：

print twoSum([2, 7, 11, 15], 9)   # =>[0, 1] 2+7
print twoSum([2, 7, 11, 15], 22)  # =>[1, 3] 7+15
print twoSum([2, 7, 11, 15], 23)  # => [-1, -1]  no solution

Answer 3

作為哈希表解決方案的替代方案，您可以

• 對數組進行排序（時間O(N Log N) ），
• 維護兩個索引i ， j使得num[i] + num[j] <= sum < num[i] + num[j+1] ； 每次增加i時，都會將j減少0或更多以進行調整。 i從0開始， j從末尾開始。

更糟糕的是，對於總共O(N)次操作，您會增加i N次並減少j N次。 在平等的情況下，你就完成了。

這可以就地完成。

Answer 4

嘗試使用 JavaScript，

 let qarr = [2, 3, 5, 6, 7, 9, 21, 24, 27, 35, 50, 98] //sorted Array const qk = 85 function check_sum(arr, k){ for( i in arr){ if(arr[i]+arr[arr.length-1] === k){ return [qarr.indexOf(arr[i]), qarr.indexOf(arr[arr.length-1])] } else{ if(arr[i]+arr[arr.length-1] >= k){ if(arr.length == 2){ return arr[0]+arr[1] == k ? [qarr.indexOf(arr[0], qarr.indexOf(arr[1]))] : [null, null] } else if(arr.length == 1){ return arr[0]*2 == k ? [qarr.indexOf(arr[0]), qarr.indexOf(arr[0])] : [null, null] } else{ return check_sum(arr.slice(i), k) } } } } } res = check_sum(qarr.filter(a=> a<=qk), qk) console.log('result', res)