2024年华为OD笔试机试E卷- 数组拼接 (java/c++/python)

华为OD机试E卷2024真题目录(java & c++ & python)

本人习惯先看输入输出描述，可以明确知道哪些数据已知，需要去得到什么结果，再代入更有目的性地阅读题干内容，快速理解，所以把输入输出描述放在前面，你可以试下这样阅读对你是否有帮助。

输入描述

第一行是每次读取的固定长度，0 < 长度 < 10

第二行是整数数组的数目，0 < 数目 < 1000

第3-n行是需要合并的数组，不同的数组用回车换行分隔，数组内部用逗号分隔，最大不超过100个元素。

输出描述

输出一个新的数组，用逗号分隔。

题目描述

现在有多组整数数组，需要将它们合并成一个新的数组。

合并规则，从每个数组里按顺序取出固定长度的内容合并到新的数组中，取完的内容会删除掉，如果该行不足固定长度或者已经为空，则直接取出剩余部分的内容放到新的数组中，继续下一行。

用例1

输入
3
2
2,5,6,7,9,5,7
1,7,4,3,4

输出
2,5,6,1,7,4,7,9,5,3,4,7

说明 1、获得长度3和数组数目2
2、先遍历第一行，获得2,5,6
3、再遍历第二行，获得1,7,4
4、再循环回到第一行，获得7,9,5
5、再遍历第二行，获得3,4
6、再回到第一行，获得7，按顺序拼接成最终结果

用例2

输入
4
3
1,2,3,4,5,6
1,2,3
1,2,3,4

输出
1,2,3,4,1,2,3,1,2,3,4,5,6

解题思路

首先，定义一个动态数组ans，来记录题解。

然后，将输入的3~n行对应的数组，放到一个链表中。

每次取出链表的头部，然后删除该头部数组前subLen个元素，并这subLen元素记录按顺序录入ans中：

如果删除后，该头部数组长度依旧大于0，则将该头部数组重新连接到链表尾部
如果删除后，该头部数组的长度为0，则不做操作
直到链表长度为0时，停止。此时ans中记录的就是题解。

主要难点在于，如何删除数组（或其他容器）的前subLen个元素，其实就是删除容器中某个范围的所有元素。

C++、Java、Python参考代码如下：

Java

import java.util.*;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取子串长度
        int subLen = Integer.parseInt(scanner.nextLine());

        // 读取链表数量
        int n = Integer.parseInt(scanner.nextLine());

        // 存储多个链表的集合
        LinkedList<LinkedList<Integer>> lists = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            lists.add(
                new LinkedList<>(
                    Arrays.stream(scanner.nextLine().split(","))
                        // 过滤掉输入中的空串
                        .filter(s -> !s.isEmpty())
                        .map(Integer::parseInt)
                        .collect(Collectors.toList())
                )
            );
        }

        // 输出结果
        System.out.println(getResult(subLen, lists));
    }

    /**
     * 获取最终结果的字符串
     * @param subLen 子串长度
     * @param lists 存储整数链表的集合
     * @return 处理后的结果字符串
     */
    public static String getResult(int subLen, LinkedList<LinkedList<Integer>> lists) {
        List<Integer> result = new ArrayList<>();

        while (!lists.isEmpty()) {
            LinkedList<Integer> currentList = lists.removeFirst();
            result.addAll(removeRange(currentList, 0, subLen));
            // 如果当前链表还有剩余元素，则重新加入队列
            if (!currentList.isEmpty()) {
                lists.addLast(currentList);
            }
        }

        // 将结果转换为用逗号分隔的字符串
        return result.stream()
                     .map(String::valueOf)
                     .collect(Collectors.joining(","));
    }

    /**
     * 移除链表中指定范围的元素
     * @param list 链表
     * @param start 开始索引
     * @param end 结束索引
     * @return 被移除的元素列表
     */
    public static List<Integer> removeRange(LinkedList<Integer> list, int start, int end) {
        // 确保结束索引不超过链表大小
        if (end > list.size()) end = list.size();

        // 获取子列表
        List<Integer> subList = list.subList(start, end);
        
        // 创建结果列表并清空原列表中的元素
        List<Integer> removedElements = new ArrayList<>(subList);
        subList.clear();

        return removedElements;
    }
}

C++

#include <bits/stdc++.h>
using namespace std;

/**
 * 通过指定分隔符分割输入字符串，返回整数队列
 * @param delimiter 分隔符
 * @return 包含分割结果的整数队列
 */
deque<int> splitCin(char delimiter) {
    string inputLine;
    getline(cin, inputLine);

    stringstream ss(inputLine);
    string token;

    deque<int> result;
    while (getline(ss, token, delimiter)) {
        if (!token.empty()) {
            result.emplace_back(stoi(token)); // 转换字符串为整数并添加到结果中
        }
    }

    return result;
}

int main() {
    int subLen; // 每次提取的子数组长度
    cin >> subLen;

    int n; // 子数组数量
    cin >> n;

    cin.ignore(); // 忽略换行符

    deque<deque<int>> lists(n); // 存储多个子数组
    for (int i = 0; i < n; i++) {
        lists[i] = splitCin(','); // 读取并分割每个子数组
    }

    vector<int> result; // 最终的结果数组

    // 处理所有子数组
    while (!lists.empty()) {
        deque<int> currentList = lists.front(); // 获取队首的子数组
        lists.pop_front(); // 移除队首子数组

        // 从子数组中提取指定数量的元素
        for (int i = 0; i < subLen && !currentList.empty(); i++) {
            result.emplace_back(currentList.front()); // 将元素添加到结果中
            currentList.pop_front(); // 移除已添加的元素
        }

        // 如果当前子数组还有剩余元素，则重新放回队列
        if (!currentList.empty()) {
            lists.push_back(currentList);
        }
    }

    // 输出结果，使用逗号分隔
    for (size_t i = 0; i < result.size(); i++) {
        cout << result[i];
        if (i < result.size() - 1) {
            cout << ","; // 在每个元素后添加逗号，除了最后一个
        }
    }
    cout << endl; // 输出换行符

    return 0;
}

Python

# 输入获取
subLen = int(input())  # 子串长度
n = int(input())       # 数组个数

# 读取输入数组，过滤掉空串
lists = [list(filter(lambda x: x != "", input().split(","))) for _ in range(n)]

# 算法入口
def getResult():
    result = []  # 存储最终结果

    # 处理所有列表
    while lists:
        currentList = lists.pop(0)  # 从队列中取出第一个列表
        # 获取当前列表的前 subLen 个元素
        chunk = currentList[:subLen]
        result.extend(chunk)  # 将获取的元素添加到结果中
        del currentList[:subLen]  # 删除已处理的元素

        # 如果当前列表还有剩余元素，重新加入队列
        if currentList:
            lists.append(currentList)

    return ",".join(result)  # 将结果列表转换为字符串并返回

# 算法调用
print(getResult())