Different ways to get balls from a box - algorithm

Question

You have a box with of balls ,We pull all balls from the box
But we can pull one at a time or three at a time
And the order of extraction matters.
The question is how many different ways are there to pull the balls out?
So if the:
Box contains 1 ball there is only 1 way.
Box contains 2 ball there is only 1 way.
Box contains 3 ball there is 2 way (pull 1 by one or three at once)
Box Contains 4 balls there are 3 ways:
1111
13
31
And the given was that for 7 balls there at 9 different ways to extract the balls from the box
So the question is given the amount of balls in the box,
The solution I came up with was recursive:
Int calculate(int balls){
If(balls=0) return 0;
If(balls=1) return 1;
If(balls=2) return 1;
If(balls=3) return 2;
If(balls=4) return 3;
return calculate(balls-1) + calculate(balls-3);
}
Is this correct?
Is there a way without using recursion?
Thank you

Answer 1

Your solution is correct. However, there are ways to improve the performance of the algorithm using a technique called dynamic programming. In this case, you can memoize the results, which means storing all the intermediate results in a lookup table after calculating each of them once using recursion. This allows a solution that normally requires exponential time to complete in linear time. Here's an example implementation of that in JavaScript:
function calculate (balls, map = []) {
if (balls in map) {
return map[balls]
}
switch (balls) {
case 0:
return 0
case 1:
return 1
case 2:
return 1
case 3:
return 2
default:
return map[balls] = calculate(balls - 1, map) + calculate(balls - 3, map)
}
}
console.time('dynamic')
console.log(calculate(50))
console.timeEnd('dynamic')
Compare that to the naive algorithm:
function calculate (balls) {
switch (balls) {
case 0:
return 0
case 1:
return 1
case 2:
return 1
case 3:
return 2
default:
return calculate(balls - 1) + calculate(balls - 3)
}
}
console.time('naive')
console.log(calculate(50))
console.timeEnd('naive')

Answer 2

You don't need memoization (at least not for all values) or solving the recursion to write a non-recursive program for this - or similar cases.
Something like the following will do:
function calculate (balls) {
if (balls=0) return 0; /* Or remove this line */
if (balls<3) return 1;
resMinus3=1; /* The result for i-3 */
resMinus2=1; /* For i-2 */
resMinus1=1; /* And for i-1 */
for(i=3;;++i) {
newRes=resMinus1+resMinus3; /* The recursion formula */
if (i>=balls) return newRes;
resMinus3=resMinus2; /* Shifting results */
resMinus2=resMinus1;
resMinus1=newRes;
}
}
The reason is that to compute the value for balls you only need values for balls-1 and balls-3, so you only need to keep track of three previous results to update the new one. Alternatively you could write this as a matrix update:
[resMinus1;resMinus2;resMinus3] <-[0,1,0;0,0,1;1,0,1]*[resMinus1;resMinus2;resMinus3]

Answer 3

From a link in the comments, you can find this equation:
a(n) = Sum_{i=0..floor(n/3)} binomial(n-2*i, i)
function binom(n, k) {
var coeff = 1;
for (var i = n-k+1; i <= n; i++) coeff *= i;
for (var i = 1; i <= k; i++) coeff /= i;
return coeff;
}
function calculate (balls) {
sum = 0;
for (i = 0; i <= Math.floor(balls/3); i++){
sum += binom(balls - 2*i, i);
}
return sum;
}
console.time('someMathGenius')
console.log(calculate(50))
console.timeEnd('someMathGenius')

Answer 4

For N balls, you can pull between 0 and floor(n/3) triples.
For N balls where you pull k triples, you also pull N-3k singles.
Now the problem is reduced to counting the distinct ways you can order k things of one type, and N-3k things of another type. This is choose(k + N-3k, k) = choose(N-2k,k).
Final answer is the sum from k=0 to floor(N/3) of choose(N-2k,k).
N=0: choose(0,0) = 1 so there is 1 way of choosing nothing.
N=1: choose(1,0) = 1
N=2: choose(2,0) = 1
N=3: choose(3,0) + choose(1,1) = 1+1 = 2
N=4: choose(4,0) + choose(2,1) = 1+2 = 3
...
N=7: choose(7,0) + choose(5,1) + choose(3,2) = 1 + 5 + 3 = 9