victory的博客

长安一片月,万户捣衣声

0%

268.丢失的数字

题目描述

给定一个包含 [0, n] 中 n 个数的数组 nums ,找出 [0, n] 这个范围内没有出现在数组中的那个数。

示例 1:
输入:nums = [3,0,1]
输出:2
解释:n = 3,因为有 3 个数字,所以所有的数字都在范围 [0,3] 内。2 是丢失的数字,因为它没有出现在 nums 中。

示例 2:
输入:nums = [0,1]
输出:2
解释:n = 2,因为有 2 个数字,所以所有的数字都在范围 [0,2] 内。2 是丢失的数字,因为它没有出现在 nums 中。

题目链接

思路

  1. 一次遍历
    遍历0~n的数字,如果不在nums数组中,则将其返回。
  2. 排序
    将数组排序之后,即可根据数组中每个下标处的元素是否和下标相等,得到丢失的数字。
    注:如果长度为n的数组(下标为0~n-1)元素与下标都相等,则丢失元素为n
  3. 位运算
    数组 nums 中有 n 个数,在这 n 个数的后面添加从 0 到 n 的每个整数,则添加了 n+1 个整数,共有 2n+1 个整数。
    在 2n+1 个整数中,丢失的数字只在后面 n+1 个整数中出现一次,其余的数字在前面 n 个整数中(即数组中)和后面 n+1 个整数中各出现一次,即其余的数字都出现了两次。
    根据出现的次数的奇偶性,可以使用按位异或运算得到丢失的数字。按位异或运算^满足交换律和结合律,且对任意整数 x 都满足 x^x=0 和 x^0=x。
    由于上述 2n+1 个整数中,丢失的数字出现了一次,其余的数字都出现了两次,因此对上述 2n+1 个整数进行按位异或运算,结果即为丢失的数字。
  4. 数学
    丢失的数字 = 0~n的和 - nums数组的和

    代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    class Solution(object):
    def missingNumber(self, nums):
    """
    一次遍历

    遍历0~n,如果数字不在nums中,就将它返回
    :type nums: List[int]
    :rtype: int
    """
    for i in range(len(nums) + 1):
    if i not in nums:
    return i

    def missingNumber1(self, nums):
    """
    将数组排序之后,即可根据数组中每个下标处的元素是否和下标相等,得到丢失的数字。

    注:如果长度为n的数组(下标为0~n-1)元素与下标都相等,则丢失元素为n
    """
    nums.sort()

    for i, num in enumerate(nums):
    if i != num:
    return i

    return len(nums)

    def missingNumber2(self, nums):
    """
    位运算
    """
    xor = 0

    for i, num in enumerate(nums):
    xor ^= i ^ num

    return xor ^ len(nums)

    def missingNumber3(self, nums):
    """
    数学运算
    """
    n = len(nums)

    total = (n*(n+1)) // 2
    nums_sum = sum(nums)

    return total - nums_sum


    if __name__ == "__main__":
    slt = Solution()
    nums = [3, 0, 1]
    # missing_number = slt.missingNumber(nums)
    # missing_number = slt.missingNumber1(nums)
    # missing_number = slt.missingNumber2(nums)
    missing_number = slt.missingNumber3(nums)
    print(missing_number)

文件操作

由于我在之前上传的博客文件(markdown文件)中使用了缩进表示代码块,这中方式显示的代码块不够美观,最近发现可以使用

来表示python代码块,以这种方式表示的代码块非常美观。但是我的博客中可能有上百篇需要去修改,因此考虑使用python自动化修改,这个过程需要使用文件操作方面的知识,因此又将python文件操作相关知识又练习了一遍,然后再抽出时间去修改博客文件代码块的表示方式。

注意: 在打开文件时,当mode选择’w+’,’a+’,’ab+’,’wb+’时,虽然官方文档说明这几种模式为可读可写,但是在使用这几种模式读文件时,读出内容为空,原因见以上示例中。

