2024年华为OD机试真题-推荐多样性-Java-OD统一考试（C卷）

素颜马尾好姑娘i 2024-04-07 16:32 97阅读 0赞

> **题目描述：**
> 
> 推荐多样性需要从多个列表中选择元素，一次性要返回N屏数据（窗口数量），每屏展示K个元素（窗口大小），选择策略：
> 
> 1. 各个列表元素需要做穿插处理，即先从第一个列表中为每屏选择一个元素，再从第二个列表中为每屏选择一个元素，依次类推
> 
> 2. 每个列表的元素尽量均分为N份，如果不够N个，也要全部分配完，参考样例图：
> 
> （1）从第一个列表中选择4条0 1 2 3，分别放到4个窗口中
> 
> （2）从第二个列表中选择4条10 11 12 13，分别放到4个窗口中
> 
> （3）从第三个列表中选择4条20 21 22 23，分别放到4个窗口中
> 
> （4）再从第一个列表中选择4条4 5 6 7，分别放到4个窗口中
> 
> ...
> 
> （5）再从第一个列表中选择，由于数量不足4条，取剩下的2条，放到窗口1和窗口2
> 
> （6）再从第二个列表中选择，由于数量不足4条并且总的元素数达到窗口要求，取18 19放到窗口3和窗口4
> 
> ![62a72ca4e0ab4f7ea9a91ad35eab2bf9.png][]
> 
> **输入描述：**
> 
> 第一行输入为N，表示需要输出的窗口数量，取值范围 \[1, 10\]
> 
> 第二行输入为K，表示每个窗口需要的元素数量，取值范围 \[1, 100\]
> 
> 之后的行数不定（行数取值范围\[1,10\]），表示每个列表输出的元素列表。元素之间以空格分隔，已经过排序处理，每个列表输出的元素数量取值范围\[1,100\]
> 
> **输出描述：**
> 
> 输出元素列表，元素数量=窗口数量\*窗口大小，元素之间以空格分隔，多个窗口合并为一个列表输出，参考样例：
> 
> 先输出窗口1的元素列表，再输出窗口2的元素列表，再输出窗口3的元素列表，最后输出窗口4的元素列表
> 
> **补充说明：**
> 
> 1. 每个列表会保证元素数量满足窗口要求，不需要考虑元素不足情况
> 
> 2. 每个列表的元素已去重，不需要考虑元素重复情况
> 
> 3. 每个列表的元素列表均不为空，不需要考虑列表为空情况
> 
> 4. 每个列表的元素列表已经过排序处理，输出结果要保证不改变同一个列表的元素顺序
> 
> 5. 每个列表的元素数量可能是不同的
> 
> **示例1**
> 
> 输入：
> 
> 4  
> 7  
> 0 1 2 3 4 5 6 7 8 9  
> 10 11 12 13 14 15 16 17 18 19  
> 20 21 22 23 24 25 26 27 28 29  
> 输出：
> 
> 0 10 20 4 14 24 8 1 11 21 5 15 25 9 2 12 22 6 16 26 18 3 13 23 7 17 27 19  
> 说明：

import java.util.ArrayList;
    import java.util.List;
    import java.util.Scanner;
     
    public class Main {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
     
            int n = Integer.parseInt(scanner.nextLine());
            int k = Integer.parseInt(scanner.nextLine());
     
            List<List<Integer>> lists = new ArrayList<>();
     
            while (true) {
                try {
                    String s = scanner.nextLine();
     
                    if (s.length() == 0) break;
     
                    List<Integer> numbers = new ArrayList<>();
                    for (String num : s.split(" ")) {
                        numbers.add(Integer.parseInt(num));
                    }
                    lists.add(numbers);
                } catch (Exception e) {
                    break;
                }
            }
     
            int[] windows = new int[k * n];
     
            int idx = 0;
            int level = 0;
     
            while (idx < windows.length) {
                boolean flag = false;
     
                for (int i = 0; i < n; i++) {
                    windows[idx++] = lists.get(level).remove(0);
     
                    if (lists.get(level).isEmpty() && lists.size() > 1) {
                        lists.remove(level);
                        level %= lists.size();
                        flag = true;
                    }
                }
     
                if (!flag) {
                    level = (level + 1) % lists.size();
                }
            }
     
            List<Integer> ans = new ArrayList<>();
            for (int j = 0; j < n; j++) {
                for (int i = 0; i < k; i++) {
                    ans.add(windows[i * n + j]);
                }
            }
     
            for (int num : ans) {
                System.out.print(num + " ");
            }
        }
    }

[62a72ca4e0ab4f7ea9a91ad35eab2bf9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/97faf311d7c345398d58d40d854c490c.png