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

(define g2 
   (lambda (l)                          ; de lijst
      (if (< (length l) 2)              ; stop als minder dan 2 elementen
          l
          (cons (cons (car l)           ; maak een paar ( x y )
                      (cons (cadr l)
                            '()))
                (g2 (cddr l))))))       ; ga door met de lijst min de eerste 2 elementen

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

(define g3
   (lambda (l)                           ; de lijst
      (if (< (length l) 3)               ; stop als minder dan 3 elementen
          l
          (cons (cons (car l)            ; maak een tripel ( x y z )
                      (cons (cadr l)
                            (cons (caddr l)
                                  '())))
                (g3 (cdddr l))))))       ; ga door met de lijst min de eerste 3 elementen

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 3a
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(define maak-startlijst
   (lambda (wrd)                                ; het woord
      (if (null? wrd)                           ; stop als lijst leeg is
          '()
          (cons (cons (car wrd)                 ; maak paar ( letter . 'false )
                      'false)
                (maak-startlijst (cdr wrd)))))) ; ga door met eentje kortere lijst

(define geef-oplossing
   (lambda (dpl)                                ; de dotted-pair-lijst
     (if (null? dpl)                            ; stop als lijst leeg is
         '()
         (cons (caar dpl)                       ; neem eerste letter
               (geef-oplossing (cdr dpl))))))   ; ga door met eentje kortere lijst

(define schrijf
   (lambda (dpl)                                ; de dotted-pair-lijst
      (if (null? dpl)                           ; stop als lijst leeg is
          '()
          (if (equal? (cdar dpl)                ; als letter al geraden
                      #t)
              (cons (caar dpl)                  ; geef letter
                    (schrijf (cdr dpl)))        ; ga door met eentje kortere lijst
              (cons '_                          ; anders geef '_
                    (schrijf (cdr dpl)))))))    ; ga door met eentje kortere lijst

(define check
   (lambda (ltr dpl)                            ; de letter, de dotted-pair-lijst
      (if (null? dpl)                           ; stop als lijst leeg is
          '()
          (if (or (equal? (cdar dpl)            ; als letter al eerder geraden
                          '#t)
                  (not (equal? (caar dpl)       ; of letter in lijst is niet geraden letter
                               ltr)))
              (cons (car dpl)                   ; laat eerste paar onveranderd
                    (check ltr                  ; ga door met eentje kortere lijst
                           (cdr dpl)))
              (cons (cons (caar dpl)            ; anders zet letter op #t
                          #t) 
                    (check ltr                  ; ga door met eentje kortere lijst
                           (cdr dpl)))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 3b
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(define op-de-goede-plaats
   (lambda (ls1 ls2)
      (cond ((null? ls1)        '())
            ((equal? (car ls1)
                     (car ls2)) (cons (car ls1) 
                                      (op-de-goede-plaats (cdr ls1)
                                                          (cdr ls2))))
            (else               (cons '_
                                      (op-de-goede-plaats (cdr ls1)
                                                          (cdr ls2))))
)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(define komt-voor
   (lambda (ls1 ls2)
      (komt-voor-hulp ls1 ls2 ls2)))

; ls1: (deel)lijst geraden woord
; ls2: (deel)lijst te raden woord
; woord: volledig te raden woord 
(define komt-voor-hulp
   (lambda (ls1 ls2 woord) 
      (cond ((null? ls1)        '())
            ((and (not (equal? (car ls1)
                               (car ls2)))
                  (member (car ls1)
                          woord))          (cons (car ls1) 
                                                 (komt-voor-hulp (cdr ls1)
                                                                 (cdr ls2)
                                                                 woord)))
            (else                          (cons '_
                                                 (komt-voor-hulp (cdr ls1)
                                                                 (cdr ls2)
                                                                 woord)))
)))

; met een extra integer-argument i.p.v. de hele lijst
(define kv
   (lambda (ls1 ls2)
      (kv2 ls1 ls2 0 (length ls1))))

(define kv2
   (lambda (ls1 ls2 i max)
      (cond ((>= i max) '())
            ((and (not (equal? (list-ref ls1 i)
                               (list-ref ls2 i)))
                  (member (list-ref ls1 i)
                          ls2))                  (cons (list-ref ls1 i) 
                                                       (kv2 ls1 
                                                            ls2 
                                                            (+ 1 i)
                                                            max)))
            (else                                (cons '_
                                                       (kv2 ls1 
                                                            ls2 
                                                            (+ 1 i)
                                                            max)))
)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 3c
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       
(define maak-startbord
   (lambda (i s)
      (if (zero? i)
          '()
          (cons s 
                (maak-startbord (- i 1)
                                s)))))      

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; drie manieren om vol? te definieren
; waarvan de eerste twee recursief

; vol als overal X of O staat
(define vol?
   (lambda (bord)
      (cond ((null? bord)                #t)
            ((or (equal? (car bord) 'X)
                 (equal? (car bord) 'O)) (vol? (cdr bord)))
            (else                        #f))))

; vol als nergens _ staat (recursief)
(define vol?2
   (lambda (bord)
      (cond ((null? bord)           #t)
            ((equal? (car bord) '_) #f)
            (else                   (vol? (cdr bord))))))

; vol als nergens _ staat
(define vol?3
   (lambda (bord)
      (not (member '_ bord))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; twee manieren om bezet? te definieren
; waarvan de eerste recursief

; geen foutcontrole ongebouwd: coordinaten moeten tussen
; (3.3) en (1.1) liggen en bord moet 9 elementen lang zijn
; anders op gegeven moment error
(define bezet?
   (lambda (coordinaten bord)
      (if (equal? coordinaten '(1 . 1)) ; als goede coordinaten bereikt
          (not (equal? '_ (car bord)))  ; kijk of niet leeg
          (bezet? (tel-af coordinaten)  ; anders: recursie over rest van lijst
                  (cdr bord)))))

; het is niet noodzakelijk om een hulpfunctie te gebruiken,
; we hadden de inhoud van tel-af ook in bezet? kunnen intergreren

; telt omlaag: (3.3) (3.2) (3.1) (2.3) (2.2) etc.
(define tel-af
   (lambda (coordinaten)
      (if (equal? 1 (cdr coordinaten))
          (cons (- (car coordinaten)    ; van (x.1) naar ((x-1).3)
                   1)
                3)
          (cons (car coordinaten)       ; van (x.y) naar (x.(y-1))
                (- (cdr coordinaten)
                   1)))))

; niet recursief: als coordinaten (x.y) zijn,
; moeten we het lijstelement (x-1)*3+(y-1) hebben
(define bezet?2
   (lambda (coordinaten bord)
      (not (equal? '_
                   (list-ref bord
                             (+ (* 3 
                                   (- (car coordinaten)
                                      1))
                                (- (cdr coordinaten)
                                   1)))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; gebruikt ook hulpfunctie tel-af (zie boven)

(define doe-zet
   (lambda (coordinaten symbool bord)
      (if (equal? coordinaten '(1 . 1)) ; als goede coordinaten bereikt
          (cons symbool (cdr bord))     ; vervang lijstelement door symbool 
          (cons (car bord)                     ; anders: houd 1e element,
                (doe-zet (tel-af coordinaten)  ; recursie over rest van lijst
                         symbool 
                         (cdr bord))))))