leetcode1 two_sum

import numpy as np

class Solution:
    def twoSum(self, nums, target):
        # 因为只需要找唯一解, 找到一个可以直接返回, 而且元素不重复
        d = {}
        ans = []
        for i in range(len(nums)):
            tmp = target - nums[i]
            if tmp in d.keys():
                return [d[tmp], i]

            if nums[i] not in d.keys():
                d[nums[i]] = i
        return ans

    def twoSum2(self, nums, target):
        '''
        前提是排序之后的数组, 不然2指针无法奏效
        假设我们要找到全部的解, 而且不能重复(这一点导致后面添加了很多代码)
        :param i 指向第一个元素
        :param j 指向最后一个有效的元素
        :param nums:
        :param target:
        :return: 有效的下标数组  [[]]
        '''
        i, j = 0, len(nums) - 1
        ans = []

        # 为了保证不重复, 不能让i 等于 j
        while i < j:
            if nums[i] + nums[j] < target:
                i += 1
            elif nums[i] + nums[j] > target:
                j -= 1
            else:
                ans.append([i, j])
                # 越界判断, 首先要保证nums[i]后面的元素是存在的, 不然你怎么往后比较?
                while i + 1 < j and nums[i] == nums[i + 1]:
                    i += 1
                # 执行到此, 有两种情况
                # 一种是由于 i + 1 == j  也就是说要碰面了, 这时候 nums[i] 是等于nums[i+1]的，
                # 这种情况就比较特殊， i+1 要继续执行，而且后边的j -= 1 也是正常执行，导致 i > j的 循环终止
                # 一种是nums[i] != nums[i+1], 这也就是说这是连续相等的元素的最后一个了(而且我们之前已经用过了
                # ), 下一次我们要重新找一个, 所以还要 + 1 移动到下一个位置
                i += 1
                while j - 1 > i and nums[j] == nums[j - 1]:
                    j -= 1
                j -= 1
        return ans

    def twoSum3(self, nums, target):
        '''
        如果继续改条件, 给你的数组未经过排序, 而返回值仍然要的是下标, 而且是不允许重复的
        :param nums:
        :param target:
        :return:
        '''
        # 用词典记录下标的值  存在覆盖问题, 但是这个不影响我们的答案
        d = {}
        print(nums)
        for i in range(len(nums)):
            if nums[i] not in d.keys():
                d[nums[i]] = i
        print(d)
        nums.sort()
        print(nums)
        i, j = 0, len(nums) - 1
        ans = []
        # 为了保证不重复, 不能让i 等于 j
        while i < j:
            if nums[i] + nums[j] < target:
                i += 1
            elif nums[i] + nums[j] > target:
                j -= 1
            else:
                ans.append([d[nums[i]], d[nums[j]]])
                # 越界判断, 首先要保证nums[i]后面的元素是存在的, 不然你怎么往后比较?
                while i + 1 < j and nums[i] == nums[i + 1]:
                    i += 1
                # 执行到此, 有两种情况
                # 一种是由于 i + 1 == j  也就是说要碰面了, 这时候 nums[i] 是等于nums[i+1]的，
                # 这种情况就比较特殊， i+1 要继续执行，而且后边的j -= 1 也是正常执行，导致 i > j的 循环终止
                # 一种是nums[i] != nums[i+1], 这也就是说这是连续相等的元素的最后一个了(而且我们之前已经用过了
                # ), 下一次我们要重新找一个, 所以还要 + 1 移动到下一个位置
                i += 1
                while j - 1 > i and nums[j] == nums[j - 1]:
                    j -= 1
                j -= 1
        return ans


if __name__ == '__main__':
    sol = Solution()
    nums = [2, 5, 7, 7, 11, 11, 13, 15]
    # shuffle 没有返回值
    # np.random.shuffle(nums)
    # print(nums)
    nums3 = [5, 11, 13,  11, 15, 2,7, 7,]

    res = sol.twoSum3(nums3, 18)
    print(res)