;; Programming Languages -- Spring 1996
;; Solutions to Homework One: Basic Scheme

;; erik hilsdale

;; ---- member-twice?

(define member-twice?
  (lambda (a ls)
    (cond
      ((null? ls) #f)
      ((eq? (car ls) a) (member? a (cdr ls)))
      (else
	(member-twice? a (cdr ls))))))

(define member?
  (lambda (a ls)
    (cond
      ((null? ls) #f)
      ((eq? (car ls) a) #t)
      (else
	(member? a (cdr ls))))))

;; ---- rember2

(define rember2
  (lambda (a ls)
    (cond
      ((null? ls) '())
      ((eq? (car ls) a) (cons (car ls) (rember1 a (cdr ls))))
      (else
	(cons (car ls) (rember2 a (cdr ls)))))))

(define rember1
  (lambda (a ls)
    (cond
      ((null? ls) '())
      ((eq? (car ls) a) (cdr ls))
      (else
	(cons (car ls) (rember1 a (cdr ls)))))))

;; ---- multtup

(define multtup
  (lambda (tup)
    (cond
      ((null? tup) 1)
      (else
	(* (car tup) (multtup (cdr tup)))))))

;; ---- list-index
;; This is probably the simplest way to solve this problem correctly.
;; There are more efficient ways, which we will explore as the
;; semester goes on.

(define list-index
  (lambda (i ls)
    (cond
      ((member? i ls)
       (list-index-help i ls))
      (else -1))))

(define list-index-help
  (lambda (i ls)
    (cond
      ((eq? (car ls) i) 0)
      (else
	(add1 (list-index-help i (cdr ls)))))))

;; ---- tree-mult

(define tree-mult
  (lambda (ls)
    (cond
      ((null? ls) 1)
      ((not (pair? (car ls)))
       (* (car ls) (tree-mult (cdr ls))))
      (else
	(* (tree-mult (car ls)) (tree-mult (cdr ls)))))))

;; ---- duplicate

(define duplicate
  (lambda (n i)
    (cond
      ((zero? n) '())
      (else
	(cons i (duplicate (sub1 n) i))))))

;; ---- compose2

(define compose2
  (lambda (f g)
    (lambda (x)
      (f (g x)))))

;; ---- assq

(define assq
  (lambda (a als)
    (cond
      ((null? als) #f)
      ((eq? (caar als) a) (car als))
      (else
	(assq a (cdr als))))))

;; ---- list-ref

(define list-ref
  (lambda (n ls)
    (cond
      ((zero? n) (car ls))
      (else
	(list-ref (sub1 n) (cdr ls))))))

;; ---- snoc

(define snoc
  (lambda (ls i)
    (cond
      ((null? ls) (cons i '()))
      (else
	(cons (car ls) (snoc (cdr ls) i))))))

;; ---- intersection

(define intersection
  (lambda (s0 s1)
    (cond
      ((null? s0) '())
      ((member? (car s0) s1)
       (cons (car s0) (intersection (cdr s0) s1)))
      (else
	(intersection (cdr s0) s1)))))

;; ---- count-parens

(define count-parens
  (lambda (ls)
    (cond
      ((null? ls) 2)
      ((pair? (car ls))
       (+ (count-parens (car ls))
	 (count-parens (cdr ls))))
      ((null? (car ls))
       (+ 2 (count-parens (cdr ls))))
      (else
	(count-parens (cdr ls))))))


;; ---- sum-of-squares

(define sum-of-squares
  (lambda (tup)
    (cond
      ((null? tup) 0)
      (else
	(+ (square (car tup))
	   (sum-of-squares (cdr tup)))))))

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