sicp-2.2.1

(define (last-pair lst)
  (let ([second (cdr lst)])
    (if (null? second)
      (car lst)
      (last-pair second))))

(define (append list1 list2)
   (if (null? list1)
       list2
       (cons (car list1) (append (cdr list1) list2))))

(define (reverse lst)
  (if (null? lst)
    lst
    (append
      (reverse (cdr lst))
      (list (car lst)))))

(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 (no-more? coin-values)
  (null? coin-values))

(define (except-first-denomination coin-values)
  (cdr coin-values))

(define (first-denomination coin-values)
  (car coin-values))

(define (same-parity a . z)
  (define (iter f left)
    (if (null? left)
      left
      (let* ([first (car left)]
            [second (cdr left)]
            [temp (iter f second)])
        (if (f first)
          (cons first temp)
          temp))))
  (iter
    (lambda (x) (= (remainder a 2) (remainder x 2)))
    (cons a z)))

(define (square x) (* x x))

(define (square-list items)
   (if (null? items)
       null
       (cons (square (car items))
             (square-list (cdr items)))))

(define (square-list items)
   (map square items))

(define (square-list items)
   (define (iter things answer)
     (if (null? things)
         answer
         (iter (cdr things)
               (append answer
                       (list (square (car things)))))))
   (iter items null))

(define (for-each proc items)
  (cond
    ((null? items) #t)
    (else (proc (car items))
          (for-each proc (cdr items)))))