仅使用递归编写 C 函数

Question

我想知道数组中偶数之和是否等于奇数之和，只使用递归，没有任何附加函数，除了递归，没有任何静态变量。

如果奇数之和等于偶数之和，则函数返回1，否则返回0。数组中的所有数字都是非负数。

函数签名应如下所示：

function(unsigned int a[], int n)

到目前为止，我已经写了以下内容：

function(unsigned int a[], int n)
{ 
    if(n==0) return 0;
    return (a[0]%2)?((a[0]+function(a+1,n-1)):(-a[0]+function(a+1,n-1));
}

此函数返回所需的总和，但不返回问题的答案（如果是，则为 1，如果不是，则为 0）。

是的，这是作业的一部分，但如果没有其他不允许的功能，我无法解决它。

Answer 1

如果我们假设计算中没有溢出：

int function (unsigned int a[], int n) {
    if (n >= 0) return !function(a, -n-1);
    if (++n == 0) return 0;
    return function(a+1, n) + ((a[0] % 2) ? -a[0] : a[0]);
}

在第一次调用函数时，n 是非负数，它反映了数组的大小。我们递归地调用函数并对结果进行逻辑否定，并在算术上否定n+1。一个否定的关闭允许-1代表0

在随后的调用中，偶数的总和为正累加，赔率的总和为负累加。负数n 递增，直到达到0。如果总和相等，则对负数 n 的递归调用结果为 0，否则为非零。

返回到最外层调用时，逻辑否定将其翻转，如果总和相等则返回1，否则返回0。

我将把它作为适当处理溢出的练习。

Answer 2

@jxh 漂亮答案的模组。

对递归函数的典型抱怨是用完堆栈。对于N 元素，具有N 级别的递归可能会耗尽递归限制。

以下代码改为使用log2(N) 递归级别，每次调用时将数组分成两半。

int function(const int a[], int n) {
  if (n > 0) return !function(a, -n);
  if (n == 0) return 0;
  if (n == -1) return (a[0] % 2) ? -a[0] : a[0];
  int half = n/2;
  int left = function(a, half);
  int right = function(&a[-half], -(-n - -half));
  return left + right;
}

Answer 3

这是我的解决方案，它比您的解决方案复杂得多，而且方式不好且不需要。

int balanced(unsigned int a[], int n)
{
    if (n <= 2)
    {
        int odd = 0, even = 0;
        if (a[0]%2 == 0) even += a[0];
        else odd += a[0];
        if (a[1]%2 == 0 && n == 2) even += a[1];
        else if (n == 2) odd += a[1];
        return (odd == even);
    }

    if (a[0]%2 == 0 && a[1]%2 == 0)
    {
        a[1] += a[0];
        return balanced(a+1, n-1);
    }
    if (a[0]%2 == 0 && a[2]%2 == 0)
    {
        a[2] += a[0];
        return balanced(a+1, n-1);
    }
    if (a[1]%2 == 0 && a[2]%2 == 0)
    {
        a[2] += a[1];
        a[1] = a[0];
        return balanced(a+1, n-1);
    }
    if (a[0]%2 == 0)
    {
        if (a[0] >= a[1]+a[2])
        {
            a[0] -= (a[1]+a[2]);
            a[2] = a[0];
            return balanced(a+2,n-2);
        }
        else
        {
            a[1] = a[1]+a[2]-a[0]-1;
            a[2] = 1;
            return balanced(a+1,n-1);
        }
    }
    if (a[1]%2 == 0)
    {
        if (a[1] >= a[0]+a[2])
        {
            a[1] -= (a[0]+a[2]);
            a[2] = a[1];
            return balanced(a+2,n-2);
        }
        else
        {
            a[0] = a[0]+a[2]-a[1]-1;
            a[2] = 1;
            a[1] = a[0];
            return balanced(a+1,n-1);
        }
    }
    if (a[2]%2 == 0)
    {
        if (a[2] >= a[1]+a[0])
        {
            a[2] -= (a[1]+a[0]);
            return balanced(a+2,n-2);
        }
        else
        {
            a[1] = a[1]+a[0]-a[2]-1;
            a[0] = 1;
            a[2] = a[0];
            return balanced(a+1,n-1);
        }
    }
    else
    {
        a[2] = a[0]+a[1]+a[2];
        return balanced(a+2,n-2);
    }
}