Loops/recursie

predikaten: null?, zero?, =

Recursie over een lijst (in andere talen: while)

(define lijst-recursie
   (lambda (lijst)                                               ; één argument: de lijst
       (if (null? lijst)                                            ; recursie stopt als einde van lijst bereikt
            '()                                                          ; de output voor het simpelste geval
          (cons (... (car lijst))                               ; er wordt iets gedaan met het eerste element van de lijst
                    (lijst-recursie (cdr lijst)))))))    ; recursie over de rest van de lijst

Recursie met getallen (in andere talen: for)

(define getal-recursie
   (lambda (int)
       (if (zero? int)                                              ; of b.v.: (= 1 int)
           0
         (... int
              (getal-recursie (- int 1))))))
 

Opdrachten

Voor opdracht 3: Emiel, Camiel, Iris en Jan moeten opdracht 3a doen, Ron, Martine en Jaqueline 3b en Wineke, Raquel en Ashra 3c (zoals bepaald tijdens de les).
De oplossingen deze keer niet per mail sturen, maar maandag op schijf meebrengen (of al in CZ 111 op S:/opdracht onder je eigen naam neerzetten, b.v. S:/opdracht/sabine4.txt). We gaan ze dan met z'n allen testen.

0

Denk al na over wat je als tussenopdracht wil doen.

1

Schrijf weer een functie om een lijst in groepjes van 2 op te delen (zie de opdrachten van les 2). Alleen moet de nieuwe functie kunnen werken met lijsten van willekeurige lengte.

2

Hetzelfde voor groepjes van 3.

3a

PS: Ook hier is er helaas een fout ingeslopen: In PCSCHEME is het onmogelijk om iets als (e . #f) te maken omdat #f hetzelfde is als de lege lijst en (cons 'e #f) = (cons 'e '()) dus altijd (e) levert. Vervang dus in deze opdracht alle #f's door het symbool false (zo nodig met quote), dan zou het moeten werken.

Stel dat we het spelletje galgje willen implementeren. Het te raden woord (hier: "test") staat opgesplitst in letters in een lijst:
> (define woord '(t e s t))

Schrijf een functie maak-startlijst die zo'n lijst neemt en een lijst '( (t . #f)  (e . #f)  (s . #f)  (t . #f) ) teruggeeft. Elke letter is dus vervangen door een dotted pair uit de letter en #f (false).
> (maak-startlijst woord)
( (t . #f)  (e . #f)  (s . #f)  (t . #f) )

Schrijf een functie geef-oplossing die zo'n dotted pair-lijst neemt en een lijst met alleen de letters teruggeeft.
> (geef-oplossing '( (t . #t)  (e . #t)  (s . #f)  (t . #t) )
(t e s t)

Schrijf een functie schrijf die zo'n dotted pair-lijst neemt en een lijst teruggeeft met '_  op de plaatsen waar een letter nog "false" is en de letter zelf als hij al "true" is.
'_ is het symbool wiens naam alleen maar uit een onderstreepje bestaat.
> (schrijf '( (t . #t)  (e . #t)  (s . #f)  (t . #t) )
(t e _ t)

Schrijf een functie check die een input-letter en zo'n dotted pair-lijst neemt en een nieuwe dotted pair-lijst teruggeeft waarbij een #f omgezet is naar #t als de letter in het paar dezelfde is als de input-letter. #t's die er al staan worden niet veranderd.
> (check 't '( (t . #f)  (e . #f)  (s . #f)  (t . #f) ))
( (t . #t)  (e . #f)  (s . #f)  (t . #t) )

> (check 'a '((t . #t)  (e . #f)  (s . #f)  (t . #t) )
( (t . #t)  (e . #f)  (s . #f)  (t . #t) )

> (check 'e '((t . #t)  (e . #f)  (s . #f)  (t . #t) )
( (t . #t)  (e . #t)  (s . #f)  (t . #t) )

3b

Stel dat we het spelletje lingo willen implementeren. Een woord met vijf letters staat opgesplitst in letters in een lijst:
> (define woord '(t o e t s))

Schrijf een functie op-de-goede-plaats die twee zulke lijsten neemt en een nieuwe lijst teruggeeft met de letter op de plaatsen waar de letters uit de twee woorden overeenkomen, en '_ elders.
'_ is het symbool wiens naam alleen maar uit een onderstreepje bestaat.
> (op-de-goede-plaats woord '(t o a s t))
(t o _ _ _)

Schrijf een functie komt-voor die twee zulke lijsten neemt en een nieuwe lijst teruggeeft met de letter op de plaatsen waar de letter uit het geraden woord ook in het te raden woord voorkomt (maar niet op dezelfde plaats) en '_ elders.
Gebruik hierbij (member letter woord).
> (komt-voor woord '(t o a s t))
(_ _ _ s t)

3c

PS: Sorry, eigenlijk bedoelde ik overal "bord" en niet "boord"...

Stel dat we het spelletje boter, kaas en eieren willen implementeren. Het "boord" ziet er b.v. als volgt uit:
> (define boord '( X _ O _ X _ _ _ O ) )
Dit moet je je voorstellen als
X _ O
_ X _
_ _ O

Schrijf een functie maak-startboord die een getal i en een symbool s neemt en een lijst met i keer s teruggeeft:
> (maak-startboord 9 '_)
( _ _ _ _ _ _ _ _ _ )
> (maak-startboord 5 'a)
( a a a a a )

Schrijf een predikaat vol? dat een boord neemt en true of false teruggeeft al naar gelang het boord al helemaal vol zit.
> (vol? boord)
#f
> (vol? '( X O X O X O X O O ))
#t

Schrijf een predikaat bezet? dat een dotted pair met twee koördinaten (rij, kolom) en een "boord" neemt en true of false teruggeeft al naar gelang dat vakje op het boord al bezet is.
> (bezet? '(1 . 3) boord)
#t
> (bezet? '(3 . 1) boord)
#f

Schrijf een functie doe-zet die een dotted pair met twee koördinaten (rij, kolom), een symbool ('X of 'O) en een "boord" neemt en het nieuwe boord teruggeeft met het symbool op het desbetreffende vakje toegevoegd.
> (doe-zet  '(3 . 1) 'X  boord)
( X _ O _ X _ X _ O )
 

Oplossingen