Publié : sam. 10/déc./2005 14:58
Pour le langage Lisp (dont je parlai un peu plus haut), ca ressemble à ça :
Vous pouvez remarquer que la syntaxe est très particulière...
La base de Lisp est les "Listes" !!! et donc tout ce qui est récursif.
Les listes ce construissent très facilement, mais le reste ...
ce code est le résultat de mon TP3 (fais en 20min, montre en main
) qui consiste en "la recherche de la sortie d'un labyrinthe)
Voici quelques liens
Créateur de niveaux pour le labyrinthe
télécharger Lisp (version gratuite)
Voilà, si vous avez des questions ...
Code : Tout sélectionner
;;; *****************************************************
;;; Les variables globales
;;; *****************************************************
(defvar *laby*)
(defvar *chemin*)
;;; *****************************************************
;;; Les quelques fonctions
;;; *****************************************************
;;; initialisation du labyrinthe et MAZ du chemin parcouru
(defun initLaby ()
(setq *laby* '(
(E 1 8)(1 2 9 E)(2 3 1)(3 4 2)
(4 5 3)(5 6 4)(6 7 5)(7 15 6)
(8 E 9)(9 1 10 8)(10 11 18 9)(11 12 10)
(12 13 11)(13 14 12)(14 15 13)(15 7 14)
(16 17 24)(17 25 16)(18 10 26)(19 20 27)
(20 28 19)(21 22 29)(22 23 30 21)(23 31 22)
(24 16 32)(25 17 33)(26 18 34)(27 19 35)
(28 20 36)(29 21 37)(30 22 38)(31 23 39)
(32 24 40)(33 25 34)(34 26 35 33)(35 27 34)
(36 28 44)(37 29 45)(38 30 46)(39 31 47)
(40 32 48)(41 42 49)(42 43 50 41)(43 44 51 42)
(44 36 52 43)(45 37 53)(46 38 54)(47 39 55)
(48 40 56)(49 41 50)(50 42 51 49)(51 43 52 50)
(52 44 51)(53 45 61)(54 46 62)(55 47 63)
(56 48 64)(57 58 65)(58 59 66 57)(59 60 67 58)
(60 68 59)(61 53 69)(62 54 70)(63 55 71)
(64 56 72)(65 57 66 73)(66 58 67 74 65)(67 59 68 75 66)
(68 60 76 67)(69 61 77)(70 62 78)(71 63 S)
(72 64 73)(73 65 74 72)(74 66 75 73)(75 67 76 74)
(76 68 77 75)(77 69 76)(78 70)(S 71)
(76 68 77 75)(77 69 76)(78 70)(S 71)
))
(setq *chemin* nil)
)
;;; renvoi la liste des mouvements possibles à partir du point actuel
;;; on renvoi 'S, si on est juste à côté de la sortie
(defun mvt_possible (etat_courant)
(if (member 'S (cdr (assoc etat_courant *laby*)))
(list 'S)
(cdr (assoc etat_courant *laby*))
)
)
;;; Cherche les états atteignables possibles
;;; s'appelle récursivement jusqu'à trouver la sorti (si possible...)
(defun explore (etat_courant etat_precedent)
;;;(print etat_courant)
(setq *laby* (remove (assoc etat_precedent *laby*) *laby*))
(if (equal etat_courant 'S)
(push etat_courant *chemin*)
(dolist (x (mvt_possible etat_courant))
(if (explore x etat_courant)
(progn
(push etat_courant *chemin*)
(return t)
)
)
)
)
)
;;; Cherche un chemin possible pour sortir du labyrinthe
(defun lance_laby ()
;;; réinitialise les variables
(initLaby)
;;; lance l'exploration + affichages correspondants au résulat
(if (explore 'E nil)
(progn
(print *chemin*)
"Sortie Trouvee"
)
"Sortie non Trouvee"
)
)
;;; Lance le programme
(lance_laby)La base de Lisp est les "Listes" !!! et donc tout ce qui est récursif.
Les listes ce construissent très facilement, mais le reste ...
ce code est le résultat de mon TP3 (fais en 20min, montre en main
) qui consiste en "la recherche de la sortie d'un labyrinthe)Voici quelques liens
Créateur de niveaux pour le labyrinthe
télécharger Lisp (version gratuite)
Voilà, si vous avez des questions ...
)
