算法总结所有组合的数字列表

Question

我有一个数字列表，我想加起来所有不同的组合。 例如：

• 数字为1,4,7和13
• 输出将是：

1+4=5
1+7=8
1+13=14
4+7=11
4+13=17
7+13=20
1+4+7=12
1+4+13=18
1+7+13=21
4+7+13=24
1+4+7+13=25

是否有一个公式来计算不同的数字？

Answer 1

一种简单的方法是使用与数字一样多的位来创建位集。 在你的例子中4。

然后从0001到1111计数，并对集合上每个数字1的数字求和：

数字1,4,7,13：

0001 = 13=13
0010 = 7=7
0011 = 7+13 = 20

1111 = 1+4+7+13 = 25

Answer 2

在Java中，这是一个简单的递归解决方案的样子：

public static void main(String[] args)
{
    f(new int[] {1,4,7,13}, 0, 0, "{");
}

static void f(int[] numbers, int index, int sum, String output)
{
    if (index == numbers.length)
    {
        System.out.println(output + " } = " + sum);
        return;
    }

    // include numbers[index]
    f(numbers, index + 1, sum + numbers[index], output + " " + numbers[index]);

    // exclude numbers[index]
    f(numbers, index + 1, sum, output);
}

输出：

{ 1 4 7 13 } = 25
{ 1 4 7 } = 12
{ 1 4 13 } = 18
{ 1 4 } = 5
{ 1 7 13 } = 21
{ 1 7 } = 8
{ 1 13 } = 14
{ 1 } = 1
{ 4 7 13 } = 24
{ 4 7 } = 11
{ 4 13 } = 17
{ 4 } = 4
{ 7 13 } = 20
{ 7 } = 7
{ 13 } = 13
{ } = 0

Answer 3

最着名的算法需要指数时间。 如果存在多项式时间算法，那么您将解决子集和问题 ，从而解决P = NP问题 。

这里的算法是创建长度等于你的数字基数的bitvector。 修复一组数字的枚举(n_i) 。 然后，枚举位向量的所有可能值。 对于位向量的每个枚举(e_i) ，计算e_i * n_i的总和。

这里的直觉是，您通过位向量表示数字集的子集，并生成该组数字的所有可能子集。 当位e_i等于1时， n_i在子集中，否则不在。

Knuth的TAOCP的第四卷提供了用于生成位向量的所有可能值的算法。

Answer 4

C＃：

我试图找到一些更优雅的东西 - 但是现在应该可以做到这一点......

//Set up our array of integers
int[] items = { 1, 3, 5, 7 };

//Figure out how many bitmasks we need... 
//4 bits have a maximum value of 15, so we need 15 masks.
//Calculated as:
//    (2 ^ ItemCount) - 1
int len = items.Length;
int calcs = (int)Math.Pow(2, len) - 1;

//Create our array of bitmasks... each item in the array
//represents a unique combination from our items array
string[] masks = Enumerable.Range(1, calcs).Select(i => Convert.ToString(i, 2).PadLeft(len, '0')).ToArray();

//Spit out the corresponding calculation for each bitmask
foreach (string m in masks)
{
    //Get the items from our array that correspond to 
    //the on bits in our mask
    int[] incl = items.Where((c, i) => m[i] == '1').ToArray();

    //Write out our mask, calculation and resulting sum
    Console.WriteLine(
        "[{0}] {1}={2}", 
        m, 
        String.Join("+", incl.Select(c => c.ToString()).ToArray()), 
        incl.Sum()
    );
}

输出为：

[0001] 7=7
[0010] 5=5
[0011] 5+7=12
[0100] 3=3
[0101] 3+7=10
[0110] 3+5=8
[0111] 3+5+7=15
[1000] 1=1
[1001] 1+7=8
[1010] 1+5=6
[1011] 1+5+7=13
[1100] 1+3=4
[1101] 1+3+7=11
[1110] 1+3+5=9
[1111] 1+3+5+7=16

Answer 5

这是一个简单的递归Ruby实现：

a = [1, 4, 7, 13]

def add(current, ary, idx, sum)
    (idx...ary.length).each do |i|
        add(current + [ary[i]], ary, i+1, sum + ary[i])
    end
    puts "#{current.join('+')} = #{sum}" if current.size > 1
