**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:

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) { if (num < den) return num; else return(remainder(num - den, den)); }

int remainder(int num, int den) { return num - (den * (num / den)); }

**Problem : **
The following function iteratively computes
*x*
^{n}
:

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

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
*x*
^{n} = = (*x*
^{2})^{(}
*n*/2)
when
*n*
is even to write
a more efficient solution to the above problem.

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.

Note: This code does not handle error checking.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); } }

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

Whenint 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; }