What is the magic behind that recursive function? - c

Question

Question:
Can you explain me how that fuction returns the correct result 16?
I am new to programming and now this code is recursive, however I think I am getting lost as much as I think I understand them. Even though, I believe I figure out factorial recursions or fibonacci ones.
The base is 0, that's good, but I can't figure out why I get 16... I printed every variable inside the function and dubugged, but those did not help more than troubling. When b variable is 0 (and a variable is 32) the condition is met, but why it returns value 16? I would understand a kind of function as n * fact(n-1) as in a classic factorial fuction example, but here I can't visualize how the recursion returns the expected result.
Code:
#include <stdio.h>
int fun(int a, int b)
{
if (b == 0)
{
return 0;
}
if (b % 2 == 0)
{
return fun(a+a, b/2);
}
return fun(a+a, b/2)+a;
}
int main()
{
printf("%d\n", fun(4, 4));
return 0;
}
Thanks in advance!

Answer 1

Add printouts and it will become very clear:
int fun(int a, int b)
{
printf("fun(%d, %d)\n", a, b);
if (b == 0) {
printf("b == 0, returning 0\n");
return 0;
}
if (b % 2 == 0) {
printf("b is even, returning f(%d, %d)\n", a+a, b/2);
return fun(a+a, b/2);
}
printf("b is odd, returning f(%d, %d) + %d\n", a+a, b/2, a);
return fun(a+a, b/2)+a;
}
Output:
$ ./a.out
fun(4, 4)
b is even, returning f(8, 2)
fun(8, 2)
b is even, returning f(16, 1)
fun(16, 1)
b is odd, returning f(32, 0) + 16
fun(32, 0)
b == 0, returning 0
16
So what happens in the end is that f(16, 1) will return f(32, 0) + 16 and f(32, 0) evaluates to zero, so 16 is returned.
You could also do like this, but do note that this will alter the order of the outputs because the printout need to wait for the return:
int fun(int a, int b)
{
printf("fun(%d, %d)\n", a, b);
if (b == 0) {
printf("b == 0, returning 0\n");
return 0;
}
if (b % 2 == 0) {
int ret = fun(a+a, b/2);
printf("b is even, returning f(%d, %d) = %d \n", a+a, b/2, ret);
return ret; //fun(a+a, b/2);
}
int ret = fun(a+a, b/2) + a;
printf("b is odd, returning f(%d, %d) + %d = %d \n", a+a, b/2, a, ret);
return ret;
}
Output:
$ ./a.out
fun(4, 4)
fun(8, 2)
fun(16, 1)
fun(32, 0)
b == 0, returning 0
b is odd, returning f(32, 0) + 16 = 16
b is even, returning f(16, 1) = 16
b is even, returning f(8, 2) = 16
16
A good way to understand recursion is to use pen and paper to see why the order of printouts is so different in these cases. But I leave that to you.

Answer 2

I find helpful to think about these kind of recursive functions as mathematical tools. What I mean is that a recursive function works if:
It always says the truth.
You can prove that it ends, eventually.
You don't say, but I guess that your function fun(a, b) does a multiplication a * b. And it does it by reducing it:
If b==0 then a * b -> 0
Else, if b is even then a * b -> (a+a) * (b/2).
Else (b is odd), a * b -> ((a+a) * (b/2)) + a
These equations are trivially true, as long as b >= 0 of course, which I assume that is a precondition of your function.
You also can see that it will eventually finish, as the value of b gets smaller and smaller, and it will always reach 0 at the end.
That should be enough to believe that your function works. If you want to trace each intermediate step, you can check your truth every time to ensure that you doing it properly.
a=4, b=4, b is even, so foo(4,4) -> foo(8, 2) (we know that 4*4 == 16, and 8*2 == 16 too, so we are on the right track).
a=8, b=2, b is even, so foo(8, 2) -> foo(16, 1) (16 * 1 ==16, we are still ok).
a=16, b=1, b is odd, so foo(16, 1) -> foo(32, 0) + 16. Here is the tricky part, this call is not tail-recursive, there is the latter addition. But still, 32*0 + 16 = 16 so we are on the right track.
a=32, b=0 b is 0 so it returns 0 (ok, because 32*0 = 0).
Then there is the latter sum: 0 + 16 = 16 and that value is returned all up to main.

Answer 3

There are two things about recursive functions:
recursive functions are not special. Eg. they work the same way as if you called a different function that served the same purpose for the smaller sub problems.
All functions will have their own arguments and local variables. The location of a and b is new for each invocation of a fucntion. Thus if you call the same function from itself there will be no interference between the two!
You should do substitution rules:
Replace the call with the code that is executed according to the conditionals.
Repeat until you no longer have anything to call
Example:
fun(4, 4) // initial call
fun(4+4, 4/2) // because 4 % 2 == 0
fun(8+8, 2/2) // because 2 % 2 == 0
fun(16+16, 1/2) + 16 // because 1 % 2 != 0.
0 + 16 // because 1/2 == 0 and then b == 0
16 // because 0 + 16 == 16