Recherche de mot

Recherche de mot - Ada - Programmation

Marsh Posté le 03-05-2009 à 00:43:51    

Bonsoir,
 
J'essaie d'écrire un programme me permettant de déterminer si une chaîne de caractères présente un (ou des) mot(s) ou non, et de connaître également les indices correspondant à la première lettre et la dernière lettre. Afin de voir si ce que j'ai écrit fonctionne, j'ai procédé à 6 tests unitaires; seulement, l'un d'entre eux ne fonctionne pas, comme vous allez le voir... Voici mon code:
 

Code :
  1. with Ada.Text_IO, Ada.Integer_Text_IO;
  2. use Ada.Text_IO, Ada.Integer_Text_IO;
  4. procedure programme is
  6.    procedure Chercher_Mot (Dans: in String; Trouve: out Boolean; Deb, Fin: out Positive) is
  8.    begin
  10.       Trouve := False;
  12.       for Indice in Dans'First..Dans'Last loop
  14.          if Dans(Indice) /= ' ' and  Trouve = False then
  16.             Deb := Indice;
  17.             Fin := Indice;
  18.             Trouve := True;
  20.          end if;
  22.          if Trouve = True then
  25.             if Dans(Dans'Last) /= ' ' then
  27.                Fin := Dans'Last;
  29.             else
  31.                for Indice2 in (Dans'First + Indice -1)..Dans'Last loop
  33.                   if Dans(Indice2) = ' ' then
  35.                      Fin := Indice2 -1;
  37.                   end if;
  39.                end loop;
  41.             end if;
  43.          end if;
  45.       end loop;
  47.    end Chercher_Mot;
  49.  
  52.    -- Test unitaire
  55.    procedure Tester_Chercher_Mot is
  57.       Mot_Trouve : Boolean;
  58.       Indice_Deb,
  59.       Indice_Fin : Positive;
  61.    begin
  62.       -- Cas 1 : Chaine nulle
  63.       Chercher_Mot("", Mot_Trouve, Indice_Deb, Indice_Fin);
  64.       if Mot_Trouve then
  65.          Put ("T1: Mot trouve!" );
  66.          Put(Indice_Deb);
  67.          Put(Indice_Fin);
  68.          New_Line;
  69.       else
  70.          Put("T1:Mot non trouve!" );
  71.          New_Line;
  72.       end if;
  74.       -- Cas 2: Chaine de longueur > 0 qu'avec des espaces
  75.       Chercher_Mot("    ", Mot_Trouve, Indice_Deb, Indice_Fin);
  76.       if Mot_Trouve then
  77.          Put("T2: Mot trouve!" );
  78.          Put(Indice_Deb);
  79.          Put(Indice_Fin);
  80.          New_Line;
  81.       else
  82.          Put("T2:Mot non trouve!" );
  83.          New_Line;
  84.       end if;
  86.       -- Cas 3: Chaine contenant un mot, sans espaces
  87.       Chercher_Mot("Bonjour!", Mot_Trouve, Indice_Deb, Indice_Fin);
  88.       if Mot_Trouve then
  89.          Put("T3:Mot trouve!" );
  90.          Put(Indice_Deb);
  91.          Put(Indice_Fin);
  92.          New_Line;
  93.       else
  94.          Put("T3:Mot non trouve!" );
  95.          New_Line;
  96.       end if;
  98.       -- Cas 4: Chaine comportant un mot precede par des espaces
  99.       Chercher_Mot("    Bonjour!", Mot_Trouve, Indice_Deb, Indice_Fin);
  100.       if Mot_Trouve then
  101.          Put("T4:Mot trouve!" );
  102.          Put(Indice_Deb);
  103.          Put(Indice_Fin);
  104.          New_Line;
  105.       else
  106.          Put("T4:Mot non trouve!" );
  107.          New_Line;
  108.       end if;
  110.       -- Cas 5: Chaine comportant un mot suivi d'espaces
  111.       Chercher_Mot("Bonjour!    ", Mot_Trouve, Indice_Deb, Indice_Fin);
  112.       if Mot_Trouve then
  113.          Put("T5:Mot trouve!" );
  114.          Put(Indice_Deb);
  115.          Put(Indice_Fin);
  116.          New_Line;
  117.       else
  118.          Put("T5:Mot non trouve!" );
  119.          New_Line;
  120.       end if;
  122.       -- Cas 6: Chaine comportant deux mots separes par des espaces
  123.       Chercher_Mot("Bonjour!  Bye!", Mot_Trouve, Indice_Deb, Indice_Fin);
  124.       if Mot_Trouve then
  125.          Put("T6:Mot trouve!" );
  126.          Put(Indice_Deb);
  127.          Put(Indice_Fin);
  128.          New_Line;
  129.       else
  130.          Put("T6:Mot non trouve!" );
  131.          New_Line;
  132.       end if;
  134.    end Tester_Chercher_Mot;
  136. begin
  138.    Tester_Chercher_Mot;
  140. end programme;


 
Il s'agit du Test 5 qui ne fonctionne pas, puisque le programme me revoit comme indice de fin, 11, au lieu de 8. Voyez-vous ce qui pose problème? Si des explications concernant mon code sont nécessaires, n'hésitez pas à me le faire savoir, je tenterai d'éclaircir ce que j'ai voulu faire!
 
Merci d'avance!

Reply

Marsh Posté le 03-05-2009 à 00:43:51   

Reply

Marsh Posté le 14-06-2009 à 05:37:30    

Déjà juste un avis, qui tiens qu'à moi.
Aux ligne 14 et 22 de ton code, les tests sur les booléens suffisent plutôt qu'une comparaison avec les constantes true et false. Les comparaisons sont superflus. Un simple test (ex: if Trouve then). De plus, ainsi l'expression ressemble plus à une phrase:

Code :
  1. if Dans(Indice) /= ' ' and not Trouve then


se traduit par: si Dans(Indice) n'est pas un espace et un mot pas trouvé alors...
Voilà ça ressemble pour moi à une phrase bien formé ce qui est dans l'esprit du langage ADA à été fait justement pour qu'un programme se lise comme une série de phrases.
 
Avant de voir ton problème, il y a une petite erreur à la ligne 31 de ton code:

Code :
  1. for Indice2 in (Dans'First + Indice -1)..Dans'Last loop


La partie "(Dans'First + Indice -1)" est erronnée.
En effet, la variable Indice est déjà dans l'intervalle Dans'First..Dans'Last à cause du "for" englobant.
La varible Indice n'est pas un offset (décalage) par rapport à Dans'First. Donc ceci est mieux:

Code :
  1. for Indice2 in Indice..Dans'Last loop


 
Pour ton problème maintenant.
Le problème de l'échec du test 5 vient du fait que la ligne 35 de ton code est exécuté plusieurs fois, ce qui écrase la valeur précédente. Donc en fait, l'argument Fin prends succéssivement les valeur 8, 9, 10 et 11 à chaque itération de la boucle. La valeur correcte 8 est bien afectée, mais est ecrasée ensuite. Il te faut une condition d'arrêt, c'est à dire un test qui disent si l'index de fin est trouvé.
 
De plus le test de la ligne 25 me parrait inutile, car il a l'air d'être une optimisation sans doute dans un souci d'une exécution plus rapide en enlevant des cas traités. Mais ce test ligne 25 offre une différence de comportement quand tu as plusieurs mots. Ton test unitaire 6 retroune un indice de fin différent si tu rajoute juste un espace à la fin de la chaine testée. A mon avis ce n'est pas ce que tu espérais, cela viens justement du test ligne 25.
Si pour autant tu souhaite concerver ce test, il te faut en fait partir de la fin de la chaine dans la boucle imbriquée (for Indice2) et remonter la chaine à l'envers pour trouvé le premier caractère qui ne soit pas un espace, cependant le test disparait au dépend justement de la boucle.
 
Je te poste 4 solutions:
1. Correction pour que cela fonctionne.
2. Correction plus complete en enlevant le test ligne 25
3. Autre correction plus complète avec un comportement homogène avec le test ligne 25 dans le cas où la chaine traitée a un espace à la fin.
4. Une solution plus performante.
 
Pourquoi la solution 4, car ton utilisation des boucles FOR, n'est pas une erreur en soit, puisque ça marche, mais si tu regarde attentivement, tu pourras voir des itérations dite poubelles, ces itérations, ne font rien, ne servent à rien, elles bouffent inutilement du temps de calcul. Et en plus, ces itérations "poubelle" introduit souvent des erreurs comme c'est le cas avec ton problème, donc comme avec le problème d'écrasement. En fait, ton problème de départ qui fait que le test unitaire 5 est erroné, est ce qu'on appelle justement un effet de bord qui n'est pas maitrisé.
 
De plus c'est assez visible, car le nombre de tests (if) dans la solution 4 est reduit au strict minimum.
 
Tu pourras faire des tests de vitesse, pour t'en convaincre, par exemple avec un ou plusieurs mots très longs, de mettre tes tests unitaire dans une boucle à 100000 itérations ou simplement de lancer plusieurs fois le même programme plusieurs fois (mais ce n'est pas très fiable comme test de vitesse).
 
Dans la solution 4, j'ai choisi de suivre l'idée de la solution 2, c'est à dire que l'index de fin pour le test unitaire 6 soit la in du premier mot. Ainsi on peut découper le texte en mots en appelant plusieurs fois la procédure Chercher_Mot, ce qui correspond pour moi au nom de la procédure: on cherche un mot. La solution 3 ressemble à une fonction Trim qui cherche à enlever les espaces de début et de fin.
 
Dans la solution 4, j'utilise la fonction Ada.Characters.Handling.Is_Alphanumeric plutôt que tester un simple espace, ainsi le mot découpé ne devrait contenir que des lettres et des chiffres et pas les retours à la ligne, les caractère de tabulation et des signes de ponctuation.
A la place de la fonction Ada.Characters.Handling.Is_Alphanumeric tu peux ainsi utiliser une autre fonction que tu veux pour sélectionner les caractères que tu veux dans le mot découpé. Tu peux aussi par la même occasion faire de la procédure Chercher_Mot une procédure générique avec comme paramètre une fonction de sélection des caractères.
 
Cette procédure Chercher_Mot est ainsi très proche des fonction strtok en C/C++ ou de la classe java.util.StringTokenizer en java si tu connais.
 
Solution 1:

Code :
  1. with Ada.Text_IO, Ada.Integer_Text_IO;
  2. use Ada.Text_IO, Ada.Integer_Text_IO;
  4. procedure programme is
  6.    procedure Chercher_Mot (Dans: in String; Trouve: out Boolean; Deb, Fin: out Positive) is
  8.       Fin_Trouvee : Boolean := False;
  10.    begin
  12.       Trouve := False;
  14.       for Indice in Dans'First..Dans'Last loop
  16.          if Dans(Indice) /= ' ' and not Trouve then
  18.             Deb := Indice;
  19.             Fin := Indice;
  20.             Trouve := True;
  22.          end if;
  24.          if Trouve and not Fin_Trouvee then
  27.             if Dans(Dans'Last) /= ' ' then
  29.                Fin := Dans'Last;
  30.                Fin_Trouvee := True;
  32.             else
  35.                for Indice2 in Indice..Dans'Last loop
  37.                   if not Fin_Trouvee and Dans(Indice2) = ' ' then
  39.                      Fin := Indice2 - 1;
  40.                      Fin_Trouvee := True;
  42.                   end if;
  44.                end loop;
  46.             end if;
  48.          end if;
  50.       end loop;
  52.    end Chercher_Mot;
  57.    -- Test unitaire
  60.    procedure Tester_Chercher_Mot is
  62.       Mot_Trouve : Boolean;
  63.       Indice_Deb,
  64.       Indice_Fin : Positive;
  66.    begin
  67.       -- Cas 1 : Chaine nulle
  68.       Chercher_Mot("", Mot_Trouve, Indice_Deb, Indice_Fin);
  69.       if Mot_Trouve then
  70.          Put ("T1: Mot trouve!" );
  71.          Put(Indice_Deb);
  72.          Put(Indice_Fin);
  73.          New_Line;
  74.       else
  75.          Put("T1:Mot non trouve!" );
  76.          New_Line;
  77.       end if;
  79.       -- Cas 2: Chaine de longueur > 0 qu'avec des espaces
  80.       Chercher_Mot("    ", Mot_Trouve, Indice_Deb, Indice_Fin);
  81.       if Mot_Trouve then
  82.          Put("T2: Mot trouve!" );
  83.          Put(Indice_Deb);
  84.          Put(Indice_Fin);
  85.          New_Line;
  86.       else
  87.          Put("T2:Mot non trouve!" );
  88.          New_Line;
  89.       end if;
  91.       -- Cas 3: Chaine contenant un mot, sans espaces
  92.       Chercher_Mot("Bonjour!", Mot_Trouve, Indice_Deb, Indice_Fin);
  93.       if Mot_Trouve then
  94.          Put("T3:Mot trouve!" );
  95.          Put(Indice_Deb);
  96.          Put(Indice_Fin);
  97.          New_Line;
  98.       else
  99.          Put("T3:Mot non trouve!" );
  100.          New_Line;
  101.       end if;
  103.       -- Cas 4: Chaine comportant un mot precede par des espaces
  104.       Chercher_Mot("    Bonjour!", Mot_Trouve, Indice_Deb, Indice_Fin);
  105.       if Mot_Trouve then
  106.          Put("T4:Mot trouve!" );
  107.          Put(Indice_Deb);
  108.          Put(Indice_Fin);
  109.          New_Line;
  110.       else
  111.          Put("T4:Mot non trouve!" );
  112.          New_Line;
  113.       end if;
  115.       -- Cas 5: Chaine comportant un mot suivi d'espaces
  116.       Chercher_Mot("Bonjour!    ", Mot_Trouve, Indice_Deb, Indice_Fin);
  117.       if Mot_Trouve then
  118.          Put("T5:Mot trouve!" );
  119.          Put(Indice_Deb);
  120.          Put(Indice_Fin);
  121.          New_Line;
  122.       else
  123.          Put("T5:Mot non trouve!" );
  124.          New_Line;
  125.       end if;
  127.       -- Cas 6: Chaine comportant deux mots separes par des espaces
  128.       Chercher_Mot("Bonjour!  Bye!", Mot_Trouve, Indice_Deb, Indice_Fin);
  129.       if Mot_Trouve then
  130.          Put("T6:Mot trouve!" );
  131.          Put(Indice_Deb);
  132.          Put(Indice_Fin);
  133.          New_Line;
  134.       else
  135.          Put("T6:Mot non trouve!" );
  136.          New_Line;
  137.       end if;
  139.       -- Cas 7: Chaine comportant deux mots separes par des espaces et un espace à la fin
  140.       Chercher_Mot("Bonjour!  Bye! ", Mot_Trouve, Indice_Deb, Indice_Fin);
  141.       if Mot_Trouve then
  142.          Put("T7:Mot trouve!" );
  143.          Put(Indice_Deb);
  144.          Put(Indice_Fin);
  145.          New_Line;
  146.       else
  147.          Put("T7:Mot non trouve!" );
  148.          New_Line;
  149.       end if;
  151.    end Tester_Chercher_Mot;
  153. begin
  155.    Tester_Chercher_Mot;
  157. end programme;


 
Solution 2:

Code :
  1. with Ada.Text_IO, Ada.Integer_Text_IO;
  2. use Ada.Text_IO, Ada.Integer_Text_IO;
  4. procedure programme is
  6.    procedure Chercher_Mot (Dans: in String; Trouve: out Boolean; Deb, Fin: out Positive) is
  8.       Fin_Trouvee : Boolean := False;
  10.    begin
  12.       Trouve := False;
  14.       for Indice in Dans'First..Dans'Last loop
  16.          if Dans(Indice) /= ' ' and not Trouve then
  18.             Deb := Indice;
  19.             Fin := Indice;
  20.             Trouve := True;
  22.          end if;
  24.          if Trouve and not Fin_Trouvee then
  26.             for Indice2 in Indice..Dans'Last loop
  28.                if not Fin_Trouvee and Dans(Indice2) = ' ' then
  30.                   Fin := Indice2 - 1;
  31.                   Fin_Trouvee := True;
  33.                end if;
  35.                end loop;
  37.          end if;
  39.       end loop;
  41.    end Chercher_Mot;
  46.    -- Test unitaire
  49.    procedure Tester_Chercher_Mot is
  51.       Mot_Trouve : Boolean;
  52.       Indice_Deb,
  53.       Indice_Fin : Positive;
  55.    begin
  56.       -- Cas 1 : Chaine nulle
  57.       Chercher_Mot("", Mot_Trouve, Indice_Deb, Indice_Fin);
  58.       if Mot_Trouve then
  59.          Put ("T1: Mot trouve!" );
  60.          Put(Indice_Deb);
  61.          Put(Indice_Fin);
  62.          New_Line;
  63.       else
  64.          Put("T1:Mot non trouve!" );
  65.          New_Line;
  66.       end if;
  68.       -- Cas 2: Chaine de longueur > 0 qu'avec des espaces
  69.       Chercher_Mot("    ", Mot_Trouve, Indice_Deb, Indice_Fin);
  70.       if Mot_Trouve then
  71.          Put("T2: Mot trouve!" );
  72.          Put(Indice_Deb);
  73.          Put(Indice_Fin);
  74.          New_Line;
  75.       else
  76.          Put("T2:Mot non trouve!" );
  77.          New_Line;
  78.       end if;
  80.       -- Cas 3: Chaine contenant un mot, sans espaces
  81.       Chercher_Mot("Bonjour!", Mot_Trouve, Indice_Deb, Indice_Fin);
  82.       if Mot_Trouve then
  83.          Put("T3:Mot trouve!" );
  84.          Put(Indice_Deb);
  85.          Put(Indice_Fin);
  86.          New_Line;
  87.       else
  88.          Put("T3:Mot non trouve!" );
  89.          New_Line;
  90.       end if;
  92.       -- Cas 4: Chaine comportant un mot precede par des espaces
  93.       Chercher_Mot("    Bonjour!", Mot_Trouve, Indice_Deb, Indice_Fin);
  94.       if Mot_Trouve then
  95.          Put("T4:Mot trouve!" );
  96.          Put(Indice_Deb);
  97.          Put(Indice_Fin);
  98.          New_Line;
  99.       else
  100.          Put("T4:Mot non trouve!" );
  101.          New_Line;
  102.       end if;
  104.       -- Cas 5: Chaine comportant un mot suivi d'espaces
  105.       Chercher_Mot("Bonjour!    ", Mot_Trouve, Indice_Deb, Indice_Fin);
  106.       if Mot_Trouve then
  107.          Put("T5:Mot trouve!" );
  108.          Put(Indice_Deb);
  109.          Put(Indice_Fin);
  110.          New_Line;
  111.       else
  112.          Put("T5:Mot non trouve!" );
  113.          New_Line;
  114.       end if;
  116.       -- Cas 6: Chaine comportant deux mots separes par des espaces
  117.       Chercher_Mot("Bonjour!  Bye!", Mot_Trouve, Indice_Deb, Indice_Fin);
  118.       if Mot_Trouve then
  119.          Put("T6:Mot trouve!" );
  120.          Put(Indice_Deb);
  121.          Put(Indice_Fin);
  122.          New_Line;
  123.       else
  124.          Put("T6:Mot non trouve!" );
  125.          New_Line;
  126.       end if;
  128.       -- Cas 7: Chaine comportant deux mots separes par des espaces et un espace à la fin
  129.       Chercher_Mot("Bonjour!  Bye! ", Mot_Trouve, Indice_Deb, Indice_Fin);
  130.       if Mot_Trouve then
  131.          Put("T7:Mot trouve!" );
  132.          Put(Indice_Deb);
  133.          Put(Indice_Fin);
  134.          New_Line;
  135.       else
  136.          Put("T7:Mot non trouve!" );
  137.          New_Line;
  138.       end if;
  140.    end Tester_Chercher_Mot;
  142. begin
  144.    Tester_Chercher_Mot;
  146. end programme;


 
Solution 3:

Code :
  1. with Ada.Text_IO, Ada.Integer_Text_IO;
  2. use Ada.Text_IO, Ada.Integer_Text_IO;
  4. procedure programme is
  6.    procedure Chercher_Mot (Dans: in String; Trouve: out Boolean; Deb, Fin: out Positive) is
  8.       Fin_Trouvee : Boolean := False;
  10.    begin
  12.       Trouve := False;
  14.       for Indice in Dans'First..Dans'Last loop
  16.          if Dans(Indice) /= ' ' and not Trouve then
  18.             Deb := Indice;
  19.             Fin := Indice;
  20.             Trouve := True;
  22.          end if;
  24.          if Trouve and not Fin_Trouvee then
  26.             if Dans(Dans'Last) /= ' ' then
  28.                Fin := Dans'Last;
  29.                Fin_Trouvee := True;
  31.             else
  33.                for Indice2 in reverse Indice..Dans'Last loop
  35.                   if not Fin_Trouvee and Dans(Indice2) /= ' ' then
  37.                      Fin := Indice2;
  38.                      Fin_Trouvee := True;
  40.                   end if;
  42.                end loop;
  44.             end if;
  46.          end if;
  48.       end loop;
  50.    end Chercher_Mot;
  55.    -- Test unitaire
  58.    procedure Tester_Chercher_Mot is
  60.       Mot_Trouve : Boolean;
  61.       Indice_Deb,
  62.       Indice_Fin : Positive;
  64.    begin
  65.       -- Cas 1 : Chaine nulle
  66.       Chercher_Mot("", Mot_Trouve, Indice_Deb, Indice_Fin);
  67.       if Mot_Trouve then
  68.          Put ("T1: Mot trouve!" );
  69.          Put(Indice_Deb);
  70.          Put(Indice_Fin);
  71.          New_Line;
  72.       else
  73.          Put("T1:Mot non trouve!" );
  74.          New_Line;
  75.       end if;
  77.       -- Cas 2: Chaine de longueur > 0 qu'avec des espaces
  78.       Chercher_Mot("    ", Mot_Trouve, Indice_Deb, Indice_Fin);
  79.       if Mot_Trouve then
  80.          Put("T2: Mot trouve!" );
  81.          Put(Indice_Deb);
  82.          Put(Indice_Fin);
  83.          New_Line;
  84.       else
  85.          Put("T2:Mot non trouve!" );
  86.          New_Line;
  87.       end if;
  89.       -- Cas 3: Chaine contenant un mot, sans espaces
  90.       Chercher_Mot("Bonjour!", Mot_Trouve, Indice_Deb, Indice_Fin);
  91.       if Mot_Trouve then
  92.          Put("T3:Mot trouve!" );
  93.          Put(Indice_Deb);
  94.          Put(Indice_Fin);
  95.          New_Line;
  96.       else
  97.          Put("T3:Mot non trouve!" );
  98.          New_Line;
  99.       end if;
  101.       -- Cas 4: Chaine comportant un mot precede par des espaces
  102.       Chercher_Mot("    Bonjour!", Mot_Trouve, Indice_Deb, Indice_Fin);
  103.       if Mot_Trouve then
  104.          Put("T4:Mot trouve!" );
  105.          Put(Indice_Deb);
  106.          Put(Indice_Fin);
  107.          New_Line;
  108.       else
  109.          Put("T4:Mot non trouve!" );
  110.          New_Line;
  111.       end if;
  113.       -- Cas 5: Chaine comportant un mot suivi d'espaces
  114.       Chercher_Mot("Bonjour!    ", Mot_Trouve, Indice_Deb, Indice_Fin);
  115.       if Mot_Trouve then
  116.          Put("T5:Mot trouve!" );
  117.          Put(Indice_Deb);
  118.          Put(Indice_Fin);
  119.          New_Line;
  120.       else
  121.          Put("T5:Mot non trouve!" );
  122.          New_Line;
  123.       end if;
  125.       -- Cas 6: Chaine comportant deux mots separes par des espaces
  126.       Chercher_Mot("Bonjour!  Bye!", Mot_Trouve, Indice_Deb, Indice_Fin);
  127.       if Mot_Trouve then
  128.          Put("T6:Mot trouve!" );
  129.          Put(Indice_Deb);
  130.          Put(Indice_Fin);
  131.          New_Line;
  132.       else
  133.          Put("T6:Mot non trouve!" );
  134.          New_Line;
  135.       end if;
  137.       -- Cas 7: Chaine comportant deux mots separes par des espaces et un espace à la fin
  138.       Chercher_Mot("Bonjour!  Bye! ", Mot_Trouve, Indice_Deb, Indice_Fin);
  139.       if Mot_Trouve then
  140.          Put("T7:Mot trouve!" );
  141.          Put(Indice_Deb);
  142.          Put(Indice_Fin);
  143.          New_Line;
  144.       else
  145.          Put("T7:Mot non trouve!" );
  146.          New_Line;
  147.       end if;
  149.    end Tester_Chercher_Mot;
  151. begin
  153.    Tester_Chercher_Mot;
  155. end programme;


 
Solution 4:

Code :
  1. with Ada.Text_IO, Ada.Integer_Text_IO;
  2. use Ada.Text_IO, Ada.Integer_Text_IO;
  4. with Ada.Characters.Handling; use Ada.Characters.Handling; -- Is_Alphanumeric
  6. procedure programme is
  8.    procedure Chercher_Mot (Dans: in String; Trouve: out Boolean; Deb, Fin: out Positive) is
  10.       Indice : Positive := Dans'First;
  12.    begin
  14.       Trouve := False;
  16.       while Indice <= Dans'Last and then not Is_Alphanumeric(Dans(Indice)) loop
  18.          Indice := Positive'Succ(Indice);
  20.       end loop;
  22.       if Indice <= Dans'Last then
  24.          Trouve := True;
  25.          Deb := Indice;
  27.          while Indice <= Dans'Last and then Is_Alphanumeric(Dans(Indice)) loop
  29.             Indice := Positive'Succ(Indice);
  31.          end loop;
  33.          Fin := Positive'Min(Indice, Dans'Last);
  35.       end if;
  37.    end Chercher_Mot;
  42.    -- Test unitaire
  45.    procedure Tester_Chercher_Mot is
  47.       Mot_Trouve : Boolean;
  48.       Indice_Deb,
  49.       Indice_Fin : Positive;
  51.    begin
  52.       -- Cas 1 : Chaine nulle
  53.       Chercher_Mot("", Mot_Trouve, Indice_Deb, Indice_Fin);
  54.       if Mot_Trouve then
  55.          Put ("T1: Mot trouve!" );
  56.          Put(Indice_Deb);
  57.          Put(Indice_Fin);
  58.          New_Line;
  59.       else
  60.          Put("T1:Mot non trouve!" );
  61.          New_Line;
  62.       end if;
  64.       -- Cas 2: Chaine de longueur > 0 qu'avec des espaces
  65.       Chercher_Mot("    ", Mot_Trouve, Indice_Deb, Indice_Fin);
  66.       if Mot_Trouve then
  67.          Put("T2: Mot trouve!" );
  68.          Put(Indice_Deb);
  69.          Put(Indice_Fin);
  70.          New_Line;
  71.       else
  72.          Put("T2:Mot non trouve!" );
  73.          New_Line;
  74.       end if;
  76.       -- Cas 3: Chaine contenant un mot, sans espaces
  77.       Chercher_Mot("Bonjour!", Mot_Trouve, Indice_Deb, Indice_Fin);
  78.       if Mot_Trouve then
  79.          Put("T3:Mot trouve!" );
  80.          Put(Indice_Deb);
  81.          Put(Indice_Fin);
  82.          New_Line;
  83.       else
  84.          Put("T3:Mot non trouve!" );
  85.          New_Line;
  86.       end if;
  88.       -- Cas 4: Chaine comportant un mot precede par des espaces
  89.       Chercher_Mot("    Bonjour!", Mot_Trouve, Indice_Deb, Indice_Fin);
  90.       if Mot_Trouve then
  91.          Put("T4:Mot trouve!" );
  92.          Put(Indice_Deb);
  93.          Put(Indice_Fin);
  94.          New_Line;
  95.       else
  96.          Put("T4:Mot non trouve!" );
  97.          New_Line;
  98.       end if;
  100.       -- Cas 5: Chaine comportant un mot suivi d'espaces
  101.       Chercher_Mot("Bonjour!    ", Mot_Trouve, Indice_Deb, Indice_Fin);
  102.       if Mot_Trouve then
  103.          Put("T5:Mot trouve!" );
  104.          Put(Indice_Deb);
  105.          Put(Indice_Fin);
  106.          New_Line;
  107.       else
  108.          Put("T5:Mot non trouve!" );
  109.          New_Line;
  110.       end if;
  112.       -- Cas 6: Chaine comportant deux mots separes par des espaces
  113.       Chercher_Mot("Bonjour!  Bye!", Mot_Trouve, Indice_Deb, Indice_Fin);
  114.       if Mot_Trouve then
  115.          Put("T6:Mot trouve!" );
  116.          Put(Indice_Deb);
  117.          Put(Indice_Fin);
  118.          New_Line;
  119.       else
  120.          Put("T6:Mot non trouve!" );
  121.          New_Line;
  122.       end if;
  124.       -- Cas 7: Chaine comportant deux mots separes par des espaces et un espace à la fin
  125.       Chercher_Mot("Bonjour!  Bye! ", Mot_Trouve, Indice_Deb, Indice_Fin);
  126.       if Mot_Trouve then
  127.          Put("T7:Mot trouve!" );
  128.          Put(Indice_Deb);
  129.          Put(Indice_Fin);
  130.          New_Line;
  131.       else
  132.          Put("T7:Mot non trouve!" );
  133.          New_Line;
  134.       end if;
  136.    end Tester_Chercher_Mot;
  138. begin
  140.    Tester_Chercher_Mot;
  142. end programme;


Message édité par Corebreaker le 14-06-2009 à 05:43:04
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed