Générer un quiz en Common Lisp?

Question

Je veux apprendre l'espagnol et le Lisp. J'ai plusieurs listes de mots comme les données montrent ci-dessous. Comment puis-je générer un quiz à partir des données qui ressemblent à ceci?

 
amarillo? [ ] blue [ ] yellow [ ] gray [ ] pink 
azul?  [ ] red  [ ] blue [ ] green [ ] orange 
. 
. 
. 
verde?  [ ] purple [ ] gold [ ] green [ ] black 

L'idée est d'inclure au hasard la réponse avec 3 réponses incorrectes choisis au hasard. Idéalement, les réponses incorrectes ne seraient pas trop répétitives.

 
amarillo|yellow 
azul|blue 
blanco|white 
dorado|golden 
gris|gray 
marrón|brown 
naranja|orange 
negro|black 
oro|gold 
púrpura|purple 
rojo|red 
rosa|pink 
verde|green 

Answer 1

Utilisation de LispWorks, avec prise en charge d'Unicode.

Les traductions de couleur.

(defparameter *word-data* 
"amarillo|yellow 
azul|blue 
blanco|white 
dorado|golden 
gris|gray 
marrón|brown 
naranja|orange 
negro|black 
oro|gold 
púrpura|purple 
rojo|red 
rosa|pink 
verde|green") 

quelques variables de haut niveau: une table de traduction et deux listes avec des noms de couleurs

(defvar *translation* (make-hash-table :test #'equalp)) 
(defvar *all-english-colors* nil) 
(defvar *all-spanish-colors* nil) 

analyse des données de traduction et de remplissage de la table et les listes:

(defun parse-word-data (&optional (data *word-data*)) 
    (with-input-from-string (stream data) 
    (loop for line = (read-line stream nil nil) 
      while line 
      do (let ((pos (position #\| line))) 
       (setf (gethash (subseq line 0 pos) *translation*) 
        (subseq line (1+ pos))) 
       (pushnew (subseq line 0 pos) *all-spanish-colors* 
         :test #'equalp) 
       (pushnew (subseq line (1+ pos)) *all-english-colors* 
         :test #'equalp))))) 

Trouver la traduction d'un mot espagnol:

(defun translate-s->e (word) 
    (gethash word *translation*)) 

Choisissez n éléments aléatoires dans une liste:

(defun random-elements (list &optional (n 1)) 
    (let ((elements nil) 
     (all-elements list)) 
    (loop repeat n 
      for r = (random (length all-elements)) 
      for e = (elt all-elements r) 
      do (push e elements) 
      do (setf all-elements (remove e all-elements :test #'equal))) 
    elements)) 

Choisissez trois couleurs anglais au hasard:

(defun random-english-colors (answer &optional (n 3)) 
    (random-elements (remove answer *all-english-colors* :test #'equal) n)) 

Calculer les choix -

(defun compute-choices (answer answers &optional (n 3)) 
    (let ((pos (random (1+ n)))) 
    (append (subseq answers 0 pos) 
      (list answer) 
      (subseq answers pos)))) 

Le test:

(defun test() 
    (loop for sc in *all-spanish-colors* 
     for ec = (translate-s->e sc) 
     do (apply #'format 
        t 
        "~%~a~1,16@T[ ] ~a~1,16@T[ ] ~a~1,16@T[ ] ~a~1,16@T[ ] ~a" 
        sc 
        (compute-choices ec (random-english-colors ec)))) 
    (terpri)) 

Calculer les données:

(parse-word-data) 

Le test:

CL-USER 212 > (test) 

verde   [ ] green  [ ] yellow  [ ] orange  [ ] brown 
rosa   [ ] yellow  [ ] orange  [ ] pink  [ ] golden 
rojo   [ ] gold  [ ] golden  [ ] brown  [ ] red 
púrpura   [ ] gold  [ ] red   [ ] orange  [ ] purple 
oro    [ ] orange  [ ] gold  [ ] red  [ ] white 
negro   [ ] gold  [ ] black  [ ] golden  [ ] purple 
naranja   [ ] red   [ ] gray  [ ] orange  [ ] gold 
marrón   [ ] orange  [ ] pink  [ ] brown  [ ] red 
gris   [ ] brown  [ ] green  [ ] gray  [ ] orange 
dorado   [ ] golden  [ ] pink  [ ] blue  [ ] gray 
blanco   [ ] blue  [ ] red   [ ] white  [ ] gold 
azul   [ ] brown  [ ] blue  [ ] green  [ ] purple 
amarillo  [ ] red   [ ] yellow  [ ] brown  [ ] black