Discussion :

[Kurodiam]

Bonjour,

Je suis bloquée sur un exercice depuis un assez long moment, il faut créer un seau remplie avec (set 'seau '(o o o o)) , et ensuite le vider en utilisant cons et eval (pour évaluer l'expression) :

Code :

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

1
2
Break 1 [5]> (cons 'loop (cons 'cond (cons (cons 'not (cons 'seau nil)) (cons '(return seau) (cons 'pop (cons 'seau nil))))))
(loop cond (not seau) (return seau) pop seau)

Donc comme l'expression est fausse , lorsque je teste la variable seau , l’interprète me renvoie toujours un seau rempli ...


En principe , il faut arriver à l'expression suivante :

Code :

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

 (loop (cond ((not seau) (return seau))) (pop seau))

pour obtenir une bassine vide soit nil .


J'ai essayé de suivre le raisonnement de l'exemple (+ 10 5) , mais je ne vois pas où se trouvent mes erreurs , à part le manque de quote , et l'utilisation de la fonction eval (au début).


Je ne demande pas une réponse , mais plutôt une petite piste

[Jedai]

Regardons un sous-problème :

Code :

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

(loop (cond))

Si on suit ton code, tu écrirais :

Code :

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

(cons 'loop (cons 'cond nil))

Mais ceci est incorrect et résulte en :

Code :

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

(loop cond)

car :

Code :

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

(cons 'cond nil)

correspond simplement à la liste ('cond)
et :

Code :

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

cons 'head tail)

consiste en la liste constituée de 'head puis des éléments de tail (où tail est une liste).
Donc :

Code :

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

(cons 'loop (cons 'cond nil)) == (cons 'loop ('cond)) == ('loop 'cond)

Donc si on veut bien :

Code :

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

(loop (cond))

il nous faut créer une liste dont ('cond) (la liste contenant 'cond) est un élément, autrement dit :

Code :

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

(cons 'loop (cons (cons 'cond nil) nil))

Est-ce compris ? Corrige le reste en suivant ce modèle.

--
Jedaï

[jack-ft]

J'ai la solution:

Code :

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

1
2
3
(eval (cons 'set
            (cons (cons 'quote (cons 'seau ()))
                  (cons () ())))

Remarque: j'ai obtenu ce résultat en utilisant la fonction "get-cons":

Code :

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

1
2
3
4
5
6
ELISP> (get-cons '(set 'seau nil))
(cons 'set
      (cons
       (cons 'quote
	     (cons 'seau nil))
       (cons nil nil)))

et on vérifie que c'est bon avec:

Code :

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

1
2
ELISP> (eval (get-cons '(set 'seau nil)))
(set 'seau nil)

Sinon on peut aussi utiliser (get-cons '(loop (cond ((not seau) (return seau))) (pop seau))), ainsi qu'en atteste le code suivant:

Code :

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

1
2
3
4
5
6
7
8
ELISP> (set 'seau '(o o o))
(o o o)
 
ELISP> (eval (eval (get-cons '(loop (cond ((not seau) (return seau))) (pop seau)))))
nil
 
ELISP> seau
nil

Juste pour vérifier:

Code :

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

1
2
3
4
5
6
7
 
ELISP> (eval (get-cons '(loop (cond ((not seau) (return seau))) (pop seau))))
(loop
 (cond
  ((not seau)
   (return seau)))
 (pop seau))

Il suffit juste d'écrire "get-cons", mais c'est tellement trivial que c'est laissé en exercice au lecteur... oops! à la lectrice...

[Kurodiam]

Merci Jedai et jack-ft .

Code :

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

((cond)) == (cons (cons 'cond nil) nil))        # pour obtenir une sous-liste .

Donc en suivant ce chemin :

Code :

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

((not seau)) ==    (cons (cons 'not  (cons 'seau nil)) nil)

Code :

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

(return seau) == (cons '(return seau)

En imaginant la liste :

Code :

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

((not seau) (return seau))   == (cons (cons 'not (cons 'seau nil)) (cons '(return seau) nil))

Mais comment savoir subdiviser les liste qui restent Y'a pas à dire faut avoir l’œil observateur


Sinon , concernant ta méthode @jack-ft , cette dernière n'est pas encore de mon niveau , l'énoncé est clair : il faut tout considérer comme des atomes , mais je pense que le return est une exception à la règle...
Cependant , je ne vois pas l'objectif de multiplier l'usage de cons , à part pour rendre complexe la lecture d'un code secret ...

[jack-ft]

Code :

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

((cond)) == (cons (cons 'cond nil) nil))        # pour obtenir une sous-liste .

oui

Code :

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

((not seau)) ==    (cons (cons 'not  (cons 'seau nil)) nil)

oui

Code :

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

(return seau) == (cons '(return seau)

Hummm... on peut appliquer le même principe que pour (not seau) == (cons 'not (cons 'seau nil)):

Code :

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

(return seau) == (cons 'return (cons 'seau nil))

En imaginant la liste :

Code :

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

((not seau) (return seau))   == (cons (cons 'not (cons 'seau nil)) (cons '(return seau) nil))

Attention! pour faire une liste avec A et B, il faut plus que (cons A B). Il faut (cons A (cons B nil))!

avec A == (not seau) et B == (return seau)

Mais comment savoir subdiviser les liste qui restent Y'a pas à dire faut avoir l’œil observateur

C'est pas faux! (et je préfère ma méthode automatique!)

Sinon , concernant ta méthode @jack-ft , cette dernière n'est pas encore de mon niveau ,

Cette méthode n'est pas très très compliquée... (juste une petite récursivité de bon aloi) et elle permet juste de tricher, car elle fournit très simplement le résultat que le prof attend!
Il va de soi qu'on montre au prof le résultat (le paquet de cons) et non la manière dont on l'a obtenu... hé! hé!

l'énoncé est clair : il faut tout considérer comme des atomes , mais je pense que le return est une exception à la règle...

non, non! (voir plus haut)

Cependant , je ne vois pas l'objectif de multiplier l'usage de cons , à part pour rendre complexe la lecture d'un code secret ...

C'est un objectif purement pédagogique!
Mais absolument pas du tout pratique!
C'est pour bien faire prendre conscience que la structure d'une liste avec des sous-listes n'est jamais qu'un gros paquet bien structuré de cons emboités! si je puis m'exprimer ainsi...

Du bon usage des cons!

PS: j'enverrai ma méthode après mes vacances (dans une semaine ou deux (si personne ne l'a donnée avant))

[Jedai]

Cette méthode n'est pas très très compliquée... (juste une petite récursivité de bon aloi) et elle permet juste de tricher, car elle fournit très simplement le résultat que le prof attend!
Il va de soi qu'on montre au prof le résultat (le paquet de cons) et non la manière dont on l'a obtenu... hé! hé!

Et le jour du partiel, lorsqu'on n'a pas d'ordinateur et une expression à traduire...

Bien sûr, il est très intéressant d'écrire soit même une telle fonction et faire cette traduction à la main n'est pas passionnant mais il est assez clair que l'objectif est d'intégrer mieux la structure et la syntaxe des listes chainées en Lisp, ce qui visiblement est nécessaire pour Kurodiam.

--
Jedaï