阅读全文 »

228.汇总区间

题目描述

给定一个 无重复元素 的 有序 整数数组 nums 。
返回数组中的连续区间范围列表。
列表中的每个区间范围 [a,b] 应该按如下格式输出:
“a->b” ,如果 a != b
“a” ,如果 a == b

示例 1:

1
2
3
4
5
6
输入:nums = [0,1,2,4,5,7]
输出:["0->2","4->5","7"]
解释:区间范围是:
[0,2] --> "0->2"
[4,5] --> "4->5"
[7,7] --> "7"

题目链接

思路

  1. 一次遍历
    我们从数组的位置 0 出发,向右遍历。每次遇到相邻元素之间的差值大于 1 时,我们就找到了一个区间。遍历完数组之后,就能得到一系列的区间的列表。
    在遍历过程中,维护下标 low 和 high 分别记录区间的起点和终点,对于任何区间都有 low≤high。当得到一个区间时,根据 low 和 high 的值生成区间的字符串表示。
    (1)当 low<high 时,区间的字符串表示为 “low→high”;
    (2)当 low=high 时,区间的字符串表示为 “low”。

    代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    class Solution(object):
    def summaryRanges(self, nums):
    """
    :type nums: List[int]
    :rtype: List[str]
    """
    if not nums:
    return []
    result = []
    temp_list = [nums[0]]
    for i in range(1, len(nums)):
    if nums[i] == nums[i - 1] + 1:
    temp_list.append(nums[i])
    else:
    if temp_list[0] == temp_list[-1]:
    result.append(str(temp_list[0]))
    else:
    result.append(str(temp_list[0]) + "->" + str(temp_list[-1]))
    temp_list = list()
    temp_list.append(nums[i])
    if temp_list:
    if temp_list[0] == temp_list[-1]:
    result.append(str(temp_list[0]))
    else:
    result.append(str(temp_list[0]) + "->" + str(temp_list[-1]))
    return result

    def summaryRanges1(self, nums):
    result = []
    i = 0
    n = len(nums)
    while i < n:
    low = i
    i += 1
    while i < n and nums[i] == nums[i - 1] + 1:
    i += 1
    high = i - 1
    temp = str(nums[low])
    if low < high:
    temp += "->"
    temp += str(nums[high])
    result.append(temp)
    return result

    if __name__ == "__main__":
    slt = Solution()
    nums = [0, 1, 2, 4, 5, 7]
    # nums = [0, 2, 3, 4, 6, 8, 9]
    # nums = []
    # result = slt.summaryRanges(nums)
    result = slt.summaryRanges1(nums)
    print(result)

219.存在重复元素2

题目描述

给你一个整数数组 nums 和一个整数 k ,判断数组中是否存在两个 不同的索引 i 和 j ,满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在,返回 true ;否则,返回 false 。

示例 1:
输入:nums = [1,2,3,1], k = 3
输出:true

示例 2:
输入:nums = [1,0,1,1], k = 1
输出:true

示例 3:
输入:nums = [1,2,3,1,2,3], k = 2
输出:false

题目链接

