LISP TD 4 corrections    

 


;****************************
;exo 1

(de even (n)
    (zerop (rem n 2))
)    


;****************************
;exo 2

(de amputer (s)
    (when (and (not ( atom s)) (< 1 (length s)))
    (reverse (cdr (reverse (cdr s))))
    )
)

;****************************
;exo 3

(de length (l)
    (let ((lg 0))
         (while l
                (setq l (cons (car l) rev1))
                (setq lg (1+  lg))
         )
     lg
     )
)               

(de reverse (l)
    (let ((rev1)) 
         (while l
                (setq rev1 (cons (car l) rev1))
                (setq l (cdr l))
         )
     rev1
     )
)         

(de last (l)
    (until (null (cdr l))
           (setq l (cdr l))
    )
    l
)    
      
;****************************
;exo 4

(de mapcar (fonc l)
    (when liste (cons (apply fonc (list (car l)) (mapcar fonc (cdr l)))         
         
                )     
    )
)               

;****************************
;exo 5

(de subst (new old exp)
    (cond ((equal exp old) new)
          ((atom exp) exp)
          (t (cons (subst new old (car exp))
                   (subst new old (cdr exp))
             )
           )
     )
)                    


;****************************
;exo 6

(de scalaire (v1 v2)
    (let ( (diff (sub (length v1) (length v2))) 
           (nb)
         )
         (setq nb (abs diff))
         (unless (zerop diff)
                 (if (minusp diff)
                     (setq v1 (sublist v1 nb))
                     (setq v2 (sublist v2 nb))
                 )
         )
         (apply '+ (mapcar '* v1 v2))
    )     
)    
;-------- supprimer les N derniers elements de la liste L

(de sublist (l n)
    (setq l (reverse l))
    (repeat n (setq l (cdr l)))
    (setq l (reverse l))
)
    
    
    
  
    


;****************************
;exo 7

(de present (a exp)
    (cond ((equal a exp))
          ((atom exp) ())
          ((present a (car exp)) )
          (t (present a (cdr exp)))
    )
)         

;une autre solution ***************


(de present (a exp)
    (cond ((equal a exp))
          ((atom exp) ())
          (t (apply 'or (mapcar (lambda (x) (resent a exp)) exp
                        )
             )
          )   
    )
)                        
          
          
           a (cdr exp)))
    )
) 





<\Pre> 



Vincent Vajnovszki
ven 27 fév 13:03:55 NFT 1998