Recursion with integers

Exercise 1

Using natural-number recursion, develop a Scheme procedure named power-of-two that takes a natural number as its argument and returns the result of raising 2 to the power of that number. Here's one sample call to get you started: the value of (power-of-two 3) should be 2³, or 8.

It's possible to define this procedure non-recursively, using Scheme's primitive expt procedure, but the point of the exercise is to use recursion.

Exercise 2

Develop a Scheme procedure named list-fill that takes two arguments, the second of which is a natural number, and returns a list consisting of the specified number of repetitions of the first argument.

Exercise 3

Develop a Scheme procedure named count-down that takes a natural number as argument and returns a list of all the natural numbers less than or equal to that number, in descending order:

> (count-down 5)
(5 4 3 2 1 0)

Exercise 4

Using count-from, define and test a Scheme procedure that takes a natural number as argument and returns a list of all the natural numbers that are strictly less than the argument, in ascending order. (The traditional name for this procedure is iota.)

Exercise 5

Here is a procedure that computes the product of all of the odd natural numbers up to and including number:

;;; odd-factorial: compute the product of odd natural
;;; numbers up to and including a given natural number

;;; Given:
;;;   NUMBER, an integer

;;; Result:
;;;   PRODUCT, an integer

;;; Preconditions:
;;;   (This is the exercise.)

;;; Postcondition:
;;;   PRODUCT is the product of the odd natural numbers
;;;   up to and including NUMBER.

(define odd-factorial
  (lambda (number)
    (if (= number 1)
        1
        (* number (odd-factorial (- number 2))))))

What preconditions does odd-factorial impose on its argument? What will happen if these preconditions are not met?

Exercise 6

Here is the definition of a procedure that computes the number of digits in the decimal representation of number:

;;; number-of-decimal-digits: compute the number of
;;; digits in the decimal representation of a given number

;;; Given:
;;;   NUMBER, an integer

;;; Result:
;;;   LENGTH, an integer

;;; Preconditions:
;;;   (This is part of the exercise.)

;;; Postcondition:
;;;   LENGTH is the number of digits in the decimal
;;;   representation of NUMBER.

(define number-of-decimal-digits
  (lambda (number)
    (if (< number 10)
        1
        (+ (number-of-decimal-digits (quotient number 10)) 1))))

Write out some sample calls to this procedure and test them to confirm that you get the expected answer. What preconditions does number-of-decimal-digits impose on its argument?

The definition of number-of-decimal-digits uses direct recursion. Describe the base case of this recursion. Identify and describe the way in which a simpler instance of the problem is created for the recursive call. Explain how the procedure correctly determines that the decimal numeral for the number 2000 contains four digits.

Exercise 7

Develop a Scheme procedure wrap that takes any value as its first argument and any natural number n as its second argument, and ``wraps'' the value as a singleton list n times. Here are some sample calls:

> (wrap 'contents 5)
(((((contents)))))
> (wrap #t 1)
(#t)
> (wrap (list 'alpha 'beta) 2)
(((alpha beta)))
> (wrap 'unwrapped 0)
unwrapped

Exercise 8

Develop a procedure named runs that takes a natural number n as argument and returns a list of Boolean values consisting of n runs, where a run consists of zero or more occurrences of #f followed by one occurrence of #t. The first of the n runs should be of length 1 (including the final #t), the second of length 2, and so on. Here is a sample call:

> (runs 5)
(#t #f #t #f #f #t #f #f #f #t #f #f #f #f #t)