思路

  1. 哈希表
    使用哈希表存储每一个元素的最大下表,在遍历元素的过程中,如果该元素已存在于哈希表中,则判断该元素当前下标减去该元素的最大下标,如果差值小于k,则返回True;
    如果遍历过程中没有找到为相等元素且下标之差小于k的情况,则返回False。
  2. 滑动窗口
    数组 nums 中的每个长度不超过 k+1 的滑动窗口,同一个滑动窗口中的任意两个下标差的绝对值不超过 k。如果存在一个滑动窗口,其中有重复元素,则存在两个不同的下标 i 和 j 满足 nums[i]=nums[j] 且 ∣i−j∣≤k。如果所有滑动窗口中都没有重复元素,则不存在符合要求的下标。因此,只要遍历每个滑动窗口,判断滑动窗口中是否有重复元素即可。

    代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    class Solution(object):
    def containsNearbyDuplicate(self, nums, k):
    """
    超出时间限制
    :type nums: List[int]
    :type k: int
    :rtype: bool
    """
    dict1 = dict()
    for i in range(len(nums)):
    if nums[i] not in dict1.keys():
    dict1[nums[i]] = [i]
    else:
    dict1[nums[i]].append(i)

    for key in dict1.keys():
    for i in range(len(dict1[key])):
    for j in range(i+1, len(dict1[key])):
    if abs(dict1[key][i]-dict1[key][j]) <= k:
    return True
    else:
    return False

    def containsNearbyDuplicate1(self, nums, k):
    """超出时间限制"""
    i = 0
    while i < len(nums)-1:
    j = i + 1
    while j < len(nums):
    if nums[i] == nums[j] and abs(i-j) <= k:
    return True
    j += 1
    i += 1
    return False

    def containsNearbyDuplicate2(self, nums, k):
    """哈希表"""
    pos = {}
    for i, num in enumerate(nums):
    if num in pos and i - pos[num] <= k:
    return True
    pos[num] = i
    return False

    def containsNearbyDuplicate3(self, nums, k):
    """集合"""
    s = set()
    for i, num in enumerate(nums):
    if i > k:
    s.remove(nums[i - k - 1])
    if num in s:
    return True
    s.add(num)
    return False


    if __name__ == "__main__":
    slt = Solution()
    # print(slt.containsNearbyDuplicate1([1, 2, 3, 1], 3))
    # print(slt.containsNearbyDuplicate1([1, 0, 1, 1], 1))
    # print(slt.containsNearbyDuplicate1([1, 2, 3, 1, 2, 3], 2))
    # print(slt.containsNearbyDuplicate1([99, 99], 2))

    print(slt.containsNearbyDuplicate2([1, 2, 3, 1], 3))
    print(slt.containsNearbyDuplicate2([1, 0, 1, 1], 1))
    print(slt.containsNearbyDuplicate2([1, 2, 3, 1, 2, 3], 2))
    print(slt.containsNearbyDuplicate2([99, 99], 2))

217.存在重复元素

题目描述

给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ,返回 true ;如果数组中每个元素互不相同,返回 false 。

示例 1:
输入:nums = [1,2,3,1]
输出:true

示例 2:
输入:nums = [1,2,3,4]
输出:false

题目链接

思路

  1. 遍历并统计
    遍历数组中的每一个数并统计这个数在数组中出现的次数,如果出现次数大于等于2,则返回True,
    ,如果正常结束,既遍历途中没有返回,则返回False
    注:超出时间限制!!!
  2. 集合
  3. 1 使用集合对nums数组进行去重,如果去重后的集合长度不等于数组的长度,则返回True,否则返回False
  4. 2 对于数组中每个元素,我们将它插入到集合中。如果插入一个元素时发现该元素已经存在于集合中,则说明存在重复的元素。
  5. 排序
    在对数字从小到大排序之后,数组的重复元素一定出现在相邻位置中。因此,我们可以扫描已排序的数组,每次判断相邻的两个元素是否相等,如果相等则说明存在重复的元素。

    代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    class Solution(object):
    def containsDuplicate(self, nums):
    """
    遍历并统计
    遍历数组中的每一个数并统计这个数在数组中出现的次数,如果出现次数大于等于2,则返回True,
    ,如果正常结束,既遍历途中没有返回,则返回False

    超出时间限制
    :type nums: List[int]
    :rtype: bool
    """
    for num in nums:
    if nums.count(num) >= 2:
    return True
    else:
    return False

    def containsDuplicate1(self, nums):
    """
    集合
    使用集合对nums数组进行去重,如果去重后的集合长度不等于数组的长度,则返回True,否则返回False
    """
    return len(set(nums)) != len(nums)

    def containsDuplicate2(self, nums):
    """
    排序
    在对数字从小到大排序之后,数组的重复元素一定出现在相邻位置中。因此,我们可以扫描已排序的数组,每次判断相邻的两个元素是否相等,如果相等则说明存在重复的元素。
    """
    nums.sort()
    for i in range(len(nums)-1):
    if nums[i] == nums[i+1]:
    return True
    else:
    return False

    def containsDuplicate3(self, nums):
    """
    集合
    对于数组中每个元素,我们将它插入到集合中。如果插入一个元素时发现该元素已经存在于集合中,则说明存在重复的元素。
    """
    hash_table = set()
    for num in nums:
    if num not in hash_table:
    hash_table.add(num)
    else:
    return True
    else:
    return False

    if __name__ == "__main__":
    slt = Solution()
    # result = slt.containsDuplicate([1, 2, 3, 1])
    # result = slt.containsDuplicate1([1, 2, 3, 1])
    # result = slt.containsDuplicate2([1, 2, 3, 1])
    result = slt.containsDuplicate3([1, 2, 3, 1])
    print(result)

