Filtre et tests de listes [Résolu]

[debmaths]

Bonjour,
Pour "problème cons" j'ai enfin trouvé grâce à la concaténétion des cons.

Code :

1
2
3
4
5
6
7
8
9
10
;;; corrigesimple: liste (number ) ---> liste (number)
;;; vérifier l'ordre croissant des chiffres
;;; si 2 nombres sont en ordre inverse, les permuter. Uniquement les 2 premiers
(define (corrigeSimple L)
   (if (and (pair? L) (pair? (cdr L)))
       (if (< (car L) (cadr L))
             (cons (car L) (corrigeSimple (cdr L)))
             (cons (cadr L) (cons (car L)  (cddr L))))
       (list (car L))))           ;; (car L) dernier de la liste  ou alors mettre L car reste le dernier de la liste
(trace corrigeSimple) (corrigeSimple (list 2 7 5 10 9))

Je prends un retard fou dans mes cours par correspondance.
J'ai encore 2 problèmes en suspens, si je prends autant de temps que le premier c'est grave.
-- A partir de la définition ci-dessus écrire une définition pour trier en ordre croissant les nombres d'une liste. C'est-à-dire qu'après (cons (cadr L) (cons (car L) (cddr L)) il faut relancer (corrigeSimple) avec la nouvelle liste Or je ne sais pas comment récupérer la nouvelle liste. J'ai essayé avec "list" mais cela ne fonctionne pas
Ceci est un exercice d'entrainement !!!

-- Par contre j'ai un exercice de devoir où je suis vraiment sec. Aucune idée pour pouvoir écrire une seule ligne de code:

Écrire une fonction qui vérifie l'égalité de deux listes en utilisant la fonctionnelle filter

Or filter a deux arguments: un argument test dont la réponse est obligatoirement booléenne et une seule liste.
Pour ce problème je ne vous demande pas la solution mais la voie à suivre car pour moi c'est le mur.
Merci d'avance pour votre patience.

[Trap D]

pour le premier exercice, tu peux applique corrigeSimple tant que les listes de départ et d'arrivée sont différentes, ce n'est pas efficace du tout, mais pourquoi pas.

[debmaths]

Merci pour votre réponse. J'ai une idée mais je n'arrive pas la mettre en forme correcte:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
(define (corrigeTout L)
  (let ()
  (define (corrigeSimple L)
    (if (and (pair? L) (pair? (cdr L)))
       (if (< (car L) (cadr L))
           (cons (car L) (corrigeSimple (cdr L)))
           (cons (cadr L) (cons (car L)  (cddr L))))             
       (list (car L))))    ;; (car L) dernier de la liste  ou alors mettre L car reste le dernier de la liste
  (if (corrigeSimple L) 
     (corrigeSimple L)
     #f)))
 
(trace corrigeTout) (corrigeTout (list 2 7 5 10 9))

Grosso modo ce que voudrais réaliser. Bien que cela ne fonctionne pas, est-ce la bonne voie ?

Mon problème, comme dans l'hypotèse que vous me donnez, c'est comment "pièger" la liste créer?

Quant au "filter" c'est l'inconnu absolu !!

Cordialement

[Trap D]

PENSEZ AUX BALISES CODE /CODE

le let() ne sert strictement à rien.
Moi j'aurais mis dans le let le corrigeSimple de la liste passée en argument, et si la comparaison avec la liste initiale réussit on renvoie le résultat sinon on rappelle corrigeTout.

[debmaths]

OK bien compris

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
;;; corrigeTout: liste (number ) ---> liste (number)
;;; vérifier l'ordre croissant des chiffres
;;; si 2 nombres sont en ordre inverse, les permuter. Rendre une liste avec des nombres croissants
(define (corrigeTout L)
  (let ((k (corrigeSimple L)))
  (define (corrigeSimple L)
    (if (and (pair? L) (pair? (cdr L)))
       (if (< (car L) (cadr L))
           (cons (car L) (corrigeSimple (cdr L)))
           (cons (cadr L) (cons (car L)  (cddr L))))                       
    (list (car L))))  ;; (car L) dernier de la liste  ou alors mettre L car reste le dernier de la liste))
  (if (not (equal? k L))
      (corrigeTout k)
      L)))
(trace corrigeTout) (corrigeTout (list 2 7 5 10 9))


(define (order L)
  (let ((tL (corrigeSimple L)))
    (if (not (equal? tL L))
        (order tL)
        L)))

Bien que je n'arrive pas à interpréter texto vos modifs, je pense les avoir bien tapées. L'évaluateur n'accepte pas le "let".
Peut-on mettre (corrigeTout k) donc (corrigeTout (corrigeSimple L)) ??

[Trap D]

Il faut définir corrigeSimple à l'extérieur du corps de corrigeTout, ça marchera beaucoup mieux, et d'ailleurs, corrigeTout ne sert à rien :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
;;; corrigeSimple: liste (number ) ---> liste (number)
;;; vérifier l'ordre croissant des chiffres
;;; si 2 nombres sont en ordre inverse, les permuter. Rendre une liste avec des nombres croissants
 (define (corrigeSimple L)
    (if (and (pair? L) (pair? (cdr L)))
       (if (< (car L) (cadr L))
           (cons (car L) (corrigeSimple (cdr L)))
           (cons (cadr L) (cons (car L)  (cddr L))))                       
    (list (car L))))  ;; (car L) dernier de la liste  ou alors mettre L car reste le dernier de la liste))

