Add some arithmetic fuctions

Signed-off-by: Jérôme Benoit <jerome.benoit@piment-noir.org>

diff --git a/exercices/arithmetic.lsp b/exercices/arithmetic.lsp
new file mode 100755 (executable)
index 0000000..85f3f01
--- /dev/null
+++ b/exercices/arithmetic.lsp
@@ -0,0 +1,30 @@
+#!/usr/bin/env newlisp
+
+(define (Puissance P N)
+  (cond
+    ((= N 0) 1)
+    ((= N 1) P)
+    ((< N 0) (div 1 (Puissance P (- N))))
+    ((* P (Puissance P (- N 1))))))
+(println (Puissance 5 5))
+
+; https://fr.wikipedia.org/wiki/Algorithme_d%27Euclide
+(define (pgcd N P) 
+  (cond
+    ((< N P) (pgcd P N))
+    ((= N P) N)
+    ((= P 0) N)
+    ((pgcd (- N P) P))))
+(println (pgcd 12 4))
+(println (pgcd 25 5))
+(println (pgcd 21 7))
+
+; https://fr.wikipedia.org/wiki/Coefficient_binomial
+(define (comb N P) 
+  (cond
+    ((= P 0) 1)
+    ((= N P) 1)
+    ((+ (comb (- 1 N) P) (comb (- 1 N) (- 1 P))))))
+;(println (comb 5 4))
+
+(exit)

diff --git a/exercices/lists.lsp b/exercices/lists.lsp
index 1930b1ca3a6e1b18cdf0300b80c11b6bec5a0299..39114ad8d0ba3f786f287ec5e8c015209ff50add 100755 (executable)
--- a/exercices/lists.lsp
+++ b/exercices/lists.lsp
@@ -7,6 +7,7 @@
   (if (null? L) nil
     (if (= (first L) E) true
       (mem E (rest L)))))
+(println "mem rt bool")
 (println (mem 9 L))
 
 (define (boolmemrec E L)
@@ -14,12 +15,14 @@
     ((null? L) nil)
     ((= (first L) E) true)
     ((mem E (rest L)))))
+(println "mem rec rt bool")
 (println (boolmemrec 10 L))
 
 (define (mem E L) ;la function mem a 2 arguments
   (if (null? L) nil
     (if (= (first L) E) L
       (mem E (rest L)))))
+(println "mem rt list")
 (println (mem 3 L))
 
 (define (mem E L)
@@ -27,6 +30,7 @@
     ((null? L) nil)
     ((= (first L) E) L)
     ((mem E (rest L)))))
+(println "mem rec rt list")
 (println (mem 9 L))
 (println (member 9 L))
 (println (mem 8 L))
@@ -35,6 +39,7 @@
 (define (concatene L1 L2)
   (if (null? L1) L2
     (cons (first L1) (concatene (rest L1) L2))))
+(println "concatene/append")
 (setq C (concatene L M))
 (println C)
 (println (append L M))
@@ -47,6 +52,7 @@
       ((= x (first L)) 0)
       ((+ 1 (rang x (rest L)))))
     nil))
+(println "rang/find")
 (println (rang 4 L))
 (println (find 4 L))
 (println (rang 0 L))
@@ -59,16 +65,18 @@
     ((null? L) '())
     ((= n 0) '())
     ((cons (first L) (tete (- n 1) (rest L))))))
+(println "tete/slice")
 (println (tete 3 L))
 (println (slice L 0 3))
 (println (0 3 L))
 
-(define (inter L1 L2) 
+(define (intersectL L1 L2) 
   (cond
     ((null? L1) '())
-    ((member (first L1) L2) (cons (first L1) (inter (rest L1) L2)))
-    ((inter (rest L1) L2))))
-(println (inter L M))
+    ((member (first L1) L2) (cons (first L1) (intersectL (rest L1) L2)))
+    ((intersectL (rest L1) L2))))
+(println "intersectL/intersect")
+(println (intersectL L M))
 (println (intersect L M))
 
 (setq N '(1 9 3))
@@ -78,6 +86,7 @@
     ((null? L2) nil)
     ((= (first L1) (first L2)) (inclu (rest L1) (rest L2))) 
     ((inclu L1 (rest L2)))))
+(println "inclu")
 (println (inclu N L))
 (println (inclu L M))
 ;did not found a newlisp builtin equivalent function
@@ -87,8 +96,10 @@
     ((null? L1) L2)
     ((member (first L1) L2) (unionE (rest L1) L2))
     ((cons (first L1) (unionE (rest L1) L2)))))
+(println "unionE/union")
 (println (unionE L M))
 (println (unionE N L))
+(println (union N L))
 
 ;(trace true)
 
@@ -98,6 +109,7 @@
     ((null? L) 0) 
     ((atom? L) 0) 
     ((max (+ 1 (prof (first L))) (prof (rest L))))))
+(println "prof")
 (println (prof L))
 (println (prof T))
 
@@ -109,6 +121,7 @@
     ((null? L) nil)
     ((atom? L) (list L)) ;FIXME: the "casting" is not working properly
     ((append (aplatir (first L)) (aplatir (rest L))))))
+(println "aplatir/flat")
 ;(println (aplatir T))
 (println (flat T))
 
@@ -119,6 +132,7 @@
     ((null? L) '())
     ((member (first L) (rest L)) (elim (rest L)))
     ((cons (first L) (elim (rest L))))))
+(println "elim/unique")
 (println (elim C))
 (println (unique C))
 
@@ -126,6 +140,7 @@
   (cond
     ((null? L) '())
     ((append (reverseL (rest L)) (list (first L))))))
+(println "reverseL/reverse")
 (println (reverseL L))
 (println (reverse L))
 
@@ -134,6 +149,7 @@
     ((null? 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))
 
@@ -142,6 +158,7 @@
     ((null? L) '())
     ((< (first L) n) (list>= n (rest L)))
     ((cons (first L) (list>= n (rest L))))))
+(println "list>=")
 (println (list>= 5 C))
 
 (exit)