python结果不能全部显示_python – 显示列表的所有可能的分组,仅给出子列表的数量(长度是可变的)...

问题

步骤1：给定一个数字列表,生成所有可能的分组(按顺序),只给出所需组的最终数量.

例如,如果我的数字列表是1到4,并且我想要2个最终组,可能性是：

[1], [2,3,4]

[1,2], [3,4]

[1,2,3], [4]

步骤2：对这些组进行算术运算.

例如,如果我们选择添加,最终的结果将是：

1 + 234 = 235

12 + 34 = 46

123 + 4 = 127

先前研究和类似问题

我已经看到关于SO和其他地方的许多例子涉及可变数量的组,这些组利用了范围和循环,

print [num_list[i:i+groups] for i in range(0,len(num_list),groups)]

但是,这与我想要的相反 – 在这里,团体本身的长度是固定的,而最后一个组合的数量也在振荡.

这不是功课,只是我遇到的一个有趣的问题.理想情况下,为了执行数学运算,我需要对这些单独的子列表进行迭代,所以需要被捕获.

我有一种感觉,解决方案将涉及itertools,但我似乎无法弄清组合方面的组合.

编辑/扩展步骤2

如果我想对每个分区执行不同的操作,我仍然可以这样做吗？而不是指定只是int.add,我可以以某种方式执行所有主要4操作的另一个组合？即：

symbol_list = ['+','-','*','/']

for op in symbol_list:

#something

我会结束以下可能性：

1 + 2 * 34

1 * 2 - 34

1 / 2 + 34

etc.

操作顺序可以忽略.

最终解决方案

#!/usr/bin/env python

import sys

from itertools import combinations, chain, product

# fixed vars

num_list = range(_,_) # the initial list

groups = _ # number of groups

target = _ # any target desired

op_dict = {'+': int.__add__, '-': int.__sub__,

'*': int.__mul__, '/': int.__div__}

def op_iter_reduce(ops, values):

op_iter = lambda a, (i, b): op_dict[ops[i]](a, b)

return reduce(op_iter, enumerate(values[1:]), values[0])

def split_list(data, n):

for splits in combinations(range(1, len(data)), n-1):

result = []

prev = None

for split in chain(splits, [None]):

result.append(data[prev:split])

prev = split

yield result

def list_to_int(data):

result = 0

for h, v in enumerate(reversed(data)):

result += 10**h * v

return result

def group_and_map(data, num_groups):

template = ['']*(num_groups*2 - 1) + ['=', '']

for groups in split_list(data, num_groups):

ints = map(list_to_int, groups)

template[:-2:2] = map(str, ints)

for ops in product('+-*/', repeat=num_groups-1):

template[1:-2:2] = ops

template[-1] = str(op_iter_reduce(ops, ints))

if op_iter_reduce(ops, ints) == target:

print ' '.join(template)

group_and_map(num_list, groups)