88.合并两个有序数组

题目描述

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2,另有两个整数 m 和 n ,分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中,使合并后的数组同样按 非递减顺序 排列。
注意:最终,合并后数组不应由函数返回,而是存储在数组 nums1 中。为了应对这种情况,nums1 的初始长度为 m + n,其中前 m 个元素表示应合并的元素,后 n 个元素为 0 ,应忽略。nums2 的长度为 n 。

示例 1:
输入:nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出:[1,2,2,3,5,6]
解释:需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ,其中斜体加粗标注的为 nums1 中的元素。

题目链接

思路

  1. 归并
    设置两个指针i,j,从头开始遍历两个数组,哪个指针指向位置的元素较小则加入结果列表中,该指针后移,…,依次类推。
    如果两个数组长度不一样,循环结束后,需要将长度较长的数组剩余元素加入结果列表。
  2. 双指针
    由于题目所给数组均有序,因此可以设置两个指针分别指向两个数组第一个元素,判断两个指针指向位置的元素大小,每次将较小的加入结果列表中。
    如果某一个数组先遍历结束,后续只需要遍历另一个数组的剩余元素并将其加入结果列表中。
  3. 先将数组nums2放进数组nums1的尾部,然后直接对整个数组进行排序
  4. 逆向双指针
    对双指针法进行改进,从后往前遍历数组,每次将较大元素放入结果列表中。
    在双指针法中,我们需要创建长度为m+n的新数组保存结果,因为如果直接在nums1上保存,会覆盖nums1的元素。
    与双指针方法不同的是,该方法可以原地地在nums1上保存结果(从后往前放入元素不会产生覆盖)。

    代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    class Solution(object):
    def merge(self, nums1, m, nums2, n):
    """
    归并
    :type nums1: List[int]
    :type m: int
    :type nums2: List[int]
    :type n: int
    :rtype: None Do not return anything, modify nums1 in-place instead.
    """
    i = 0
    j = 0
    result = []
    while i < m and j < n:
    if nums1[i] < nums2[j]:
    result.append(nums1[i])
    i += 1
    elif nums1[i] >= nums2[j]:
    result.append(nums2[j])
    j += 1

    if m - i != 0:
    for k in range(m - (m - i), m):
    result.append(nums1[k])
    if n - j != 0:
    for p in range(n - (n - j), n):
    result.append(nums2[p])

    nums1[:] = result

    def merge1(self, nums1, m, nums2, n):
    # 先将数组nums2放进数组nums1的尾部,然后直接对整个数组进行排序
    nums1[m:] = nums2
    quick_sort(nums1, 0, len(nums1) - 1)

    def merge2(self, nums1, m, nums2, n):
    sorted = []
    p1, p2 = 0, 0
    while p1 < m or p2 < n:
    if p1 == m:
    sorted.append(nums2[p2])
    p2 += 1
    elif p2 == n:
    sorted.append(nums1[p1])
    p1 += 1
    elif nums1[p1] < nums2[p2]:
    sorted.append(nums1[p1])
    p1 += 1
    else:
    sorted.append(nums2[p2])
    p2 += 1
    nums1[:] = sorted

    def merge3(self, nums1, m, nums2, n):
    """逆向双指针"""
    p1, p2 = m - 1, n - 1
    tail = m + n - 1
    while p1 >= 0 or p2 >= 0:
    if p1 == -1: # 如果nums1数组已经遍历完毕,遍历nums2中的剩余元素
    nums1[tail] = nums2[p2]
    p2 -= 1
    elif p2 == -1: # 如果nums2数组已经遍历完毕,遍历nums1中的剩余元素
    nums1[tail] = nums1[p1]
    p1 -= 1
    elif nums1[p1] > nums2[p2]:
    nums1[tail] = nums1[p1]
    p1 -= 1
    else:
    nums1[tail] = nums2[p2]
    p2 -= 1

    tail -= 1


    def quick_sort(arr, low, high):
    """快速排序"""
    if low < high:
    pivot = partition(arr, low, high)
    quick_sort(arr, low, pivot - 1)
    quick_sort(arr, pivot + 1, high)


    def partition(arr, low, high):
    pivot_key = arr[low]
    while low < high:
    while low < high and arr[high] >= pivot_key:
    high -= 1
    arr[low], arr[high] = arr[high], arr[low]
    while low < high and arr[low] <= pivot_key:
    low += 1
    arr[low], arr[high] = arr[high], arr[low]
    return low


    if __name__ == "__main__":
    slt = Solution()
    nums1 = [1, 2, 3, 0, 0, 0]
    nums2 = [2, 5, 6]
    # slt.merge(nums1, 3, nums2, 3)
    # slt.merge1(nums1, 3, nums2, 3)
    # slt.merge2(nums1, 3, nums2, 3)
    slt.merge3(nums1, 3, nums2, 3)
    print(nums1)

