题目61：至少在两个数组中出现的值

题目名称：至少在两个数组中出现的值

题目描述：给你三个整数数组 nums1、nums2 和 nums3，请你构造并返回一个元素各不相同的数组，且数组中的每个元素都在 至少两个 数组中出现过。

• • 1 <= nums1.length, nums2.length, nums3.length <= 100。
• • 1 <= nums1[i], nums2[i], nums3[i] <= 100。

示例：

代码框架：

1
2
3
4
5
6
7
8
9
10
def two_out_of_three(nums1, nums2, nums3):    # 返回至少在两个数组中出现的不同元素列表    # 你的代码在这里    pass# 测试print(two_out_of_three([1,1,3,2], [2,3], [3]))       # 应该输出 [2,3] 或 [3,2]print(two_out_of_three([3,1], [2,3], [1,2]))          # 应该输出 [2,3,1] 或任意顺序print(two_out_of_three([1,2,2], [4,3,3], [5]))        # 应该输出 []print(two_out_of_three([1,1], [1,1], [1]))            # 应该输出 [1]

题目62：重新格式化电话号码

题目名称：重新格式化电话号码

题目描述：给你一个字符串形式的电话号码 number。number 由数字、空格 ' '、和破折号 '-' 组成。请你按下述方式重新格式化电话号码：

• • 首先，删除所有的空格和破折号。
• • 其次，将数字从左到右每 3 个一组分块，直到剩下 4 个或更少数字。剩下的数字将按下述规定再分块：
• • 2 个数字：单个含 2 个数字的块。
• • 3 个数字：单个含 3 个数字的块。
• • 4 个数字：两个分别含 2 个数字的块。

最后用破折号将这些块连接起来。注意，重新格式化过程中 不应该 生成仅含 1 个数字的块，并且 最多 生成两个含 2 个数字的块。返回格式化后的电话号码。

• • 2 <= number.length <= 100。
• • number 由数字和 '-' 或 ' ' 组成。
• • number 中至少有两个数字。

示例：

代码框架：

1
2
3
4
5
6
7
8
9
10
def reformat_number(number):    # 返回格式化后的电话号码    # 你的代码在这里    pass# 测试print(reformat_number("1-23-45 6"))    # 应该输出 "123-456"print(reformat_number("123 4-567"))    # 应该输出 "123-45-67"print(reformat_number("123 4-5678"))   # 应该输出 "123-456-78"print(reformat_number("12"))           # 应该输出 "12"

题目63：检查数组是否经排序和轮转得到

题目名称：检查数组是否经排序和轮转得到

题目描述：给你一个数组 nums。nums 的源数组中，所有元素与 nums 相同，但按非递减顺序排列。如果 nums 能够由源数组轮转若干位置（包括 0 个位置）得到，则返回 true；否则，返回 false。源数组中可能存在 重复项。注意：我们称数组 A 在轮转 x 个位置后得到长度相同的数组 B，当它们满足 B[i] == A[(i + x) % A.length]，其中 0 <= i < A.length。

• • 1 <= nums.length <= 100。
• • 1 <= nums[i] <= 100。

示例：

代码框架：

1
2
3
4
5
6
7
8
9
10
def check(nums):    # 返回 True 或 False    # 你的代码在这里    pass# 测试print(check([3,4,5,1,2]))  # 应该输出 Trueprint(check([2,1,3,4]))    # 应该输出 Falseprint(check([1,2,3]))      # 应该输出 Trueprint(check([1,1,1]))      # 应该输出 True

题目64：构造 K 个回文字符串

题目名称：构造 K 个回文字符串

题目描述：给你一个字符串 s 和一个整数 k。请你用 s 中 所有 字符构造 k 个非空回文串。如果你可以用 s 中所有字符构造 k 个回文字符串，那么请你返回 True，否则返回 False。

• • 1 <= s.length <= 10^5。
• • s 中所有字符都是小写英文字母。
• • 1 <= k <= 10^5。

示例：

代码框架：

1
2
3
4
5
6
7
8
9
10
def can_construct(s, k):    # 返回 True 或 False    # 你的代码在这里    pass# 测试print(can_construct("annabelle", 2))                     # 应该输出 Trueprint(can_construct("leetcode", 3))                      # 应该输出 Falseprint(can_construct("true", 4))                          # 应该输出 Trueprint(can_construct("yzyzyzyzyzyzyzy", 2))               # 应该输出 True

题目65：数组中的 k-diff 数对

题目名称：数组中的 k-diff 数对

题目描述：给你一个整数数组 nums 和一个整数 k，请你在数组中找出 不同的 k-diff 数对，并返回不同的 k-diff 数对 的数目。k-diff 数对定义为一个整数对 (nums[i], nums[j])，并满足下述全部条件：

• • 0 <= i, j < nums.length
• • i != j
• • |nums[i] - nums[j]| == k

注意，|val| 表示 val 的绝对值。

• • 1 <= nums.length <= 10^4。
• • -10^7 <= nums[i] <= 10^7。
• • 0 <= k <= 10^7。

示例：

代码框架：

1
2
3
4
5
6
7
8
9
10
def find_pairs(nums, k):    # 返回不同的 k-diff 数对数目    # 你的代码在这里    pass# 测试print(find_pairs([3,1,4,1,5], 2))          # 应该输出 2print(find_pairs([1,2,3,4,5], 1))          # 应该输出 4print(find_pairs([1,3,1,5,4], 0))          # 应该输出 1print(find_pairs([1,2,4,4,3,3,0,9,2,3], 3))  # 应该输出 2

题目66：统计作战单位数

