Discussion :

[ogiacomo]

Bonsoir à tous !! Je suis étudiant en DUT informatique et j'aurais aimé savoir comment parvenir à créer des actions (procédures) telles que l'union, l'intersection et la différence symétrique sur deux ensembles E1 et E2. Je dispose de deux tableaux pour représenter chaque ensemble et je dispose également d'un troisième tableau pour enregistrer les valeurs de chaque action.

Voici un exemple avec l'intersection:

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
22
23
24
25
26
27
28
29
30
31
32
33
34
Procedure Intersection1 (E1,E2: in ensemble, E3: out ensemble)is
 
--LEXIQUE
 
      J: Integer range 1..Lmax;
      K: Integer range 1..Lmax;     
 
   begin
      -- parcours de E1  
       K:=1; 
      for I in 1..E1.L  loop 
            -- schéma recherche de E2
           j:=1;
 
            while J <= E2.L and then E1.T(I)/= E2.T(J) loop
 
            J:=J+1;
 
         end loop;
          -- j<=Lde E2 +1 et E1.T(I)= E2.T(J) 
         if E1.T(I) = E2.T(J) then 
 
 
            E3.T(K):= E1.T(I);  -- on recopie les valeurs T[I] de E1 sur un nouveau ruban
 
            K:=K+1;
           else NULL;
 
         end if;
       end loop;         
 
   E3.L:= K-1;     
 
End Intersection1;

Toute aide sera la bienvenue. Merci à vous et bonne fin de soirée.

[Hibou57]

Ogiacomo, c'est très bien tout ça... mais je ne vois pas où est le problème, puisque tu y arrive parfaitement. Tu as interprété la sémantique de l'opération en ternes algorithmiques de manière direct... il ne te reste plus qu'à faire la même chose avec l'union et la différence symétrique. Continue comme tu as fais, c'est très bien

[ogiacomo]

Ogiacomo, c'est très bien tout ça... mais je ne vois pas où est le problème, puisque tu y arrive parfaitement. Tu as interprété la sémantique de l'opération en ternes algorithmiques de manière direct... il ne te reste plus qu'à faire la même chose avec l'union et la différence symétrique. Continue comme tu as fais, c'est très bien

En fait, j'ai bien réussi l'intersection...le problème c'est que je ne sais pas quel "schéma" je dois utiliser pour l'union, ou l'inclusion (qui doit être une fonction booléenne). N'est-il pas possible de me montrer en language ADA quel est la structure pour une telle fonction ???(Union, ici)

En tout cas, merci d'avoir tout de même répondu Hibou57

[Hibou57]

Eh bien..... pour réaliser l'union, tu cré une procédure qui rempli E3 avec tous ce qui est dans E1 et/ou dans E2.

Et pour l'inclusion, tu fais une fonction booléenne qui renvoie True si tous les éléments de E1 sont aussi dans E2, et False dans l'autre cas.

Voià

[ogiacomo]

