我有一个谜题,我想用Python解决它.

难题:

一个商人的重量为40公斤,他在他的店里使用.有一次,它从他的手上掉下来,分成4块.但令人惊讶的是,现在他可以通过这4件的组合称重1公斤到40公斤之间的任何重量.

所以问题是,这4件的重量是多少？

现在我想用Python解决这个问题.

我从拼图中得到的唯一约束是4个总和是40.我可以过滤掉总和为40的所有4个值的集合.

import itertools as it

weight = 40
full = range(1,41)
comb = [x for x in it.combinations(full,4) if sum(x)==40]

length of comb = 297

现在我需要检查每组值comb并尝试所有操作组合.

例如,如果(a,b,c,d)是第一组值comb,我需要检查a,b,c,d,a+b,a-b, .................a+b+c-d,a-b+c+d........,依此类推.

我尝试了很多,但我陷入了这个阶段,即如何检查所有这些计算组合到每组4个值.

题 :

1)我想我需要列出所有可能的组合[a,b,c,d] and [+,-].

2)有没有人有更好的想法,告诉我如何从这里前进？

另外,我想完全没有任何外部库的帮助,只需要使用python的标准库.

编辑:对不起,迟到的信息.答案是(1,3,9,27),这是我几年前发现的.我检查并验证了答案.

编辑:目前,fraxel答案是完美的time = 0.16 ms.总是欢迎更好,更快的方法.

问候

方舟

我正在尝试以优雅的方式编写一个函数,它将对字典列表进行分组并聚合(求和)like-keys的值.

例:

my_dataset = [  
    {
        'date': datetime.date(2013, 1, 1),
        'id': 99,
        'value1': 10,
        'value2': 10
    },
    {
        'date': datetime.date(2013, 1, 1),
        'id': 98,
        'value1': 10,
        'value2': 10
    },
    {
        'date': datetime.date(2013, 1, 2),
        'id' 99,
        'value1': 10,
        'value2': 10
    }
]

group_and_sum_dataset(my_dataset, 'date', ['value1', 'value2'])

"""
Should return:
[
    {
        'date': datetime.date(2013, 1, 1),
        'value1': 20,
        'value2': 20
    },
    {
        'date': datetime.date(2013, 1, 2),
        'value1': 10,
        'value2': 10
    }
]
"""

我已经尝试使用itertools为groupby和总结每个like-key值对,但我在这里遗漏了一些东西.这是我的功能目前的样子:

def group_and_sum_dataset(dataset, group_by_key, sum_value_keys):
    keyfunc = operator.itemgetter(group_by_key) …

我试图找出将两个列表合并为所有可能组合的最佳方法.所以,如果我从这样的两个列表开始:

list1 = [1, 2]
list2 = [3, 4]

结果列表如下所示:

[[[1,3], [2,4]], [[1,4], [2,3]]]

也就是说,它基本上产生一个列表列表,其中包含两者之间的所有潜在组合.

我一直在研究itertools,我很确定答案,但是我无法想出办法让它以这种方式行事.我最接近的是:

list1 = [1, 2, 3, 4]
list2 = [5, 6, 7, 8]
print list(itertools.product(list1, list2))

哪个产生:

[(1, 5), (1, 6), (1, 7), (1, 8), (2, 5), (2, 6), (2, 7), (2, 8), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (4, 6), (4, 7), (4, 8)]

因此,它会在每个列表中执行所有可能的项目组合,但不是所有可能的结果列表.我怎么做到这一点？

编辑:最终目标是能够单独处理每个列表以确定效率(我正在使用的实际数据更复杂).因此,在上面的原始示例中,它将工作如下:

list1 = [1, 2]
list2 = [3, 4]

