56. 合并区间
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi]
。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。示例 1：
输入：intervals = [[1,3],[2,6],[8,10],[15,18]] 输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].示例 2：
输入：intervals = [[1,4],[4,5]] 输出：[[1,5]] 解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
提示：
1 <= intervals.length <= 104 intervals[i].length == 2 0 <= starti <= endi <= 104来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/merge-intervals
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution:def merge(self, intervals: List[List[int]]) -> List[List[int]]:intervals.sort(key = lambda x:x[0])list_01 = []list_01.append(intervals[0])for i in range(1,len(intervals)):if intervals[i][0] > list_01[-1][1]:list_01.append(intervals[i])if intervals[i][0] <= list_01[-1][1] and list_01[-1][1] < intervals[i][1]:list_01[-1][1] = intervals[i][1]return list_01
274. H 指数
给定一位研究者论文被引用次数的数组（被引用次数是非负整数）。编写一个方法，计算出研究者的 h 指数。
h 指数的定义：h 代表“高引用次数”（high citations），一名科研人员的 h 指数是指他（她）的 （N 篇论文中）总共有 h
篇论文分别被引用了至少 h 次。且其余的 N - h 篇论文每篇被引用次数 不超过 h 次。例如：某人的 h 指数是 20，这表示他已发表的论文中，每篇被引用了至少 20 次的论文总共有 20 篇。
示例：
输入：citations = [3,0,6,1,5]
输出：3 解释：给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5 次。
由于研究者有 3 篇论文每篇 至少 被引用了 3 次，其余两篇论文每篇被引用 不多于 3 次，所以她的 h 指数是 3。提示：如果 h 有多种可能的值，h 指数是其中最大的那个。
来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/h-index
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution:def hIndex(self, citations: List[int]) -> int:citations.sort()fin_num = 0for i in range(len(citations)):if len(citations) - i <= citations[i]:if fin_num < len(citations) - i:fin_num = len(citations) - i if len(citations) - i - 1 <= citations[i]:if fin_num < len(citations) - i - 1:fin_num = len(citations) - i - 1return fin_num
349. 两个数组的交集
给定两个数组，编写一个函数来计算它们的交集。
示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2] 输出：[2]
示例 2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出：[9,4]
说明：
输出结果中的每个元素一定是唯一的。 我们可以不考虑输出结果的顺序。来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/intersection-of-two-arrays
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution:def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:list_01 = []dict_01 = {
}for i in nums1:if i in dict_01:continueelse:dict_01[i] = 1for i in nums2:if i in dict_01:list_01.append(i)list_02 = list(set(list_01))return list_02
969. 煎饼排序
给你一个整数数组 arr ，请使用 煎饼翻转 完成对数组的排序。
一次煎饼翻转的执行过程如下：
选择一个整数 k ，1 <= k <= arr.length 反转子数组 arr[0...k-1]（下标从 0 开始）例如，arr = [3,2,1,4] ，选择 k = 3 进行一次煎饼翻转，反转子数组 [3,2,1] ，得到 arr =
[1,2,3,4] 。以数组形式返回能使 arr 有序的煎饼翻转操作所对应的 k 值序列。任何将数组排序且翻转次数在 10 * arr.length
范围内的有效答案都将被判断为正确。示例 1：
输入：[3,2,4,1] 输出：[4,2,4,3] 解释： 我们执行 4 次煎饼翻转，k 值分别为 4，2，4，和 3。 初始状态 arr
= [3, 2, 4, 1] 第一次翻转后（k = 4）：arr = [1, 4, 2, 3] 第二次翻转后（k = 2）：arr = [4, 1, 2, 3] 第三次翻转后（k = 4）：arr = [3, 2, 1, 4] 第四次翻转后（k = 3）：arr = [1,
2, 3, 4]，此时已完成排序。示例 2：
输入：[1,2,3] 输出：[] 解释： 输入已经排序，因此不需要翻转任何内容。 请注意，其他可能的答案，如 [3，3]
，也将被判断为正确。提示：
1 <= arr.length <= 100 1 <= arr[i] <= arr.length arr 中的所有整数互不相同（即，arr 是从 1 到 arr.length 整数的一个排列）来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/pancake-sorting
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution:def pancakeSort(self, arr: List[int]) -> List[int]:# 4231 3# 1324 4# 3124 3# 2134 2# 1234# a[0:3] = list(reversed(a[0:3])) list_01 = sorted(arr)list_02 = []point = len(arr) - 1while True:if list_01 == arr:breakif arr.index(list_01[point]) == 0:list_02.append(point+1)arr[0:point+1] = list(reversed(arr[0:point+1]))point -= 1continueelse:list_02.append(arr.index(list_01[point])+1)arr[0:arr.index(list_01[point])+1] = list(reversed(arr[0:arr.index(list_01[point])+1]))return list_02
1509. 三次操作后最大值与最小值的最小差
给你一个数组 nums ，每次操作你可以选择 nums 中的任意一个元素并将它改成任意值。
请你返回三次操作后， nums 中最大值与最小值的差的最小值。
示例 1：
输入：nums = [5,3,2,4] 输出：0 解释：将数组 [5,3,2,4] 变成 [2,2,2,2]. 最大值与最小值的差为 2-2
= 0 。示例 2：
输入：nums = [1,5,0,10,14] 输出：1 解释：将数组 [1,5,0,10,14] 变成 [1,1,0,1,1] 。
最大值与最小值的差为 1-0 = 1 。示例 3：
输入：nums = [6,6,0,1,1,4,6] 输出：2
示例 4：
输入：nums = [1,5,6,14,15] 输出：1
提示：
1 <= nums.length <= 10^5 -10^9 <= nums[i] <= 10^9来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-difference-between-largest-and-smallest-value-in-three-moves
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution:def minDifference(self, nums: List[int]) -> int:nums.sort()if len(nums) <= 3:return 0nums_01 = nums[-1] - nums[3]nums_02 = nums[-4] - nums[0]nums_03 = nums[-2] - nums[2]nums_04 = nums[-3] - nums[1]return min(nums_01,nums_02,nums_03,nums_04)