Okay !! Merci beaucoup !!!!! Maintenant y a plus quà mettre tout ça en language Ada !! (sauf si tu peux m'aider !! lol)

[Hibou57]

Salut!

Comment ça marche ? Tu as trouvé un bonne solution ?

[ogiacomo]

oui, j'ai trouvé une bonne solution, sauf pour l'inclusion dont le schéma ne m'est pas encore arrivé !!! Voici ce que j'ai trouvé pour l'union:

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
procedure Union1 ( E1, E2 : in Ensemble; E3 : out Ensemble) is
      -- { e.i. : E1 et E2 existent }
      -- { e.f. : E3 correspond à l'union des ensembles E1 et E2 }
      -- remarque : pour la réalisation de cette action, on n'appliquera pas
      -- la technique de sentinelle dans les recherches
 
 
   --LEXIQUE
      I: integer range 1..Lmax;
      J: Integer range 1..Lmax; 
      K: Integer range 1..Lmax;     
 
  BEGIN
     -- { e.i. : E1 et E2 existent }
 
      -- parcours de E1(schéma n°1)  
      K:=1;
 
      for I in 1..E1.L  loop 
            -- schéma n°1 de recherche de E2
           J:=1;
 
            while J <= E2.L and then E1.T(I)= E2.T(J) loop
 
            J:=J+1;
 
        END LOOP;
 
        -- J <= L de E2 +1 ou E1.T(I)/= E2.T(J) 
 
         if E1.T(I) /= E2.T(J) -- on a trouvé 
 
 
            then E3.T(K):=E1.T(I); -- on recopie les valeurs T[I] de E1 sur un nouveau ruban
            K:=K+1;
 
             else Null;-- on a pas trouvé
         end if;
end loop;         
 
 
   E3.L:= K-1;  -- ================================
   -- on obtient le début de E3
--parcours de E2 (schéma n°1)
for J in 1..E2.L  loop 
            -- schéma recherche N°1 de E1
           I:=1;
 
            while I <= E1.L and then E1.T(I)= E2.T(J) loop
 
            I:=I+1;
 
        END LOOP;
 
        -- I <= L de E2 +1 ou E1.T(I)/= E2.T(J)
 
         if E1.T(I)/= E2.T(J)
 
           then E3.T(K):=E2.T(J); K:=K+1; -- on recopie les valeurs T[J] de E2 sur un nouveau ruban
            else NULL;  -- on a pas trouvé
            end if;
 
   end loop;  
 
     E3.L := K-1;
 
     -- { e.f. : E3 correspond à l'union des ensembles E1 et E2 }
 
End Union1;

Tout fonctionne correctement sauf l'incusion dont je n'ai pas trouvé le principe !!

[Hibou57]

Voilà.... je voulais juste attendre de voir si tu trouverais,.. mais bon, je ne vais pas te laisser mariner jusqu'à Noël quand même

J'ai essayé de l'écrire un peu avec ton style, pour que ça te paraisse plus lisible (N.B. si tu ne connais pas les étiquettes de boucle, c'est un peu comme les noms de procédure... c'est sympa parfois pour rendre le code plus lisible)

Mais au fait, je me demandais pourquoi tu déclare toujours par exemple « Truc : Natural range 1..LMax » sans déclarer de type correspondant à « Natural range 1..LMax » ?

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
function Inclus1 ( E1, E2 : in Ensemble) return Boolean is
   -- { e.i. : E1 et E2 existent }
   -- { e.f. : renvoie True si tous les éléments de E1 sont dans E2 }
   --LEXIQUE
      Founded : Boolean; -- Présence ou non d'un élément de E1 dans E2.
   BEGIN
      -- { e.i. : E1 et E2 existent }
      -- Cas trivial : si le cardinal de E2 est inférieur au cardinal de E1
      -- alors E1 n'est évidement pas inclus dans E2.
      if E2.L < E1.L then return False;
      end if;
      -- Parcours de tous les éléments de E1
      Parcours_de_E1: for i in 1..E1.L loop
         -- E1.T(i) est l'élément courant de E1. On parcours tous les éléments
         -- de E2 pour voir si on y trouve l'élément courant de E1. Si on
         -- ne l'a pas trouvé après avoir parcouru tous les éléments de E2,
         -- alors cet élément de E1 n'est pas dans E2, et on en déduit donc
         -- que E1 n'est pas inclus dans E2 (dans ce cas on retourne False).
         -- Founded est un boolean qui indique si l'élément courant de E1 a été
         -- trouvé dans E2.
         Founded := False;
         -- Parcours de tous les éléments de E2 (pour tester si on y trouve
         -- l'élément courant de E1).
         Parcours_de_E2: for j in 1..E2.L loop
            -- E1.T(i) est l'élément courant de E1 (celui que dont on teste
            -- la présence). E2.T(j) est l'élément courant de E2
            if E2.T(j) = E1.T(i) then
               Founded := True;
               exit; -- L'élément trouvé, pas besoin de parcourire le reste.
            END IF;
         END LOOP Parcours_de_E2;
         -- Il suffit qu'un seul élément de E1 ne soit pas dans E2 pour
         -- qu'on en déduise que E1 n'est pas inclus dans E2.
         if not Founded then return False;
         END IF;
         -- On boucle pour passer à l'élément suivant de E1 et tester sa
         -- présence dans E2.
      END LOOP Parcours_de_E1;
      -- Comme l'abscence d'une élément de E1 dans E2 provoque la fin du calcul
      -- avec renvoie de False, si on arrive ici, c'est que tous les élément
      -- de E1 ont été trouvés dans E2, et donc que E1 est inclus dans E2.
      -- On peut alors gaiement renvoyer True.
      return True;
   END Inclus1;

[ogiacomo]

Merci hibou ! Je n'aurasi jamais cru que tu puisses arriver jusque là mais tu ne peux pas t'imaginer comme c'est super sympathique de m'avancer autant !!!!!
Dommage que je ne puisse pas te rendre la pareille vu que je suis simplement débutant dans ce domaine......

Cependant, il demeure un problème, lorsque je vais appeler cette fonction, il va me dire qu'il manque le nom de la procedure...:

Code :

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

1
2
3
 -- Rangement dans E3 de l'inclusion de E1 et E2 
      Inclus1(E1,E2);
   Put_Line(""); Put("Inclusion (version 1) de E1 dans E2 : "); Put_Line("");

PS: pour ce qui est de la déclaration des types, je ne peux pas faire ainsi puisque je n'ai pas les mêmes valeurs pour chaque action. Je veux dire pas là que par, exemple, pour un tableau, j'appelerais son indice i et pour un autre j. Or, pour une fonction donnée je ne ferais pas forcément appel au deux indice à la fois..(j'espère que je me suis bien explqué)

Merci encore en tout cas pour ton aide si précieuse.