如何按特定往返顺序将数字列表拆分为最少子列表

需求说明 #

• 输入：包含1到n（或0到n-1，依具体场景）的连续数字列表
• 核心要求：拆分为数量最少的子列表，每个子列表的元素数量不得超过30个
• 分配规则：采用往返式顺序分配元素——先从第一个子列表依次分配到最后一个，接着从最后一个子列表反向分配回第一个，循环此逻辑，而非从头开始新一轮正向分配

示例展示 #

示例1：总数68时（需拆分为3个子列表）

输入代码：

a = [i for i in range(68)]  # 生成0到67的列表

输出结构：

[[0,5,6,11,12,17,18,...], [1,4,7,10,13,16,19,...], [2,3,8,9,14,15,20,...]]

示例2：需拆分为4个子列表时

输出结构：

[[0,7,8,15,16,...], [1,6,9,14,17,...], [2,5,10,13,18,...], [3,4,11,12,19,...]]

完整示例（n=65，拆分为7个子列表）

输出：

[0,13,14,28,29,42,43,56,57]
[1,12,15,27,30,41,44,55,58]
[2,11,16,26,31,40,45,54,59]
[3,10,17,25,32,39,46,53,60]
[4,9,19,24,33,38,47,52,61]
[5,8,20,23,34,37,48,51,62]
[6,7,21,22,35,36,49,50,63,64]

实现方案 #

思路解析

1. 计算最少子列表数：通过向上取整公式 (n + 29) // 30 得到，确保每个子列表元素数不超过30
2. 初始化子列表：创建对应数量的空列表用于存放分配后的元素
3. 往返分配逻辑：
   • 以 2 * 子列表数 为一个周期，每个周期包含一轮正向分配和一轮反向分配
   • 对每个元素的索引，计算其在周期内的位置，判断是正向还是反向阶段，进而确定所属子列表

Python代码实现

def split_list_round_robin_reverse(n, start_from_1=False):
    # 计算最少需要的子列表数量
    num_groups = (n + 29) // 30
    groups = [[] for _ in range(num_groups)]
    
    for idx in range(n):
        # 计算当前元素在周期内的位置，周期长度为2*子列表数
        cycle_len = 2 * num_groups
        pos_in_cycle = idx % cycle_len
        
        # 确定当前元素所属的子列表索引
        if pos_in_cycle < num_groups:
            group_idx = pos_in_cycle
        else:
            group_idx = 2 * num_groups - 1 - pos_in_cycle
        
        # 若需要从1开始的数字，替换为idx+1
        groups[group_idx].append(idx + 1 if start_from_1 else idx)
    
    return groups

# 测试用例
# 测试n=68，从0开始
print("n=68（0-67）的拆分结果：")
for group in split_list_round_robin_reverse(68):
    print(group)

# 测试n=65，从0开始
print("\nn=65（0-64）的拆分结果：")
for group in split_list_round_robin_reverse(65):
    print(group)

# 测试n=68，从1开始
print("\nn=68（1-68）的拆分结果：")
for group in split_list_round_robin_reverse(68, start_from_1=True):
    print(group)

内容的提问来源于stack exchange，提问作者Thomas vincent