;;; Exercice 1 ;;; 1.1 ; (a) (+ 2 3 4) ; (b) (E G) ; (c) (1 8 27) ; (d) (2 3 4) ; (e) 9 ;;; 1.2 (defun mystere (l1 l2) (cond ((or (endp l1) (endp l2)) l1) ((a (car l1) l2) (mystere (cdr l1) l2)) (t (cons (car l1) (mystere (cdr l1) l2))))) (defun a (x l) (and l (or (eq (car l) x) (a x (cdr l))))) ; (a) (C G) ; (b) mystere construit la liste des éléments de l1 qui ne sont pas dans l2 ;;; Exercice 2 ;;; 2.1 (defun compose (f g) (lambda (x) (funcall g (funcall f x)))) ;;; 2.2 (funcall (compose (lambda (x) (* x x)) (lambda (x) (+ x 1))) 2) ;;; 2.3 (defun n-compose (f n) (if (zerop n) #'identity (compose f (n-compose f (1- n))))) ;;; Exercice 3 ;;; 3.1 (defun compte-occ (sym l) (cond ((endp l) 0) ((atom (car l)) (if (eq sym (car l)) (1+ (compte-occ sym (cdr l))) (compte-occ sym (cdr l)))) (t (+ (compte-occ sym (car l)) (compte-occ sym (cdr l)))))) ;;; 3.2 (defparameter dico '((recipe . recette) (egg . oeuf) (eggs . oeufs) (flour . farine))) ;;; (a) (defun traduire-mot (a dico) (if (numberp a) a (let ((v (assoc a dico))) (if (null v) (list '? a) (cdr v))))) ;;; (b) (defun traduire (l dico) (cond ((endp l) l) ((atom (car l)) (cons (traduire-mot (car l) dico) (traduire (cdr l) dico))) (t (cons (traduire (car l) dico) (traduire (cdr l) dico))))) ;;; Exercice 4 (defvar *environment* (make-hash-table :test #'eq)) ;;; 4.1 (defstruct (variable (:print-function (lambda (v stream depth) (declare (ignore depth)) (format stream "variable ~A = ~A" (variable-name v) (variable-value v))))) (name nil :type symbol) (value 0 :type number)) ;;; 4.2 (setf (gethash 'a *environment*) (make-variable :name 'a :value 12)) ;;; 4.3 (defun evaluate-arithm-expr (expr) (cond ((numberp expr) expr) ((symbolp expr) (variable-value (gethash expr *environment*))) ((eq '* (car expr)) (apply (car expr) (evaluate-args (cdr expr)))) (t (error "erreur de syntaxe")))) (defun evaluate-args (args) (mapcar #'(lambda (e) (evaluate-arithm-expr e)) args))