C函数使用加法和减法获取数组的所有总和

Question

使用加法和减法来获得数组中所有 N 个数字的总和的最佳方法是什么（在 C 中）？

例如（N = 3）：

arr[] = [30, 14, 2]

results:
-30-14-2 = -46
-30-14+2 = -42
-30+14-2 = -18
-30+14+2 = -14
 30-14-2 = 14
 30-14+2 = 18
 30+14-2 = 42
 30+14+2 = 46

可以看出，有2^N个解。

我还注意到，加法和减法符号的交替方式与二进制计数 (000 001 ... 110 111) 相同，这可能很有用。

也许递归方法是最好的，但我发现递归思考非常困难。

因此，我希望有人能向我解释解决这个问题的最佳策略是什么。

—————————

编辑：

我有一个可用的 Python 代码，但这使用了集合 set()，这在 C 中不可用。（arr 是一个包含所有数字的数组。）

out = set()
out.add(0)
for i in range(0, len(arr)):
    tmp = set()
    for j in out:
        tmp.add(j + arr[i])
        tmp.add(j - arr[i])
    out = tmp
print(out)

—————————

编辑：

通过用数组替换集合并进行一些小的更改，我得到了它的工作。感谢所有评论的人！

Answer 1

在这种情况下，递归似乎比数据结构更可取，因为问题的指数性质意味着您可以实际测试的任何 n 值都没有堆栈溢出的风险，但您可以利用堆栈的优势隐式存储功能。

可以使用索引i 非常直接地编写递归逻辑。基本情况是i >= n；打印您累积的总和。否则，从总和中减去ith 元素并在没有i 的数字列表的其余部分上递归。在第二个分支中，将ith 元素添加到总和中，并在没有i 的数字列表的其余部分上递归。如果 i 如 cmets 中指出的那样，您也可以使用指针将元素移出数组。

请注意，此过程将包含重复的结果，因此如果您想消除这些重复的结果，您最初的设定想法值得追求。

在函数中混合 IO 和逻辑通常是糟糕的设计，但为了简单起见，我将在这里打破这条规则：

#include <stdio.h>

void print_possible_sums(int nums_len, int *nums, int sum, int i) {
    if (i >= nums_len) {
        printf("%d\n", sum);
    }
    else {
        print_possible_sums(nums_len, nums, sum - nums[i], i + 1);
        print_possible_sums(nums_len, nums, sum + nums[i], i + 1);
    }
}

int main() {
    int arr[] = {30, 14, 2};
    print_possible_sums(sizeof(arr) / sizeof(arr[0]), arr, 0, 0);
    return 0;
}

输出：

-46
-42
-18
-14
14
18
42
46

Answer 2

我已经制作了一个算法来解决这个问题。也许我写的不是尽可能高效（所以也许可以改进），但至少它是有效的。

让我知道是否可以。

#include <stdio.h>
#include <math.h>
#include <stdlib.h>

#define MAX 4
void cycle(int arr[MAX]);
int toRepeat(int arr[MAX], int s);

int main(){
    int arr[MAX] = {1, 2, 3, 4};
    cycle(arr);
}

void cycle(int arr[MAX]){
    int a, ris;
    a = pow(2, MAX);
    for (int i= 0; i < a; i++){
        ris = toRepeat(arr, i);
        printf(" = %3d \n", ris);
    }
}

int toRepeat(int arr[MAX], int s){
    int pos = 0;
    int ris = 0;
    int a;
    bool flag;
    a = pow(2, MAX);
    if (s < a/2) {
        ris += arr[pos];
        printf("+%d", arr[pos]);
    } else {
        ris -= arr[pos];
        printf("-%d", arr[pos]);
    }
    pos++;
    
    for (int i= 2; i < a; i = i * 2){
        for (int j= 0; j < i/2; j++) {
            if (s%i == j) {
                ris += arr[pos];
                printf("+%d", arr[pos]);
                pos++;
                flag = true;
                break;
            }
        }
        if (!flag){
            ris -= arr[pos];
            printf("-%d", arr[pos]);
            pos++;
        }
        flag = false;
    }
    return ris;
}

输出：

+1+2+3+4 =  10
+1-2+3+4 =   6
+1+2-3+4 =   4
+1-2-3+4 =   0
+1+2+3-4 =   2
+1-2+3-4 =  -2
+1+2-3-4 =  -4
+1-2-3-4 =  -8
-1+2+3+4 =   8
-1-2+3+4 =   4
-1+2-3+4 =   2
-1-2-3+4 =  -2
-1+2+3-4 =   0
-1-2+3-4 =  -4
-1+2-3-4 =  -6
-1-2-3-4 = -10

Answer 3

我也是，我也是！

使用bool negative[3 + 1] = {0}; 保留一个数组。在每一步计算array[i] * (negative[i]?-1:1) 的总和。每一步都会以负数递增下一个值，就好像它是一个二进制数一样。当最高元素 negative[3] 为真时，循环结束 - 所以我们想要通过所有可能性。

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <assert.h>

int calc_sum(size_t len, const int vals[len], const bool negative[len]) {
    int sum = 0;
    for (size_t i = 0; i < len; ++i) {
        sum += vals[i] * (negative[i] ? -1 : 1);
    }
    return sum;
}

bool *sequence_init(size_t len) {
    // error checking omitted
    return calloc(len + 1, sizeof(bool));
}

bool sequence_continue(size_t len, bool t[len + 1]) {
    assert(t);
    const bool go_on = !t[len];
    if (!go_on) {
        // automatically free on loop end
        free(t);
    }
    return go_on;
}

void sequence_next(size_t len, bool t[len + 1]) {
    assert(t);
    for (size_t i = 0; i < len + 1; ++i) {
        if (!t[i]) {
            t[i] = 1;
            break;
        } else {
            t[i] = 0;
        }
    }
}

int main() {
    const int vals[3] = { 30, 14, 2 };
    const size_t len = 3;
    for(
        bool *sequence = sequence_init(len);
        sequence_continue(len, sequence);
        sequence_next(len, sequence)
    ) {
        for (size_t i = 0; i < len; ++i) {
            printf("%2d*%d %c ",
                sequence[i]?-1:1,
                vals[i],
                i + 1 != len ? '+' : '='
            );
        }
        const int sum = calc_sum(len, vals, sequence);
        printf("%d\n", sum);
    }
}

代码输出：

 1*30 +  1*14 +  1*2 = 46
-1*30 +  1*14 +  1*2 = -14
 1*30 + -1*14 +  1*2 = 18
-1*30 + -1*14 +  1*2 = -42
 1*30 +  1*14 + -1*2 = 42
-1*30 +  1*14 + -1*2 = -18
 1*30 + -1*14 + -1*2 = 14
-1*30 + -1*14 + -1*2 = -46