秋招刷题复习day1

今天复习字符串与数组

  

 

 第二题

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        '''
一种遍历的解法
        for i in range(len(nums)):
            if nums[i] >= target:
                return i
        return len(nums)
        '''
二分法的解法
        left, right = 0, len(nums) - 1
        while(left <= right):
            mid = (left + right)//2
            if nums[mid] == target:
                return mid
            elif nums[mid] >= target:
                right = mid-1
            elif nums[mid] <= target:
                left = mid+1
        return left

第三题：旋转矩阵

 

class Solution(object):
    def rotate(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: None Do not return anything, modify matrix in-place instead.
        """
        row = len(matrix)
        
水平翻转
        for i in range(row//2):
            for j in range(row):
                matrix[row-i-1][j],matrix[i][j] =matrix[i][j],matrix[row-i-1][j]
        镜像翻转
        for i in range(row):
            for j in range(i):
                matrix[i][j],matrix[j][i] = matrix[j][i], matrix[i][j]

第四题：零矩阵

 

class Solution(object):
    def setZeroes(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: None Do not return anything, modify matrix in-place instead.
        """
        n=len(matrix)
        m=len(matrix[0])
        row=[0]*n
        col=[0]*m


        for i in range(n):
            for j in range(m):
                if matrix[i][j]==0:
                    row[i]=1
                    col[j]=1
        
        for i in range(n):
            for j in range(m):
                if row[i]==1 or col[j]==1:
                    matrix[i][j]=0

思路：可以引入其他变量进行统计

 

zip() 函数功能：

   将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。当各个迭代器中元素的个数不一致时，则返回列表中长度最短的情况，利用 *号操作符，可以将元组解压为列表。

class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
#这是因为会按照abcd的顺序排序
        if not strs: return ""
        s1=min(strs)
        s2=max(strs)
        for i, x in enumerate(s1):
            if x!=s2[i]:
                return s2[:i]
        return s1

        #另一种解法
        res=''
        for i in (zip(*strs)):
            if len(set(i)) == 1:
                res +=i[0]
            else:
                break
        return res



  

class Solution(object):
    def reverseString(self, s):
        """
        :type s: List[str]
        :rtype: None Do not return anything, modify s in-place instead.
        """
        i,j=0,len(s)-1
        while(i<j):
            s[i],s[j]=s[j],s[i]
            i +=1
            j -=1
        return s

 落泪，第一道自己做出来的题

 

class Solution(object):
    def arrayPairSum(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        a = sorted(nums)
        b = sum(a[::2])
        return b

其实就是排序后求偶数下标之和

 双指针做的

class Solution(object):
    def twoSum(self, numbers, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
        left=0
        right=len(numbers)-1
        while(left<=right):
            sum=numbers[left]+numbers[right]
            if sum == target:
                return left+1,right+1             
            elif sum>target:
                right -=1
            elif sum< target:
                left +=1
        return -1
        


            
        
            

 

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        
        slow=0
        n=len(nums)
        for fast in range(n):
            if nums[fast]!=val:
                nums[slow]=nums[fast]
                slow +=1
        return slow