Python LeetCode上的二和

我想问一个LeetCode问题：

给定一个整数数组，找出两个数字，使它们相加为 特定的目标号码

函数twoSum应该返回两个数字的索引，以便 它们加起来就是目标，其中index1必须小于index2。 请注意，您返回的答案（index1和index2）为 不是零基的

您可以假设每个输入都有一个解决方案

输入：numbers={2,7,11,15}，target=9输出：index1=1，index2=2

第一次尝试是使用两个for循环，这给了我O（n^2），不幸的是它没有通过。因此，我尝试使用：

target - current = index

并搜索字典上是否存在索引

这是我的代码：

class Solution:
    def twoSum(self, nums, target):
        dic = {}

        #A number can appear twice inside the same index, so I use a list
        for i in xrange(0, len(nums)):
            try:
                dic[nums[i]].append(i)
            except:
                dic[nums[i]] = []
                dic[nums[i]].append(i)

        try:
            for items_1 in dic[nums[i]]:
                for items_2 in dic[target-nums[i]]:
                    if(items_1+1 != items_2+1):
                        l = []
                        if(items_2+1 > items_1+1):
                            l.append(items_1+1)
                            l.append(items_2+1)
                        else:
                            l.append(items_2+1)
                            l.append(items_1+1)
                        return l
        except:
            pass

我在本地开发了它，并且我能够通过LeetCode抱怨的一个测试用例得到正确的结果：[-3,4,3,90]，0

我得到的输出是[1,3]，但在LeetCode上它返回null，有人知道为什么会发生这种情况吗

def twosum(nums=(6, 7, 11, 15, 3, 6, 5, 3), target=6):
    lookup = dict(((v, i) for i, v in enumerate(nums)))
    return next(( (i+1, lookup.get(target-v)+1) 
            for i, v in enumerate(nums) 
                if lookup.get(target-v, i) != i), None)

我没有对此进行过广泛的测试，但基本逻辑应该是合理的。该算法可分为两个阶段：

为NUM中的所有索引、值对创建值->索引字典。请注意，可以有多个具有不同索引的值。在这种情况下，最高索引将存储在字典中，较低索引将被覆盖。当然，这种行为是可以修改的，但我不认为这个问题需要修改，因为问题陈述的一部分是这样的：“你可以假设每个输入都有一个解决方案。”因此，每个输入都有一个唯一的输出，所以我们不必担心返回一对“错误的”索引

循环遍历num的枚举，将

i

作为索引，将

v

作为值。检查

target-v

是否是我们创建的字典中的键，同时断言该键指向的值不是

i

。如果这是真的，则返回元组

i+1，lookup.get（target-v）+1

---

你想要的东西大致如下：

#! python3

def two_sum(arr,targ):
    look_for = {}
    for n,x in enumerate(arr,1):
        try:
            return look_for[x], n
        except KeyError:
            look_for.setdefault(targ - x,n)

a = (2,7,1,15)
t = 9
print(two_sum(a,t))  # (1,2)

a = (-3,4,3,90)
t = 0
print(two_sum(a,t))  # (1,3)

在这里，您可以根据需要构建值字典。字典由您正在查找的值设置关键帧，对于每个值，您跟踪其第一次出现的索引。一旦你得到一个满足问题的值，你就完成了。只有一个for循环

唯一的其他细节是在每个索引中添加1，以满足荒谬的要求，即索引是基于1的。这将教你Python编程

---

使用setdefault函数将键添加到字典中，因为如果键已经存在，您希望保留其值（最低索引）。

我刚刚传递了以下代码。充分利用字典和注释中的信息，发现只有一种解决方案。在逐个保存查找字典中的数字时，在已保存的查找字典中搜索目标数字。当NUM中有两个相同的值时，此方法可以节省空间并防止索引覆盖

def twosum(self, nums, target):
    lookup = {}
    for cnt, num in enumerate(nums):
        if target - num in lookup:
            return lookup[target-num], cnt
        lookup[num] = cnt            

---

这个答案使用基于零的索引，因为这是索引的正常方式，而不是基于一的索引。它还使用描述性变量名，是为了理解而编写的

from typing import List, Tuple

def twosum_indices_linear(nums: List[int], target: int) -> Tuple[int, int]:
    numtoindexmap = {}
    for num1_index, num1 in enumerate(nums):
        num2 = target - num1
        try:
            num2_index = numtoindexmap[num2]
        except KeyError:
            numtoindexmap[num1] = num1_index  
            # Note: Use `numtoindexmap.setdefault(num1, num1_index)` instead for lowest num1_index.
        else:
            return tuple(sorted([num1_index, num2_index]))

示例：

print(twosum_indices_linear([2, 7, 11, 15], 9))
(0, 1)

print(twosum_indices_linear([3, 3], 6))
(0, 1)

