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

题目描述

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

输入描述

输入有两行内容，第一行为{minAverageLost}，第二行为{数组}，数组元素通过空格(”“)分隔， minAverageLost及数组中元素取值范围为0~100的整数，数组元素的个数不会超过100个。

输出描述

找出平均值9小于等于minAverageLost的最长时间段，输出数组下标对，格式{beginlndex}-{endlndx}(下标从0开始),如果同时存在多个最长时间段，则输出多个下标对且下标对之间使用空格("“)拼接，多个下标对按下标从小到大排序。

只能说标准答案的代码太绝了！！！！！！

import java.sql.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringJoiner;

public class Main {
    public static void main(String[] args) {


//
//        服务之间交换的接口成功率作为服务调用关键质量特性，某个时间段内的接口失败率使用一个数组表示，
//        数组中每个元素都是单位时间内失败率数值，数组中的数值为0~100的整数，
//        给定一个数值(minAverageLost)表示某个时间段内平均失败率容忍值，即平均失败率小于等于minAverageLost,
//                找出数组中最长时间段，如果未找到则直接返回NULL。
//
//        输入描述
//
//        输入有两行内容，第一行为{minAverageLost}，第二行为{数组}，数组元素通过空格(”“)分隔，
//        minAverageLost及数组中元素取值范围为0~100的整数，数组元素的个数不会超过100个。
//
//        输出描述
//
//        找出平均值9小于等于minAverageLost的最长时间段，输出数组下标对，格式{beginlndex}-{endlndx}(下标从0开始),
//            如果同时存在多个最长时间段，则输出多个下标对且下标对之间使用空格("“)拼接，多个下标对按下标从小到大排序。
        Scanner sc = new Scanner(System.in);

       // int minAverageLost = Integer.parseInt(sc.nextLine());
        //String[] strings=sc.nextLine().split("[ ]");
        String string="0 0 100 0 2 99 2 2";
        String[] strings=string.split("[ ]");
        int k=5;
        int[] nums = Arrays.stream(strings).mapToInt(Integer::parseInt).toArray();

        System.out.println(getResult(nums,k));
    }

    public static String getResult(int[] nums, int minAverageLost) {
        int n = nums.length;

        int[] preSum = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            preSum[i] = preSum[i - 1] + nums[i - 1];
        }

        ArrayList<int[]> ans = new ArrayList<>();
        int maxLen = 0;
//        for (int i=0;i<n;i++){
//            for (int j=i+1;j<=n;j++){
//                int lost =(j - i) * minAverageLost;
//                int sum = preSum[j] - preSum[i];
//                if (sum<=lost){
//                    if ((j-i)>=maxLen){
//
//                    }
//                }
//            }
//        }
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j <= n; j++) {
                // sum 是 区间 [i, j-1] 的和
                int sum = preSum[j] - preSum[i];
                int len = j - i;
                int lost = len * minAverageLost;

                if (sum <= lost) {
                    if (len >= maxLen) {
                        if (len > maxLen) {
                            ans = new ArrayList<>();
                        }
                        ans.add(new int[] {i, j - 1});
                        maxLen = len;
                    }
                }
            }
        }

        if (ans.size() == 0) return "NULL";

        ans.sort((a, b) -> a[0] - b[0]);
        //首先，比较两个子数组的第一个元素。在这种情况下，0 和 2 是要被比较的第一个元素。
//        如果第一个元素不同，则根据它们的值来确定排序顺序。在这里，0 小于 2，因此 [0, 1] 排在 [2, 3] 前面。
//        如果第一个元素相同（例如两个子数组的第一个元素都是 0），则需要比较第二个元素来确定排序顺序。在这个例子中，1 和 3 是要被比较的第二个元素。

        StringJoiner sj = new StringJoiner(" ");
        for (int[] an : ans) sj.add(an[0] + "-" + an[1]);//对于每个子数组an，将其第一个元素和第二个元素通过"-"连接起来，并添加到StringJoiner对象sj中。
        return sj.toString();
    }
}