fonction read lisp

Bonjour,

Je veux crée une fonction read-tree, qui lit les mots dans l'ordre. Elle présente les cas suivants :

si l'arbre n'a pas de fils, on le renvoie ;
on effectue un append sur le résultat de la récursion dans la partie gauche, sur le père et sur le résultat de la récursion dans la partie droite.

Cette fonction tient en quatre lignes (une pour la définition, une pour cond, et une pour chaque clause). La dernière clause étant probablement trop longue pour tenir sur une ligne, disons qu'elle tiendra en sept lignes (une pour append et une pour chacun de ses arguments).

et il faut imprimer cette liste dans un fichier.

quelqu’un pour m'expliquer cette fonction ?

ok pour aider mais pas pour faire le travail...

Montre un prototype de la fonction!

Bonjour,

Je veux crée une fonction read-tree, qui lit les mots dans l'ordre. Elle présente les cas suivants :

si l'arbre n'a pas de fils, on le renvoie ;
on effectue un append sur le résultat de la récursion dans la partie gauche, sur le père et sur le résultat de la récursion dans la partie droite.

Cette fonction tient en quatre lignes (une pour la définition, une pour cond, et une pour chaque clause). La dernière clause étant probablement trop longue pour tenir sur une ligne, disons qu'elle tiendra en sept lignes (une pour append et une pour chacun de ses arguments).

et il faut imprimer cette liste dans un fichier.

quelqu’un pour m'expliquer cette fonction ?

J'ai déja fais une fonction qui s'appelle french-string>= qui compare deux chaine de caractère et qui renvois t si c vrai sinon faux; et une autre fonctionajoute (T arbre) qui insere dans une arbre des chaine de caractère exemple




(setq arbre (ajoute "k" nil)) => ("k")
(setq arbre (ajoute "a" arbre)) => ("k" ("a"))
(setq arbre (ajoute "m" arbre)) => ("k" ("a") ("m"))
(setq arbre (ajoute "n" arbre)) => ("k" ("a") ("m" nil ("n")))
(setq arbre (ajoute "b" arbre)) => ("k" ("a" nil ("b")) ("m" nil ("n")))

et je pense les utiliser dans la fonction lis-arbre

le prob j'ai pas encore compris la fonction je sais que je dois utiliser ses deux focntions dedant

Tu devrais étudier un peu les arbres, c'est une structure importante en LISP.
Là tu as un cas particulier du parcours des arbres, le parcours en profondeur de gauche à droite.

Quels sont les différents types d'arbre que la fonction peut recevoir?
1. l'arbre est nil -> on renvoie nil
2. l'arbre est un atome -> pour que cela fonctionne avec la fonction append on le transforme en liste
3. l'arbre est une liste -> dans ce cas-là il y a deux possibilités:
3.1 le second membre de la liste est nil -> on place le premier membre au début de la liste créée en appliquant la fonction au troisième membre
3.2 le second membre n'est pas nil -> il faut mettre au début le résultat de la fonction appliquée au second membre de la liste.

Code:

---

1 2 3 4 5 6 7

(defun conv (r) (unless (null r) ;; si nil on renvoie nil (if (atom r) (list r) ;; si c'est un atome on renvoie une liste, car append fonctionne avec des listes (let ((nxt (cons (first r) (conv (third r))))) ;; la suite (le père avec le frère de droite) (if (second r) ;; si le deuxième membre n'est pas nil... (append (conv (second r)) nxt) ;; on lui accroche la suite nxt))))) ;; sinon on ne renvoie que la suite

---

Code:

---

1 2 3 4 5 6 7

(defun conv (r) (unless (null r) ;; si nil on renvoie nil (if (atom r) (list r) ;; si c'est un atome on renvoie une liste, car append fonctionne avec des listes (let ((nxt (cons (first r) (conv (third r))))) ;; Je n'es pas vu en cours first ni le third ?? ça veut dire quoi ? (if (second r) ;; si le deuxième membre n'est pas nil... second c'est pas cdr ?? (append (conv (second r)) nxt) ;; on lui accroche la suite nxt))))) ;; sinon on ne renvoie que la suite

---

j'ai essayé de comprendre la fonction et voila ce que ça donne

Code:

---

1 2 3 4 5 6 7

(defun lis-arbre (arbre) (cond ((not arbre) nil) ((atom arbre) (list arbre)) ((setq nxt (cons (car arbre) (lis-arbre (cdr arbre))))) (( not (equal (cdr arbre)) nil) (append (lis-arbre (cdr arbre)) nxt) nxt)))

---

first, second, third, fourth, fifth, etc. sont des fonctions pour accéder au premier, deuxième, troisième, etc. membre de la liste.
first = (car lst), second = (car (cdr lst)), third = (car (cdr (cdr lst))), etc. // second est différent de cdr: (second '(1 2 3)) = 2, (cdr '(1 2 3)) = '(2 3)
c'est à mon avis plus propre que les combinaisons de car et cdr, et marginalement plus lisible que cadr, caddr, cadddr qui sont des contractions de ces combinaisons.

Je ne suis pas sûr que ta réécriture soit correcte :
- le (setq ...) est interprété comme une des clauses de cond (qui en l'occurrence sera toujours T si l'exécution arrive jusqu'à ce cas), donc ça ne va pas trop.
- pour tester si quelque chose n'est pas nul, pas la peine d'écrire (not (equal nil) x); il suffit de mettre x: il sera assimilé à T s'il n'est pas nil.
- null est préférable à not pour tester la nullité
- si tu tiens absolument à cond, tu devrais le réécrire comme ça (tu es obligée de te répéter) :

Code:

---

1 2 3 4 5 6

(defun lis-arbre (arbre) (cond ((null arbre) nil) ((atom arbre) (list arbre)) ((second arbre) (append (lis-arbre (second arbre)) (cons (car arbre) (lis-arbre (second arbre))))) ( T (cons (car arbre) (lis-arbre (second arbre)))))))

---

par ailleurs tu devrais utiliser plutôt let que setq: avec let tu as un contexte purement local, tandis qu'avec setq, si tu as une variable appelée nxt déjà définie elle prendra la valeur que donne setq.

Je vous remercie pour les explications