end    
add([], a, 0, 0)

哪个打印

1+4+7+13 = 25
1+4+7 = 12
1+4+13 = 18
1+4 = 5
1+7+13 = 21
1+7 = 8
1+13 = 14
4+7+13 = 24
4+7 = 11
4+13 = 17
7+13 = 20

如果您不需要在每一步都打印数组，则可以使代码更简单，更快，因为不会创建其他数组：

def add(ary, idx, sum)
    (idx...ary.length).each do |i|
        add(ary, i+1, sum + ary[i])
    end
    puts sum
end
add(a, 0, 0)

我不认为你可以比这简单得多。

Answer 6

这个Perl程序似乎可以做你想要的。 它通过不同的方式从k项中选择n项 。 计算有多少组合很容易，但是获得每个组合的总和意味着你必须最终添加它们。 当我问到Perlmonks时，我有一个类似的问题如何计算邮票的正确组合？ 。

Math :: Combinatorics模块还可以处理许多其他情况。 即使您不想使用它，文档也有很多关于该问题的其他信息的指针。 其他人可能会为您喜欢的语言建议适当的库。

#!/usr/bin/perl

use List::Util qw(sum);
use Math::Combinatorics;

my @n = qw(1 4 7 13);

foreach my $count ( 2 .. @n ) {
    my $c = Math::Combinatorics->new(
        count => $count,  # number to choose
        data => [@n],
        );

    print "combinations of $count from: [" . join(" ",@n) . "]\n";

    while( my @combo = $c->next_combination ){
        print join( ' ', @combo ), " = ", sum( @combo ) , "\n";
        }
    }

Answer 7

Mathematica解决方案：

