Some variables renaming for consitency

[TD_LISP.git] / exercices / lists.lsp

diff --git a/exercices/lists.lsp b/exercices/lists.lsp
index 39114ad8d0ba3f786f287ec5e8c015209ff50add..1facea2e83233b8bdd14f76061bb548ad2031483 100755 (executable)
--- a/exercices/lists.lsp
+++ b/exercices/lists.lsp
@@ -46,11 +46,11 @@
 
 ;(trace true)
 
-(define (rang x L)
-  (if (boolmemrec x L)
+(define (rang E L)
+  (if (boolmemrec E L)
     (cond 
-      ((= x (first L)) 0)
-      ((+ 1 (rang x (rest L)))))
+      ((= E (first L)) 0)
+      ((+ 1 (rang E (rest L)))))
     nil))
 (println "rang/find")
 (println (rang 4 L))
@@ -60,11 +60,11 @@
 
 ;(trace nil)
 
-(define (tete n L) 
+(define (tete N L)
   (cond 
     ((null? L) '())
-    ((= n 0) '())
-    ((cons (first L) (tete (- n 1) (rest L))))))
+    ((= N 0) '())
+    ((cons (first L) (tete (- N 1) (rest L))))))
 (println "tete/slice")
 (println (tete 3 L))
 (println (slice L 0 3))
@@ -144,21 +144,59 @@
 (println (reverseL L))
 (println (reverse L))
 
-(define (list< n L)
+(define (list< N L)
   (cond
     ((null? L) '())
-    ((>= (first L) n) (list< n (rest L)))
-    ((cons (first L) (list< n (rest L))))))
+    ((>= (first L) N) (list< N (rest L)))
+    ((cons (first L) (list< N (rest L))))))
 (println "list<")
 (println (list< 5 L))
 (println (list< 5 C))
 
-(define (list>= n L)
+(define (list>= N L)
   (cond
     ((null? L) '())
-    ((< (first L) n) (list>= n (rest L)))
-    ((cons (first L) (list>= n (rest L))))))
+    ((< (first L) N) (list>= N (rest L)))
+    ((cons (first L) (list>= N (rest L))))))
 (println "list>=")
 (println (list>= 5 C))
 
+;(trace true)
+
+(define (qsort L)
+  (cond
+    ((null? L) '())
+    ((append 
+       ;the pivot is the first element of the list
+       (qsort (list< (first L) (rest L))) 
+       (cons (first L) '()) 
+       (qsort (list>= (first L) (rest L)))))))
+(println "qsort")
+(println (qsort C))
+
+;(trace nil)
+
+;we suppose both lists are flat
+(setq L1 '(A ? ? B C D ?))
+(setq L2 '(? A B ? C ? ? D))
+
+(define (removeC C L)
+  (cond
+    ((null? L) '())
+    ((= C (first L))) (removeC C (rest L))
+    (((cons (first L) (removeC C (rest L)))))))
+(println "removeC")
+(println (removeC A L1))
+;escape character in newLISP?
+(println (removeC \? L1))
+
+(define (filtre L1 L2 C)
+  (cond 
+    ((and (null? L1) (null? L2)) true)
+    ((and (not (null? L1)) (null? L2)) nil)
+    ((and (null? L1) (not (null? L2))) nil)
+    ((and (inclu L1 L2) (inclu L2 L1) true))))
+(println "filtre")
+;(println (filtre L1 L2 ?))
+
 (exit)