(define (order L)
  (let ((tL (corrigeSimple L)))
    (if (not (equal? tL L))
        (order tL)
        L)))

[debmaths]

OUH !! LA!! CHAPEAU !!!
Je comprends que je n'y arrivais pas . Je ne savais pas qu'avec un "let" on pouvait obtenir une liste résultat. C'est le gros point sur lequel je butais. D'autre part faire tourner la définition jusqu'à ce que la liste entrée soit égale à la liste sortie, fallait y penser !! BRAVO !!
J'abuse !! HUM !! Une idée pour mon filter SVP

[Trap D]

Envoyé par debmaths

OUH !! LA!! CHAPEAU !!!
Je comprends que je n'y arrivais pas . Je ne savais pas qu'avec un "let" on pouvait obtenir une liste résultat. C'est le gros point sur lequel je butais. D'autre part faire tourner la définition jusqu'à ce que la liste entrée soit égale à la liste sortie, fallait y penser !! BRAVO !!
J'abuse !! HUM !! Une idée pour mon filter SVP

Oui enfin, pour le tri c'est notoirement inefficace, mais comme ton tri s'apparente à un tri à bulle on ne peut pas trop demander.
Pour le filtre, je te laisse mariner un peu (le temps que je trouve quelque chose de simple )

[debmaths]

Je pense qu'il n'y a qu'une solution. La fonctionnelle "filter" aurait comme liste argument L2 et dans test on aurait "= lecture de L1" qui serait lui-même une définition. A chaque passage dans "test" on devrait lire la liste L1. Si c'est cela je n'arrive pas le mettre en code.
Cordialement

[debmaths]

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
(define (xfiltre test? L1)
  (if (pair? L1)
      (let ((k (xfiltre test? (cdr L1))))
      (if (test? (car L1))
          (cons (car L1)
           k)
           k))
      (list)))


(define (test? L2 L1)
  (define (egal2 e)
    (= (car L1) e))
  (xfiltre egal2 (cdr L1)))
(trace xfiltre) (test? (list 1 3 5) (list 1 6 5) )

Voici une idée de ce que je pense répondre à la question mais le code de test? est faux !!!!

[Trap D]

Encore une fois, ton code de xfiltre est incorrect ne serait-ce que parce que tu renvoies list tout seul qui n'a rien a voir avec les arguments passés, renvoie plutôt L que list. Je te propose comme code pour xfiltre :

Code :

1
2
3
4
(define (xfiltre test? L)
  (cond ((null? L) L)
        ((test? (car L)) (cons (car L) (xfiltre test? (cdr L))))
        (else(xfiltre test? (cdr L)))))

Mais connais-tu le cond ?

Dans ton cours quelle sont exactement les conditions que doit remplir xfiltre ?

[debmaths]

Voici ce que l'on me demande

"Écrire une fonction qui vérifie l'égalité de deux listes en utilisant la fonctionnelle filter"

Pour "filtre simple" voici ce que j'avais écrit:

Code :

1
2
3
4
5
6
7
8
define (xfiltre test? L)
  (if (pair? L)
      (let ((k (xfiltre test? (cdr L))))
        (if (test? (car L))
            (cons (car L)
            k)
            k))
   (list)))

[debmaths]

En désespoir de cause j'ai tourné le problème. J'ai créé une liste "association" et j'ai traité couple par couple. Cela ne correspond pas au problème posé mais enfin....
Merci pour votre serviabilité

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
(define (merge  L1 L2)
  (cond ((and (null? L1) (null? L2)) L1)
         ((or (null? L1) (null? L2)) #f)
        (else 
         (let ((x (merge (cdr L1) (cdr L2))))
           (if (eq? x #f)
               #f
               (cons (list (car L1) (car L2)) x))))))     ;; pourquoi seul la combinaison (cons (list permet de faire cadr sur couple
    
;;; liste (nombre) --> liste (nombre)
;;; (xfiltre1 = L3 L4) : rend une liste des nombres égaux entre L3 et L4
;;; () * () rend ()
;;; exemple (1 2 3) (1 2 4)--> (1 2)
;;; rend #f si nombre d'arguments entre L3 et L4 différents ou 1 liste vide
;;; = peut être remplacé par < ou >

(define (xfiltre1 test? L3 L4)
  (let ((tL (merge L3 L4)))
        
    (define (xfiltre2 tL)   
    (if (pair?  tL)
        (let ((couple (car tL))
              (k (xfiltre2 (cdr tL))))
        (if (test? (car couple) (cadr couple))
           (cons (car couple) k)
            k))
        (list)))
   
    
    (if (eq? tL #f)
         #f
    (xfiltre2 tL))))

(trace xfiltre1) (xfiltre1 = (list 1 2 3) (list 1 2 3))