思路：暴力枚举

• 观察一下数据范围，发现数组长度$n\le 100$，因此我们可以枚举所有的时间段

• 外层循环枚举左端点，内层循环枚举右端点，遇到符合要求的，就判断长度是否是最长的，如果最长就更新$manlen$和$res$，如果不是最长，但是和最长的一样长，就把当前时间段添加到答案里面

• 总的时间复杂度为$O(n^2)$，完全不会超时

JavaScript代码

let n = 0;
let w = new Array(110).fill(0);
let res = [];
let maxlen = 0;

const readline = require("readline");
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
});

rl.question("", (m) => {
    rl.question("", (line) => {
        w = line.split(" ").map(Number);
        n = w.length;
        for (let l = 0; l < n; l++) {
            for (let r = l; r < n; r++) {
                let sum = 0;
                for (let i = l; i <= r; i++) {
                    sum += w[i];
                }
                if (sum <= m * (r - l + 1)) {
                    if (maxlen < r - l + 1) {
                        maxlen = r - l + 1;
                        res = [];  // 需要把之前的答案清楚
                    }
                    if (maxlen == r - l + 1) {
                        res.push([l, r]);  // 添加答案
                    }
                }
            }
        }
        for (let e of res) {
            process.stdout.write(`${e[0]}~${e[1]} `);
        }
        rl.close();
    });
});

C++代码

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
    int n;
    cin >> n;
    vector<int> vec;
    int temp;
    while (cin >> temp) {
        vec.push_back(temp);
        if (cin.get() == '\n')
            break;
    }
    int len = 0;
	vector<vector<int> > res;
	int m = vec.size();
	for (int i = 0; i < m; i++) {
		int sum = 0;
		for (int j = i; j < m; j++) {
			sum += vec[j];
			if (sum <= n * (j - i + 1)) {
				if (len < j - i + 1) {
					len = j - i + 1;
					res.clear();
				}
				if (len == j - i + 1)
					res.push_back({ i,j });
			}
		}
	}
    int k = res.size();
	for (int i = 0; i < k; i++) {
		if (i != k - 1)
			cout << res[i][0] << "-" << res[i][1] << " ";
		else
			cout << res[i][0] << "-" << res[i][1];
	}
	return 0;
}

Java代码

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt(); //第一行读入一个整数m
        int[] w = new int[110];
        int n = 0;
        while (sc.hasNextInt()) {  //第2行读入n个整数
            w[n++] = sc.nextInt();
        }
        List<List<Integer>> res = new ArrayList<>();  //存放所有的时间段
        int maxlen = 0;  //满足题目条件最大长度的时间段
        for (int l = 0; l < n; l++) {  //枚举数组左端点
            for (int r = l, sum = 0; r < n; r++) {  //枚举数组右端点
                sum += w[r];
                if (sum <= m * (r - l + 1)) {  //当前区间满足题目条件
                    if (maxlen < r - l + 1) {
                        maxlen = r - l + 1;
                        res.clear();  //需要把之前的答案清楚
                    }
                    if (maxlen == r - l + 1) {
                        res.add(Arrays.asList(l, r));  //添加答案
                    }
                }
            }
        }
        for (List<Integer> e : res) {
            System.out.printf("%d~%d ", e.get(0), e.get(1));
        }
    }
}

Python代码

n = 0
w = [0] * 110
res = []
maxlen = 0

m = int(input())  # 第一行读入一个整数m
w=list(map(int, input().split()))
n=len(w)

for l in range(n):  # 枚举数组左端点
    for r in range(l, n):  # 枚举数组右端点
        sum = 0
        for i in range(l, r + 1):
            sum += w[i]
        if sum <= m * (r - l + 1):  # 当前区间满足题目条件
            if maxlen < r - l + 1:
                maxlen = r - l + 1
                res.clear()  # 需要把之前的答案清楚
            if maxlen == r - l + 1:
                res.append([l, r])  # 添加答案

for e in res:
    print(f"{e[0]}~{e[1]}", end=" ")

题目描述

服务之间交换的接口成功率作为服务调用关键质量特性，某个时间段内的接口失败率使用一个数组表示，数组中每个元素都是单位时间内失败率数值，数组中的数值为 $0$ ~ $100$ 的整数，给定一个数值( $minAverageLost$ )表示某个时间段内平均失败率容忍值，即下均失败率小于等于 $minAverageLost$ ，找出数组中最长时间段，如果未找到则直接返回 $NULL$。

输入描述

输入有两行内容，第一行为($minAverageLost$)，

第二行为(数组)，数组元素通过空格(“ “)分隔，$minAverageLost$及数组中元素取值范围为 $0-100$的整数，数组元素的个数不会超过 $100$ 个

输出描述

找出平均值小于等于 $minAverageLost$ 的最长时间段，输出数组下标对，格式($beginindex )-(endindx)(下标从 $0$ 开始)，如果同时存在多个最长时间段，则输出多个下标对与下标对之间使用空格(” ”)拼接，多个下标对按下标对从小到大排序。

样例1

输入

1
0 1 2 3 4

输出

0-2

说明：

$A$、输入解释: $minAverageLost = 1$ ,数组[$0,1,2,3,4$]

$B$、前 $3$ 个元素的平均值为 $1$ ，因此数组第一个至第三个数组下标，即 $0$ - $2$

样例2

输入

2
0 0 100 2 2 99 0 2

输出

0-1 3-4 6-7

说明

A、输入解释: $minAverageLost = 2$ ，数组[ $0,0,100,2,2,99,0,2$]

B、通过计算小于等于 $2$ 的最长时间段为:数组下标为 $0$ - $1$ 即[$0,0$],数组下标为$3$ - $4$即[$2$，$2$],数组下标为 $6$ - $7$，即[$0,2$], 这三个部分都满足平均值小于等 $2$ 的要求，因此输出 $0$ - $1$ $3$ - $4$ $6$ -$7$