;;;;;;;
;; 1 ;;
;;;;;;;

;; A-E: se oppgave1.pdf

;; F

(car (cdr '(0 42 #t 'bar) ))

;; G

(car (cdr (car '((0 42) (#t 'bar)) )))

;; H

(car (car (cdr '((0) (42 #t) ('bar)) )))

;; I - bare cons

(cons (cons 0
            (cons 42
                  '()))
      (cons (cons #t
                  (cons 'bar
                        '()))
            '()))
          

;; I - bare list

(list (list 0 42) (list #t 'bar))

;;;;;;;
;; 2 ;;
;;;;;;;

;; A

(define (length2 items)
  (define (iter l acc)
    (if (null? l)
        acc
        (iter (cdr l) (+ acc 1))))
  (iter items 0))

;; B

;; recuce-reverse er halerekursiv, fordi det siste den gjør
;; er å kalle seg selv.
;; Den gir opphav til en iterativ prosess.
(define (reduce-reverse proc init items)
  (if (null? items)
      init
      (reduce-reverse proc
                      (proc (car items) init)
                      (cdr items))))

;; C

(define (all? pred items)
  (if (null? items)
      #t
      (and (pred (car items)) (all? pred (cdr items)))))

(all? (lambda (x) (<= x 10))
      '(1 2 3 4 5))
(all? (lambda (x) (<= x 10))
      '(1 2 3 4 50))

;; D

(define (nth i items)
  (if (= i 0)
      (car items)
      (nth (- i 1) (cdr items))))

;; E

(define (where item items)
  (define (iter l i)
    (if (null? l)
        #f
        (if (= item (car l))
            i
            (iter (cdr l) (+ i 1)))))
  (iter items 0))

;; F

(define (map2 proc la lb)
  (if (or (null? la) (null? lb))
      '()
      (cons (proc (car la) (car lb))
            (map2 proc (cdr la) (cdr lb)))))

;; G

(map2 (lambda (a b) (/ (+ a b) 2))
      '(1 2 3 4) '(3 4 5))

;; H

(define (both? proc)
  (lambda (a b) (and (proc a) (proc b))))

;; I

(define (self proc)
  (lambda (x) (proc x x)))