Grundlagen der funktionsorientierten Programmierung mit SCHEME/Das NIM-Spiel

Wiki-Quelltext dieser Seite.

<language>SchemeJS</language>
[[Bild:Nim1.jpg|miniatur||hochkant=1|Das NIM-Spiel]]

'''Autor: Michael Schneider (2011)'''

== Spielregel ==

Der Computer bestimmt zwischen 50 und 100 eine zufällige Anzahl von Hölzchen.<br />
Im Wechsel nehmen nun Mitspieler bzw. Computer eine beliebige Anzahl beiseite - mindestens 1, höchstens aber die Hälfte der noch vorhandenen Hölzchen.<br />
Wer das letzte Hölzchen nehmen muss, hat verloren!

== Implementation des NIM-Spiels ==

<code id="5bb689ee65b30">
(define zweipot
  (lambda (n)
    (expt 2 n)))

(define vergleich
  (lambda (zahl n)
    (cond
      [(> zahl (zweipot n)) (vergleich zahl (+ n 1))]
      [(< zahl (zweipot n)) (- n 1)]
      [else
       n])))

;----- Aufruf des Spiels -----
;----- anfang = 1 ==> Spieler beginnt -----
;----- anfang = 2 ==> Computer beginnt -----
(define nim
  (lambda (anfang)
    (let ([max (+ (random 50) 50)])
      (cond
        [(= anfang 2) (computer max)]
        [(= anfang 1) (mensch max)]
        [else
         (showMessage "Unzulässige Eingabe!") 'ok]))))

;----- Ablauf, wenn Mensch am Zug ist -----
(define mensch
  (lambda (max)
    (let ([eingabe (inputDialog (string-append "Anzahl der Hölzchen im Spiel: " 
                                               (number->string max) 
                                               " - Wie viele Hölzchen nehmen?"))])
      (cond
        [(equal? eingabe 'null) 'ok]
        [(= max 1) (showMessage "Schade! Du hast verloren!") 'ok]
        [else
         (let ([anzahl (string->number eingabe)])
           (if (or (equal? anzahl +nan.0) (> anzahl (/ max 2)) (< anzahl 1))
               (begin
                 (showMessage "Fehlerhafte Eingabe!")
                 (mensch max))
               (computer (- max anzahl))))]))))

;---- Ablauf, wenn Computer am Zug ist -----
(define computer
  (lambda (max)
    (cond
      [(= (- (zweipot (+ (vergleich max 1) 1)) max) 1) (stark max)]
      [else
       (schwach max)])))

;----- Ablauf, wenn Mensch stark spielt -----
(define stark
  (lambda (max)
    (cond 
      [(= max 1) 
       (showMessage "Anzahl der Hölzchen im Spiel: 1 - Computer nimmt 1 Hölzchen.")
       (showMessage "Glückwunsch! Du hast gewonnen!") 'ok]
      [else
       (let ([zahl (+ (random (/ (- max 1) 2)) 1)])       
         (showMessage (string-append "Anzahl der Hölzchen im Spiel: " (number->string max) 
                                     " - Computer nimmt " (number->string zahl) " Hölzchen."))   
         (mensch (- max zahl)))])))

;----- Ablauf, wenn Mensch schwach spielt -----
(define schwach
  (lambda (max) 
    (let ([zahl (- max (- (zweipot (vergleich max 1)) 1))])     
      (showMessage (string-append "Anzahl der Hölzchen im Spiel: " (number->string max) 
                                  " - Computer nimmt " (number->string zahl) " Hölzchen."))
      (mensch (- max zahl)))))
</code>

== Start des NIM-Spiels ==

Der Prozeduraufruf erfolgt mit:

 (nim 1) ; Der Spieler beginnt.
 (nim 2) ; Der Computer beginnt.

<run id="4e627150bf408">
(nim 1)
</run>

Zurück zum [[Grundlagen_der_funktionsorientierten_Programmierung_mit_SCHEME/Der_Algorithmusbegriff|Algorithmusbegriff]].