【力扣0001】两数之和（python3+golang）

由于刚上研事不多且想到以后的就业方向，决定来刷一下Leetcode，由于最近在练习python于是就索性逼着自己用python写，导致飘红一片........

---

题干：

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

---

分析：

刚开始想用两个for直接暴力，结果在28/29个数据上时间超限了，果断放弃

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        l=len(nums)
        for n1 in range(0,l):
            for n2 in range(n1+1,l):
                if nums[n1]+nums[n2]==target:
                    return [n1,n2]

后来想用把target分解成a+b的方式进行遍历，没想到输入还有负数，于是在[-3,4,3,9] 0这种数据上WA了.....

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(0,int(target/2)+1):
            if (i in nums)&(target-i in nums):      
                l=len(nums)
                flag1=False
                flag2=False
                for n in range(0,l):
                    if (nums[n]==i)&(flag1==False):
                        x=n
                        flag1=True
                    elif (nums[n]==target-i)&(flag2==False):
                        y=n
                        flag2=True
                    if(flag1==True)&(flag2==True):
                        return [x,y]

输入：
[-3,4,3,90]
0
输出：
[]
预期：
[0,2]

---

代码：

最后果断选择在nums[n]存在的情况下，判断target-nums[n]是否在非nums[n]的情况下存在，再进行输出二者的坐标，否则继续遍历。通过了！

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:   
                l=len(nums)
                for n in range(0,l):
                    t=target-nums[n]
                    if t in nums[n+1:]:
                        x=nums.index(nums[n])
                        for i in range(n+1,l):
                            if t==nums[i]:
                                y=i;
                                return [x,y]

执行用时840ms，

---

当然，还有更高效的算法

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:   
                hashmap={}
                for ind,num in enumerate(nums):
                    hashmap[num] = ind
                for i,num in enumerate(nums):
                    j = hashmap.get(target - num)
                    if j is not None and i!=j:
                        return [i,j]

运行时间：64ms

时间20ms：

class Solution:
    def twoSum(self, nums: list[int], target: int) -> list[int]:
        hashtalbe={}
        for i,num in enumerate(nums):
            if target-num in hashtalbe:
                return [hashtalbe[target-num],i]
                break
            hashtalbe[nums[i]]=i

go语言版本：

func twoSum(nums []int, target int) []int {
    for i:=0 ;i<len(nums);i++{
        x:=target-nums[i]
        for j:=i+1;j<len(nums);j++{
            if nums[j]==x{
                return []int{i,j}
            }
        }
    }
    return []int{-1,-1}
}