Voici le Sujet:
On se propose d'écrire une fonction appelée Supprimer qui prend en argument une Liste L et retourne la liste L privée de son premier élément de tête.
Et moi ma solution :
Code:Fonction SUPPRIMER_X(X:entier;L:liste):liste Variable A,B : liste Début Si L= NULL alors Début A <= NULL Fin Sinon Début Si L^.Val=X alors Début A <= SUPPRIMER_X(X ;L^.lien) Fin Sinon Début NOUVEAU (B) B^.Val <= L^.Val B^.Lien <= SUPPRIMER_X(X ;L^.lien) A <= B Fin Fin Retourner (A) Fin
Dernière modification par yoda1234 ; 03/03/2009 à 12h40.
Bon, à part le pseudo code qui me donne mal à la tête (mais je suppose que la syntaxe vous est imposée), voici quelques questions:
- à quoi sert l'argument X alors que l'énoncé demmande de supprimer le premier élément de la liste...
- ta chaine est-elle simplement chainée ou doublement chainée ?
PS: Le nom des variables A, B, X et L rendent le code illisible, et si tu les appelais avec des noms un peu plus clairs ?
Il ne s'agit pas seulement de supprimer le premier element de la liste concernant X mais de supprimer tous les X qui se trouve dans la liste.
C'est une liste simple.
Pour ce qui est du choix des variables, propose moi autre chose
Envoyé par SHAICI
donc ce n'est pas le même sujet que celui de ton premier message ?
Pour ce qui est du choix des variables, propose moi autre chose
Non, je ne vais rien te proposer. Si tu suis des cours d'infos tu devrais savoir qu'on n'utilise pas de noms de variables qui n'ont aucun sens.
Après tu te débrouilles comme tu veux mais j'espère qu'un prof d'algo sérieux n'hésite pas à retirer plusieurs points pour des variables ayant ce genre de noms !
Excusez moi une erreur s'est glissée dans la redaction du sujet. Voici le bon
On se propose d'écrire une fonction appelée Supprimer_x qui prend en argument un élément X et L une Liste et retourne la liste L privée de toutes les occurrences de X.
Salut,
C'est cool que tu aies précisé ton sujet, mais personne ne le fera à ta place
Donc, comme te l'a dit Faith, mets des noms de variables explicites, des balises code pour la lisibilité et indente.
Je comprend ce qui m'ai demandé dans l'exercice mais je n'arrive pas à le transecrire en pseudo code.
Voici commence je le comprend :
Si Liste vide, il n'y a plus rien à supprimer
On retourne Vide
Si l'élément en cours de traitement doit être supprimé
Alors on le supprime en prenant soin de mémoriser l'adresse de l'élément suivant.
L'élément ayant été supprimé, la liste commencera à l'élément suivant pointant sur une liste qui ne contient plus aucun élément ayant la valeur recherchée.
Si l'élément en cours de traitement ne doit pas être supprimé,
alors la liste finale commencera par cet élément et suivra une liste ne contenant plus d'élément ayant la valeur recherchée
On retourne la liste
Je ne connais pas ce langage, mais pour essayer de le comprendre, j'ai remplacé tes Début par "{" et tes Fin par "}". Avec l'indentation obligatoire, comme cela a été dit, ça donne ceci (tu conviendras que c'est plus facile à lire) :
Deux choses me chagrinent dans ton code.Code:Fonction SUPPRIMER_X(X:entier;L:liste):liste Variable A,B : liste { Si L= NULL alors { A <= NULL } Sinon { Si L^.Val=X alors { A <= SUPPRIMER_X(X ;L^.lien) } Sinon { NOUVEAU (B) B^.Val <= L^.Val B^.Lien <= SUPPRIMER_X(X ;L^.lien) A <= B } } Retourner (A) }
1) La liste B: est inutile. Il suffit d'analyser le contenu de la liste L: passée en paramètre à la fonction SUPPRIMER_X, et ce de la première valeur à la dernière, et de charger la liste A: avec toutes les valeurs rencontrées différentes de X. Ce qui va te donner :
Si L^.Val différent de X alors Nouveau(A), etc.
2) Sur la ligne d'instruction
ta fonction s'appelle elle-même. Ce n'est pas interdit, on appelle cette technique "récursivité". Mais ce n'est pas encore, à mon avis, de ton niveau. Donc à éviter puisque tu n'en as pas besoin, car trop difficile et surtout trop long à débugger.B^.Lien <= SUPPRIMER_X(X ;L^.lien)
Pourtant, le pseudo-code a été fait pourCe n'est pas un langage en soi, c'est une espèce d'hybride entre le langage humain et du code. Z'aime bien, mwé.
Ce que tu as décrit, c'est un traitement récursif. Es-tu obligé(e) de le faire ainsi ou tu peux faire en itératif? Parce que ton énoncé permet de faire un pitite boucle qui règle les choses vite fait bien fait.
j'ai pensé qu'une fonction recursive serais plus simple à faire. Pour l'iterative je ne sais pas comment la faire.
Euh, le récursif plus simple que l'itératif... Je ne sais pasDisons que ça dépendra du langage auquel tu appliqueras l'algo après. Je ne suis pas sûre que faire du récursif (ie, une fonction qui s'auto-appelle) soit plus simple qu'une boucle en C par exemple, alors qu'en Prolog ou Caml, il me semble que ce soit le cas. Mais bon, vu qu'ici il s'agit de pseudocode, on va faire les deux et tu verras par toi-même
L'itératif c'est une boucle (for, while, ce-que-tu-veux).
Je te conseille de réfléchir autrement à ce problème : au lieu de le penser immédiatement en terme de "je dois absolument faire un truc en info", pense-le comme si tu devais l'expliquer à quelqu'un qui ne fait pas d'info. Tu lui dirais quoi?
Une fois que tu auras éclairci ça, pose sur une feuille ce que tu as retenu comme étapes principales. C'est là que tu dois en arriver au pseudocode qui a quelques règles :
* tu déclares explicitement la fonction que tu crées (j'écris n'importe quoi, hein) :
* tu déclares tes variables en précisant leur type :Code:fonction comptage_pommes (arguments)
* tu écris les choses clairement :Code:variables : LISTE : liste; 2 : entier; POUET : string;
Propose quelque chose, on corrigeraCode:Début si ... pour ... faire instructions; finpour finsi retourner ...; fin
