Cours de KHAYATA Mohamed

LISP

ESIEA-OUEST 2001-2002

1

Evaluation d’expression ___________________________________________________ 3

Quelques fonctions _______________________________________________________ 4 Fonctions numériques : ________________________________________________________________ 4 fonctions booléennes : _________________________________________________________________ 4 quelques fonctions :___________________________________________________________________ 4 comparaisons :_______________________________________________________________________ 4 quelques fonctions :___________________________________________________________________ 5 gestion des listes _____________________________________________________________________ 5 quelques fonctions____________________________________________________________________ 6

Fonctions nommées _______________________________________________________ 7 fonction APLATIR qui tranforme une liste de sous-listes en une liste simple ______________________ 7 fonction CHERCHER le nieme element ___________________________________________________ 7 fonction (append predefinie) CONCATENATION___________________________________________ 7 fonction (equal predefinie)qui teste si deux LISTES sont EGALES______________________________ 7 fonction qui ENLEVE le dernier element __________________________________________________ 8 fonction qui EXTRAIT les N PREMIERS elements d'une LISTE _______________________________ 8 fonction FACTORIEL_________________________________________________________________ 9 fonction FACTORIEL bis (n'utilise pas la pile) _____________________________________________ 9 fonction FIBONACHI ________________________________________________________________ 10 fonction (INSERT) qui PLACE un ENTIER selon sa valeur dans une liste d'entiers deja triée ________ 10 fonction qui PLACE un entier selon sa valeur dans une liste d'entiers deja triée ___________________ 10 fonction (length predefinie) LONGUEUR ________________________________________________ 11 fonction (length predefinie) LONGUEUR ________________________________________________ 11 fonction qui donne le MIN d'une LISTE d'entiers___________________________________________ 11 fonction qui calcul le NOMBRE d'OCCURENCES dans une liste______________________________ 11 fonction qui calcul le NOMBRE d'OCCURENCES dans une liste avec un ACCUmulateur __________ 12 fonction PLACER un element a la FIN d'une liste __________________________________________ 12 fonction PLACER un element au rang N _________________________________________________ 12 fonction qui teste si une liste l1 est PREFIXE de la liste l2____________________________________ 12 fonction qui teste si une liste l1 est PREFIXE de la liste l2____________________________________ 13 fonction PRODUIT __________________________________________________________________ 13 fonction PUISSANCE ________________________________________________________________ 14 fonction qui donne les elements d'une liste pour les RANGS PAIRS ____________________________ 14 fonction REMPLACER le Nieme element PAR un AUTRE ELEMENT dans une liste _____________ 14 fonction qui RENVERSE une liste d'elements sans liste auxiliaire______________________________ 14 fonction qui RENVERSE une liste d'elements avec une liste auxiliaire __________________________ 15 fonction SOMME ___________________________________________________________________ 15 fonction produit _____________________________________________________________________ 16 fonction qui teste si une liste l1 est SOUS LISTE de la liste l2_________________________________ 16 fonction qui EXTRAIT les N premiers elements d'une liste ___________________________________ 17 fonction qui SUPPRIME toutes les OCCURENCES d'un element d'une liste _____________________ 17 fonction (member predefinie)qui TESTE si un ELEMENT est un MEMBRE d'une liste ____________ 17 fonction qui PLACE un entier selon sa VALEUR dans une liste d'entiers deja triée ________________ 18 fonction qui PLACE un entier selon sa VALEUR dans une liste d'entiers deja triée ________________ 18 equation du second degré _____________________________________________________________ 19 fonction ajouter n a chaque element de la liste _____________________________________________ 19 calaculatrice1_______________________________________________________________________ 19 fonction qui evalue une expression infixee qui est completement paranthesee et ne contient que des operateurs binaires___________________________________________________________________ 20 fonction filtrage (filtrage p l) ___________________________________________________________ 20 redefinition de APPLY a partir de EVAL (primitive) ________________________________________ 20 fonction MAPCAR que l'on nommera redmap _____________________________________________ 21 fonction qui resoud une equation du second degre __________________________________________ 21 fonction qui donne la transposee d'une matrice_____________________________________________ 21 transformer une liste de liste en list ______________________________________________________ 22

Les arbres______________________________________________________________ 23 fonctions __________________________________________________________________________ 24

2

