渣渣的Leetcode之旅（Python3）_排序练习（56,274,349,969,1509）

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 = 0
        for 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 - 1
        return 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:
                continue
            else:
                dict_01[i] = 1
        for 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) - 1
        while  True:
            if list_01 == arr:
                break
            if arr.index(list_01[point]) == 0:
                list_02.append(point+1)
                arr[0:point+1] = list(reversed(arr[0:point+1]))
                point -= 1
                continue
            else:
                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 0
        nums_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)