我有一个数字列表，我想要添加所有不同的组合。 例如：
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
是否有使用不同数字计算此公式的公式？
答案 0 :(得分：28)
执行此操作的一种简单方法是使用与数字一样多的位创建位集。 在你的例子中4.
然后从0001到1111计数，并对集合中每个数字1加1：
数字1,4,7,13：
0001 = 13=13
0010 = 7=7
0011 = 7+13 = 20
1111 = 1+4+7+13 = 25
答案 1 :(得分：7)
以下是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
答案 2 :(得分：6)
最着名的算法需要指数时间。如果存在多项式时间算法，那么您将解析subset sum problem，从而求解P=NP problem。
这里的算法是创建长度等于你的数字基数的位向量。修复您的一组数字的枚举(n_i)。然后，枚举位向量的所有可能值。对于位向量的每个枚举(e_i)，计算e_i * n_i的总和。
这里的直觉是，您通过位向量表示数字集的子集，并生成该组数字的所有可能子集。当位e_i等于1时，n_i位于子集中，否则不是。
Knuth TAOCP的第四卷提供了生成位向量的所有可能值的算法。
答案 3 :(得分：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
答案 4 :(得分：4)
这是一个简单的递归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)
我认为你不能比这简单得多。
答案 5 :(得分：3)
这个Perl程序似乎可以做你想要的。它通过不同的方式选择n items from k items。计算有多少组合很容易，但是获得每个组合的总和意味着你必须最终添加它们。当我问Perlmonks时，我在How can I calculate the right combination of postage stamps?上遇到了类似的问题。
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";
}
}
答案 6 :(得分：3)
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
答案 7 :(得分：2)
您可以使用位向量枚举所有子集。
在for循环中，从0到2变为N次幂减去1（如果你不关心空集，则从1开始）。
在每次迭代时，确定设置了哪些位。第N位表示集合的第N个元素。对于每个设置位，取消引用该组的相应元素并添加到累计值。
ETA：由于此问题的性质涉及指数复杂性，因此您可以枚举的集合的大小存在实际限制。如果事实证明你不需要所有子集，你可以查找“n选择k”以获取枚举k个元素子集的方法。
答案 8 :(得分：1)
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）种可能的配置，减零。在此示例中，算法返回按升序总阻力排序的数据，首先支持有效的波段配置，对于每个配置，波段按降序阻抗排序。
答案 9 :(得分：0)
这不是生成总和的代码，但它会生成排列。在你的情况下：
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];
答案 10 :(得分：0)
如果您想避免维护成本，您可能有兴趣查看GNU Scientific Library。对较长序列求和的实际过程将变得非常昂贵（比在步骤基础上生成单个置换更多），大多数架构都具有可以提供相当令人印象深刻的加速的SIMD /向量指令（我将提供此类实现的示例但我还不能发布网址。）
答案 11 :(得分：0)
谢谢扎克，
我正在创建银行对帐解决方案。我把你的代码放到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回复我的最终解决方案
答案 12 :(得分：0)
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]，因此我们附上清单直到清单为空。
答案 13 :(得分：0)
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();
}
}
答案 14 :(得分：0)
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");
}
}