Ca marche ! Première version alpha-alpha... (jc)

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*))
-
-(defun down (L)
-  (push
-    (setf *current*
-      (cons (+ 1 (first L)) (cons (second L) (cons (+ 1 (third L)) ())))) *db*))
-
-(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)) (last L)))) *db*)
+    *current*))
+  
+(defun down (L)
+  (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*)
+    *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)))))
+