;exercice 2 : renvoie c
(print (caddr '(a b c d)))
(print (caadr '((a b)(c d))))
(print (caadr(cdar  '(((a) (b) (c) (d))))))
(print (car(caaddr '(a (b) ((c)) (((d)))))))
(print (caaddr '((((a))) ((b)) (c) d)))
(print (cadar  '((((a) b) c) d)))

;exercice 4 : determiner l'operateur manquant
(print(cons '(a b c) '()))
(print (append '(a b) '(c d)))
(setq l '(a b))
(print (list l l))
(print (cons 'l l))
(print (list '(a b c) '()))
(print (append l l))
(print (append '(a b c) '()))
(print (cons '(a b) '(c d)))


;exercice 5
(defun PGCD (x y)
	(IF (= (MOD x y) 0) y (PGCD x (MOD x y))
)
)
;///////////////////////////////////
;/ execution de la fonction PGCD
;///////////////////////////////////
(print (PGCD 1000000563450 1544540))

;***********************************
;* fonction de rotation : ROT
;***********************************
(defun ROT (a)
	 (print(append (cdr a) (list(car a)) ))
)
	
;///////////////////////////////////
;/ execution de rot
;///////////////////////////////////
(ROT '(a b c d))

;******************************************
;* fonction de duplication de liste : DUP
;******************************************
(defun DUP (l)

	(IF (NULL l) l (cons (car l) (DUP (cdr l)))
	)
)

;//////////////////////////////////////////
;/ execution de DUP
;//////////////////////////////////////////
(print (DUP '(a b c d)))


;*********************************************
;* calcul du nombre d'atome d'une liste : CAL
;*********************************************
(defun CAL (liste)
  (if (NULL liste)
       0
       (+ (CAL (cdr liste)) 1)
   )
)

;/////////////////////////////////////////////
;/ execution de CAL
;/////////////////////////////////////////////
(print (CAL '(A B C D E)))

;********************************************
;* fonction reverse
;********************************************
(defun REV (liste)
  (if (NULL liste)
       NIL
       (append (REV (cdr liste)) (list (car liste)))
   )
)

;////////////////////////////////////////////
;/ execution de REV
;////////////////////////////////////////////
(print (rev '(A B C D)))

;*************************************************
;* fonction de duplication d'une renverse : DUPREV
;*************************************************
(defun DUPREV (liste)
  (append (rev liste) (rev  liste))
)

;//////////////////////////////////////////////////
; execution de DUPREV
;//////////////////////////////////////////////////
(print (duprev '(A B C )))

;*************************************************
;premier et dernier element d'une liste:PRD
;*************************************************
(defun PRD (liste)
   (list (car liste) (car(rev liste)))
)

;////////////////////////////////////////
;/ execution de PRD ver 1.0
;////////////////////////////////////////
(print (PRD '(A B C D E)))

;*************************************************
;premier et dernier element d'une liste:PRD2
;*************************************************
(defun PRD2 (liste)
  (if (NULL (cddr liste))
      liste
      (PRD2 (cons (car liste) (cddr liste)))
   )
)

;////////////////////////////////////////
;/ execution de PRD ver 2.0
;////////////////////////////////////////
(print (PRD2 '(A B C D E)))

;***************************************************
;* fonction de calcul de la suite recursive : suite
;***************************************************
(defun suite (x)
  (if (= x 1)
      x
    (if (evenp x)
	(suite (/ x 2))
        (suite (+ (* 3 x) 1))
    )
  )
)

;////////////////////////////////////////////////////
;/ execution de suite
;////////////////////////////////////////////////////
; (print (suite (read)))

;***************************************************
;determination du nbre median de 3 nbres:median
;***************************************************
(defun median (x y z)
       (max (min x y) (min y z) (min z x))
)
;///////////////////////////////////////////////////
;execution  de median
;//////////////////////////////////////////////////
(print (median 12 4 87))