KHAYATA Mohamed CommonLisp Le lisp (version française) List Processing conçu par John Mc-Carty en 1961 . langage fonctionnel non typé(12 « toto » A) et symbolique . environnement : évaluateur (interpréteur) (common)LISP une introduction à la programmation H. WERTZ MASSON

Objets Lisp / | \

Atomes listes tableau Atomes :

- nombres (entiers, réels, complex : c(a b)) - chaînes de caractères : « toto » - symboles : X13, toto - NIL : « faux » - T : « vrai »

Listes : - ‘(‘liste-objets’)’ : (1 2 toto)

(1 2 (3 4)) - ()

Evaluation d’expression Toute expression soumise à l’interpréteur Lisp est évaluée et l’interpréteur retourne une valeur ou un message d’erreur. Atomes : un atome qui n’est pas un symbole est évalué à lui-même. Clisp >2 ↵2 > « toto » ↵ « toto » >1.e-2 ↵0.01 >#c(2 3) ↵#c(2 3) >() ↵NIL >toto ↵***message d’erreur >’toto ↵toto (‘ : interdire l’évaluation) Les autres symboles sont évalués en cherchant la valeur qui leur est associée. L’appel d’une fonction est de la forme Forme :: (nom_de_fonction s_expression*) S_expression :: Forme | atome >(+ 1 2) ↵3 >(1 2 3) ↵***message d’erreur >(quote s_expression) >(quote (+ 1 2)) >’s_expression

3

Quelques fonctions

Fonctions numériques : +, -, *, / (entiers et réels) >(/ 5 2) ↵5/2 >(floor (/ 5 2)) ↵2 ;1/2 >(rem 5 2) ↵1 (modulo) (a + b) (+ a b)

fonctions booléennes : and, or, not T : “vrai” Nil : « false » >(and T nil) ↵NIL >(or T nil) ↵T >(and (or T nil) nil) ↵NIL

quelques fonctions : >(atom 5) ↵ >(atom NIL) ↵ >(atom ()) ↵ >(atom « toto ») ↵ >(atom ‘toto) ↵ >(atom ‘(1 2)) ↵ >(null ()) ↵T >(null ‘(1 2)) ↵NILL

comparaisons : =, <, >, <=, >= (entiers, réels) >(= 1 3) ↵ >(< 2 3) ↵ >(<> 2 3) >(not (= 2 3)) >(eq 2 (+ 1 1)) ↵ >(eq ‘toto ‘toto) ↵ eq : tester l’égalité entre deux atomes sauf les chaînes de caractères >(eq « toto » « toto ») equal : teste l’égalité entre duex objets >(equal ‘(1 2) ‘(1 2)) ↵ >(equal « toto » « toto ») ↵

4

quelques fonctions : (if condition s_expression [s_expression]) >(if (> 3 2) 3) ↵3 >(if (< 3 2) 2) ↵NIL >(if (< 3 2) 3 2) ↵2 (cond (test1 s_expression1) (test2 s_expression2) (t s_expresion))

