Grundlagen der funktionsorientierten Programmierung mit SCHEME/Das NIM-Spiel

Wiki-Quelltext dieser Seite.

<language>Scheme</language>
'''Autor: Michael Schneider'''<br />

=== Implementation des NIM-Spiels ===

<code id="4e6149da560b2">
(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 (+ (randomint 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 ([anzahl ""])      
      (set! anzahl 
            (string->number 
             (inputdialog (string-append "Anzahl der Hölzchen im Spiel: " (number->string max) 
                                         " - Wie viele Hölzchen nehmen?"))))
      (cond
        [(= max 1) (display "Schade! Du hast verloren!") (newline) 'ok]
        [(or (> anzahl (/ max 2)) (< anzahl 1)) (showmessage "Fehlerhafte Eingabe!") (mensch max)]
        [else
         (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.")
       (display "Glückwunsch! Du hast gewonnen!") (newline) 'ok]
      [else
       (let ([zahl (+ (randomint (/ (- 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 ===

'''Spielregel:'''<br />

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

Der Prozeduraufruf erfolgt mit:

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

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

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