思路

按照题意模拟即可，代码实现的话，这里首先是按照要求将要传入的数据（也就是输入的3个列表）弄成一维的（就是把3个列表按照某个顺序转为1个列表），然后再通过一维的转为二维的数组（这个二维就是题目中的窗口填充的数据，7行4列的那一个数据），然后再输出即可。

JavaScript

// 引入readline模块，用于从标准输入读取用户输入
const readline = require('readline');

// 创建readline接口，设置输入为标准输入，输出为标准输出
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

// 定义变量 n、m 和数组 arr 用于存储输入的数据
let n, m;
let arr = [];

// 监听用户输入的每一行
rl.on('line', (line) => {
    // 如果 n 未赋值，将当前行的第一个整数赋值给 n
    if (!n) {
        n = parseInt(line);
    }
    // 如果 n 已赋值而 m 未赋值，将当前行的第一个整数赋值给 m
    else if (!m) {
        m = parseInt(line);
    }
    // 如果 n 和 m 均已赋值，将当前行的数字部分转为数字数组并添加到 arr 数组中
    else {
        arr.push(line.split(' ').map(Number));
    }
});

// 监听用户输入结束
rl.on('close', () => {
    // 创建二维数组 mp，用于存储转换后的数据
    let mp = new Array(m).fill().map(() => new Array(n).fill(0));
    // 用于存储一维数据
    let nums = [];
    // 存储每一个列表目前数据取到哪了
    let target = new Array(arr.length).fill(0);

    // 将列表数据转为一维数据，填充整个二维窗口
    while (nums.length < n * m) {
        for (let i = 0; i < arr.length; i++) {
            let nxt = Math.min(arr[i].length, target[i] + n);
            for (let j = target[i]; j < nxt; j++) {
                nums.push(arr[i][j]);
                target[i] = nxt;
            }
        }
    }

    // 将一维数据转为二维数组
    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            mp[i][j] = nums[i * n + j];
        }
    }

    // 输出二维数组
    for (let j = 0; j < n; j++) {
        for (let i = 0; i < m; i++) {
            // 使用 process.stdout.write 输出，避免在输出过程中自动换行
            process.stdout.write(mp[i][j] + " ");
        }
    }
});

Java

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 = scanner.nextInt();
        int m = scanner.nextInt();

        // 用于存储输入数据的二维列表
        List<List<Integer>> arr = new ArrayList<>();
        // 不定行输入，通过捕捉异常来判断是否结束输入
        while (true) {
            try {
                // 读取一行数据并转换为整数列表
                List<Integer> row = new ArrayList<>();
                Scanner lineScanner = new Scanner(scanner.nextLine());
                while (lineScanner.hasNextInt()) {
                    row.add(lineScanner.nextInt());
                }
                arr.add(row);
            } catch (Exception e) {
                // 捕捉异常表示输入结束
                break;
            }
        }

        // 用于存储输出的二维数组
        int[][] mp = new int[m][n];
        // 用于存储一维数据
        List<Integer> nums = new ArrayList<>();
        // 存储每一个列表目前数据取到哪了
        int[] target = new int[arr.size()];

        // 将列表数据转为一维数据，填充整个二维窗口
        while (nums.size() < n * m) {
            for (int i = 0; i < arr.size(); i++) {
                int nxt = Math.min(arr.get(i).size(), target[i] + n);
                for (int j = target[i]; j < nxt; j++) {
                    nums.add(arr.get(i).get(j));
                    target[i] = nxt;
                }
            }
        }

        // 将一维数据转为二维数组
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                mp[i][j] = nums.get(i * n + j);
            }
        }

        // 输出二维数组
        for (int j = 0; j < n; j++) {
            for (int i = 0; i < m; i++) {
                System.out.print(mp[i][j] + " ");
            }
        }
    }
}

C++

#include <iostream>
#include <vector>
#include <sstream>
using namespace std;

int main() {
    int n, m;
    // 读取输入的行数和列数
    cin >> n >> m;

    vector<vector<int>> arr; // 用于存储输入数据的二维列表
    string line;

    // 逐行读取输入数据
    while (getline(cin, line)) {
        if (line.empty()) { // 如果当前行为空则跳过
            continue;
        }
        vector<int> row;
        istringstream iss(line);
        int num;
        // 逐个数字处理当前行数据
        while (iss >> num) {
            row.push_back(num); // 将数字添加到当前行的列表中
        }
        arr.push_back(row); // 将当前行的列表添加到二维列表中
    }

    int mp[m][n]; // 用于存储输出的二维数组
    vector<int> nums; // 用于存储一维数据
    int target[arr.size()] = {0}; // 存储每一个列表目前数据取到哪了

    // 将列表数据转为一维数据，填充整个二维窗口
    while (nums.size() < n * m) {
        for (int i = 0; i < arr.size(); i++) {
            int nxt = min((int)arr[i].size(), target[i] + n);
            for (int j = target[i]; j < nxt; j++) {
                nums.push_back(arr[i][j]); // 将二维数据转为一维
                target[i] = nxt; // 更新每个列表的指针
            }
        }
    }

    // 将一维数据转为二维数组
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            mp[i][j] = nums[i * n + j];
        }
    }

    // 输出二维数组
    for (int j = 0; j < n; j++) {
        for (int i = 0; i < m; i++) {
            cout << mp[i][j] << " "; // 按照规则输出二维数组
        }
    }
    return 0;
}

Python

n = int(input())
m = int(input())
arr = []
while True:#不定行输入
    try:
        arr.append(list(map(int, input().split())))
    except:
        break
mp = [[0] * n for i in range(m)]#m行n列存储二维数据
nums = []#一维的数据
target = [0] * len(arr)#存储每一个列表目前数据取到哪了
while len(nums) < n * m:#这里主要是希望一维数据能够填充完整个二维窗口，所以是n*m阈值
    for i in range(len(arr)):#这里解释起来有点麻烦，建议读者自己模拟一下
        nxt = min(len(arr[i]), target[i] + n)
        for j in range(target[i], nxt):
            nums.append(arr[i][j])#将列表数据转为一维
            target[i] = nxt#更新每个列表的指针
for i in range(m):#一维数据转为二维数组，这一步其实不需要的（可以直接按照某种规则输出，不需要转化），
    				#但是写出来可以让思路明朗一点
    for j in range(n):
        mp[i][j] = nums[i * n + j]
for j in range(n):#二维数组输出
    for i in range(m):
        print(mp[i][j], end = " ")

题目描述

推荐多样性需要从多个列表中选择元素，一次性要返回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

输入描述

第一行输入为N，表示需要输出的窗口数量，取值范围[1,10]

第二行输入为K，表示每个窗口需要的元素数量，取值范用[1,100]

之后的行数不定(行数取值范围[1,10])，表示每个列表输出的元素列表。元素之间以空格分隔，已经过排序处理，每个列表输出的元素数量取值范围[1,100]

输出描述

输出元素列表，元素数量=窗口数量*窗口大小，元素之间以空格分隔，多个窗口合并为一个列表输出，参考样例:

先输出窗口1的元素列表，再输出窗口2的元素列表，再输出窗口3的元素列表，最后输出窗口4的元素列表

样例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

说明：1.每个列表会保证元素数最满足窗口要求，不需要考虑元素不足情况 2.每个列表的元素已去重，不需要考虑元素重复情况 3.每个列表的元素列表均不为空，不需要考虑列表为空情况 4.每个列表的元素列表已经过排序处理，输出结果要保证不改变同一个列表的元素顺序 5.每个列表的元素数量可能是不同的