Pasted

#lang racket
 
;;;;;;;;;;
;; 2.17 ;;
;;;;;;;;;;
 
;; I believe it's customary with Racket to use first instead of car and rest
;; instead of cdr.
 
(define (my-last-pair lst)
  (define rest-of-list (rest lst))
  (if (empty? rest-of-list)
    lst
    (my-last-pair rest-of-list)))
 
(define lst (list 1 2 3 4))
(my-last-pair lst)
;; '(4)
 
;;;;;;;;;;
;; 2.18 ;;
;;;;;;;;;;
 
(define (my-reverse lst)
  (define (iter old-lst new-lst)
    (if (empty? old-lst)
      new-lst
      (iter (rest old-lst) (cons (first old-lst) new-lst))))
  (iter lst empty))
 
(my-reverse lst)
;; '(4 3 2 1)
 
;;;;;;;;;;
;; 2.19 ;;
;;;;;;;;;;
 
(define us-coins (list 50 25 10 5 1))
(define uk-coins (list 100 50 20 10 5 2 1 0.5))
 
(define (cc amount coin-values)
  (cond [(= amount 0) 1]
        [(or (< amount 0) (no-more? coin-values)) 0]
        [else
          (+ (cc amount
                 (except-first-denomination coin-values))
             (cc (- amount
                    (first-denomination coin-values))
                 coin-values))]))
 
(define (first-denomination coin-values)
  (first coin-values))
(define (except-first-denomination coin-values)
  (rest coin-values))
(define (no-more? coin-values)
  (empty? coin-values))
 
(cc 100 us-coins)
;; 292
(cc 100 (my-reverse us-coins))
;; 292
(cc 100 (shuffle us-coins))
;; 292
 
;; I don't think re-ordering the list of coin values affects the final answer.
;; The validity of the recursion does not depend on the order of the
;; denominations.
 
;;;;;;;;;;
;; 2.20 ;;
;;;;;;;;;;
 
(define (my-filter predicate? items)
  (cond [(empty? items) empty]
        [(predicate? (first items))
         (cons (first items)
               (my-filter predicate? (rest items)))]
        [else (my-filter predicate? (rest items))]))
 
(define (same-parity x . ys)
  (define (same-parity-as-x? y)
    (= (remainder (- x y) 2) 0))
  (cons x (my-filter same-parity-as-x? ys)))
 
(same-parity 1 2 3 4 5 6 7)
;; '(1 3 5 7)
(same-parity 2 3 4 5 6 7)
;; '(2 4 6)
 
;;;;;;;;;;
;; 2.21 ;;
;;;;;;;;;;
 
(define (square-list items)
  (if (empty? items)
    empty
    (cons (sqr (first items))
          (square-list (rest items)))))
 
(define (my-map proc items)
  (if (empty? items)
    empty
    (cons (proc (first items))
          (my-map proc (rest items)))))
 
(define (new-square-list items)
  (map sqr items))
 
(square-list (list 1 2 3 4))
;; '(1 4 9 16)
(new-square-list (list 1 2 3 4))
;; '(1 4 9 16)
 
;;;;;;;;;;
;; 2.22 ;;
;;;;;;;;;;
 
;; cons'ing up a new list by cdr'ing down an old list processes the elements in
;; last-in-first-out order.  So everything is reversed.  It's like a stack where
;; cons is the push and car/cdr is the pop.
 
;; Reversing the arguments does not work because you can't cons a list onto an
;; element.
 
;;;;;;;;;;
;; 2.23 ;;
;;;;;;;;;;
 
(define (my-for-each proc items)
  (cond [(empty? items) (void)]
        [else
          (proc (first items))
          (my-for-each proc (rest items))]))
 
(my-for-each displayln (list 57 321 88))
;; 57
;; 321
;; 88