gestion des listes (1 2 3) tête : 1, queue : (2 3) tête : car queue : cdr >(car ‘(1 2)) ↵ >(cdr ‘(1)) ↵ >(car ()) ↵NIL >(cdr ()) ↵NIL >(car ‘(())) ↵NIL (car (car l)) ≡ (caar l) cadar ≡ car (cdr (car La fonction (cons e l) Construit une liste dont le premier élément (« car ») est e et dont la queue (« cdr ») est l. >(cons 1 (cons 2 (cons 3 ()))) ↵(1 2 3) >(cons (car ‘(a b c)) (cdr ‘(a b c))) ↵(a b c) >(cons ‘(1 2 3) ‘(())) ↵((1 2 3)) >(null ‘(1 2)) ↵NIL >(null (cdr ‘(1))) ↵T >(list 1 2 ‘(3)) ↵(1 2 (3)) >(listp ‘(1 2)) ↵ vérifie si c’est une liste >(cons 1 2) ↵(1 . 2) une paire pointée >(car ‘(1 . 2)) ↵1 >(cdr ‘(1 . 2)) ↵2 >(cons ‘(1 2) ‘(1)) ↵((1 2) 1)

5

quelques fonctions une fonction nommée est définie à l’aide de defun (defun nom_fonction (paramètres_formelles) s-expression) >(nom_fonction paramètre s_expression) ↵ >(defun carre(x) (* x x)) ↵carre >(carre 2) ↵4 fichier.lisp >(load ‘fichier.lisp) ↵ Break> ctr+D sortir des interruptions Définition d’une variable globale >(setq x ‘(1 2 3)) ↵X >x ↵(1 2 3) variable locale >(let ((var1 vaeur1) … (varn valeurn)) corps de let) >(setq x 5) ↵x >x ↵5 >(let ((x 3)) x) ↵3 >x ↵5 >(cons 1 (2 3)) ↵(1 2 3) >(cons (1) (2 3)) ↵((1) 2 3) >(append (1) (2 3)) ↵(1 2 3) >(cons 1 2) ↵(1 . 2) >(cons (1) 2) ↵((1) . 2) (1 . (2)) ≡ (1 2) Une liste est une paire pointée dont le « cdr » est une liste. (eval expression) renvoie le résultat de l’évaluation de l’expression >(eval ‘(+ 1 2)) ↵3 >(setq a ‘(+ 1 2)) >(eval a) ↵3 (apply fonction (parm1 .. parmn)) : permet d’appliquer la fonction à la liste des paramètres >(apply ‘carre ‘(2)) ↵4 >(apply ‘oddp ‘(3)) ↵T oddp est prédéfinie (mapcar fonction (v1…vn)) : renvoie la liste des applications de la fonction à chaque valeur vi >(mapcar f(v1..vn)) ↵(f(v1)…f(vn)) la fonction doit être unaire. >(mapcar ‘car ‘((1 2)(3 4 5) (6))) ↵(1 3 6) mapcar est non primitive : on peut la redéfinir, car est primitive.

6

Fonctions nommées

fonction APLATIR qui tranforme une liste de sous-listes en une liste simple ; fonction APLATIR qui tranforme une liste de sous-listes en une liste simple ; (aplatir '(1 (2 (3 4 (5 6) 7) 8) ())) ----> (1 2 3 4 5 6 7 8) (defun aplatir (l) (cond ((null l) l) ((listp (car l)) (append (aplatir (car l)) (aplatir (cdr l)))) (T (cons (car l) (aplatir (cdr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction CHERCHER le nieme element ; fonction CHERCHER le nieme element ; (cherche 4 '(6 5 4 3 2 3 4 5 6)) ----> 3 (defun cherche (n l) (cond ((< (length l) n) "Erreur de longueur") ((= n 1) (car l)) (T (cherche (- n 1) (cdr l))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction (append predefinie) CONCATENATION ; fonction (append predefinie) CONCATENATION ; (conc '(1 2 3) '(4 5 6)) ----> (1 2 3 4 5 6) (defun conc (l1 l2) (cond ((null l1) l2) ((null l2) l1) (T (cons (car l1) (conc (cdr l1) l2))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction (equal predefinie)qui teste si deux LISTES sont EGALES ; fonction (equal predefinie)qui teste si deux LISTES sont EGALES ; (egalel '(1 2 3) '(1 2 3)) ----> T ; (egalel '(1 2 3) '(1 2)) ----> NIL (defun egalel (l1 l2) (cond ((and (null l1) (null l2)) T) ((not (= (length l1) (length l2))) NIL) (T (and (equal (car l1) (car l2)) (egalel (cdr l1) (cdr l2)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

7

fonction qui ENLEVE le dernier element ; fonction qui ENLEVE le dernier element ; (enleve '(1 2 3)) ----> (1 2) (defun enleve (l) (cond ((null l) l) ((null (cdr l)) nil) (T (cons (car l) (enleve (cdr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction qui EXTRAIT les N PREMIERS elements d'une LISTE ; fonction qui EXTRAIT les N PREMIERS elements d'une LISTE ; (extraitn 2 '(6 5 4 3 2 1)) ----> (6 5) (defun extraitn (n l) (cond ((< (length l) n) "Erreur de longueur") ((= n 0) NIL) (T (cons (car l) (extraitn (- n 1) (cdr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

8

fonction FACTORIEL ; fonction FACTORIEL ; (f 3) ---> 6 ; (f 4) ---> 24 (defun f (x) (cond ((= x 0) 1) ((> x 0) (* x (f (- x 1)))) ((< x 0) (* x (f (+ x 1)))) (T "Erreur"))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction FACTORIEL bis (n'utilise pas la pile) ; fonction FACTORIEL bis (n'utilise pas la pile) ; (f 0 3) ---> 6 ; (f 0 4) ---> 24 (defun fbis (accum n) (cond ((>= n 1) (fbis (* accum n) (- n 1))) ((= n 0) accum))) ;>(trace f_bis) >(trace f) ;>(f_bis 5) >(f 5) ;(fb ’1 ’5) (f ’5) ;(fb ’5 ’4) (f ’4) ;(fb ’20 ’3) (f ’3) ;(fb ’60 ’2) (f ’2) ;(fb ’120 ’1) (f ’1) ;(fb ’120 ’0) (f ’0) ;f→120 f→1 ;f→120 f→1 ;f→120 f→2 ;f→120 f→6 ;f→120 f→24 ;f→120 f→120 ;120 120 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

9

fonction FIBONACHI ; fonction FIBONACHI ; (fibo 3) ----> 2 ; (fibo 4) ----> 3 (defun fibo (n) (cond ((= n 0) 0) ((= n 1) 1) ((> n 1) (+ (fibo (- n 2)) (fibo (- n 1)))) (T "Erreur"))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction (INSERT) qui PLACE un ENTIER selon sa valeur dans une liste d'entiers deja triée ; fonction (INSERT) qui PLACE un ENTIER selon sa valeur dans une liste d'entiers deja triée ; (insert 5 '(1 2 3 4 6)) ----> (1 2 3 4 5 6) (defun insert (e l) (cond ((null l) (list e)) ((<= e (car l)) (cons e l)) (T (cons (car l) (insert e (cdr l)))))) ; fonction qui FUSIONNE deux listes triees ; (fusion '(1 3 5 7) '(2 4 6)) ----> (1 2 3 4 5 6) (defun fusion (l1 l2) (cond ((null l1) l1) ((null (cdr l1)) (insert (car l1) l2)) (T (fusion (cdr l1) (insert (car l1) l2))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction qui PLACE un entier selon sa valeur dans une liste d'entiers deja triée ; fonction qui PLACE un entier selon sa valeur dans une liste d'entiers deja triée ; (insert 5 '(1 2 3 4 6)) ----> (1 2 3 4 5 6) (defun insert (e l) (cond ((null l) (list e)) ((<= e (car l)) (cons e l)) (T (cons (car l) (insert e (cdr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

10

fonction (length predefinie) LONGUEUR ; fonction (length predefinie) LONGUEUR ; (long '(1 2 3 4 5 6)) ----> 6 (defun long (l) (cond ((null l) 0) (T (+ 1 (long(cdr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction (length predefinie) LONGUEUR ; fonction (length predefinie) LONGUEUR ; (long '(1 2 3 4 5 6)) ----> 6 (defun long (l) (cond ((null l) 0) (T (+ 1 (long(cdr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction qui donne le MIN d'une LISTE d'entiers ; fonction qui donne le MIN d'une LISTE d'entiers ; min est une fonction predefinie ; (min 5 7) ----> 5 ; (minimum '(5 46 8 73 12 56 3)) ----> 3 (defun minimum (l) (cond ((null l) "pas de min") ((null (cdr l)) (car l)) (T (min (car l) (minimum (cdr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction qui calcul le NOMBRE d'OCCURENCES dans une liste ; fonction qui calcul le NOMBRE d'OCCURENCES dans une liste ; (occ 5 '(1 2 3 5 6 5 4 5)) ----> 3 (defun occ (e l) (cond ((null l) 0) ((equal e (car l)) (+ (occ e (cdr l)) 1)) (T (occ e (cdr l))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

11

fonction qui calcul le NOMBRE d'OCCURENCES dans une liste avec un ACCUmulateur ; fonction qui calcul le NOMBRE d'OCCURENCES dans une liste avec un ACCUmulateur ; (occ 5 '(1 2 3 5 6 5 4 5)) ----> 3 (defun occ_accu (e l accu) (cond ((null l) accu) ((equal e (car l)) (occ_accu e (cdr l) (+ accu 1))) (T (occ_accu e (cdr l) accu)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction PLACER un element a la FIN d'une liste ; fonction PLACER un element a la FIN d'une liste ; (placer 111 '(1 2 3)) ----> (1 2 3 111) (defun placer (x l) (cond ((null l) (list x)) ((not (null (cdr l))) (cons (car l) (placer x (cdr l)))) (T (list (car l) x) ))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction PLACER un element au rang N ; fonction PLACER un element au rang N ; (placern 111 2 '(1 2 3)) ----> (1 111 2 3) (defun placern (x n l) (cond ((< (length l) n) "Erreur de longueur") ((= n 1) (cons x (cons (car l) (cdr l)))) (T (cons (car l) (placern x (- n 1) (cdr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction qui teste si une liste l1 est PREFIXE de la liste l2 ; fonction qui teste si une liste l1 est PREFIXE de la liste l2 ; (prefixl '(1 2 3) '(1 2 3 4 5)) ----> T ; (prefixl '(1 2 2) '(1 2 3 4 5)) ----> NIL (defun prefixl (l1 l2) (cond ((> (length l1) (length l2)) "Erreur de longueur") ((null l1) T) ((> (length l1) 0) (if (equal (car l1) (car l2)) (prefixl (cdr l1) (cdr l2)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

12

fonction qui teste si une liste l1 est PREFIXE de la liste l2 ; fonction qui teste si une liste l1 est PREFIXE de la liste l2 ; (prefixln '(1 2 3) '(1 2 3 4 5)) ----> T ; (prefixln '(1 2 2) '(1 2 3 4 5)) ----> NIL (defun prefixln (l1 l2) (cond ((> (length l1) (length l2)) "Erreur de longueur") ((null l1) T) (T (and (equal (car l1) (car l2)) (prefixln (cdr l1) (cdr l2)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction PRODUIT ; fonction PRODUIT ; (prod '(1 2 3 2)) ----> 12 ; 0 si l = nil ; (car l ) * 1 si (cdr l) = nil si (car l) est un atome ; produit(l) produit (cdr l) si (cdr l)<>nil ; produit(car l) * 1 si (cdr l) = nil si (car l) est une liste ; produit(cdr l) si (cdr l)<>nil (defun prod (l) (cond ((null l) 0) ((null (car l)) (prod (cdr l))) ((atom (car l)) (if (null (cdr l)) (car l) (* (car l) (prod (cdr l))))) (T (if (null (cdr l)) (prod (car l)) (* (prod (car l)) (prod (cdr l))))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

13

fonction PUISSANCE ; fonction PUISSANCE ; (puissance 2 3) ----> 8 ; n = 0 1 ;puissance(x, n) = n = 1 x ; x * puissance(x, n-1) ; (defun puissance (x n) (cond ((< n 0) (if (= 0 x) "Erreur, div par Zéro" (/ 1 (puissance x (- 0 n))))) ((>= n 1) (* x (puissance x (- n 1)))) ((= n 0) 1) (T "erreur"))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction qui donne les elements d'une liste pour les RANGS PAIRS ; fonction qui donne les elements d'une liste pour les RANGS PAIRS ; (rang_pair '(1 3 5 7 9 11 13)) ----> (3 7 11) (defun rang_pair (l) (cond ((null l) l) ((null (caddr l)) (cadr l)) (T (cons (cadr l) (rang_pair (cddr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction REMPLACER le Nieme element PAR un AUTRE ELEMENT dans une liste ; fonction REMPLACER le Nieme element PAR un AUTRE ELEMENT dans une liste ; (remplacer 5 12 '(5 5 5 5 5 5)) ----> (5 5 5 5 12 5) (defun remplacer (n e l) (cond ((< (length l) n) "Erreur de longueur") ((= n 1) (cons e (cdr l))) (T (cons (car l) (remplacer (- n 1) e (cdr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction qui RENVERSE une liste d'elements sans liste auxiliaire ; fonction qui RENVERSE une liste d'elements sans liste auxiliaire ; (renverser '(1 2 3)) ----> (3 2 1) (defun renverser (l) (cond ((null l) l) (T (append (renverser (cdr l)) (list (car l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

14

fonction qui RENVERSE une liste d'elements avec une liste auxiliaire ; fonction qui RENVERSE une liste d'elements avec une liste auxiliaire ; (renverser_aux '(1 2 3) ()) ----> (3 2 1) (defun renverser_aux (l laux) (cond ((null l) laux) (T (renverser_aux (cdr l) (append (list (car l)) laux))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction SOMME ; fonction SOMME ; (somme '(1 2 3 2)) ----> 8 ; = 0 si l = nil ;somme(l) = (car l) + somme (car l) si (car l) est un atome ; = somme((car l)) + somme((cdr l)) autrement (defun somme (l) (cond ((null l) 0) ((atom (car l)) (+ (car l) (somme (cdr l)))) ((listp (car l)) (+ (somme (car l)) (somme (cdr l)))) (T "Erreur"))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

15

fonction produit ; fonction produit (defun prod (l) (cond ((null l) 0) ((null (car l)) (prod (cdr l))) ((atom (car l)) (if (null (cdr l)) (car l) (* (car l) (prod (cdr l))))) (T (if (null (cdr l)) (prod (car l)) (* (prod (car l)) (prod (cdr l))))))) ; fonction somme (defun somme (l) (cond ((null l) 0) ((atom (car l)) (+ (car l) (somme (cdr l)))) (T (+ (somme (car l)) (somme (cdr l)))))) ; fonction SOMME_PROD ; (somme_prod '(1 2 3 4)) ----> 10.24 (defun somme_prod (l) (cons (somme l) (prod l))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction qui teste si une liste l1 est SOUS LISTE de la liste l2 ; fonction qui teste si une liste l1 est SOUS LISTE de la liste l2 (defun prefixln (l1 l2) (cond ((> (length l1) (length l2)) NIL) ((null l1) T) (T (and (equal (car l1) (car l2)) (prefixln (cdr l1) (cdr l2)))))) ; fonction qui teste si une liste l1 est SOUS-LISTE de la liste l2 ; (ssliste '(1 2 3 4 5) '(5 5 5 1 2 3 4 5 6 9 )) ----> T ; (ssliste '(1 0 3 4 5) '(5 5 5 1 2 3 4 5 6 9 )) ----> NIL (defun ssliste (l1 l2) (cond ((> (length l1) (length l2)) NIL) ((prefixln l1 l2) T) (T (ssliste l1 (cdr l2))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

16

fonction qui EXTRAIT les N premiers elements d'une liste ; fonction qui EXTRAIT les N premiers elements d'une liste (defun extraitn (n l) (cond ((< (length l) n) "Erreur de longueur") ((= n 0) NIL) (T (cons (car l) (extraitn (- n 1) (cdr l)))))) ; fonction qui teste si deux LISTES sont EGALES (defun egalel (l1 l2) (cond ((and (null l1) (null l2)) T) ((not (= (length l1) (length l2))) NIL) (T (and (equal (car l1) (car l2)) (egalel (cdr l1) (cdr l2)))))) ; fonction qui teste si une liste l1 est SOUS-LISTE de la liste l2 ; (ssliste_extrait '(1 2 3 4 5) '(5 5 5 1 2 3 4 5 6 9 )) ----> T ; (ssliste_extrait '(1 0 3 4 5) '(5 5 5 1 2 3 4 5 6 9 )) ----> NIL (defun ssliste_extrait (l1 l2) (cond ((> (length l1) (length l2)) NIL) ((egalel (extraitn (length l1) l2) l1) T) (T (ssliste_extrait l1 (cdr l2))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction qui SUPPRIME toutes les OCCURENCES d'un element d'une liste ; fonction qui SUPPRIME toutes les OCCURENCES d'un element d'une liste ; (supprl 5 '( 1 5 6 4 2 5 6 5 65 5)) ----> (1 6 4 2 6 65) (defun supprl (e l) (cond ((null l) l) ((equal e (car l)) (supprl e (cdr l))) (T (cons (car l) (supprl e (cdr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction (member predefinie)qui TESTE si un ELEMENT est un MEMBRE d'une liste ; fonction (member predefinie)qui TESTE si un ELEMENT est un MEMBRE d'une liste ; (testm 25 '(1 25 3 6)) ----> T ; (testm 25 '(1 2 3 6)) ----> NIL (defun testm (e l) (cond ((null l) NIL) ((= e (car l)) T) (T (testm e (cdr l))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

17

fonction qui PLACE un entier selon sa VALEUR dans une liste d'entiers deja triée ; fonction qui PLACE un entier selon sa VALEUR dans une liste d'entiers deja triée ; (insert 5 '(1 2 3 4 6)) ----> (1 2 3 4 5 6) (defun insert (e l) (cond ((null l) (list e)) ((<= e (car l)) (cons e l)) (T (cons (car l) (insert e (cdr l)))))) ; fonction de TRIE (ordre croissant) par insertion ; (assez complique, utiliser (trace trie)) ; (trie '(8 6 7 2 3 1 4 5)) ----> (1 2 3 4 5 6 7 8) (defun trie (l) (cond ((null l) l) ((not (equal (car l) (insert (car l) (cdr l)))) (insert (car l) (trie (cdr l)))) (T (cons (car l) (trie (cdr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction qui PLACE un entier selon sa VALEUR dans une liste d'entiers deja triée ; fonction qui PLACE un entier selon sa VALEUR dans une liste d'entiers deja triée ; (insert 5 '(1 2 3 4 6)) ----> (1 2 3 4 5 6) (defun insert (e l) (cond ((null l) (list e)) ((<= e (car l)) (cons e l)) (T (cons (car l) (insert e (cdr l)))))) ; fonction de TRIE (ordre croissant) par insertion ; (trie_prof '(8 6 7 2 3 1 4 5)) ----> (1 2 3 4 5 6 7 8) ; explications ; (trier (3 2 1))=(insert 3 (trier (2 1))) ; =(insert 3 (insert 2 (trier 1))) ; =(insert 3 (insert 2 (insert 1))) ; =(1 2 3) (defun trie_prof (l) (cond ((null l) l) (T (insert (car l) (trie_prof (cdr l))) ))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

18

equation du second degré ;evaluation d une equation du secondus degresus (defun seconddeg (a b c) (let ((q (- (* b b) (* 4 a c)))) (cond ((= q 0) (/ (- b) (* 2 a))) ((> q 0) (cons (/ (+ (- b) (sqrt q)) (* 2 a)) (/ (- (- b) (sqrt q)) (* 2 a)))) (t (cons (cons (/ (- b) (* 2 a)) (/ (sqrt (- q)) (* 2 a))) (list (cons (/ (- b) (* 2 a)) (/ (- (sqrt (- q))) (* 2 a)))))) ) ) ) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction ajouter n a chaque element de la liste ; fonction ajouter n a chaque element de la liste ; en utilisant MAPCAR dont l'argument 'fonction' ; est une fonction LAMBDA ; explication MAPCAR ; (mapcar f (v1 ... vn)) ----> (f(v1) ... f(vn)) ; ici f = (lambda (x) (+ x n)) ; et l = (v1 ... vn) ; explication de AJOUTERN ; on additionne n (c'est le principe de la fonction, ici lambda) ; a chaque valeur v1 ... vn (principe de mapcar) ; (ajouter 5 '(1 5 3)) ----> (6 10 8) (defun ajoutern (n l) (mapcar (lambda (x) (+ x n)) l)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

calaculatrice1 ; calaculatrice1 ; (calculatrice1 1 '+ 2) ----> 3 (defun calculatrice1 (l1 op l2) (apply op (list l1 l2))) ; calculatrice2 ; (calculatrice2 '+ '(1 2 3 4)) ----> 10 (defun calculatrice2 (op l) (apply op l)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

19

fonction qui evalue une expression infixee qui est completement paranthesee et ne contient que des operateurs binaires ; fonction qui evalue une expression infixee qui est completement ; paranthesee et ne contient que des operateurs binaires ; (eval_infix '((1 - 2) + ((3 * 4) - 1))) ----> 10 ;expr : (expr1 op expr2) ; car cadr caddr (defun eval_infix (l) (cond ((null l) 0) ((null (cdr l)) (eval_infix (car l))) ((and (atom (car l)) (atom (caddr l))) (funcall (cadr l) (car l) (caddr l))) ((atom (car l)) (funcall (cadr l) (car l) (eval_infix (caddr l)))) ((atom (caddr l)) (funcall (cadr l) (eval_infix (car l)) (caddr l))) (T (funcall (cadr l) (eval_infix (car l)) (eval_infix (caddr l)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction filtrage (filtrage p l) ; fonction filtrage (filtrage p l) donnant ; la liste des elements de l qui satisfont la fonction "predicat" ; predicat signifie que la fonction f doit renvoyer un booleen ; (filtrage 'oddp '(1 2 3 4)) ----> (1 3) (defun filtrage (f v) (cond ((null v) v) ((apply f (list (car v))) (cons (car v) (filtrage f (cdr v)))) (T (filtrage f (cdr v))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

redefinition de APPLY a partir de EVAL (primitive) ; redefinition de APPLY a partir de EVAL (primitive) ; (eval '(+ 1 2)) ----> 3 ; (apply '+ '(1 2)) ----> 3 ; (eval (fonction arguments)) ; (apply fonction (arguments)) (defun redapply (op l) (eval (cons op l))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

20

fonction MAPCAR que l'on nommera redmap ; fonction MAPCAR que l'on nommera redmap ; l'argument 'fonction' est unaire ; (redmap 'car '((1 2) (3 4 5) (6))) ----> (1 3 6) (defun redmap (f v) (cond ((null v) v) (T (cons (apply f (list (car v))) (redmap f (cdr v)))) )) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction qui resoud une equation du second degre ; fonction qui resoud une equation du second degre ; ax² + bx + c ; (second_degre 1 1 1) ----> pas de solution reel ; (second_degre 1 2 1) ----> -1 ; (second_degre 2 3 1) ----> (-1/2 . -1) (defun second_degre (a b c) (let ((d (- (* b b) (* 4 a c)))) (cond ((= d 0) (/ (- b) (* 2 a))) ((> d 0) (cons (/ (+ (- b) (sqrt d)) (* 2 a)) (/ (+ (- b) (- (sqrt d))) (* 2 a)))) (T "pas de solution reel")))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

fonction qui donne la transposee d'une matrice ; fonction qui donne la transposee d'une matrice ; une matrice ((a11 a12 a13) (a21 a22 a23) (a31 a32 a33)) ; (setq A '((1 2 3) (4 5 6) (7 8 9))) ; (transpose A) ----> ((1 4 7) (2 5 8) (3 6 9)) (defun transpose (A) (cond ((null (car A)) NIL) (T (cons (mapcar 'car A) (transpose (mapcar 'cdr A)))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defun inter_uni (a b) (cond ((null a) (cons NIL b)) ((testm (car a) b) (cons (cons (car a) (car (inter_uni (cdr a) b))) (cdr (inter_uni (cdr a) b)))) (T (cons (car (inter_uni (cdr a) b)) (cons (car a) (cdr (inter_uni (cdr a) b))))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

21

transformer une liste de liste en list ;transformer une liste de liste en list (defun transforme (l) (cond ((null l) ()) ((listp (car l)) (append (transforme (car l)) (transforme (cdr l)))) (t (append (list(car l)) (transforme (cdr l)))) ) ) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

22

Les arbres Un arbre binaire ordonné est représenté en lisp par :

- la liste vide s’il s’agit de l’arbre vide - par un atome s’il contient un seul nœud - une liste de 3 éléments : (r fg fd)

12

5 17 3 7 13 20

9

(12 (5 3 (7 () 9)) (17 13 20)) r fg fd car cadr caddr

23

fonctions ;chercher si un element appartient à un arbre (defun appa (x a) (cond ((null a) nil) ((and (atom a) (equal a x)) T) ((and (atom a) (not(equal a x))) NIL) ((equal (car a) x) T) ((> x (car a)) (appa x (caddr a))) (t (appa x (cadr a))) ) ) ;nombre de noeuds dans un arbre (defun nbn (a) (cond ((null a) 0) ((atom a) 1) (t (+ 1 (nbn (cadr a)) (nbn (caddr a)))) ) ) ;la hauteur de l'arbre (defun hauteur (a) (cond ((null a) 0) ((atom a) 1) (t (+ 1 (max (hauteur (cadr a)) (hauteur (caddr a))))) ) ) ;parcours d'arbre (defun parcours (a) (cond ((null a) ()) ((atom a) (list a)) (t (append (parcours (cadr a)) (append (list (car a)) (parcours (caddr a))))) ) ) ;ajouter un element dans une feuille (defun addfa (x a) (cond ((null a) x) ((and (atom a) (equal a x)) '(element deja dans arbre)) ((and (atom a) (> a x)) (list x a ())) ((and (atom a) (< a x)) (list () a x)) ((equal (car a) x) '(element deja dans arbre)) ((> x (car a)) (append (list (car a)) (append (list (cadr a)) (list (addfa x (caddr a)))))) (t (append (list (car a)) (append (list (addfa x (cadr a))) (list(caddr a))))) ) )

24