华为社招算法题

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

输入：第一行是每次读取的固定长度，第2-n行是需要合并的数组，不同的数组用回车换行分隔，数组内用逗号分隔。

输出：新的数组，用逗号分隔

示例：

输入:

3

2,5,6,7

1,7,4

输出：

2,5,6,1,7,4,7

Java实现的代码：

考虑到可能整体长度不是固定长度的倍数，因此这个算法稍微复杂了点，题目中也没有保证输入的整体数组长度一定是固定长度的倍数，只能说这题太坑，要考虑这种情况

import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            // 读取的长度
            String t_Str = sc.nextLine();
            if (t_Str.equals("")) {
                continue;
            }
            int t = Integer.parseInt(t_Str);
            // 存放每个数组
            ArrayList<int[]> list = new ArrayList<>();
            // 存放结果
            ArrayList<Integer> res = new ArrayList<>();
            // 读取一行信息
            while (sc.hasNextLine()) {
                String input = sc.nextLine();
                if (input.equals("")) {break;}
                String[] input_s = input.split(",");
                int[] arr = new int[input_s.length];
                for (int i = 0;i<arr.length;i++) {
                    arr[i] = Integer.parseInt(input_s[i]);
                }
                list.add(arr);
            }
            if (list.size() > 0) {
                // 每个数组当前的读取位置，初始化为-1
                int[] loc = new int[list.size()];
                for (int i=0;i<loc.length;i++) {
                    loc[i] = -1;
                }
                // 当前行数
                int cur = 0;
                int add_t = t;
                // 所有的数组读取完毕才能结束循环
                while (true) {
                    // 取出当前行
                    int[] arr = list.get(cur);
                    int curIndex = loc[cur];
                    // 每次移动的位置是add_t;
                    if (curIndex + add_t <arr.length) {
                        curIndex += add_t;
                    } else {
                        add_t = t - (arr.length-curIndex-1);
                        curIndex = arr.length-1;
                    }

                    for (int i=loc[cur]+1;i<=curIndex;i++) {
                        res.add(arr[i]);
                    }

                    loc[cur] = curIndex;

                    // 寻找下一行是哪一行
                    if (cur == loc.length-1) {
                        cur = 0;
                    } else {
                        cur++;
                    }
                    while (loc[cur] == list.get(cur).length-1) {
                        if (cur == list.size() -1) {
                            cur = 0;
                        } else {
                            cur++;
                        }

                        // 遍历一次看有没有空行
                        int index = -1;
                        for (int i=0;i<list.size();i++) {
                            if (loc[i] < list.get(i).length-1) {
                                index = i;
                                break;
                            }
                        }
                        if (index == -1) {
                            cur = list.size();
                            break;
                        }
                    }

                    // 上面的循环找了一圈都没有空余元素的时候，则退出，退出的时候,cur必定等于loc.length,此时退出循环
                    if (cur == list.size()) {
                        break;
                    }

                }
                for (int i=0;i<res.size();i++) {
                    System.out.print(res.get(i));
                    if (i < res.size()-1) {
                        System.out.print(",");
                    } else {
                        System.out.println();
                    }
                }
            }

        }
    }
}