Discussion :

[080983]

Bonjour,

pouvez vous m'aider svp a ecrire un algorithme qui permet de parcourir un tableau de listes

tab( A1,A2,A3,A4,..Ak)

A1, A2,A3,A4,Ak sont des listes d'éléments.
A1(A,B,C,D,........Z)
A2(1,2,3,4,.........n)
A3(a,b,c,d,..........z)
A4(A1,A2,A3,A4,.......An)
Ak(a1,a2,a3,a4,.......an)

je veux parcourir toutes les listes et tester les éléments des listes.
chaque élément est testé avec un appel d'une fonction. comment appeler cette fonction "k=f(p)" dans l'algo pour tester les éléments de la liste ?
si k=0 j'élémine cet élément.
sinon je contruit une nouvelle liste L1 avec le reste des éléments différents de 0.

Merci



je suis débutantes en algorithmique.

Merci pour vos aides

[picodev]

Bonjour,
tu déjà posé cette question ici : Parcours de listes dans une liste.

Les réponses seront sensiblement les mêmes :

Tu écris une procédure qui filtre une liste

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
procedure liste_filtrer( liste : type liste )
début
  si non liste_est_vide(liste) alors
    courant : type élément = liste_tete(liste)
    faire
      suivant : type élément = liste_suivant(liste, courant)
      si f(p)=0 alors
        liste_effacer_element(liste, courant)
      fin si
      courant = suivant
    tant que suivant != NIL
  fin si
fin

Et tu écris une procédure qui parcourt le tableau de liste en appliquant le filtre à chaque liste

Code :

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

1
2
3
4
5
6
 
procedure tableau_filtre( tableau : tableau de liste )
début
  pour i de 1 à nombre_élément(tableau)
    liste_filtre(tableau[i])
fin

…
Rien de compliqué, l'algo c'est la transition entre le problème compris en français et le début du codage. La syntaxe est libre, même si elle est forcément orientée vers le langage cible. Le plus compliqué est d'exprimer ce que tu veux en français le reste vient tout seul.

[080983]

Merci picodev.

est ce que le parcourt des liste dans une liste est le meme parcourt des listes dans un tableau?

je veux poser quelques questions:

pourquoi la première procédure qui filtre les listes ?
qu'est ce que tu veux dire avec
si non liste_est_vide(liste)?

liste_effacer_element(liste, courant)?

on peut pas faire des boucles imbriquée qui permettent de parcourir le tableau et les listes en meme temps?

Merci

[picodev]

Merci picodev.

est ce que le parcourt des liste dans une liste est le meme parcourt des listes dans un tableau?

Tu accède à un tableau en indiquant l'indice de l'élément que tu veux récupérer. Parcourir un tableau revient à faire varier l'indice du début (0 ou 1 suivant les langages) à la fin (taille-1 ou taille) du tableau.

Les listes ne sont pas faites pour être accédées en plein milieu. Le parcours d'une liste se fait en accédant à la tête de liste puis en passant au suivant.

je veux poser quelques questions:

pourquoi la première procédure qui filtre les listes ?

Plus tu auras des procédures courtes qui ne font qu'une chose plus tu écriras un algo clair.

qu'est ce que tu veux dire avec
si non liste_est_vide(liste)?

Si la liste est vide il n'y a rien à faire, car une liste peut ne pas contenir d'éléments … Il te faut donc une fonction qui t'indique si la liste est vide ou non.

liste_effacer_element(liste, courant)?

Tu veux effacer un élément de la liste ? oui ? alors il te faut une fonction qui te le fasse

on peut pas faire des boucles imbriquée qui permettent de parcourir le tableau et les listes en meme temps?

Merci

Si bien sûr mais ce sera moins clair, moins lisible, moins compréhensible.

[080983]

Merci pour tes réponses picodev!!


pouvez vous me montrer ce que peut être le contenu des fonctions

liste_effacer_element(liste, courant)?


aussi pour liste_est_vide(liste)?



Merci d'avance et je suis désolée!!

[picodev]

Ce sont typiquement des fonctions qui vont dépendre de l'implémentation et qu'on ne détaille jamais vraiment lors de l'algo.
En quelque sorte, ce sont les fonctions dont tu vas avoir besoin qui vont influer quelle implémentation choisir.
Une liste peut tout aussi bien être implémentée à base de pointeurs que par un simple tableau. Si un moment donné tu as besoin de trier la liste alors cela peut t'amener à orienter l'implémentation vers une liste sous forme de tableau …