66.加一

题目描述

给定一个由 整数 组成的 非空 数组所表示的非负整数,在该数的基础上加一。
最高位数字存放在数组的首位, 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外,这个整数不会以零开头。

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

题目链接

思路

  1. 从后往前找第一个不为9的元素,并将该位置后的9置零
  2. 将数组转化为数字加一再将结果转化为整数数组

    代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    class Solution(object):
    def plusOne(self, digits):
    """
    从后往前找第一个不为9的元素,并将该位置后的9置零
    :type digits: List[int]
    :rtype: List[int]
    """
    n = len(digits)
    for i in range(n - 1, -1, -1):
    if digits[i] != 9:
    digits[i] += 1
    for j in range(i + 1, n):
    digits[j] = 0
    return digits
    return [1] + [0] * n

    def plusOne1(self, digits):
    """将数组转化为数字加一再将结果转化为整数数组"""
    num = ""
    for digit in digits:
    num += str(digit)
    return list([int(ch) for ch in str(int(num) + 1)])


    if __name__ == "__main__":
    slt = Solution()
    # result = slt.plusOne([1, 2, 3])
    result = slt.plusOne1([1, 2, 3])
    print(result)

35.搜索插入位置

题目描述

给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。如果目标值不存在于数组中,返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。

示例 1:
输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:
输入: nums = [1,3,5,6], target = 2
输出: 1

题目链接

