给定数字N，如何调用递归调用N次？

Question

I have an array of numbers: S= {4,5} and I want to check if this group creates the sum = 13 .

In this case, yes: 4 + 4 + 5 = 13

Another example: s={4,5} , sum = 6 -> no

I wrote a recursive function to solve this:

public static boolean isSumOf(int [] s,int n)
    {
        if(n == 0)
            return true;
        if(n < 0)
            return false;

        return isSumOf(s,n-s[0]) || isSumOf(s,n-s[1]);
    }

But this function works only for 2 numbers in the array. I need to write a recursive function that will deal with N numbers, like {4,9,3} or {3,2,1,7} etc.

I'm not sure how can I do this? How can I call a recursion N times, according to the length of the array? Or maybe I should change my algorithm completely? Also - I'm not allowed to use loops.

Answer 1

return isSumOf(s,n-s[0]) || isSumOf(s,n-s[1]);

You can generalize this with a loop like this:

for (int i = 0; i < s.length; ++i) {
  if (isSumOf(s,n-s[i])) return true;
}
return false;

But, since you can't use loops, you can write the equivalent loop as another recursive method:

boolean withoutLoop(int [] s,int n, int i) {
  if (i >= s.length) return false;
  return isSumOf(s,n-s[i]) || recurse(s, n, i+1);
}

and then call it like so from your isSumOf method:

public static boolean isSumOf(int [] s,int n)
{
    if(n == 0)
        return true;
    if(n < 0)
        return false;

    return withoutLoop(s, n, 0);  // Change here.
}

Or, if you want to write it more concisely:

return (n == 0) || (n < 0 && withoutLoop(s, n, 0));

Answer 2

Break the problem down:

1. Sum the numbers
2. Is the sum equal to 13?

Then think of a way to express summing an array as recursive task; eg Sum of elements 1 to N is element 1 + Sum of elements 2 to N.

Finally, turn that idea / expression into code.

Answer 3

For any recursion problem, use the template:

ResultType recursiveMethod(params) {
     if( /* this is the simplest case */ ) {
         return answer for the simplest case
     } else {
         partialResult = solve part of the problem
         resultForRest = recursiveMethod(rest of problem)
     }
}

Particularly for list processing, this becomes:

if(list is empty) {
    return solution for an empty list
} else {
    r = call self recursively for tail of list
    return solution for head of list combined with r
}

(Where "head" is the first item, and "tail" is the rest. Tail may be empty.)

For your problem, the simplest case is an empty array:

 if(s.length == 0) {
      return n == 0;
 }

For the else , the "part of the problem" is s[0] and the "rest of the problem" is s[1] onwards.

 ... 
 } else {
     int head = s[0];
     int[] tail = Arrays.copyOfRange(s,1,s.length-1);
     return isSumOf(tail, n - head);
 }

The code would be cleaner (and probably more efficient) if you used a List instead of an array directly, because you could then use List.subList() instead of copyOfRange() .

You could also pass the whole array each time, along with an extra parameter indicating how much of the array has already been accounted for.

Answer 4

This should work:

public static boolean isSumOf(int [] s,int n)
    {
        if(n == 0)
            return true;
        if(n < 0)
            return false;

        for (int x: s) {
            if (isSumOf(s, n-x)) {
                return true;
            }
        }
        return false;
    }

UPDATE:

Oh! no loop, only recursion, you will need an extra argument:

public static boolean isSumOf(int [] s,int n)
    {
        if(n == 0)
            return true;
        if(n < 0)
            return false;

        return isSum2(s, n, 0);
    }

public static boolean isSum2(int [] s,int n,int i)
    {
        if (i >= s.length)
            return false;

        return isSumOf(s,n-s[i]) || isSum2(s,n,i+1);
    }