【华为OD机试真题】通信误码【2022 Q4 | 100分】 java代码实现

■ 题目描述

【通信误码】

信号传播过程中会出现一些误码，不同的数字表示不同的误码ID，取值范围为1~65535，用一个数组记录误码出现的情况，
每个误码出现的次数代表误码频度，请找出记录中包含频度最高误码的最小子数组长度。

输入描述

误码总数目：取值范围为0~255，取值为0表示没有误码的情况。
误码出现频率数组：误码ID范围为1~65535，数组长度为1~1000。

输出描述

包含频率最高的误码最小子数组长度

示例1 输入输出示例仅供调试，后台判题数据一般不包含示例

输入

5

1 2 2 4 1

输出

2

说明

频度最高的有1和2，频度是2（出现的次数都是2）。
可以包含频度最高的记录数组是[2 2]和[1 2 2 4 1]，
最短是[2 2]，最小长度为2。

示例2 输入输出示例仅供调试，后台判题数据一般不包含示例

输入

7
1 2 2 4 2 1 1

输出

4
说明

频度最高的是1和2，最短的是[2 2 4 2]

Java代码实现：

 

package quicktest;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * @Author: liliangxing
 * private code share in https://gitee.com/liliangxing/
 * public code share in https://github.com/liliangxing/
 * ■ 题目描述
 *
 * 【通信误码】
 *
 * 信号传播过程中会出现一些误码，不同的数字表示不同的误码ID，取值范围为1~65535，用一个数组记录误码出现的情况，
 * 每个误码出现的次数代表误码频度，请找出记录中包含频度最高误码的最小子数组长度。
 *
 * 输入描述
 *
 * 误码总数目：取值范围为0~255，取值为0表示没有误码的情况。
 * 误码出现频率数组：误码ID范围为1~65535，数组长度为1~1000。
 *
 * 输出描述
 *
 * 包含频率最高的误码最小子数组长度
 *
 * 示例1 输入输出示例仅供调试，后台判题数据一般不包含示例
 *
 * 输入
 *
 * 5
 *
 * 1 2 2 4 1
 *
 * 输出
 *
 * 2
 *
 * 说明
 *
 * 频度最高的有1和2，频度是2（出现的次数都是2）。
 * 可以包含频度最高的记录数组是[2 2]和[1 2 2 4 1]，
 * 最短是[2 2]，最小长度为2。
 *
 * 示例2 输入输出示例仅供调试，后台判题数据一般不包含示例
 *
 * 输入
 *
 * 7
 * 1 2 2 4 2 1 1
 *
 * 输出
 *
 * 4
 * 说明
 *
 * 频度最高的是1和2，最短的是[2 2 4 2]
 */
public class Details128293415 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        while (s.hasNextLine()) {
            List<Integer> chargeNumArr = new ArrayList<>();
            int n = Integer.parseInt(s.nextLine());
            List<Integer> ints =
                    Arrays.stream(s.nextLine().trim().split(" ")).map(Integer::parseInt).collect(Collectors.toList());

            int result = chargeBottle(n, ints);
            System.out.println(result);
        }
    }

    private static int chargeBottle(int n, List<Integer> ints) {
        int maxLen = (1 << 31) - 1;
        if (n == 0) {
            return 0;
        }
        int maxCount = 0;
        Set<Integer> maxCode = new HashSet<>();
        Map<Integer, List<Integer>> k_v = ints.stream().collect(Collectors.groupingBy(Integer::new));
        for (List<Integer> v : k_v.values()) {
            maxCount = Math.max(maxCount, v.size());
        }
        for (Map.Entry<Integer, List<Integer>> entry : k_v.entrySet()) {
            if (entry.getValue().size() == maxCount) {
                maxCode.add(entry.getKey());
            }
        }
        for (Integer integer : maxCode) {
            int lo = 0;
            int hi = ints.size() - 1;
            while (true) {
                if (ints.get(lo).equals(integer)) {
                    break;
                }
                lo = lo + 1;
            }
            while (true) {
                if (ints.get(hi).equals(integer)) {
                    break;
                }
                hi = hi - 1;
            }
            if (lo <= hi) {
                maxLen = Math.min(maxLen, hi - lo + 1);
            }
        }
        return maxLen;
    }
}