Problem : Write a function to recursively print out an integer in any base from base 2 to base 9.

void print_base(int num, int base) { if (num / base) print_base(num / base, base); putchar(num % base + '0'); }

Problem : Write a recursive function int count_digit(int n, int digit); to count the number of digits in a number n (n > 0) that are equal to a specified digit. For example, if the digit we're searching for were 2 and the number we're searching were 220, the answer would be 2.

int count_digit(int n, int digit) { int count; if (n == 0) return 0; if (n % 10 == digit) return 1 + count_digit(n / 10, digit); else return count_digit(n / 10, digit); }

Problem : For some reason, the computer you're working on doesn't allow you to use the modulo operator % to compute the remainder of a division. Your friend proposes the following function to do it:

int remainder(int num, int den) { if (num < den) return num; else return(remainder(num - den, den)); }
Does this function work? Is there a better way?

Yes, the function does work, however there is a much more efficient method to compute the remainder by taking advantage of integer division:
int remainder(int num, int den) { return num - (den * (num / den)); }

Problem : The following function iteratively computes xn:

int exponentiate_i(int x, int n) { int i, result = 1; for(i=0; i<n; i++) result *= x; return result; }
Write a function to do this recursively in O(n) time).

int exponentiate_r(int x, int n) { if (n==0) return 1; else return x * exponentiate_r(x, n-1); }

Problem : Use the knowledge that xn = = (x2)(n/2) when n is even to write a more efficient solution to the above problem.

If n is even, then xn = = (x2)(n/2). If n is odd, then xn = = x*(x2)((n - 1)/2). So:
int exponentiate2_r(int x, int n) { if (n==0) return 1; else if (n % 2==0) return exponentiate2_r(x*x, n/2); else return x * exponentiate2_r(x*x, (n-1) / 2); }

Problem : The classic fibonacci problem, where the next term in the sequence is the sum of the previous two terms, is often called fib2. One could also imagine a sequence fibN, where N is the number of previous terms to sum up. Write this function recursively.

int fibN(int num, int terms) /* terms is the N */ { int i, total = 0; if (num<=1) return 1; else { for(i=1; i <= terms; i++) total += fibN(num-i, terms); return(total); } }
Note: This code does not handle error checking.

Problem : What operation does the following function implement when p is 0, 1, and 2?

int mystery(n, m, p) { int i, result = 0; if (p==0) return n+m; for (i=0; i< m; i++) result += mystery(result,n,p-1); return result; }

When p==0, this is an addition function. When p==1, this is a multiplication function. When p==2, this is a power function.