Petit semi predicat en scheme

Bonjour,

pour ton exo MAX

en français

fonction (max L)
si L n'est pas une liste retourner 0

sinon si longueur de L =1 alors c'est la maxi : retourner element 1 de L

sinon si element 1 de L > element 2 de L alors constuire une nouvelle liste L
avec element 1 de L et elements 3 jusqu'au dernier de L; appeler (max L) ;recursivité

sinon L=nouvelle liste avec 2e element jusqu'au dernier de L ; appeler (max L); recursivité

fin fonction

En Algo:

Fonction max( L)
SI L n'est pas liste retourne(0)
  SINON SI Longueur(L) = 1 ALORS retourne(1er elem);(car L)
    SINON SI (1er elem L) >(2eme elem L) ALORS (max (L=nouvelle liste((1er elem L) (3e elem ->dernier elem L)))
       SINON (max (L=2e elem ->dernier elem L))

Fin Fonction

En scheme:

(define (max L)
(if (pair? L)
    (if (= (length L) 1) (car L)
       (if (> (car L) (car(cdr L)))
          (max (cons (car L) (cdr (cdr L))))
          (max (cdr L)))
     )
0)
) 

;test
(define  A '(10 2 13 3 9)); -> (13) 
(max A)

(define  B '(10 2 5 3 9)); -> (10) 
(max B)

(define C 10)
(max C); -> 0

Excuses-moi mais je ne comprends pas.

je dois écrire un semi predicat en scheme qui prend une liste en parametre et qui renvoie la valeur maximum d'une liste , exemple :
(fonction '(2 5 3) -> (5) ...c'est clair

(max '(2 6 8)) , ça doit me rendre '(8 2) , où 2 est l'occurence du terme dans la liste ...c'est pas clair

Reformule ton énoncé s'il te plait.

OK, je reviens dans quelques minutes...

Apres quelques longes minutes voila le resultat, je sais pas si c'est vraiment ce que tu cherches mais ça marches
les variables i et j sont utilisées comme index.

(define i 0) ; index de position du max
(define j 0) ; conteur d'itération

(define (max L)
(set! j (+ 1 j))
  (if (pair? L)
    (if (= (length L) 1) (list (car L) i)
       (if (> (car L) (car(cdr L)))
           (max (cons (car L) (cdr (cdr L))))
           (begin (set! i j)(max (cdr L))))
     )
  0)
) 
;test
(set! i 0)
(set! j 0)
(define  A '(10 2 13 3 9)); -> (13 2) 
(max A)
(set! i 0)
(set! j 0)
(define  B '(10 2 5 3 9)); -> (10 0) 
(max B)
(set! i 0)
(set! j 0)
(define C 10)
(max C); -> 0

petite rectif il faut renvoyer FAUX pour une liste vide

(define i 0) ; index de position du max
(define j 0) ; conteur d'itération

(define (max L)
(set! j (+ 1 j))
  (if (pair? L)
    (if (= (length L) 1) (list (car L) i)
       (if (> (car L) (car(cdr L)))
           (max (cons (car L) (cdr (cdr L))))
           (begin (set! i j)(max (cdr L))))
     )
  #f)
) 
;test
(set! i 0)
(set! j 0)
(define  A '(10 2 13 3 9)); -> (13 2) 
(max A)
(set! i 0)
(set! j 0)
(define  B '(10 2 5 3 9)); -> (10 0) 
(max B)
(set! i 0)
(set! j 0)
(define C '())
(max C); -> #f ;liste vide