华为OD机试真题 - 数组合并（Java & JS & Python & C & C++）

本文链接：https://blog.csdn.net/nezhajava/article/details/137155402

题目描述

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

输入描述

第一行，每次读取的固定长度，长度0<len<10；
第二行是整数数组的数目，数目 0<num<10000；
第3~n行是需要合并的数组，不同的数组用换行分割，元素之间用逗号分割，最大不超过100个元素。

输出描述

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

Java算法源码

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int len = scanner.nextInt(); // 行每次读取的固定长度
    int num = scanner.nextInt(); // 整数数组的数目
    String s = scanner.nextLine(); // nextInt后有空行，先读取一次

    List<List<String>> arrays = new ArrayList<>(num);
    int maxArrayLen = 0;
    int totalLen = 0;
    for (int i = 0; i < num; i++) {
        List<String> array = Arrays.stream(scanner.nextLine().split(",")).collect(Collectors.toList());
        arrays.add(array);
        totalLen += array.size();
        maxArrayLen = Math.max(maxArrayLen, array.size());
    }


    // 计算每个数组最多需要截取几次，即遍历次数
    int cycle;
    if (maxArrayLen % len == 0) {
        cycle = maxArrayLen / len;
    } else {
        cycle = maxArrayLen / len + 1;
    }

    // 拼接结果数组
    List<String> results = new ArrayList<>(totalLen);

    int start;
    int end;
    for (int i = 0; i < cycle; i++) {
        for (List<String> array : arrays) {
            start = i * len;
            end = (i + 1) * len;
            int size = array.size();

            // 如果开始index已经大于数组最大，说明该数组取完了
            if (start > size - 1) {
                continue;
            }

            // 结束index最大为size
            if (end > size) {
                end = size;
            }

            // 取指定长度的子数组
            results.addAll(array.subList(start, end));
        }
    }
    System.out.println(String.join(",", results));
}

输入

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

说明

获得长度3和数组数目2
先遍历第一行获得2,5,6
再遍历第二行获得1,7,4
再循环回到第一行获得7,9,5
再遍历第二行获得3,4
再回到第一行获得7

JavaScript算法源码

// 主函数  
function main() {  
    // 创建一个readline接口用于读取输入  
    const readline = require('readline');  
    const rl = readline.createInterface({  
        input: process.stdin,  
        output: process.stdout  
    });  
  
    // 读取第一行输入，以空格分隔获取len和num的值  
    rl.question('请输入行每次读取的固定长度和整数数组的数目（用空格分隔）：', (input) => {  
        const [len, num] = input.split(' ').map(Number);  
  
        // 读取nextInt后的空行  
        rl.question('', (s) => {  
            // 初始化数组列表和最大数组长度、总长度变量  
            const arrays = [];  
            let maxArrayLen = 0;  
            let totalLen = 0;  
  
            // 读取num个整数数组  
            for (let i = 0; i < num; i++) {  
                rl.question('', (line) => {  
                    // 将读取的字符串按逗号分割，并转换为字符串数组  
                    const array = line.split(',').map(String);  
                    arrays.push(array);  
                    totalLen += array.length;  
                    maxArrayLen = Math.max(maxArrayLen, array.length);  
  
                    // 如果读取完所有数组，则进行下一步处理  
                    if (i === num - 1) {  
                        processArrays(arrays, len, maxArrayLen, totalLen);  
                    }  
                });  
            }  
        });  
    });  
}  
  
// 处理数组的函数  
function processArrays(arrays, len, maxArrayLen, totalLen) {  
    // 计算每个数组最多需要截取几次  
    let cycle = Math.ceil(maxArrayLen / len);  
  
    // 初始化结果数组  
    const results = [];  
  
    // 遍历截取次数  
    for (let i = 0; i < cycle; i++) {  
        // 遍历每个数组  
        for (const array of arrays) {  
            let start = i * len;  
            let end = (i + 1) * len;  
  
            // 如果开始索引大于数组长度，说明该数组已处理完  
            if (start >= array.length) {  
                continue;  
            }  
  
            // 如果结束索引大于数组长度，则修正为数组长度  
            if (end > array.length) {  
                end = array.length;  
            }  
  
            // 将指定长度的子数组添加到结果数组中  
            results.push(...array.slice(start, end));  
        }  
    }  
  
    // 输出拼接后的结果数组，用逗号连接  
    console.log(results.join(','));  
  
    // 关闭readline接口  
    rl.close();  
}  
  
// 调用主函数  
main();

Python算法源码

import sys

