日常刷题(3)

1. 查找接口成功率最优时间段

1.1. 题目描述

服务之间交换的接口成功率作为服务调用关键质量特性，某个时间段内的接口失败率使用一个数组表示，

数组中每个元素都是单位时间内失败率数值，数组中的数值为0~100的整数，

给定一个数值(minAverageLost)表示某个时间段内平均失败率容忍值，即平均失败率小于等于minAverageLost，

找出数组中最长时间段，如果未找到则直接返回NULL。

1.2. 输入描述

输入有两行内容，第一行为{minAverageLost}，第二行为{数组}，数组元素通过空格(” “)分隔，

minAverageLost及数组中元素取值范围为0~100的整数，数组元素的个数不会超过100个。

1.3. 输出描述

找出平均值小于等于minAverageLost的最长时间段，输出数组下标对，格式{beginIndex}-{endIndx}(下标从0开始)，

如果同时存在多个最长时间段，则输出多个下标对且下标对之间使用空格(” “)拼接，多个下标对按下标从小到大排序。

1.4. 用例

输入
1
0 1 2 3 4
输出 0-2
说明
输入解释：minAverageLost=1，数组[0, 1, 2, 3, 4]
前3个元素的平均值为1，因此数组第一个至第三个数组下标，即0-2

输入
2
0 0 100 2 2 99 0 2
输出 0-1 3-4 6-7
说明
输入解释：minAverageLost=2，数组[0, 0, 100, 2, 2, 99, 0, 2]
通过计算小于等于2的最长时间段为：
数组下标为0-1即[0, 0]，数组下标为3-4即[2, 2]，数组下标为6-7即[0, 2]，这三个部分都满足平均值小于等于2的要求，
因此输出0-1 3-4 6-7

1.5. 题目解析

最朴素的想法就是把所有时段都遍历一遍。但是这样平均值算了很多遍，有点不合适，所以用动态规划优化一下求和。

1.6. 代码

class Solution:
    def __call__(self, min_average_lost: int, lost: List[int]):
        pre_sum = [0]
        for l in lost:
            pre_sum.append(l + pre_sum[-1])

        max_len = 0
        ans = []
        for i in range(len(lost)):
            for j in range(i + 1, len(lost) + 1):
                average_lost = (pre_sum[j] - pre_sum[i]) / (j - i)

                if average_lost > min_average_lost:
                    continue

                if (j - i) > max_len:
                    ans = [[i, j - 1]]
                    max_len = j - i
                    
                elif (j - i) == max_len:
                    ans.append([i, j - 1])
        return ans

2. 查找众数及中位数

2.1. 题目描述

众数是指一组数据中出现次数量多的那个数，众数可以是多个。

中位数是指把一组数据从小到大排列，最中间的那个数，如果这组数据的个数是奇数，那最中间那个就是中位数，如果这组数据的个数为偶数，那就把中间的两个数之和除以2，所得的结果就是中位数。

查找整型数组中元素的众数并组成一个新的数组，求新数组的中位数。

2.2. 输入描述

输入一个一维整型数组，数组大小取值范围 0<N<1000，数组中每个元素取值范围 0<E<1000

2.3. 输出描述

输出众数组成的新数组的中位数

2.4. 用例

输入 10 11 21 19 21 17 21 16 21 18 15
输出 21
输入 2 1 5 4 3 3 9 2 7 4 6 2 15 4 2 4
输出 3
输入 5 1 5 3 5 2 5 5 7 6 7 3 7 11 7 55 7 9 98 9 17 9 15 9 9 1 39
输出 7

2.5.解题思路

遍历统计

2.6.代码

class Solution:
    def __call__(self, nums: List[int]):
        cnt, max_cnt = {}, -1
        for num in nums:
            cnt[num] = cnt.get(num, 0) + 1
            max_cnt = max(max_cnt, cnt[num])

        clean_nums = list(filter(lambda x: cnt[x] == max_cnt, cnt.keys()))
        clean_nums.sort()

        i = len(clean_nums) // 2
        if len(clean_nums) % 2 != 0:
            return clean_nums[i]
        else:
            return (clean_nums[i] + clean_nums[i - 1]) / 2