将列表拆分为几乎相等的部分并返回边界

Question

我想拆分一个列表并返回边界，因此在扩展中不应存在单个元素。

例如

split(list(range(1,101)),2) 
# should return 
[[1,50],[51,100]]

split(list(range(1,101)),3)
# should return
[[1,33],[34,66],[67,100]]

split(list(range(1,6)),3)
# should return
[[1,2],[3,5]] # Ideally last element should merge with last if last one has no pair.

到目前为止我尝试过

def split(l, n):
    x = list(range(1, l+1))
    return [x[i:i+n] for i in range(0, len(x), int(len(x)/n))]

print(split(20, 2))

返回[[1, 2], [11, 12]] 而不是[[1, 10], [11, 20]]

Answer 1

这应该会有所帮助，它没有使用完整的列表范围，而只是使用您感兴趣的“边框”，一些创意zip()ping 并在创建范围后修复错误：

def split(l, n):
    stride =(l//n)
    r = list(range(1, l+stride, stride))  # overbuild needed range

    # adjust zipped value by 1 if needed
    k = [ [a , b-1 ] for a,b in zip(r,r[1:]) ]

    # fix special cases 
    for _ in range(n+1): # guesstimate of fixes needed

        if k[-1][0] == k[-1][1]: # last pair identical 
            k.pop()    # remove it and fix new last index to be l  instead
            k[-1][1] = l        
        elif k[-1][1] != l:
            k[-1][1] = l

    return k

print(split(100, 2))
print(split(100, 4))
print(split(103, 3))
print(split(6, 3))

输出：

[[1, 50], [51, 100]]                          # split(100, 2)
[[1, 25], [26, 50], [51, 75], [76, 100]]      # split(100, 4)
[[1, 34], [35, 68], [69, 103]]                # split(103, 3)
[[1, 2], [3, 4], [5, 6]]                      # split(6, 3)

我用您的示例对其进行了粗略的测试，检查逻辑是否适合您的所有特殊情况。

尤其是# guesstimate of fixes needed 可能太多了...我有一种预感，最多 2 个就足够了

Answer 2

这是一个非常快速的解决方案，需要注意的是最长的子列表将位于最后而不是第一个（但是组仍将尽可能均匀）：

def fast_chunks(start, stop, chunks):
  l = math.ceil(((stop-start)/chunks)-1)
  fin = []
  for j in range(chunks-1):
    fin.append([start, start+l])
    start += l + 1
  fin.append([start, stop])
  return fin

在行动：

In [41]: fast_chunks(1, 100, 2)
Out[41]: [[1, 50], [51, 100]]

In [42]: fast_chunks(1, 100, 3)
Out[42]: [[1, 33], [34, 66], [67, 100]]

In [43]: fast_chunks(1, 6, 2)
Out[43]: [[1, 3], [4, 6]]

使用numpy 和np.array_split 的简单解决方案：

def _split(start, stop, n):
    return [[i[0], i[-1]] for i in np.array_split(np.arange(start, stop+1), n)]

在行动：

In [54]: _split(1, 20, 2)
Out[54]: [[1, 10], [11, 20]]

In [55]: _split(1, 100, 2)
Out[55]: [[1, 50], [51, 100]]

In [56]: _split(1, 6, 2)
Out[56]: [[1, 3], [4, 6]]

在计时方面，fast_chunks 的表现要好于其他人：

In [45]: %timeit chrisz_fast_chunks(1, 1000000, 100)
24.5 µs ± 496 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [27]: %timeit artner_split(1000000, 100)
58 µs ± 1.02 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [22]: %timeit gahan_split(1000000, 100)
77 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [23]: %timeit chrisz_split(1, 1000000, 100)
1.77 ms ± 39.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [24]: %timeit pylang_split(1000000, 100)
72 ms ± 445 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

Answer 3

def csplit(m,n):
    div_ = m//n
    step = div_ if div_ > 1 else 2  # determine step for range function (at least 2 'alternate steps')
    lis = []
    for i in range(1, m+1, step):
        if (m-(i+max(1, div_-1))) > 1:
            # append list only if remains at least two elements remains 
            lis.append([i,i+max(1, div_-1)])
        else:
            if not m == i:
                # in case if m and i not equal and not more then one element left then construct list which include that element
                lis.append([i, m])
            break  # break the loop from iterating any further
    return lis

if __name__ == "__main__":
    print(csplit(100, 2))
    print(csplit(100, 3))
    print(csplit(5, 3))

输出：

[[1, 50], [51, 100]]
[[1, 33], [34, 66], [67, 100]]
[[1, 2], [3, 5]]

---

同一个班轮：

def csplit(m,n):
    return [[i,i+max(1, m//n-1)] if (m-(i+max(1, m//n-1))) > 1 else [i, m] for i in range(1, m+1, max(m//n, 2)) if not i==m]

Answer 4

我认为您的预期结果不一致，但这里有一些简单的方法可能会对您有所帮助。

使用第三方库more_itertools（通过> pip install more_itertools安装）：

代码

import more_itertools as mit


def split(val, n):
    """Return a list of equally divided intervals."""
    a = [list(c)[0] for c in mit.divide(n, range(1, val+1))]
    b = [list(c)[-1] for c in mit.divide(n, range(1, val+1))]
    return list(zip(a, b))

演示

split(100, 2)
# [(1, 50), (51, 100)]

split(99, 3)
# [(1, 33), (34, 66), (67, 99)]

split(100, 3)
# [(1, 34), (35, 67), (68, 100)]

split(20, 2)
# [(1, 10), (11, 20)]