思路

  1. 利用二分查找目标值,如果存在,返回其索引,如果不存在,寻找插入位置。
    (1)二分查找找到目标值,时间复杂度为O(log n)
    (2)二分查找没找到目标值,时间复杂度为O(log n) + O(n)
    因此,该方法会时间复杂度不符合题意。
  2. 根据题意,找到大于等于目标值的位置,该位置即为插入位置/目标值的位置。
    该方法需要遍历数组,因此时间复杂度为O(n),不符合题意。
  3. 二分查找变形

    代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    class Solution(object):
    def searchInsert(self, nums, target):
    """
    利用二分查找目标值,如果存在,返回其索引,如果不存在,寻找插入位置。
    (1)二分查找找到目标值,时间复杂度为O(log n)
    (2)二分查找没找到目标值,时间复杂度为O(log n) + O(n)
    :type nums: List[int]
    :type target: int
    :rtype: int
    """
    index = self.binarySearch(nums, 0, len(nums), target)
    if index != -1:
    return index
    else:
    return self.findBigger(nums, target)

    def binarySearch(self, arr, low, high, key):
    if low <= high:
    mid = (low + high) // 2
    if arr[mid] == key:
    return mid
    elif arr[mid] > key:
    return self.binarySearch(arr, low, mid - 1, key)
    elif arr[mid] < key:
    return self.binarySearch(arr, mid + 1, high, key)
    return -1

    def findBigger(self, arr, num):
    if num < arr[0]:
    return 0
    if num > arr[len(arr) - 1]:
    return len(arr)
    for i in range(len(arr)):
    if arr[i] < num:
    continue
    else:
    break
    return i

    def searchInsert1(self, nums, target):
    """
    找到大于等于目标值的位置,该位置即为插入位置/目标值的位置。
    :type nums: List[int]
    :type target: int
    :rtype: int
    """
    if target < nums[0]:
    return 0
    if target > nums[len(nums) - 1]:
    return len(nums)

    for i in range(len(nums)):
    if nums[i] >= target:
    return i
    elif nums[i] < target:
    continue
    return i

    def searchInsert2(self, nums, target):
    """searchInsert1的简化版"""
    if target > nums[len(nums) - 1]:
    return len(nums)

    for i in range(len(nums)):
    if nums[i] < target:
    continue
    else:
    break
    return i

    def searchInsert3(self, nums, target):
    """
    二分查找变形
    不断用二分法逼近查找第一个大于等于 target的下标
    """
    l = 0
    r = len(nums) - 1
    while l <= r:
    mid = l + (r - l) // 2
    if nums[mid] < target:
    l = mid + 1
    else:
    r = mid - 1
    return l


    if __name__ == "__main__":
    slt = Solution()
    # result = slt.searchInsert([1, 3, 5, 6], 7)
    # result = slt.searchInsert1([1, 3, 5, 6], 7)
    # result = slt.searchInsert2([1, 3, 5, 6], 7)
    result = slt.searchInsert3([1, 3, 5, 6], 7)
    print(result)

7.21开发测试面经

  • sql语句

    表结构

    ​ 表名:student
    ​ 字段:id name score

    问题:成绩倒数第二/正数第二的学生名字

    SELECT student.name, student.scores FROM student ORDER BY scores DESC LIMIT 1, 1

    SELECT student.name, student.scores FROM student ORDER BY scores ASC LIMIT 1, 1

  • 内外连接

    SELECT student.name, student.scores, class.id FROM student INNER JOIN class ON student.classid = class.id

    SELECT student.name, student.scores, class.id FROM student LEFT JOIN class ON student.classid = class.id

    SELECT student.name, student.scores, class.id FROM student RIGHT JOIN class ON student.classid = class.id

  • selenium定位元素

    1
    2
    3
    4
    5
    6
    7
    8
    driver.find_element_by_xpath()
    driver.find_element_by_name()
    driver.find_element_by_tag_name()
    driver.find_element_by_link_text()
    driver.find_element_by_partial_link_text()
    driver.find_element_by_class_name()
    driver.find_element_by_css_selector()
    driver.find_element_by_id()
  • tcp三次握手?握手的时候怎么确认对方的身份?

  • TCP四次挥手

  • 网络七层模型及各层常见协议
    在这里插入图片描述

  • 算法

    • 两数之和

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      class Solution(object):

      def twoSum(self, nums, target):

      hashtable = dict()
      for i,num in enumerate(nums):
      if target - num in hashtable:
      return [hashtable[target-num], i]
      hashtable[nums[i]] = i
      return []
    • 实现LRU
      LRU