1.1合并区间

以数组 $intervals$ 表示若干个区间的集合，其中单个区间为 $intervals[i]=[starti,endi]$ 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

先对输入列表进行排序，然后判断结果区间的end在不在当前区间之间，在就合并，不在就添加进入结果区间。

代码

 def merge(self, intervals):
        intervals.sort(key=lambda x: x[0])  #按照第一个元素排序

        merged = []
        for interval in intervals:
            # 如果列表为空，或者当前区间与上一区间不重合，直接添加
            #merged[-1][1]表示返回列表最后一个区间的end 
            #interval[0]表示当前区间的strat
            if not merged or merged[-1][1] < interval[0]:
                merged.append(interval)
            else:
                # 否则的话，我们就可以与上一区间进行合并
                merged[-1][1] = max(merged[-1][1], interval[1])
        return merged

1.2轮转数组

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]

数组翻转
代码

    def reverse(self,nums, start, end):
        while (start < end):
            t = nums[start]
            nums[start] = nums[end]
            nums[end] = t
            start += 1
            end -= 1
    def rotate(self,nums,k):
        k%=len(nums) #求余
        n=len(nums)
        self.reverse(nums,0,n-1)  #将整个数组翻转
        self.reverse(nums,0,k-1)  #将要移动的数据翻转
        self.reverse(nums,k,n-1)  #将剩下的数据翻转
        return nums

1.3除自身以外数组的乘积

给你一个整数数组$nums$，返回数组$answer$ ，其中 $answer[i]$ 等于 $nums$ 中除 $nums[i]$ 之外其余各元素的乘积 。题目数据保证数组 $nums$之中任意元素的全部前缀元素和后缀的乘积都在 32位整数范围内。不要使用除法，且在 $O(n)$ 时间复杂度内完成此题。

输入: nums = [1,2,3,4]
输出: [24,12,8,6]

利用索引左侧所有数字的乘积和索引右侧所有数字的乘积（即前缀与后缀）相乘得到答案

代码

    def productExceptSelf(self,nums):
        n=len(nums)
        # L 和 R 分别表示左右两侧的乘积列表
        L, R, answer = [0] * n, [0] * n, [0] * n

        # L[i] 为索引 i 左侧所有元素的乘积
        # 对于索引为 '0' 的元素，因为左侧没有元素，所以 L[0] = 1
        L[0] = 1
        for i in range(1, n):
            L[i] = nums[i - 1] * L[i - 1]

        # R[i] 为索引 i 右侧所有元素的乘积
        # 对于索引为 'length-1' 的元素，因为右侧没有元素，所以 R[length-1] = 1
        R[n - 1] = 1
        for i in reversed(range(n - 1)):
            R[i] = nums[i + 1] * R[i + 1]

        # 对于索引 i，除 nums[i] 之外其余各元素的乘积就是左侧所有元素的乘积乘以右侧所有元素的乘积
        for i in range(n):
            answer[i] = L[i] * R[i]
        return answer

1.4缺失的一个正数

给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。（最小正整数为1,0既不是正数也不是负数）

输入：nums = [1,2,0]
输出：3

输入1：nums = [7,8,9,11,12]
输出1：1

假设数组的长度为 N，那我们容易发现，我们能找到的缺失的第一个正数一定在1 ~ (N+1) 中。如果数组中的数字就是1 ~ N，则 (N+1) 就是第一个缺失的正数，否则 1 ~ N 中一定缺失了某个正数，因此可以发现此处需要进行排序和查找的数字只有数组中处于1 ~ N 中的数字，其他数字可以无视。

我们知道数组除了储存功能外还有 0 ~ (N-1) 共计 N 个下标，且可以和数字 1 ~ N 形成一一对应，因此我们可以利用下标来进行排序。

我们只需要遍历一次数组，将每个位于1 ~ N 的数字放到其在数组对应下标（数字减一）的位置中，其他数字直接标记为 N+1，这样当我们再次从头到尾遍历数组时，遇到第一个和下标不对应的数字，该下标对应的数字就是缺失的第一个正数。

代码

    def firstMissingPositive(self, nums):
        n = len(nums) #将不需要考虑的数字赋值为N+1
        idx=0
        while idx<n:
            if nums[idx]<=0 or nums[idx]>n:
                nums[idx]=-1
                idx+=1
            # 否则将其交换到该数字nums[idx]对应的位置上nums[nums[idx]-1]
            # 如果不需要交换则往前走
            else:
                if nums[idx]==idx+1: #如果对应的位置已经有了，直接下一位
                    idx+=1
                else:
                    t=nums[nums[idx]-1]
                    nums[nums[idx]-1]=nums[idx] #把当前位置的数据放在value-1的位置上去
                    nums[idx]=t
        for i in range(n):
            if nums[i]!=i+1: #结果就是遇见的第一个不等于该位置上的数
                return i+1
        return n+1  #否则就是N+1

参考知乎
参考代码