leetcode 初级 python

数组

•  从排序数组中删除重复项

示例：

给定 nums = [0,0,1,1,1,2,2,3,3,4],

函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0，1，2，3，4

 数组为“引用”

class Solution:
    def removeDuplicates(self, nums: 'List[int]') -> 'int':
        
        n = len(nums)
        if n == 0:
            return 0
        
        number = 0                  #number 记录最后的不一样的数的位置，即要替换的数的位置  
        for i in range(n):
            if nums[i] != nums[number]:
                number = number+1
                nums[number] = nums[i]  #将不同的数赋到 number位置上
        
        return number+1  

        

•  买卖股票的最佳时机 II

示例：

[7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

class Solution:
    def maxProfit(self, prices: 'List[int]') -> 'int':
        n=len(prices)
        if n==0:
            return 0
        
        profit = 0
        for i in range(n-1):
            if prices[i]<prices[i+1]:
                profit += prices[i+1]-prices[i]
        return profit

• 旋转数组

将数组中的元素向右移动 k 个位置

示例 1:

输入: [1,2,3,4,5,6,7]和 k = 3输出: [5,6,7,1,2,3,4]解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]

class Solution: 
    def rotate(self, nums: 'List[int]', k: 'int') -> 'None':
        """
        Do not return anything, modify nums in-place instead.
        """                
        n = len(nums)
        k = k % n               #如果担心k>n的话，加上这句
        nums[:] = nums[n-k:] + nums[:n-k]    #数组一拼就成了

• 存在重复

• 判断一个整数数组里是否存在重复元素

class Solution:
    def containsDuplicate(self, nums: 'List[int]') -> 'bool':
        
        #不能用双for，用k-v   字典
        d={}
        for i in nums:
            if i in d:
                return True
            d[i] = 1
        return False

• 只出现一次的数字

一个数组 其他元素都出现了两次，只有一个数只出现了一次，找出它

class Solution:
    def singleNumber(self, nums: 'List[int]') -> 'int':
        d={}
        for i in nums:
            if i in d:
                d[i] = 2
            else:
                d[i] = 1
        for i in d:
            if d[i]==1:
                return i

• 两个数组的交集 II

示例 :

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

class Solution:
    def intersect(self, nums1: 'List[int]', nums2: 'List[int]') -> 'List[int]':
        res = []
        d= {}
        for i in nums1:
            if i in d:
                d[i] += 1
            else:
                d[i] = 1
        for i in nums2:
            if i in d and d[i]>0:
                d[i] -= 1
                res.append(i)
        return res

• 加一

示例 :

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

class Solution:
    def plusOne(self, digits: 'List[int]') -> 'List[int]':
        n = len(digits)
        for i in range(n-1,-1,-1):
            if digits[i] != 9:
                digits[i] += 1
                return digits
            else:
                digits[i] = 0
        
        #如果到这了 就全是0嘛 
        digits.insert(0,1)  #自动顺延了？
        return digits

• 移动零

示例:

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

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

class Solution:
    def moveZeroes(self, nums: 'List[int]') -> 'None':
        """
        Do not return anything, modify nums in-place instead.
        """
        n = len(nums)
        k = 0
        for i in range(n):
            if nums[i] == 0:
                k += 1
            if nums[i] != 0:
                nums[i-k] = nums[i]
                if k>0:
                    nums[i] = 0

• 两数之和

示例:

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

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

class Solution:
    def twoSum(self, nums: 'List[int]', target: 'int') -> 'List[int]':
        n = len(nums)
        for i in range(n):
            if target-nums[i] in nums:
                j = nums.index(target-nums[i])
                if i!=j:
                    return [i,j]

• 有效的数独

判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。

1. 数字 1-9 在每一行只能出现一次。
2. 数字 1-9 在每一列只能出现一次。
3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

数独部分空格内已填入了数字，空白格用 '.' 表示

class Solution:
    def isValidSudoku(self, board: 'List[List[str]]') -> 'bool':
        #这个题让使用双重for
        
        #第i行j列  是  3*(i//3)+(j//3)  这个九宫格  
        
        dic_row = [{},{},{},{},{},{},{},{},{}]   #这一行
        dic_col = [{},{},{},{},{},{},{},{},{}]   #这一列
        dic_box = [{},{},{},{},{},{},{},{},{}]   #这一个九宫格
        
        for i in range(len(board)):
            for j in range(len(board)):
                num = board[i][j]         #当前格子里的数
                if num == '.':
                    continue
                if num not in dic_row[i] and num not in dic_col[j] and num not in dic_box[3*(i//3)+(j//3)]:
                    dic_row[i][num] = 1      #第i行的 这个数的字典 置1
                    dic_col[j][num] = 1      #第j行
                    dic_box[3*(i//3)+(j//3)][num] = 1
                else:
                    return False
        return True

•  旋转图像

给定一个 n × n 的二维矩阵表示一个图像。

将图像顺时针旋转 90 度。

说明：

你必须在原地旋转图像

示例 :

给定 matrix = 
[
  [1,2,3],
  [4,5,6],
  [7,8,9]
],

原地旋转输入矩阵，使其变为:
[
  [7,4,1],
  [8,5,2],
  [9,6,3]
]

class Solution:
    def rotate(self, matrix: 'List[List[int]]') -> 'None':
        """
        Do not return anything, modify matrix in-place instead.
        """
        #也可以用双for
        #主对角线 翻转，垂直中线 翻转， 时间复杂度 O(n^2)，空间复杂度 O(1)
        
        n = len(matrix)
        for i in range(n):
            for j in range(i+1,n):      #这里加个i+1，是因为  不用换对角线 而且减少重复操作
                temp = matrix[i][j]
                matrix[i][j] = matrix[j][i]
                matrix[j][i] = temp
                
        for i in range(n):
            #垂直中线 翻转  也就是倒序
            matrix[i] = matrix[i][::-1]