Discussion :

[debmaths]

Merci de m'avoir sorti du pétrin pour "Fonction interne et let ". Je profite de votre savoir pour un autre sujet sur lequel je bute depuis quelques jours. Je plante sur la fonction "cons" et je ne voie pas pourquoi !!! Merci pour votre aide

[Trap D]

Il ne faut pas hésiter à poster le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
;;; 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)))
          (let ((k (cons (car L) (corrigeSimple (cdr L)))))
          (if (> (car L) (cadr L))
==>             (((cons (cadr L) (list car L))) 
             k)
             k)
        (list (car L)))))

En dehors de la correction de l'algo, il faut dejà corriger les parenthèses en trop ou manquantes.
Sur la ligne marquée d'un ==>, il y a beaucoup de corrections à faire.
Est-ce normal qu'il y ait deux lignes avec uniquement k ?

[debmaths]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
;;; 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)))
          (let ((k (cons (car L) (corrigeSimple (cdr L)))))
          (if (> (car L) (cadr L))
            (((cons (cadr L) (list (car L)))) 
             k)
             k)
        (list (car L)))))

J'ai corrigé l'erreur de parenthèse sur la ligne "cons" mais toujours résultat "liste vide" !!
Si test vérifié je voudrais exécuter "cons" et ensuite k SINON k. C'est pour cela qu'il y a 2 fois k.
Je dois dire qu'en cas d'erreurs Scheme n'est guère explicite.
Merci encore pour votre aide.

[debmaths]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

J'ai le même problème avec cette fonction de filtre. Est-ce que la cause serait identique ?

[Trap D]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Ton problème vient ici de list ?????

Pour

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
;;; 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)))
          (let ((k (cons (car L) (corrigeSimple (cdr L)))))
          (if (> (car L) (cadr L))
            (((cons (cadr L) (list (car L)))) 
             k)
             k)
        (list (car L)))))

Examinons ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 (((cons (cadr L) (list (car L)))) 
             k)

Si on decoupe en fonction de ton parenthésage tu as d'abord
(cons (cadr L) (list (car L))) qui signifie que tu concatène (cadr L) à (list (car L)) Pas de problème. Appelons A cette expression.
Tu écris en suite (A) ce qui veut dire que A est considéré comme une fonction que tu appelles, déjà une erreur.
Ensuite le résultat de l'appel à A est considéré lui même comme une fonction que tu appelles avec l'argument k. Surement pas ce que tu pensais.

[debmaths]

J'en perds mon latin même si je ne le parle pas !!!
-définition filtre : "list" , je ne comprends pas !! Ne trouvant pas l'erreur j'ai bidouillé. J'ai suprimé (list),rien. Je l'ai remplacé par (), rien !!!!
-CorrigeSimple: il y avait en effet une paire de parenthèses en trop pour "cons". En modifiant: même erreur.

J'ai dans les deux définitions la même configuration: une concaténétion suiivie d'un appel de fonction récursive. Il doit y avoir de ma part une erreur d'écriture ou d'incompréhension Scheme à ce sujet. Pouvez-vous me mettre sur la voie ? Merci pour votre patience.

[Trap D]

pour xFiltre, c'est tout simple, que renvoies-tu lorsque le test if (pair? L)
échoue ?

Pour corrigeSimple c'est un peu plus complique, qu'attends-tu exactement comme résultat pour (corrigeSimple '(1 5 3 2)) par exemple.

[debmaths]

-- filtre : lorsque la liste entrée est vide je désirerais récupérer la liste créée par concaténation. Donc pour moi c'est "list"
-- corrigeSimple : je désire à la sortie, comme je l'ai spécifié (1 3 5 2). A partir de vos données j'avais réussi dans mes différents essais à trouver (1 3 5), je ne recopiais pas la liste entièrement !!!

Je pense que vous me donnez ces deux indications pour me mettre sur la voie mais cela fait des heures que je suis dessus, je ne vois pas d'issue et mon cours , à mon avis, ne répond pas à mon problème. Désolé

[Trap D]

Au vu de votre réponse, je crois que vous n'avez pas compris le principe de la récursivité.
Voici la solution pour xFiltre.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Un exemple d'utilisation

> (xfiltre integer? (list 1 2.5 3 3.7 4 5 6 7.9))
(1 3 4 5 6)

Je vous invite à écrire à la main chauqe ligne de calcul pour bien comprendre le fonctionnement.
Une fois ceci compris, il y aura beaucoup moins de difficultés pour résoudre le deuxième exercice.

[Trap D]

Ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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)))

n fonctionne pas :
(xfiltre odd? (cons 1 3)) devrait retourner (1 3), il ne retourne que (1) !

[debmaths]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Bienvenue dans DrScheme, version 372 [3m].
Langage: Language pour LI101.
(1 3)

Désolé mais pour moi ça fonctionne. J'ai "list" au lieu de "cons" dans l'exécution

[Trap D]

Ça marche effectivement avec (list 1 3) mais ça devrait fonctionner aussi avec (cons 1 3) qui est une paire pointée dans le test (pair? (cons 1 3)) réussit et donne 1 et ensuite 3 car le test (pair? 3) échoue et doit donc L c'est à dire 3.

PS pensez aux balises code /code :

[debmaths]

Je ne comprends pas très bien. Est-ce que cela concerne les n-uplets ? Si oui, dans notre problème je ne traite que des nombres isolés.
J'ai oublié de signaler que la définition corrigeSimple fonctionne pour une liste ayant des nombres croissants. Je deviens enragé avec cette définition.
Pour les messages précédents je n'ai pas trouvé comment on présente le code !!!
Bonne semaine
Cordialement

[debmaths]

Désolé me voilà de retour car vous êtes le seul sur terre à pouvoir m'aider. J'ai corrigé "corrigeSimple" en mettant le let sur le deuxième if mais toujours la même chose. En descendant l'algorithme je me suis aperçu que si ma définition avait fonctionné, j'aurais corrigé les 2 derniers nombres inversés et non les premiers. Si j'arrive à bien comprendre cet exercice d'entrainement, je crois que j'aurai fait un grand pas dans la compréhension de la récursivité, c'est pour cela que je persévère.
Cordialement

[Trap D]

Reprenons ce que dois faire corrigeSimple :

;;; vérifier l'ordre croissant des chiffres
;;; si 2 nombres sont en ordre inverse, les permuter. Uniquement les 2 premiers

A chaque étape, la liste L est décomposée en 3 éléments (car l) (cadr L) et (cddr L)
Verifier l'ordre croissant :
si deux éléments consécutifs sont dans l'ordre, on concatène le premier avec le résultat de l'application de corrigeSimple au reste de la liste
on renverra donc (cons (car L) (corrigeSimple (cdr L)))
si deux éléments ne sont pas dans l'ordre, on concatene le deuxième élément et le premier élément avec le résultat de l'application de corrigeSimple au reste de la liste
on renverra donc (cons (cadr L) (cons (car l)(corrigeSimple (cddr L))))
Ce qui donne comme code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
;;; 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) (corrigeSimple (cddr L)))))
       L))

Tu obtiens bien ce qui est recherché :

> (corrigeSimple '(1 5 3 2))
(1 3 5 2)

[debmaths]

EH !!! BEN !!! Je n'aurais jamais pu l'écrire car je ne savais pas que l'on pouvait mettre plusieurs "cons" concaténer.
Merci pour tout