def main():
    len = int(input())  # 行每次读取的固定长度
    num = int(input())  # 整数数组的数目
    input()  # nextInt后有空行，先读取一次

    arrays = []
    maxArrayLen = 0
    totalLen = 0
    for i in range(num):
        array = input().split(",")
        arrays.append(array)
        totalLen += len(array)
        maxArrayLen = max(maxArrayLen, len(array))

    # 计算每个数组最多需要截取几次，即遍历次数
    if maxArrayLen % len == 0:
        cycle = maxArrayLen / len
    else:
        cycle = maxArrayLen / len + 1

    # 拼接结果数组
    results = []

    for i in range(cycle):
        for array in arrays:
            start = i * len
            end = (i + 1) * len
            size = len(array)

            if start > size - 1:
                continue

            if end > size:
                end = size

            results.extend(array[start:end])

    print(",".join(results))

if __name__ == "__main__":
    main()

C算法源码

#include <stdio.h> // 头文件包含
#include <stdlib.h>

int main() {
    int len, num; // 声明变量
    scanf("%d", &len); // 输入行每次读取的固定长度
    scanf("%d", &num); // 输入整数数组的数目
    char s[100]; // assuming 100 characters for s
    fgets(s, 100, stdin); // nextInt后有空行，先读取一次

    // 初始化变量
    char** arrays = (char**) malloc(num * sizeof(char*));
    int maxArrayLen = 0;
    int totalLen = 0;

    // 循环读取数组并计算相关信息
    for (int i = 0; i < num; i++) {
        char temp[100]; // assuming 100 characters for temp
        scanf("%s", temp);

        char* array = (char*) malloc((strlen(temp) + 1) * sizeof(char));
        strcpy(array, temp);

        arrays[i] = array;
        totalLen += strlen(array);
        maxArrayLen = (maxArrayLen > strlen(array)) ? maxArrayLen : strlen(array);
    }

    // 计算循环次数
    int cycle;
    if (maxArrayLen % len == 0) {
        cycle = maxArrayLen / len;
    } else {
        cycle = maxArrayLen / len + 1;
    }

    // 初始化变量
    char** results = (char**) malloc(totalLen * sizeof(char*));
    int start, end;

    // 拼接结果数组
    for (int i = 0; i < cycle; i++) {
        for (int j = 0; j < num; j++) {
            start = i * len;
            end = (i + 1) * len;
            int size = strlen(arrays[j]);

            if (start > size - 1) {
                continue;
            }

            if (end > size) {
                end = size;
            }

            int length = end - start;
            char* temp_result = (char*) malloc((length + 1) * sizeof(char));
            strncpy(temp_result, arrays[j] + start, length);
            temp_result[length] = '\0';
            results[totalLen + i * (num) + j] = temp_result;
        }
    }

    // 输出结果
    for (int i = 0; i < totalLen; i++) {
        if (i != 0) printf(",");
        printf("%s", results[i]);
    }
    printf("\n");

    // 释放内存
    for (int i = 0; i < num; i++) {
        free(arrays[i]);
    }
    free(arrays);

    for (int i = 0; i < totalLen; i++) {
        free(results[i]);
    }
    free(results);

    return 0;
}

C++算法源码

#include <iostream>  
#include <vector>  
#include <sstream>  
#include <string>  
  
int main() {  
    // 读取输入  
    std::string line;  
    std::getline(std::cin, line);  
    std::istringstream iss(line);  
    int len, num;  
    iss >> len >> num; // 行每次读取的固定长度和整数数组的数目  
    std::getline(std::cin, line); // nextInt后有空行，先读取一次  
  
    std::vector<std::vector<std::string>> arrays(num);  
    int maxArrayLen = 0;  
    int totalLen = 0;  
    for (int i = 0; i < num; i++) {  
        std::getline(std::cin, line);  
        std::istringstream iss2(line);  
        std::string item;  
        std::vector<std::string> array;  
        while (std::getline(iss2, item, ',')) {  
            array.push_back(item);  
        }  
        arrays[i] = array;  
        totalLen += array.size();  
        maxArrayLen = std::max(maxArrayLen, (int)array.size());  
    }  
  
    // 计算每个数组最多需要截取几次，即遍历次数  
    int cycle;  
    if (maxArrayLen % len == 0) {  
        cycle = maxArrayLen / len;  
    } else {  
        cycle = maxArrayLen / len + 1;  
    }  
  
    // 拼接结果数组  
    std::vector<std::string> results;  
    results.reserve(totalLen);  
  
    for (int i = 0; i < cycle; i++) {  
        for (const auto& array : arrays) {  
            int start = i * len;  
            int end = std::min((i + 1) * len, (int)array.size());  
  
            // 如果开始index已经大于数组最大，说明该数组取完了  
            if (start >= array.size()) {  
                continue;  
            }  
  
            // 如果结束index大于数组长度，则调整为数组长度  
            if (end > array.size()) {  
                end = array.size();  
            }  
  
            // 取指定长度的子数组  
            results.insert(results.end(), array.begin() + start, array.begin() + end);  
        }  
    }  
  
    // 输出结果  
    for (size_t i = 0; i < results.size(); i++) {  
        std::cout << results[i];  
        if (i < results.size() - 1) {  
            std::cout << ",";  
        }  
    }  
    std::cout << std::endl;  
  
    return 0;  
}