Get first merged list: [[1,3], [2, …

给定列表和排除元素,是否可以忽略包含这些元素的组合的计算？

例1

鉴于l = [1, 2, 3, 4, 5],我想计算甚至在计算之前size 4包含的所有组合和排除组合(1, 3).

结果将是:

    All results:            Wanted results:

    [1, 2, 3, 4]            [1, 2, 4, 5]
    [1, 2, 3, 5]            [2, 3, 4, 5]
    [1, 2, 4, 5]
    [1, 3, 4, 5]
    [2, 3, 4, 5]

已删除包含1和3的所有组合.

例2

由@Eric Duminil建议

结果l = [1, 2, 3, 4, 5, 6],size 4和

• 排(1, 2, 3)在第二栏

• 排除(1, 2)在第三栏

  All results: …

  Run Code Online (Sandbox Code Playgroud)

我知道在Stack Overflow上已经多次询问过与此类似的问题,但是我需要从列表中删除重复的元组,但不仅仅是它们的元素匹配,它们的元素必须处于相同的顺序.换言之,(4,3,5)与(3,4,5)将同时出现在输出中,而如果有两个(3,3,5)和(3,3,5)中,只有一个将是在输出中.

具体来说,我的代码是:

import itertools

x = [1,1,1,2,2,2,3,3,3,4,4,5]
y = []

for x in itertools.combinations(x,3):
    y.append(x)
print(y)

其中输出相当冗长.例如,在输出中,应该有(1,2,1)和(1,1,2).但应该只有一个(1,2,2).

zip如果迭代的长度不相等,我正在寻找一个很好的方法来引发异常的几个迭代.

在迭代项是列表或具有len方法的情况下,此解决方案简洁明了:

def zip_equal(it1, it2):
    if len(it1) != len(it2):
        raise ValueError("Lengths of iterables are different")
    return zip(it1, it2)

但是,如果it1和it2是生成器,则前一个函数将失败,因为未定义长度TypeError: object of type 'generator' has no len().

我想这个itertools模块提供了一种简单的方法来实现它,但到目前为止我还没有找到它.我想出了这个自制的解决方案:

def zip_equal(it1, it2):
    exhausted = False
    while True:
        try:
            el1 = next(it1)
            if exhausted: # in a previous iteration it2 was exhausted but it1 still has elements
                raise ValueError("it1 and it2 have different lengths")
        except StopIteration:
            exhausted = True
            # it2 must …

我是Python的新手,试图在Python 3中构建一个旧的python文件.我遇到了几个构建错误,我解决了.但是在这一点上我遇到了错误.我不知道如何解决这个问题.代码部分如下所示.

return itertools.ifilter(lambda i: i.state == "IS", self.storage)

我有一个奇怪的问题,itertools.groupby用于分组查询集的元素.我有一个模特Resource:

from django.db import models 

TYPE_CHOICES = ( 
    ('event', 'Event Room'),
    ('meet', 'Meeting Room'),
    # etc 
)   

class Resource(models.Model):
    name = models.CharField(max_length=30)
    type = models.CharField(max_length=5, choices=TYPE_CHOICES)
    # other stuff

我的sqlite数据库中有几个资源:

>>> from myapp.models import Resource
>>> r = Resource.objects.all()
>>> len(r)
3
>>> r[0].type
u'event'
>>> r[1].type
u'meet'
>>> r[2].type
u'meet'

因此,如果我按类型分组,我自然会得到两个元组:

>>> from itertools import groupby
>>> g = groupby(r, lambda resource: resource.type)
>>> for type, resources in g:
...   print type
...   for resource …

在Python 3.3中,itertools.accumulate()通常会对提供的iterable重复应用加法运算,现在可以将函数参数作为参数; 这意味着它现在重叠functools.reduce().粗略看一下,现在两者之间的主要区别似乎是:

1. accumulate()默认为求和但不允许显式提供额外的初始条件,reduce()而不默认为任何方法但允许您提供初始条件以使用1/0元素序列,并且
2. accumulate()首先采用迭代,然后先reduce()获取函数.

这两者之间还有其他差异吗？或者这仅仅是两个函数的行为问题,最初的不同用途开始随时间收敛？

我想为numpy 实现itertools.combinations.根据这个讨论,我有一个适用于一维输入的功能:

def combs(a, r):
    """
    Return successive r-length combinations of elements in the array a.
    Should produce the same output as array(list(combinations(a, r))), but 
    faster.
    """
    a = asarray(a)
    dt = dtype([('', a.dtype)]*r)
    b = fromiter(combinations(a, r), dt)
    return b.view(a.dtype).reshape(-1, r)

并且输出有意义:

In [1]: list(combinations([1,2,3], 2))
Out[1]: [(1, 2), (1, 3), (2, 3)]

In [2]: array(list(combinations([1,2,3], 2)))
Out[2]: 
array([[1, 2],
       [1, 3],
       [2, 3]])

In [3]: combs([1,2,3], 2)
Out[3]: 
array([[1, 2],
       [1, 3],
       [2, 3]]) …