[080983]

Merci bp picodev.

[080983]

une dernière question !

si j'ai plusieurs test si f(p)=0, si f(p)=1 (créer une nouvelle liste avec ces éléments), et si f(p)=2 ( créer nouvelles listes avec des combinaisons)

si f(p)=0 alors
liste_effacer_element(liste, courant)
fin si

comment sera le code la procédure liste_filtrer(liste)?

Merci

[picodev]

Je peux te faire la même réponse que dans l'autre discussion :

Je ne peux pas faire ton travail à ta place ... mais google peut t'aider à trouver des algos qui te seront utiles.
Par exemple pour générer tous les tuples dont tu as besoin tu peux t'inspirer de l'algo L de Knuth dans le fascicule 2b de son TAOCP (à utiliser dans le squelette que je t'ai donné).
Le tout est de bien organiser tes données.

[080983]

[080983]

comment faire le test avec une fonction?? est ce que ça c'est juste?
voici la procédure.

procedure liste_filtrer( liste : type liste )
début
si non liste_est_vide(liste) alors
courant : type élément = liste_tete(liste)
faire
suivant : type élément = liste_suivant(liste, courant)
si function1 (list, courant)=0 alors
liste_effacer_element(liste, courant)
fin si
si function1(list,courant)=1 alors
liste-certain_element(liste,courant)
fin si
si function1(list, courant) !=0 and function1(list, courant)!=1 alors
liste_combination_element(list,courant)
fin si
courant = suivant
tant que suivant != NIL
fin si
fin

[picodev]

Insère ton code en utilisant les balises [code ] et [/code ] sinon ce n'est pas lisible.

Comme je te le disais dans l'autre fil, il vaut mieux faire une première passe pour effacer ce que tu veux. Une autre procédure pour le reste, voire deux …
Le principal est de pouvoir le faire à la main avec une feuille et crayon. Écrire l'algorithme pour décrire ce que tu as fait à la main.

[080983]

Insère ton code en utilisant les balises [code ] et [/code ] sinon ce n'est pas lisible.

Comme je te le disais dans l'autre fil, il vaut mieux faire une première passe pour effacer ce que tu veux. Une autre procédure pour le reste, voire deux …
Le principal est de pouvoir le faire à la main avec une feuille et crayon. Écrire l'algorithme pour décrire ce que tu as fait à la main.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 procedure liste_filtrer( liste : type liste )
début
si non liste_est_vide(liste) alors
courant : type élément = liste_tete(liste)
faire
      suivant : type élément = liste_suivant(liste, courant)
         si function1 (list, courant)=0 alors
         liste_effacer_element(liste, courant)
         fin si
         si function1(list,courant)=1 alors
         liste-certain_element(liste,courant)
         fin si
         si function1(list, courant) !=0 and function1(list, courant)!=1 alors
          liste_combination_element(list,courant)
         fin si
courant = suivant
tant que suivant != NIL
fin si
fin

[anapurna]

salut ,


en reprenant ton code j'ai un doute

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
procedure liste_filtrer( liste : type liste )
début
  si non liste_est_vide(liste) alors
    courant : type élément = liste_tete(liste)
	tant que suivant != NIL
      suivant : type élément = liste_suivant(liste, courant)
      si function1 (list, courant)=0 alors
        liste_effacer_element(liste, courant)  // ici tu supprime l’élément courant ? 
      fin si
      si function1(list,courant)=1 alors  
               // si tu as supprimé l’élément courant, là tu a plantage assuré  à moins de penser a mettre sinon entre les deux si
        liste-certain_element(liste,courant)
      fin si
      si function1(list, courant) !=0 and function1(list, courant)!=1 alors // idem qu'au dessus 
        liste_combination_element(list,courant)
      fin si
      courant = suivant
    Fin tant que 
  fin si
fin

dans le cas du sinon une autre presentation est possible

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
procedure liste_filtrer( liste : type liste )
début
  si non liste_est_vide(liste) alors
    courant : type élément = liste_tete(liste)
    tant que suivant != NIL
       suivant : type élément = liste_suivant(liste, courant)
       Indice =  function1 (list, courant)
       choix indice Faire
         0 faire liste_effacer_element(liste, courant) fin faire
         1 faire  liste-certain_element(liste,courant) fin faire
        sinon
        faire   
           liste_combination_element(list,courant)
        fin faire 
      fin choix
      courant = suivant
    Fin tant que 
  fin si
fin