leepcode语法练习

Posted 2021-11-30 williamkong94

leepcode语法练习（二）

1.存在重复

给定一个整数数组，判断是否存在重复元素。

如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。

示例 1:

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

示例 2:

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

示例 3:

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

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        dic = {}
        if len(nums) > 0:
            for i in nums:
                if i in dic:
                    dic[i] += 1
                else :
                    dic[i] = 1
            for j in dic :
                if dic[j] > 1:
                    return True
                    break
            else:
                return False
        else :
            return False

2.只出现一次的数字

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

说明：

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

 class Solution:
    def singleNumber(self, nums: List[int]) -> int:
    dic = {}
        for i in nums:
            if i in dic:
                dic[i] += 1
            else :
                dic[i] = 1
        for j in dic :
            if dic[j] == 1 :
                return j
                break

3.两个数组的交集 II

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

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]

示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]

说明：

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

进阶:

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

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        s1 =set(nums1)
        s2 =set(nums2)
        lis2 = []
        lis = list(s1 & s2)
        for i in lis :
            if nums1.count(i)  > nums2.count(i) :
                lis2.extend([i]*nums2.count(i))
            else :
                lis2.extend([i]*nums1.count(i))
        return lis2

4.加一

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

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

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

示例 1:

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

示例 2:

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

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        j = len(digits)
        for i in range(j) :
            if digits[j-1-i] < 9:
                digits[j-1-i] += 1
                break
            else :
                digits.pop(j-1-i)
                digits.insert(j-1-i,0)
                if i == j-1 :
                    digits.insert(0,1)
        return digits
                

5.移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

说明:

1. 必须在原数组上操作，不能拷贝额外的数组。
2. 尽量减少操作次数。

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        for i in nums :
            if i == 0:
                nums.remove(i)
                nums.append(i)

6. 整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321

示例 2:

输入: -123
输出: -321

示例 3:

输入: 120
输出: 21

注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [?231, 231 ? 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

class Solution:
    def reverse(self, x: int) -> int:
        lis = list(str(x))
        if lis[0] != '-' :
            lis.reverse()
            s = ''.join(lis)
            if int(s) <=  2**31 - 1:
                return int(s)
            else :
                return 0
        else :
            lis.pop(0)
            lis.reverse()
            s = ''.join(lis)
            if int(s) <=  2**31:
                return -int(s) 
            else :
                return 0