按数字和将整数列表排序为列表列表

Question

我正在尝试编写一个Python函数，将数字列表排序为数字列表，每个子列表仅包含具有较大列表中子列表索引的数字总和的数字。

因此，例如，对于从1到25的所有数字，它应产生如下列表列表：

[[], [1, 10], [2, 11, 20], [3, 12, 21], [4, 13, 22], [5, 14, 23], [6, 15, 24], [7, 16], [8, 17], [9, 18], [19]]

到目前为止，我有以下代码：

def digit_sum(integer_data_type):
    int_string = str(integer_data_type)
    sum = 0
    for digits in int_string:
        sum += int(digits)
    return sum


def organize_by_digit_sum(integer_list):
    integer_list.sort()
    max_ds = 9*len(str(max(integer_list)))+1
    list_of_lists = []
    current_ds = 0
    while current_ds <= max_ds:
            current_list = []
            for n in integer_list:
                    if digit_sum(n) == current_ds:
                            current_list.append(n)
            list_of_lists.append(current_list)
            current_ds += 1
    return list_of_lists

显然，这是低效的，因为它必须从0到最大位数之和的每个位数之和一遍又一遍地遍历整个整数列表。

同样，它最初假定最大位数之和是最大整数长度的9倍。 明确地说，我确实希望始终有一个可能的digit_sum为零的子列表，以便我可以通过列表列表的索引引用特定数字总和的子列表。

我希望函数只需要遍历列表中的每个整数一次，并将其附加到正确的子列表中即可。

我将不胜感激。

Answer 1

如果您不介意使用itertools ，则此方法应该更有效。

from itertools import groupby
digit_sum = lambda x: sum(int(i) for i in str(x))
[list(g) for _, g in groupby(sorted(range(1,26), key = digit_sum), key = digit_sum)]
                                  # ^^^^^^^^^^ replace this with your actual data
# [[1, 10],
#  [2, 11, 20],
#  [3, 12, 21],
#  [4, 13, 22],
#  [5, 14, 23],
#  [6, 15, 24],
#  [7, 16, 25],
#  [8, 17],
#  [9, 18],
#  [19]]

它的工作方式：使用sorted()整数的数字和对原始列表进行排序，以便您可以使用groupby()方法按数字的和对列表进行分组，然后遍历各组并转换整数每个组到一个列表。

更新 ：要获取子列表的数字总和等于索引的列表，可以首先创建字典：

dict_ = dict((k,list(g)) for k, g in groupby(sorted(range(1,26), key = digit_sum), key = digit_sum))

dict_
# {1: [1, 10],
#  2: [2, 11, 20],
#  3: [3, 12, 21],
#  4: [4, 13, 22],
#  5: [5, 14, 23],
#  6: [6, 15, 24],
#  7: [7, 16, 25],
#  8: [8, 17],
#  9: [9, 18],
#  10: [19]}

[dict_.get(key, []) for key in range(max(dict_.keys()))]
# [[],
#  [1, 10],
#  [2, 11, 20],
#  [3, 12, 21],
#  [4, 13, 22],
#  [5, 14, 23],
#  [6, 15, 24],
#  [7, 16, 25],
#  [8, 17],
#  [9, 18]]

Answer 2

以下代码在数据上仅循环一次，并返回一个字典，其键为和，而值为与该和相对应的项：

from collections import defaultdict
from pprint import pprint

def group_by_sum(lst):
    d = defaultdict(list)
    for i in lst:
        d[sum(int(j) for j in str(i))].append(i)
    return d

pprint(group_by_sum(range(1, 25)))
# {1: [1, 10],
#  2: [2, 11, 20],
#  3: [3, 12, 21],
#  4: [4, 13, 22],
#  5: [5, 14, 23],
#  6: [6, 15, 24],
#  7: [7, 16],
#  8: [8, 17],
#  9: [9, 18],
#  10: [19]}

您可以根据总和对字典值进行排序以得到一个列表，但是我认为将数据保留为字典可能会更好。

Answer 3

如果您想要一个留下空列表的解决方案，而空间效率不是您的主要关注点，那么我将使用元组列表：

>>> def digit_sum(digits):
...   total = 0
...   while digits != 0:
...     total += digits % 10
...     digits = digits // 10
...   return total
... 
>>> numbers = list(range(1,26))
>>> pairs = sorted((digit_sum(n),n) for n in numbers)
>>> pairs
[(1, 1), (1, 10), (2, 2), (2, 11), (2, 20), (3, 3), (3, 12), (3, 21), (4, 4), (4, 13), (4, 22), (5, 5), (5, 14), (5, 23), (6, 6), (6, 15), (6, 24), (7, 7), (7, 16), (7, 25), (8, 8), (8, 17), (9, 9), (9, 18), (10, 19)]
>>> maximum_sum = pairs[-1][0]
>>> list_of_lists = [[] for _ in range(maximum_sum+1)]
>>> for pair in pairs:
...   list_of_lists[pair[0]].append(pair[1])
... 
>>> list_of_lists
[[], [1, 10], [2, 11, 20], [3, 12, 21], [4, 13, 22], [5, 14, 23], [6, 15, 24], [7, 16, 25], [8, 17], [9, 18], [19]]
>>> 

因此，假设您的数据稀疏得多：

>>> numbers = [4,25,47,89]
>>> pairs = sorted((digit_sum(n),n) for n in numbers)
>>> pairs
[(4, 4), (7, 25), (11, 47), (17, 89)]
>>> maximum_sum = pairs[-1][0]
>>> list_of_lists = [[] for _ in range(maximum_sum+1)]
>>> for pair in pairs:
...   list_of_lists[pair[0]].append(pair[1])
... 
>>> from pprint import pprint
>>> pprint(list_of_lists,width=2)
[[],
 [],
 [],
 [],
 [4],
 [],
 [],
 [25],
 [],
 [],
 [],
 [47],
 [],
 [],
 [],
 [],
 [],
 [89]]
>>> 

您可以这样访问数据：

>>> list_of_lists[17]
[89]
>>> list_of_lists[8]
[]
>>> 

Answer 4

很容易：

list_of_lists = [[] for i in range(11)]

for i in range(25):
    digit_sum = sum(int(i) for i in str(i))
    list_of_lists[digit_sum].append(i)

print (list_of_lists)