Add some arithmetic fuctions

[TD_LISP.git] / exercices / lists.lsp

#!/usr/bin/env newlisp

(setq L '(1 9 3 7 0 5))
(setq M '(2 6 5 4 0 1 3))

(define (mem E L) ;la function mem a 2 arguments
  (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)
  (cond
    ((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)
  (cond
    ((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))
(println (member 8 L))

(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))

;(trace true)

(define (rang x L)
  (if (boolmemrec x L)
    (cond 
      ((= 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))
(println (find 0 L))

;(trace nil)

(define (tete n L) 
  (cond 
    ((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 (intersectL L1 L2) 
  (cond
    ((null? L1) '())
    ((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))
(define (inclu L1 L2) 
  (cond
    ((null? L1) true)
    ((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

(define (unionE L1 L2)
  (cond
    ((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)

(setq T '(((4)((2 5))((((((6 7)))))))))
(define (prof L) 
  (cond 
    ((null? L) 0) 
    ((atom? L) 0) 
    ((max (+ 1 (prof (first L))) (prof (rest L))))))
(println "prof")
(println (prof L))
(println (prof T))

;(trace nil)
;(trace true)

(define (aplatir L) 
  (cond
    ((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))

;(trace nil)

(define (elim L) 
  (cond
    ((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))

(define (reverseL L)
  (cond
    ((null? L) '())
    ((append (reverseL (rest L)) (list (first L))))))
(println "reverseL/reverse")
(println (reverseL L))
(println (reverse L))

(define (list< n L)
  (cond
    ((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))

(define (list>= n L)
  (cond
    ((null? L) '())
    ((< (first L) n) (list>= n (rest L)))
    ((cons (first L) (list>= n (rest L))))))
(println "list>=")
(println (list>= 5 C))

(exit)