CS 257 (Spring 2003) Homework 4

• Problem 1 (Marroquin Pattern)

  The Marroquin pattern of order n is formed by superimposing three square arrays of points of size 2n + 1. Consequently, each array has an odd number of rows and columns. The arrays are rotated about the center (i.e., n + 1) point. The orientations of the arrays (relative to the x-axis) are 0, 60, and 120 degrees. You will write a function called marroquin which takes a single integer argument, n, and returns the Marroquin pattern of order n. Example:

  >(marroquin 9)
  >#<struct:graphic>
  

  

• Problem 2 (Tail-Recursive Spiral)

  The following program draws a spiral:

  (define spiral
    (lambda (angle len n)
      (if (= n 0)
          (adjoin)
          (adjoin (bend angle)
                  (straight len)
                  (spiral angle (add1 len) (sub1 n))))))
  

  Rewrite spiral so that it is tail-recursive. You are free to use any helper-functions you may require.

• Problem 3 (Macro Expansion)

  Write a function, cond->if, which takes a cond expression as its argument and returns the equivalent expression using if's. For example:

  > (cond->if '(cond ((= x 1) 'foo) ((= x 2) 'bar) (else 'error)))
  (if (= x 1) (quote foo) (if (= x 2) (quote bar) (quote error)))
  > 
  

  You may assume that every cond expression has an else part.

• Problem 4 (Recognizing Tail Recursive Definitions)

  The definition of a function, foo, is a <tail definition> if it has the following form:

  (define foo (lambda (<symbol>*) <tail wrt foo>))

  where <symbol>* is zero or more symbols and an expression is <tail wrt foo> if it is not an application of foo:

  <contains no foo applications>

  or

  if it is an application of foo to zero or more expressions which contain no applications of foo:

  (foo <contains no foo applications>*)

  or

  if all applications of foo are contained in expressions which are (themselves) tail recursive with respect to foo and which occur in any of the following contexts:
  • (if <contains no foo applications> <tail wrt foo> <tail wrt foo>)
  • (and <contains no foo applications>* <tail wrt foo>)
  • (or <contains no foo applications>* <tail wrt foo>)

  where <contains no foo applications> is an expression which contains no applications of foo, and <contains no foo applications>* is zero or more expressions which contain no applications of foo.

  Write a function, tail-definition?, which takes an expression, expr, as an argument, and returns #t if the expression is a <tail definition> and #f otherwise. For example:

  > (tail-definition? '(define fact (lambda (x acc) (if (= x 0) acc (fact (- x 1) (* x acc))))))
  #t
  > (tail-definition? '(define fact (lambda (x) (if (= x 0) 1 (* (fact (- x 1)))))))
  #f
  > (tail-definition? '(define member? (lambda (item ls) (and (not (null? ls)) (or (eq? item (car ls)) (member? item (cdr ls)))))))
  #t
  >
  
  

  Hint: Divide and conquer. Write helper-functions, tail-wrt? and no-applications-of?. Both take a function name, fname, and an expression, expr, as arguments. tail-wrt? returns #t if expr is tail with respect to fname and #f otherwise. no-applications-of? returns #t if there are no applications of fname in expr, and #f otherwise.

• Problem 5

  Exercises 5.3, 5.6, 5.8 from Springer and Friedman.

• Problem 6

  The function list? takes an s-expression, s, as an argument and returns #t if s is a list and #f otherwise. Give a definition of the function, list-all?, which takes an s-expression, s, as an argument and returns #t if s is a list and all pairs in s are also lists. Otherwise, list-all? returns #f. For example,

  > (list-all? '(1 ((2 3)) (4))))
  #t
  > (list-all? '(1 ((2 . 3)) (4))))
  #f
  

  You may use list? to define list-all?.

  When You Should Hand It In

  The above should be handed in Tues. March 11 by midnight. Start early! Problems 1 and 4 are quite challenging.

  * This webpage is located at http://cs.unm.edu/~williams/cs257/homework4s03.html