commit 1b4844ca6a7783d171e926baaea6a34619178d72
parent 938329bffcb8b4cf06e3db38012660619fd29df0
Author: John Charron <rm_rf_windows@yahoo.fr>
Date: Sat, 6 Nov 2010 22:32:05 +0100
Ca marche ! Première version alpha-alpha... (jc)
Diffstat:
1 file changed, 54 insertions(+), 32 deletions(-)
diff --git a/exo4-codage-lisp/couples.lisp b/exo4-codage-lisp/couples.lisp
@@ -3,7 +3,7 @@ Auteur : John CHARRON
email : charron.john@gmail.com
Ce petit program a plein de défauts, je le sais, n'en parlons pas pour l'instant.
-L'idée ici était de s'amuser, de faire des progrès en LISP, de faire une implémentation
+L'idée ici était de m'amuser, de faire des progrès en LISP, de faire une implémentation
d'une question de complexité : le programme sera amélioré par la suite (meilleurs moyens
de récupérer des données (plus efficace), etc.), il ne s'agit qu'un début.
L'idée ici est de générer des couples avec une clé :
@@ -14,12 +14,9 @@ L'idée ici est de générer des couples avec une clé :
- les fonctions "right" "down-left", "down", "up-right" imitent le movement des
coordonnées sur un graphe mais au les coordonnées "y" positifs sont en DESSOUS du graphe
- "move" s'occupe de choisir "right", "down-left" etc. selon les valeurs dans *current*
- - Pour que "move" marche, il faut mettre à jour à chaque "move" *max-x* et *max-y*, ce que
- je n'arrive pas à faire pour l'instant. Ca marche si j'entre "manuellement" (move *current*)
- puis (update-max-x-y *current*) alternativement, mais je n'arrive pas à faire une fonction
- qui fait cela automatiquement (voir la fonction "move-and-update" qui ne marche pas). *max-x*
- et *max-y* n'est pas mis à jour à temps !
- - "zig-zag" est censé faire n "move-and-update" en un seul coup
+ - Pour que "move" marche, il faut mettre à jour à chaque "move" *max-x* et *max-y* (ici à l'aide
+ de la fonction "update-max-x-y"
+ - "zig-zag" fait n "move-and-update" en un seul coup et affiche le contenu de *db* (toutes les couples)
|#
@@ -36,28 +33,52 @@ L'idée ici est de générer des couples avec une clé :
(defvar *max-y* 0) ;; valeur maximal de y jusque "là"
(setf *max-y* 0)
-
-;;les fonctions "right" "down-left", "down", "up-right" imitent le movement des
-;; coordonnées sur un graphe mais au les coordonnées "y" positifs sont en DESSOUS du graphe
+#| pour remettre toutes les variables globales à leur valeurs par défaut
+afin de tester, de refaire un 'zig-zag', etc.
+|#
+(defun reset ()
+ (progn
+ (defvar *current* (list 0 0 0)) ;; liste courante (clé x y)
+ (setf *current* (list 0 0 0))
+ (defvar *db* nil) ;; base de données qui stocke tous les "(clé x y)"
+ (setf *db* nil)
+ (push *current* *db*)
+ (defvar *max-x* 0) ;; valeur maximal de x jusque "là"
+ (setf *max-x* 0)
+ (defvar *max-y* 0) ;; valeur maximal de y jusque "là"
+ (setf *max-y* 0)
+ *current*))
+
+#| Les fonctions "right" "down-left", "down", "up-right" imitent le movement des
+coordonnées sur un graphe mais au les coordonnées "y" positifs sont en DESSOUS du graphe
+|#
(defun right (L)
- (push
- (setf *current*
- (cons (+ 1 (first L)) (cons (+ 1 (second L)) (last L)))) *db*))
-
+ (progn
+ (push
+ (setf *current*
+ (cons (+ 1 (first L)) (cons (+ 1 (second L)) (last L)))) *db*)
+ *current*))
+
(defun down (L)
- (push
- (setf *current*
- (cons (+ 1 (first L)) (cons (second L) (cons (+ 1 (third L)) ())))) *db*))
+ (progn
+ (push
+ (setf *current*
+ (cons (+ 1 (first L)) (cons (second L) (cons (+ 1 (third L)) ())))) *db*)
+ *current*))
(defun up-right (L)
+ (progn
(push
(setf *current*
- (cons (+ 1 (first L)) (cons (+ 1 (second L)) (cons (- (third L) 1) ())))) *db*))
+ (cons (+ 1 (first L)) (cons (+ 1 (second L)) (cons (- (third L) 1) ())))) *db*)
+ *current*))
(defun down-left (L)
- (push
- (setf *current*
- (cons (+ 1 (first L)) (cons (- (second L) 1) (cons (+ 1 (third L)) ())))) *db*))
+ (progn
+ (push
+ (setf *current*
+ (cons (+ 1 (first L)) (cons (- (second L) 1) (cons (+ 1 (third L)) ())))) *db*)
+ *current*))
(defun update-max-x (L)
(if (> (second L) *max-x*)
@@ -84,7 +105,7 @@ L'idée ici est de générer des couples avec une clé :
(print "in RIGHT") ;;
(right L))
((and (zerop (second L)) (= *max-x* *max-y*)) ;; DOWN
- (print "in LEFT")
+ (print "in DOWN")
(down L))
((> *max-x* *max-y*) ;; DOWN-LEFT
(print "in DOWN-LEFT")
@@ -94,20 +115,21 @@ L'idée ici est de générer des couples avec une clé :
(up-right L))))
#|
-Pour que "move" marche, il faut mettre à jour à chaque "move" *max-x* et *max-y*, ce que
-je n'arrive pas à faire pour l'instant. Ca marche si j'entre "manuellement" (move *current*)
-puis (update-max-x-y *current*) alternativement, mais je n'arrive pas à faire une fonction
-qui fait cela automatiquement (voir la fonction "move-and-update" qui ne marche pas). *max-x*
-et *max-y* n'est pas mis à jour à temps ! |#
+On fait un "move" et puis un "update-max-x-y"
+Attention : il faut bien faire un setf L, sinon, le paramètre L de "update-max-x-y utilise la valeur
+de L inchangé !
+|#
(defun move-and-update (L)
(progn
- (move L)
- (update-max-x-y L)))
+ (setf L (move L))
+ (update-max-x-y L)
+ *db*))
-;; "zig-zag" est censé faire n "move-and-update" en un seul coup
+;; "zig-zag" fait n "move-and-update" en un seul coup et affiche le contenu de *db* (toutes les couples)
(defun zig-zag (L n)
(if (zerop n)
- (move-and-update L)
+ (move-and-update *current*)
(progn
- (move-and-update L)
+ (move-and-update *current*)
(zig-zag L (- n 1)))))
+
