Lotto 6 aus 49

Aus ProgrammingWiki

< Grundlagen der funktionsorientierten Programmierung mit SCHEME

Archivierte Version vom 2014-08-14T07:40:51+00:00. Aktuelle Version

Inhaltsverzeichnis

1 Vorüberlegungen
2 Algorithmus
3 Implementation
4 Gleichverteilung der Lottozahlen

Ziehungsgerät zum Lotto 6 aus 49

Autor: Berger, Veit

Vorüberlegungen

In einer beliebigen Anzahl sollen Lottoziehungen 6 aus 49 simuliert werden.
Zunächst ist es kein Problem, Zufallszahlen zwischen 1 und 49 zu bestimmen (s. Prozeduren mit Zeichenketten und Listen).
Wir sollten aber daran denken, dass diese Zahlen in einer korrekten Lottoziehung paarweise verschieden sein müssen.

Algorithmus

Wir wollen uns für eine endständig rekursive Problemlösung entscheiden, in der wir eine Liste mit korrekten Lottozahlen im rekursiven Abstieg einer entsprechenden Prozedur bilden. Mit einer Zählvariablen steuern wir den Ablauf:

Falls der Zähler Null ist, gib die vollständige Liste einer Lottoziehung zurück.
Anderenfalls lege eine Zufallszahl zwischen 1 und 49 fest.
Prüfe, ob sie bereits Element der aktuellen Teilziehung ist.
Trifft dieser Fall zu, wiederhole die Ziehung bei unverändertem Zählerstand.
Anderenfalls füge die Zufallszahl zur Teilziehung hinzu und führe die Ziehung bei dem um 1 verminderten Zähler fort.

Implementation

Um eine aufsteigend sortierte Lottoziehung zu ermitteln, modifizieren wir den Listen-Konstruktor cons geringfügig zu cons-sort.

(define lottozahl
  (lambda (max)
    (+ 1 (random max))))

(define lottoziehung
  (lambda (n max)
    (letrec
        ([element?
          (lambda (el ls)
            (cond
              [(null? ls) #f]
              [(eqv? el (car ls)) #t]
              [else
               (element? el (cdr ls))]))]
         [cons-sort
          (lambda (el ls)
            (cond
              [(null? ls) (list el)]
              [(< el (car ls)) (cons el ls)]
              [else
               (cons (car ls) (cons-sort el (cdr ls)))]))]
         [ziehung
          (lambda (n ls)
            (if (= n 0)
                ls
                (let ([z (lottozahl max)])
                  (if (element? z ls) 
                      (ziehung n ls)
                      (ziehung (- n 1) (cons-sort z ls))))))])
      (ziehung n ()))))

(define lottoziehungen
  (lambda (n max anz)
    (if (= anz 0)
        ()
        (cons (lottoziehung n max) (lottoziehungen n max (- anz 1))))))

(lottoziehungen 6 49 5)

Gleichverteilung der Lottozahlen

Wir wollen uns von einer hinreichenden Güte der Lottozahlen überzeugen.
Dazu zählen wir das Auftreten jeder gezogenen Lottozahl in einer 49-elementigen Liste. Bei einer großen Anzahl von Ziehungen müsste sich eine Gleichverteilung der Lottozahlen ergeben. Diese visualisieren wir in einem Balkendiagramm (s. Mehrfachrekursionen).
Zur Erinnerung: Syntax der Prozedur balkendiagramm für numerische Listen:

(balkendiagramm <ls>) ; <ls> ... Liste mit Zahlenwerten</ls></ls>

(define verteilung
  (lambda (min max ls)
    (letrec
        ([startliste
          (lambda (pos)
            (if (< pos min)
                ()
                (cons 0 (startliste (- pos 1)))))]  
         [poszaehlen
          (lambda (pos erg-ls)
            (if (= pos 1) 
                (cons (+ 1 (car erg-ls)) (cdr erg-ls))
                (cons (car erg-ls) (poszaehlen (- pos 1) (cdr erg-ls)))))]
         [zaehlen
          (lambda (ls erg-ls)
            (cond 
              [(null? ls) erg-ls]
              [(list? (car ls)) (zaehlen (car ls) (zaehlen (cdr ls) erg-ls))]
              [else
               (zaehlen (cdr ls) (poszaehlen (car ls) erg-ls))]))])
      (zaehlen ls (startliste max)))))

(balkendiagramm (verteilung 1 49 (lottoziehungen 6 49 10000)))

Zurück zum Algorithmusbegriff.

Lotto 6 aus 49

Inhaltsverzeichnis

Vorüberlegungen

Algorithmus

Implementation

Gleichverteilung der Lottozahlen

Suche