题目名称：统计作战单位数

题目描述：n 名士兵站成一排。每个士兵都有一个 独一无二 的评分 rating。每 3 个士兵可以组成一个作战单位，分组规则如下：

• • 从队伍中选出下标分别为 i、j、k 的 3 名士兵，他们的评分分别为 rating[i]、rating[j]、rating[k]。
• • 作战单位需满足：rating[i] < rating[j] < rating[k] 或者 rating[i] > rating[j] > rating[k]，其中 0 <= i < j < k < n。

请你返回按上述条件可以组建的作战单位数量。每个士兵都可以是多个作战单位的一部分。

• • 3 <= n <= 1000。
• • 1 <= rating[i] <= 10^5。
• • rating 中的元素 互不相同。

示例：

代码框架：

1
2
3
4
5
6
7
8
9
10
def num_teams(rating):    # 返回可以组建的作战单位数量    # 你的代码在这里    pass# 测试print(num_teams([2,5,3,4,1]))  # 应该输出 3print(num_teams([2,1,3]))      # 应该输出 0print(num_teams([1,2,3,4]))    # 应该输出 4print(num_teams([4,3,2,1]))    # 应该输出 4

题目67：最小移动次数使数组元素相等 II

题目名称：最小移动次数使数组元素相等 II

题目描述：给你一个长度为 n 的整数数组 nums，返回使所有数组元素相等需要的最少移动次数。在一步操作中，你可以使数组中的一个元素加 1 或者减 1。

• • 1 <= nums.length <= 10^5。
• • -10^9 <= nums[i] <= 10^9。

示例：

代码框架：

1
2
3
4
5
6
7
8
9
10
def min_moves2(nums):    # 返回使所有数组元素相等的最少移动次数    # 你的代码在这里    pass# 测试print(min_moves2([1,2,3]))        # 应该输出 2print(min_moves2([1,10,2,9]))     # 应该输出 16print(min_moves2([1,0,0,8,6]))    # 应该输出 14print(min_moves2([5]))            # 应该输出 0

题目68：有效三角形的个数

题目名称：有效三角形的个数

题目描述：给定一个包含非负整数的数组 nums，返回其中可以组成三角形三条边的三元组个数。三角形两边之和大于第三边。

• • 1 <= nums.length <= 1000。
• • 0 <= nums[i] <= 1000。

示例：

注：为清晰起见，示例一改为经典 LeetCode 示例。

示例：

代码框架：

1
2
3
4
5
6
7
8
9
10
def triangle_number(nums):    # 返回可以组成三角形的三元组个数    # 你的代码在这里    pass# 测试print(triangle_number([2,2,3,4]))  # 应该输出 3print(triangle_number([4,2,3,4]))  # 应该输出 4print(triangle_number([0,0,0]))    # 应该输出 0print(triangle_number([1,1,1]))    # 应该输出 1

题目69：非重叠矩形中的随机点

题目名称：非重叠矩形中的随机点

题目描述：给定一个由非重叠的轴对齐矩形的数组 rects，其中 rects[i] = [ai, bi, xi, yi] 表示 (ai, bi) 是第 i 个矩形的左下角点，(xi, yi) 是第 i 个矩形的右上角点。设计一个算法来随机挑选一个被某一矩形覆盖的整数点。矩形周长上的点也算做是被矩形覆盖。所有满足要求的点必须等概率被返回。在给定的矩形覆盖的空间内的任何整数点都有可能被返回。请注意，整数点是具有整数坐标的点。实现 Solution 类：

• • Solution(rects)：用给定的矩形数组 rects 初始化对象。
• • pick()：返回一个随机的整数点 [u, v]，它被矩形所覆盖。
• • 1 <= rects.length <= 100。
• • rects[i].length == 4。
• • 0 <= ai < xi <= 10^9。
• • 0 <= bi < yi <= 10^9。
• • xi - ai <= 2000。
• • yi - bi <= 2000。
• • 所有的矩形不重叠。

示例：

代码框架：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import randomclass Solution:    def __init__(self, rects):        # 初始化        # 你的代码在这里        pass    def pick(self):        # 随机返回一个被矩形覆盖的整数点        # 你的代码在这里        pass# 测试sol = Solution([[-2,-2,1,1],[2,2,4,6]])print(sol.pick())  # 应该返回矩形内的随机整数点print(sol.pick())  # 应该返回矩形内的随机整数点

题目70：找到 K 个最接近的元素

题目名称：找到 K 个最接近的元素

题目描述：给定一个 排序好 的数组 arr，两个整数 k 和 x，从数组中找到最靠近 x（两数之差最小）的 k 个数。返回的结果必须要是按升序排好的。整数 a 比整数 b 更接近 x 需要满足：

• • |a - x| < |b - x| 或者
• • |a - x| == |b - x| 且 a < b
• • 1 <= k <= arr.length。
• • 1 <= arr.length <= 10^4。
• • arr 按升序排列。
• • -10^4 <= arr[i], x <= 10^4。

示例：

代码框架：

1
2
3
4
5
6
7
8
9
10
def find_closest_elements(arr, k, x):    # 返回最接近 x 的 k 个数，按升序排列    # 你的代码在这里    pass# 测试print(find_closest_elements([1,2,3,4,5], 4, 3))        # 应该输出 [1,2,3,4]print(find_closest_elements([1,2,3,4,5], 4, -1))       # 应该输出 [1,2,3,4]print(find_closest_elements([1,2,3,4,5], 3, 5))        # 应该输出 [3,4,5]print(find_closest_elements([1,1,1,10,10,10], 1, 9))   # 应该输出 [10]