print(twosum_indices_linear([6, 7, 11, 15, 3, 6, 5, 3], 6))
(4, 7)

信用证：

这是我的答案

class Solution:
    def twoSum(self, nums, target):
        ls = []
        for i in range(0, len(nums)):
            item = target - nums[i]
            nums[i] = "done"
            if item in nums:
                if i != nums.index(item):
                    ls.append(i)
                    ls.append(nums.index(item))
                    return ls

此解决方案具有时间效率（比leetcode上80%的解决方案快），但占用大量内存

我喜欢

    def two_sum(arr,targ):
        look_for = {}
        for n,x in enumerate(arr,1):
            try:
               return look_for[x], n
            except KeyError:
               look_for.setdefault(targ - x,n)

但由于对大型数组调用枚举花费的时间太长，timedome失败。最好跳过枚举，只保留索引计数：

def findCombo(l,target):
    lookup = {}
    n = 0
    for x in l:
        try:
            return (n,lookup[x])
        except KeyError:            
            lookup.setdefault (target-x,n)
        n = n + 1

    return None

注意：Python timedome问题使用从0开始的索引

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        r = []

        for i in range(len(nums)):
            temp = target - nums[i]
            if temp in r:
                return [i,nums.index(temp)]

            r.append(nums[i])

请在此处检查提交内容：

一次传递哈希表 这可以一次完成How Teo？当它迭代并将元素插入哈希时，它还应该回过头来检查当前元素的补码是否已经存在于哈希中。如果存在，我们已找到解决方案并立即返回

复杂性： 时间复杂度：O（n）。我们只遍历一次包含n元素的列表。每次在表中查找只需O（1）时间

空间复杂性：O（n）。所需的额外空间取决于哈希表中存储的项数，该哈希表最多存储n个元素

constnums=[2,7,11,15]；
常数目标=9；
/**
*@param{number[]}nums
*@param{number}目标
*@return{number[]}
*/
设twoSum=函数（nums，目标）{
让map=newmap；
对于（变量i=0；ilog（twoSum（nums，target））如果有人还在为这个问题寻找javascript解决方案


/**
1.二和
给定一个整数数组，返回两个数字的索引，使它们相加到一个特定的目标。
您可以假设每个输入都有一个解决方案，并且不能两次使用同一个元素。
例子：
给定nums=[2,7,11,15]，target=9，
因为nums[0]+nums[1]=2+7=9，
返回[0,1]。
* */
/**
*@param{number[]}nums
*@param{number}目标
*@return{number[]}
*/
函数twoSum（nums，target）{
const numsObjs={}；//创建nums obj，值作为键，索引作为值，例如：[2,7,11,15]=>{2:0,7:1,11:2,15:3}
for（设i=0；i控制台。日志（两个（[3，7，3]，6））< /COD> < P>这是我在C++中的答案。我希望您可以将其转换为python

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_set<int>s;
        vector<int>ans;
    int j =0;
    for(int i=0;i<nums.size();i++)
    {
        int temp = target -nums[i];
        //int tempInd = i ;
        if(s.find(temp)!=s.end()){
            //cout<<i<<" ";
             ans.push_back(i) ;
            for(int j=0;j<nums.size();j++)
            {
                if(temp == nums[j]){
                    //cout<<j<<endl;
                    ans.push_back(j) ;
                break;
                }
            }
        }
        s.insert(nums[i]);

    }
        return ans ;
    }
};

类解决方案{
公众：
向量twoSum（向量和nums，单位
nums = [2, 7, 11, 15]
target = 9
l = []
x = 1
length = len(nums) - 1
for i in nums:
    l.append(nums.index(i))
    if (target - i) in nums[x:]:
       l.append(length - nums[::-1].index(target - i))
       break
    else:
       l = []
       x = x + 1
print(l)

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_set<int>s;
        vector<int>ans;
    int j =0;
    for(int i=0;i<nums.size();i++)
    {
        int temp = target -nums[i];
        //int tempInd = i ;
        if(s.find(temp)!=s.end()){
            //cout<<i<<" ";
             ans.push_back(i) ;
            for(int j=0;j<nums.size();j++)
            {
                if(temp == nums[j]){
                    //cout<<j<<endl;
                    ans.push_back(j) ;
                break;
                }
            }
        }
        s.insert(nums[i]);

    }
        return ans ;
    }
};

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        res=[[nums.index(val),nums[ind +1:].index(target-val)+ ind +1] for ind,val in enumerate(nums) if target -val in nums[ind +1:]]
        return res[0]

def twoSum(nums: List[int], target: int) -> List[int]:
   output = []
   for i in nums:
        for j in nums:
            if i + j == target and nums.index(i) != nums.index(j):
                output.append(nums.index(i))
                output.append(nums.index(j))
                return output

print(twoSum([2,7,11,15],9))
print(twoSum([3,2,4],6))

[0, 1]
[1, 2]