Bergervei/Das allgemeine zufällige Kfz-Kennzeichen

Wiki-Quelltext dieser Seite.

<language>Scheme</language>
<code id="5068056a51fa0" hidden>
;-- M. Hielscher / Chr. Wagenknecht --
(define random-maker
  (let* ((multiplier 48271)
         (modulus 2147483647)
         (apply-congruence
          (lambda (current-seed)
            (let ((candidate (modulo (* current-seed multiplier) modulus)))
              (if (zero? candidate)
                  modulus
                  candidate))))
         (coerce
          (lambda (proposed-seed)
            (if (integer? proposed-seed)
                (- modulus (modulo proposed-seed modulus)) 19880214))))
  (lambda (initial-seed)
    (let ((seed (coerce initial-seed)))
      (lambda args
        (cond ((null? args)
               (set! seed (apply-congruence seed))
               (/ (- modulus seed) modulus))
              ((null? (cdr args))
               (let* ((proposed-top
                       (ceiling (abs (car args))))
                      (exact-top
                       (if (inexact? proposed-top)
                           (inexact->exact proposed-top)
                           proposed-top))
                      (top
                       (if (zero? exact-top)
                           1
                           exact-top)))
                 (set! seed (apply-congruence seed))
                 (inexact->exact (floor (* top (/ seed modulus))))))
              ((eq? (cadr args) 'reset)
               (set! seed (coerce (car args))))
              (else
               (display "random: unrecognized message")
               (newline))))))))

(require-library 'sisc/libs/srfi/srfi-19)
(import srfi-19)

(define random (random-maker (time-nanosecond (current-time))))
</code>

Eine Lösungsidee besteht darin, zunächst eine zufällige Zeichenkette aus zwei Großbuchstaben zu erzeugen. Aus dieser kann nun eine Teil-Zeichenkette gewonnen werden, deren Länge zufällig mit 1 oder 2 festgelegt wird.

=== Lokale Wertbindungen mit dem Sprachelement <tt>let</tt> ===

Zur übersichtlichen Implementation ist es ratsam, die aus zwei zufällig gewählten Großbuchstaben bestehende Zeichenkette an eine ''lokale Variable'' zu binden.
Lokale Wertbindungen werden mit dem Sprachelement <tt>let</tt> in einer Liste definiert.

'''Beispiel:'''

<code id="50680498788d0">
(define lokal
  (lambda (n)
    (let ([x 5] [y 4])
      (* n x y))))
</code>

<run id="5068049878995">
(lokal 10)
</run>

=== Implementation des Kennzeichen-Generators ===

Damit ist die Rückgabe eines allgemeinen zufälligen Kfz-Kennzeichens kein Problem:

<code id="50683cc962b8a">
(define alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZ")

(define zufallskennzeichen
  (lambda (kuerzel)
    (let ([zk (string-append
               (string (string-ref alphabet (random (- (string-length alphabet) 1))))
               (string (string-ref alphabet (random (- (string-length alphabet) 1)))))])
      (string-append (string-upcase kuerzel) 
                     "-"
                     (substring zk 0 (+ 1 (random 2)))
                     " "
                     (number->string (+ 1 (random 9999)))))))
</code>

<run id="50683cc962c03">
(zufallskennzeichen "DD")
</run>

Um uns von der Leistungsfähigkeit unseres Generators zu überzeugen, genrieren wir nun eine große Anzahl von Kfz-Kennzeichen:

<code>
(define kennzeichentest
  (lambda (kuerzel max)
    (if (= max 0)
        'ok
        (begin
          (display (zufallskennzeichen kuerzel)) (newline)
          (kennzeichentest kuerzel (- max 1))))))
</code>

<run id="506ac2015b7ec">
(kennzeichentest "DD" 100)
</run>

Zurück zu [[Bergervei/Prozeduren mit Zeichenketten|Prozeduren mit Zeichenketten]].