{#, Total@#}& /@ Subsets[{1, 4, 7, 13}]  //MatrixForm

输出：

{}  0
{1} 1
{4} 4
{7} 7
{13}    13
{1,4}   5
{1,7}   8
{1,13}  14
{4,7}   11
{4,13}  17
{7,13}  20
{1,4,7} 12
{1,4,13}    18
{1,7,13}    21
{4,7,13}    24
{1,4,7,13}  25

Answer 8

您可以使用位向量枚举所有子集。

在for循环中，从0到2到Nth幂减1（或者如果你不关心空集，则从1开始）。

在每次迭代时，确定设置了哪些位。 第N位表示集合的第N个元素。 对于每个设置位，取消引用该组的相应元素并添加到累计值。

ETA：因为这个问题的本质涉及指数复杂性，所以你可以枚举的集合的大小存在实际限制。 如果事实证明您不需要所有子集，则可以查找“n选择k”以获取枚举k个元素的子集的方法。

Answer 9

PHP：这是一个非递归实现。 我不是说这是最有效的方法（这确实是指数2 ^ N - 请参阅JasonTrue的回复和评论），但它适用于一小部分元素。 我只想快速写一些东西来获得结果。 我将算法基于Toon的答案。

$set = array(3, 5, 8, 13, 19);

$additions = array();
for($i = 0; $i < pow(2, count($set)); $i++){
    $sum = 0;
    $addends = array();
    for($j = count($set)-1; $j >= 0; $j--) {
        if(pow(2, $j) & $i) {
            $sum += $set[$j];
            $addends[] = $set[$j];
        }
    }
    $additions[] = array($sum, $addends);
}

sort($additions);

foreach($additions as $addition){
    printf("%d\t%s\n", $addition[0], implode('+', $addition[1]));
}

哪个会输出：

0   
3   3
5   5
8   8
8   5+3
11  8+3
13  13
13  8+5
16  13+3
16  8+5+3
18  13+5
19  19
21  13+8
21  13+5+3
22  19+3
24  19+5
24  13+8+3
26  13+8+5
27  19+8
27  19+5+3
29  13+8+5+3
30  19+8+3
32  19+13
32  19+8+5
35  19+13+3
35  19+8+5+3
37  19+13+5
40  19+13+8
40  19+13+5+3
43  19+13+8+3
45  19+13+8+5
48  19+13+8+5+3

例如，这种情况可能是一组用于解决问题的阻力带。 假设您获得5个波段，每个波段具有以磅为单位表示的不同阻力，您可以组合波段来总计总阻力。 带阻力为3,5,5,13和19磅。 此设置为您提供32（2 ^ 5）种可能的配置，减零。 在该示例中，算法首先返回有利于有效频带配置的按升序总电阻排序的数据，并且对于每个配置，频带按降序电阻排序。

Answer 10

v=[1,2,3,4]#variables to sum
i=0
clis=[]#check list for solution excluding the variables itself
def iterate(lis,a,b):
    global i
    global clis
    while len(b)!=0 and i<len(lis):
        a=lis[i]
        b=lis[i+1:]
        if len(b)>1:
            t=a+sum(b)
            clis.append(t)
        for j in b:
            clis.append(a+j)
        i+=1
        iterate(lis,a,b)
iterate(v,0,v)

它用python编写。 我们的想法是在单个整数和列表中打破列表。 [1,2,3,4]分为1，[2,3,4]。 我们现在通过添加整数和剩余列表的总和来追加总和。此外，我们采用每个单独的总和，即1,2; 1,3; 1,4。 检查表现在应为[1 + 2 + 3 + 4,1 + 2,1 + 3,1 + 4]然后我们递归调用新列表，即现在int = 2，list = [3,4]。 清单现在将附加[2 + 3 + 4,2 + 3,2 + 4]，因此我们附上清单直到清单为空。

Answer 11

set是sums的集合，list是原始数字的列表。

它的Java。

public void subSums() {
    Set<Long> resultSet = new HashSet<Long>();
    for(long l: list) {
        for(long s: set) {
            resultSet.add(s);
            resultSet.add(l + s);
        }
        resultSet.add(l);
        set.addAll(resultSet);
        resultSet.clear();
    }
}

Answer 12

这不是生成总和的代码，但它会生成排列。 在你的情况下：

1; 1,4; 1,7; 4,7; 1,4,7; ...

如果我有一个周末的时刻，如果它有趣，我可以修改它来得出总和。

这只是来自Igor Ostrovsky博客的一段有趣的LINQ代码，名为“使用LINQ简化程序的7个技巧”（ http://igoro.com/archive/7-tricks-to-simplify-your-programs-with-linq/ ）。

T[] arr = …;
var subsets = from m in Enumerable.Range(0, 1 << arr.Length)
              select
                  from i in Enumerable.Range(0, arr.Length)
                  where (m & (1 << i)) != 0
                  select arr[i];

Answer 13

public static void main(String[] args) {
        // this is an example number
        long number = 245L;
        int sum = 0;

        if (number > 0) {
            do {
                int last = (int) (number % 10);
                sum = (sum + last) % 9;
            } while ((number /= 10) > 0);
            System.err.println("s = " + (sum==0 ? 9:sum);
        } else {
            System.err.println("0");
        }
    }

Answer 14

谢谢Zach，

我正在创建银行对帐解决方案。 我将你的代码放到jsbin.com进行一些快速测试并在Javascript中生成：

function f(numbers,ids, index,  sum, output, outputid, find )
{
    if (index == numbers.length){
          var x ="";
          if (find == sum) {
              y= output + " } = " + sum + "  " + outputid + " }<br/>" ;
          }
        return;
    }
    f(numbers,ids, index + 1, sum + numbers[index], output + " " + numbers[index], outputid + " " + ids[index], find);
    f(numbers,ids, index + 1, sum, output, outputid,find);
}

var y;

f( [1.2,4,7,13,45,325,23,245,78,432,1,2,6],[1,2,3,4,5,6,7,8,9,10,11,12,13], 0, 0, '{','{', 24.2);
if (document.getElementById('hello')) {
  document.getElementById('hello').innerHTML = y;
}

我需要它来生成一个ID列表，以便从下一个匹配的数字中排除。

我将使用vb.net回发我的最终解决方案

Answer 15

如果您想避免维护成本，您可能有兴趣查看GNU Scientific Library。 对较长序列求和的实际过程将变得非常昂贵（比在步骤基础上生成单个置换更多），大多数架构都具有可以提供相当令人印象深刻的加速的SIMD /向量指令（我将提供此类实现的示例但我还不能发布网址）。