二刷 leetcode (2)

136. 只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1

示例 2:

输入: [4,1,2,1,2]
输出: 4

代码如下：

class Solution5:
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        #### the first method, 利用python集合的特性Counter()函数
        # from collections import Counter
        # c = Counter(nums)
        # c1 = sorted(c.items(), key = lambda x: x[1], reverse=False)
        # # print(c1[0][0])
        # return c1[0][0]

        #### the second method, 运用了 位运算符，异或运算符 ^ ……
        res = 0
        for num in nums:
            res = res ^ num
            print(res)
        return res

s = Solution5()
print(s.singleNumber([2,2,1,1,3]))

350. 两个数组的交集 II

给定两个数组，写一个方法来计算它们的交集。

例如:
给定 nums1 = [1, 2, 2, 1], nums2 = [2, 2], 返回 [2, 2].

注意：

•    输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
•    我们可以不考虑输出结果的顺序。

跟进:

• 如果给定的数组已经排好序呢？你将如何优化你的算法？
• 如果 nums1 的大小比 nums2 小很多，哪种方法更优？
• 如果nums2的元素存储在磁盘上，内存是有限的，你不能一次加载所有的元素到内存中，你该怎么办？

代码：

class Solution:
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        
        #### the first method
        # dict_nums,res = {},[]
        # for num in nums1:
        #     dict_nums[num] = dict_nums.get(num, 0) + 1
        # for num in nums2:
        #     if num in nums1 and dict_nums[num]:
        #         res.append(num)
        #         dict_nums[num] -= 1
        # return res
        
        #### the second method， 运用python collections.Counter()的特性
        from collections import Counter
        nums1 = Counter(nums1)
        nums2 = Counter(nums2)
        # print((nums1 and nums2).elements())
        return list((nums1 & nums2).elements())
    
        ####  the third method 
        nums1.sort()
        nums2.sort()
        idx1 = 0
        idx2 = 0
        while idx1 < len(nums1) and idx2 < len(nums2):
            different = nums1[idx1] - nums2[idx2]
            if different == 0:
                res.append(nums1[idx1])
                idx1 += 1
                idx2 += 1
            elif different < 0:
                idx1 += 1
            else:
                idx2 += 1
        return res
                

66. 加一

给定一个非负整数组成的非空数组，在该数的基础上加一，返回一个新的数组。

最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。

示例 2:

输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。

代码如下，几种方法：

class Solution1(object):
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        #### the first method
        # if len(digits) == 0:
        #     return [1]
        # elif digits[-1] == 9:
        #     digits = self.plusOne(digits[:-1])
        #     digits.extend(0)
        # else:
        #     digits[-1] += 1
        # return digits

        #### the second method
        # carry = 1
        # for i in range(len(digits) -1, -1, -1):
        #     if digits[i] + carry == 10:
        #         digits[i] = 0
        #         carry = 1
        #     else:
        #         digits[i] += carry
        #         carry = 0
        # if carry == 1:
        #     digits.insert(0,1)
        # return  digits

        #### 最优解答方法，是利用str 和 int 类型的转换
        # sum = 0
        # res = []
        # for num in digits:
        #     sum = 10 * sum + num
        # sum += 1
        # for i in str(sum):
        #     res.append(int(i))
        # return res

        #### 最优解法使用递归

        def indexPlusOne(lists, index):
            if index == -1:
                lists.insert(0, 1)
            elif lists[index] == 9:
                lists[index] = 0
                indexPlusOne(lists, index - 1)
            else:
                lists[index] += 1

        indexPlusOne(digits, len(digits) - 1)
        return digits