Discussion :

[stendhal666]

Bonjour,

Il m'arrive quelque chose d'incompréhensible (en tout cas pour moi). Appliquer la fonction reverse dans le corps de la fonction et au résultat de la fonction n'a pas le même effet:

Cas n° 1:

Code :

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

1
2
3
4
5
6
7
8
9
(defun decompose (nb) ; renvoie la liste des chiffres qui composent le nombre ex: 123 -> '(1 2 3)
  (labels ((dcmp (n)
	     (cond ((= n 0) nil)
		   (:else
		    (let* ((div (truncate (/ n 10)))
			   (r (- n (* div 10))))
		      (cons r (decompose div)))))))
    (let ((res (dcmp nb)))
      (reverse res)))) ; reverse dans le corps de la fonction

Résultat:

Code :

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

1
2
CL-USER> (decompose 123)
(2 1 3)

Cas n° 2:

Code :

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

1
2
3
4
5
6
7
8
9
(defun decompose (nb)
  (labels ((dcmp (n)
	     (cond ((= n 0) nil)
		   (:else
		    (let* ((div (truncate (/ n 10)))
			   (r (- n (* div 10))))
		      (cons r (decompose div)))))))
    (let ((res (dcmp nb)))
      res)))

Résultat:

Code :

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

1
2
CL-USER> (reverse (decompose 123)) ; reverse en dehors
(1 2 3)

Mon implémentation de CL est Clozure CL.

Quelqu'un a une idée?
Merci d'avance

[byjav]

D'habutude, on marque la clause par défaut de COND avec T, pas avec :ELSE. D'ailleurs, ici on n'a que deux branches, alors il faut mieux utiliser le plus spécifique IF. La fonction TRUNCATE renvoie deux valeurs, dont la deuxième est le reste. Alors on peut écrire la même fonction d'une façon plus idiomatique comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
(defun decompose (nb)
  (labels ((dcmp (n)
             (if (zerop n)
                 nil
                 (multiple-value-bind (div r) (truncate n 10)
                   (cons r (dcmp div))))))
    (let ((res (dcmp nb)))
      (if (null res)
          '(0)
          (reverse res)))))

Il serait encore plus idiomatique d'utiliser une boucle au lieu de la récursion.

[stendhal666]

Merci pour ces remarques, toutes très pertinentes, mais qui n'expliquent pas pourquoi le 'reverse a des effets différents dans et en dehors de la fonction, si?

[jack-ft]

Quelqu'un a une idée?

Pas testé... juste une idée...

Ta fonction "decompose" est récursive croisée!

Elle passe par une sous-fonction "dcmp" qui construit une liste dans un sens qui lui est propre et indépendant de "decompose".

Pas testé, mais, peut-être que si tu remplaces dans l'une des versions (cons r (decompose div)) par quelque chose comme (append (decompose div) (list r)), tu vas retrouver le même résultat.

Tu peux aussi le vérifier en traçant les 2 fonctions "dcmp" et "decompose" (peut-être faudra-t-il externaliser la sous-fonction).

HTH

[jack-ft]

De plus, je ne comprends pas trop l'intérêt de la récursivité croisée avec la sous-fonction

On peut, àmha, simplifier la fonction (la rendre plus lisible) avec:

Code :

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

1
2
3
4
5
6
7
8
9
(defun decompose (nb) ; renvoie la liste des chiffres qui composent le nombre ex: 123 -> '(1 2 3)
  (labels ((rev-decompose (n)
	     (cond ((= n 0) nil)
		   (:else
		    (let* ((div (truncate (/ n 10)))
			   (r (- n (* div 10))))
		      (cons r (rev-decompose div)))))))
    (let ((res (rev-decompose nb)))
      (reverse res)))) ; reverse dans le corps de la fonction

Du coup, on voit clairement une fonction rev-decompose autonome (pas de récursivité croisée) qui calcule la décomposition inversée
et la fonction decompose qui se contente de "reverser" le résultat de la précédente!

Rq: dans tous les cas, il y a un petit bug pour le calcul de (decompose 0)...
mais il est plus facile à corrige avec ma version (na!):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
(defun decompose (nb) ; renvoie la liste des chiffres qui composent le nombre ex: 123 -> '(1 2 3)
  (labels ((rev-decompose (n)
	     (cond ((= n 0) nil)
		   (:else
		    (let* ((div (truncate (/ n 10)))
			   (r (- n (* div 10))))
		      (cons r (rev-decompose div)))))))
    (if (= 0 n)
      (list 0)
      (let ((res (rev-decompose nb)))
        (reverse res))))) ; reverse dans le corps de la fonction

ce qui prouve la supériorité de ma méthode

[stendhal666]

Merci Jack-ft!
C'est bien liée à cette récursion croisée, qui était une simple erreur d'écriture, pas un choix réfléchi! Un reverse interne donne maintenant le résultat attendu.
Toujours étonnant à quel point on peut passer à côté de ce genre de choses malgré un bon nombre de relectures et les copier/coller vers le forum!

[jack-ft]

Merci Jack-ft!

Si la réponse te plait, n'hésite pas à plusser !

[byjav]

Merci pour ces remarques, toutes très pertinentes, mais qui n'expliquent pas pourquoi le 'reverse a des effets différents dans et en dehors de la fonction, si?

Pardon, il paraît que j'avais effacé la première partie de ma reponse.