Discussion :

[Ric_racim]

Bonjour.
je suis étudiant et j'ai besoin de votre aide pour la résolution de ce projet, merci pour votre aide.
Cordialement.

[Alcatîz]

Bonjour et bienvenue,

Voilà un bel exercice. Pour que nous puissions t'aider, merci d'expliquer ce que tu as fait, quels problèmes tu rencontres, avec les extraits du code où ceux-ci apparaissent.

[Ric_racim]

Bonjour et bienvenue,

Voilà un bel exercice. Pour que nous puissions t'aider, merci d'expliquer ce que tu as fait, quels problèmes tu rencontres, avec les extraits du code où ceux-ci apparaissent.

Alors j'en suis a la question "D" de la recherche de mot j'ai pu réaliser la grille et l'afficher et ajouter le tableau de mots, mais en ce qui en est de la recherche alors la... Si vous savez comment faire la procédure merci

[anapurna]

salut

dans ton tableau tu recherche le premier caractère de ton mots
à partir de là tu cherche le second caractère dans toutes les directions dans les cases accolé
si tu ne trouve pas le second caractère ... tu cherche de nouveau le premier caractère plus loin dans le tableau et ainsi de suite jusqu'à la fin de ton mots
tu peut optimiser tes recherche si la longueur du mots dépasse le nombre de case restant dans ton tableau tu passe a l'autre direction

[Ric_racim]

Voilà ce que j'ai pu écrire pour la procédure mais rien ne marche :

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
procedure RechMot(G: Grille ; T: TabMot);
var x,y,i,j,q : integer;
begin
	while (i<=39) do {pour chaque ligne de la grille}
	while (y<=15) and (i<=39)do  {pour chaque cologne de la grille}
	while (G[x,y]=T[i,j]) {si la lettre du mot = la lettre de la grille} and (j<=15) do  {si le mot n'a pas atteint la limite}
	begin
		j:=j+1; {on avance dans le mot}
		q:=y;
		q:=q+1; {on avance dans la grille}
    if (j=16) then {si on trouve le mot}
    begin
    	writeln(G[x,y]);
    	i:=i+1; {on passe a un autre mot}
    end
    else {si on ne trouve pas le mot}
    begin
    	y:=y+1; {on passe a une autre cologne de la grille}
    	j:=0;
    end; {quand les collognes de la grille se terminent}
    x:=x+1; {on passe a une autre ligne de la grille}
    y:=1;
end;
end;

[anapurna]

salut

déjà il faut que tu fasse la recherche dans les 8 direction

regarde le tableau
// les 8 directions possibles
{ 5 6 7 }
{ 4 + 0 }
{ 3 2 1 }

ce qui nous donne
// les 8 directions possibles

Code :

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

1
2
3
4
5
 
   direction : array [1..8] of TPos = ((x: 0;y:-1),(x: 1;y:-1),
                                                    (x: 1;y: 0),(x: 1;y: 1),
	   	                                    (x: 0;y: 1),(x:-1;y: 1),
	       					    (x:-1;y: 0),(x:-1;y:-1));

je verrais le début plus comme cela

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
 
  for i := 1 to nbmots do 
  begin            //  on cherche chaque mot
    mot := T[i];   // mot a chercher 
    long := length (mot);  // longueur du mots
    for li := 1 to MAX do // Toutes les lignes  
    begin
      for co := 1 to MAX do  // Toutes les colonnes 
      begin
         if upcase (G[li-1, co-1]) = upcase(mot[1]) then 
	 begin     { on a trouv‚ la 1Šre lettre }
           y := li;                         // position de départ
           x := co;
	  dir := 1 ;
	  Found := False;
	  while  (dir <= 8) and Not(Found) do
	  begin       // parcours dans les huit directions
             .....    // a partir de la il faut chercher dans tout les direction

bon je te laisse reflechir un peu a la suite a donner .. On va pas tout te faire

[Ric_racim]

Merci je vais déjà me casser la tête sur ça, c'est déjà beaucoup.

[wiwaxia]

Bonjour,

L'énoncé indique une recherche effectuée dans toutes les directions; je n'en vois que trois, si l'on s'en tient au sens de lecture:
# horizontalement vers la droite (H1),
# verticalement vers le bas (V1),
# en diagonale descendante vers la droite (D1).
Mais rien n'oblige à exclure les sens opposés (H2, V2, D2), ou un parcours parallèle à la seconde diagonale, à droite vers le haut (D3) ou à gauche vers le bas (D4).
Soit autant de sous-procédures de recherche (RechH1, RechD1, RechV1 ...) - au maximum 8 - se caractérisant par une énumération particulière des indices.

La recherche dans la grille pourrait par exemple se programmer comme suit:

Code Pascal :

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
 
CONST Nmot = 39; DimG = 15;
TYPE T_Grille = ARRAY[1..DimG, 1..DimG] OF Char;
        T_TabMot = ARRAY[1..Nmot] OF String;
... / ...
PROCEDURE RechMot;
  BEGIN
    FOR n:= 1 TO Nmot DO 
      BEGIN
        Lm:= Lengh(TabMot);
        RechH1(Lm, TabMot[n]);
        RechV1(Lm, TabMot[n]);
        RechD1(Lm, TabMot[n]);
... / ...
      END
  END;

avec pour la recherche horizontale vers la droite:

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
 
PROCEDURE RechH1(l: Byte; Mot: String; G_: T_Grille);
  VAR x, X1, X2, y, Y1, Y2: Byte; Test: Boolean;
  BEGIN
    X1:= 1; X2:= DimT -(l - 1);
    Y1:= 1; Y2:= DimG
    FOR x:= X1 TO X2 DO
      FOR y:= Y1 TO Y2 DO
        IF (G_[x, y]=Mot[1]) THEN
          BEGIN
             Test:= True; 
             FOR k:= 1 TO (l - 1) DO
               IF (G_[x + 1, y]<>Mot[k + 1] THEN Test:= False 
          END;
    IF Test THEN ColorationH1(x, y, Mot)
  END;

Les autres procédures (RechV1, RechD1, ...) comportent des variantes décisives, mais mineures.

Je me suis efforcé de suivre la notation de l'énoncé; en l'absence de compilation, il y a probablement quelques erreurs.

Des variantes sont possibles; ce qui compte, c'est le plan de recherche.
Il faut par ailleurs prévoir l'affichage de la grille, qui reviendra plusieurs fois, et l'écriture de la constante d'intialisation du tableau, assez pénible

[wiwaxia]

(Suite)

Anapurna a eu la bonne idée de caractériser chaque direction de recherche par un vecteur:

(Dx, Dy) = (1, 0), (0,1), (1, 1) ...

ce qui permet effectivement de ramener les sous-procédures à une seule.

Il faut introduire un nouveau type de variable:

Code :

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

1
2
3
4
5
 
TYPE T_Vecteur = ARRAY[1..2] OF Shortint;
     T_TabV = ARRAY[1..3] OF T_Vecteur;
 
CONST Direction: T_TabV = ((1,0), (0, 1), (1, 1));

Libre à chacun de passer de 3 directions à 8, il suffit d'introduire des composantes négatives.

[anapurna]

salut

a chacun sa façon de voir

j'utilise un incrément de déplacement selon la direction se qui me permet de n'avoir qu'une fonction de recherche de mots
et si je trouve le mots dans une direction ... j’arrête ma recherche de mots dans les direction suivante
de plus un boucle for ne me semble pas la plus adapté
imaginons que le dexieme caractere ne soit pas le bon ... il faut allez j'usqu,au bout de la boucle quand meme
alors q'une boucle while me semble plus indiqué

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
 
Function TrouvMots(mot : String;li,co : Integer;Deplac : TDeplacement;G : TGrille): Boolean;
var
  S : String;
  i : Integer;
  Long,
  Posli,Posco : integer;
begin
  Result := False;
  i := 0;
  Long := Length(mot);
  Fin := False;
  While (i < Long) and (not(Result)) and (not(Fin)) do
  begin
    Inc(i);
    Posco :=  ...;
    Posli  :=  ...;
    if (Posco in [1..Max]) and (Posli in [1..Max]) then
    begin
      S:=S+G[Posco,Posli];
      if mot[i] <> G[Posco,Posli] Then
        Fin := True;
      Result :=  mot=S;
    end
    else Fin := True;
  end;

pour ce faire j'utilise un tableau de déplacement qui me donne le pas de direction a appliquer pour ma recherche

Code :

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

1
2
3
4
 
const
  Tabdir : array [1..8] of TDeplacement = ((x: 0;y:-1),(x: 1;y:-1),(x: 1;y: 0),(x: 1;y: 1),
	   	                           (x: 0;y: 1),(x:-1;y: 1),(x:-1;y: 0),(x:-1;y:-1));

ce qui dans le corp principale
peut se traduire par

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
 
....
    for li := low(G) to High(G) do
    begin
      for co := low(G[li]) to High(G[li]) do
      begin
        if upcase (G[co,li]) = upcase(mot[1]) then
        begin
          dir := low(TabDir)-1;
          Found := False;
          While (dir <= High(TabDir)) and (Not(Found)) do
          begin
            Inc(Dir);
            Found := TrouvMots(mot,li,co,TabDir[dir],G);
            IF Found  Then 
              Colorier(...);
         end;
         ....
      end;
   end;
end;

j'ai même poussez le vice a colorier de couleur différente selon le sens (verticale,horizontale , diagonale(D-G),diagonale(G-D)

mais je ne peux fournir le résultat tans qu'il n'ai pas lui même arrivé au bout de son exercice

[wiwaxia]

... et si je trouve le mots dans une direction ... j’arrête ma recherche de mots dans les direction suivante
de plus un boucle for ne me semble pas la plus adapté
imaginons que le dexieme caractere ne soit pas le bon ... il faut allez j'usqu,au bout de la boucle quand meme
alors q'une boucle while me semble plus indiqué ...

Effectivement, je n'ai pas tenu compte de ce que chaque mot de la liste n'intervient qu'une seule fois ... ce que ne précise pas l'énoncé.

Le parcours systématique de la grille ne concerne que la première lettre du mot:

Code :

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

1
2
3
    FOR x:= X1 TO X2 DO
      FOR y:= Y1 TO Y2 DO
        IF (G_[x, y]=Mot[1]) THEN

c'est seulement après qu'on examine la coïncidence totale des lettres restantes:

Code :

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

1
2
3
             Test:= True; 
             FOR k:= 1 TO (l - 1) DO
               IF (G_[x + 1, y]<>Mot[k + 1] THEN Test:= False

Il y a d'autres façons d'effectuer cette vérification, et de l'accélérer (avec While).

Le parcours peut bien sûr être écourté en fonction des mots déjà trouvés; il s'agit cependant de l'amélioration d'un programme de base, que le demandeur doit comprendre.

[anapurna]

Effectivement, je n'ai pas tenu compte de ce que chaque mot de la liste n'intervient qu'une seule fois ... ce que ne précise pas l'énoncé.

Le parcours systématique de la grille ne concerne que la première lettre du mot:

Code :

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

1
2
3
    FOR x:= X1 TO X2 DO
      FOR y:= Y1 TO Y2 DO
        IF (G_[x, y]=Mot[1]) THEN

c'est seulement après qu'on examine la coïncidence totale des lettres restantes:

Cela je l'avais bien intégré... je fais le même

Code :

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

1
2
3
             Test:= True; 
             FOR k:= 1 TO (l - 1) DO
               IF (G_[x + 1, y]<>Mot[k + 1] THEN Test:= False

....

Par contre dans ta version tu le fais pour chaque direction.

Je pense qu'il y a une erreur dans ta boucle for, ne serait-ce pas plutôt :

Code :

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

1
2
3
             Test:= True; 
   FOR k:= 1 TO (l - 1) DO
               IF (G_[x + k, y]<>Mot[k + 1] THEN Test:= False

Sinon tu lis uniquement la deuxième lettre du mot de la grille en le comparant à toutes les lettres du mot.
Le déplacement doit être simultané entre le mot et la grille.

[wiwaxia]

... je pense qu'il y a une erreur dans ta boucle for
ne serais ce pas plutôt :
Code :
Test:= True;
FOR k:= 1 TO (l - 1) DO
IF (G_[x + k, y]<>Mot[k + 1] THEN Test:= False

sinon tu lis uniquement la deuxième lettre du mots de la grille en le comparant a toutes les lettres du mots
le déplacement doit être simultané entre le mot et la grille

C'est exact, ce lapsus m'avait échappé.

... par contre dans ta version tu le fait pour chaque direction ...

Trois procédures de recherche (RechH1, RechD1, RechV1 ... ) pour les trois directions respectivement envisagées, cela peut convenir ... et c'est d'un accès relativement facile pour le débutant confronté au problème.
Mais si les 8 directions s'avèrent possibles, alors une procédure plus générale s'impose, qui dépend d'un nouveau paramètre

le vecteur (u, v) tel que u et v = 0 ou ± 1 .

Il faudrait que Ric_racim donne plus de précisions sur ce point.

[wiwaxia]

Il y a une autre contrainte dont on n'a apparemment pas parlé: c'est le non-chevauchement des mots écrits selon une même direction, susceptible de se produire lorsque la fin d'un mot se confond avec le début de l'autre; par exemple:

LUGES / SOLIDES
TOUT / TAXE
ATH / HECTARE

HECTARE / REEAXMINE
RILLETTES / ESSES
XYLENE / NEGATON

Il faudrait donc affecter chaque case du tableau d'un indice ou l'un booléen permettant de bloquer une seconde utilisation dans une direction donnée; tout changement de direction serait précédé d'une ré-initialisation de la variable.

Et compte tenu de cette remarque, le fait d'envisager 8 directions de recherche (outre que beaucoup sont contraires au sens naturel de lecture) me paraît être une position difficile à tenir.

[anapurna]

Salut

Dans ce cas-là le premier mot trouvé ne sera peut-être pas forcément le bon.
Imaginons que le mot se retrouve x fois dans la grille, cela veut dire qu'il va falloir explorer x solutions par mot jusqu’à obtenir le résultat final.
Un peu comme l’algorithme (alpha beta) utilisé dans les jeux d’échecs afin de trouver la meilleure des solutions, ce qui va considérablement complexifier le problème et en espérant qu'il n'existe qu'une seule solution.

Je ne pense pas que pour l’apprentissage de l'informatique on leur demande un projet aussi ambitieux, par contre pour l'affichage miroir c'est une convention : en France on lit de gauche à droite mais dans d'autre pays cette convention n'est pas appliquée (Japon ou Maghreb par exemple).

Cela ressemble beaucoup aux grilles de mots cachés que tu trouves dans le commerce, celles-ci se lisent dans tous les sens de mémoire.

[wiwaxia]

... dans ce cas là le premier mot trouvé ne seras peut être pas forcement le bon
imaginons que le mots se retrouve x fois dans la grille cela veut dire qu'il va falloir explorer
... / ...
ce qui va considérablement complexifier le problème et en espérant qu'il n'existe qu'une seul solution ...

En effet, la difficulté du problème change radicalement de niveau. Il faut supposer que la grille ne comporte aucune séquence aussi malveillante qu'improbable, telle que 'TOUTAXE' ou 'XYLENEGATON' .
La consigne d'exclusion devrait d'ailleurs s'étendre au caractère venant immédiatement après la fin du mot détecté, dans la mesure où deux mots alignés ne sont pas adjacents. Mais là, on sort peut-être du sujet ...

... par contre pour l'affichage miroir c'est une convention en France on lit de gauche a droite
mais dans d'autre pays cette convention n'est pas appliqué (japon ou Maghreb par exemple)
cela ressemble beaucoup aux grilles de mots caché que tu trouve dans le commerce
celle-ci se lis dans tout les sens de mémoire

C'est beaucoup plus qu'une convention de jeu, c'est une donnée fondamentale de culture ! Et l'on se doute bien que l'énoncé, transposé dans une langue sémitique (en supposant que cela soit possible), privilégie pour la lecture le sens lévograde; la dissymétrie n'en persistera pas moins, la lecture vers la droite étant alors exclue.

Envisager les huit directions implique la disparition de toute référence linguistique: on ne recherche plus des mots, mais des séquences arbitraires de lettres, qu'on pourrait remplacer par des nombres, des couleurs ou tout signe arbitraire.

[wiwaxia]

La recherche des mots dans la grille n'est pas facile à coder, mais constitue un problème intéressant.

Voici ce que donne une version réduite du programme dans les trois directions particulières déjà mentionnées; la généralisation aux huit directions du plan n'est pas difficile.

L'essentiel est de prévoir des tableaux d'enregistrements, tant pour la grille que pour la liste des noms, afin de mémoriser les éléments détectés.

Code Pascal :

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
 PROGRAM Remplissage_Grille;
 
 USES Crt;
 
 CONST DimG = 15; Nmot = 39;
 
 TYPE T_Lettre = RECORD  Car: Char; Ind: Word  END;
      T_Grille = ARRAY[1..DimG, 1..DimG] OF T_Lettre;
      T_Mot    = RECORD  Seq: String; Dir: Word  END;
      T_Liste  = ARRAY[1..Nmot] OF T_Mot;
 
 VAR Grille: T_Grille;
     ListeM: T_Liste;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Utilitaires
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 PROCEDURE A_;
   VAR Touche: Char;
   BEGIN
     Touche:= ReadKey;
   END;
 
 PROCEDURE Couleur(Ind: Byte);
   BEGIN
     CASE Ind OF  0: TextColor(07);
                  1: TextColor(12);
                  2: TextColor(10);
                  ELSE TextColor(09)  END
   END;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Affichage de la grille et de la liste des mots
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 PROCEDURE AffL;
   CONST C1 = 20; C2 = 11; C3 = 14; L1 = 36;
   VAR k, x, y, z: Byte;
   BEGIN
     TextBackGround(0);
     FOR k:= 1 TO Nmot DO
       BEGIN
         z:= (k - 1) MOD 3; x:= C1 * z;    Inc(x, 12);
         z:= (k - 1) DIV 3; y:= L1 + z;
         GotoXY(x, y);      TextColor(15); Write(ListeM[k].Seq);
         TextColor(13);     GotoXY(x + C2, y);
         Write(Length(ListeM[k].Seq):2);
         GotoXY(x + C3, y); Couleur(ListeM[k].Dir);
         Write(ListeM[k].Dir:3);
       END
   END;
 
 PROCEDURE AffG;
   CONST C1 = 19; L1 = 2;
   VAR i, j, y: Byte;
   BEGIN
     TextBackGround(0); ClrScr;
     FOR i:= 1 TO DimG DO
       BEGIN
         y:= L1; Inc(y, 2 * i); GotoXY(C1, y);
         FOR j:= 1 TO DimG DO BEGIN
                                Couleur(Grille[j, i].Ind);
                                Write(Grille[j, i].Car, '  ')
                              END
       END
   END;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Recherche des mots
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 PROCEDURE RechD1(VAR Mot: T_Mot; VAR G_: T_Grille);
    VAR j, k, Lm, x, X1, X2, Xk, y, Y1, Y2: Byte; Test: Boolean;
   BEGIN
     Lm:= Length(Mot.Seq);
     X1:= 1; X2:= DimG - (Lm - 1);
     Y1:= 1; Y2:= DimG - (Lm - 1);
     FOR x:= X1 TO X2 DO
       FOR y:= Y1 TO Y2 DO
         IF (G_[x, y].Car=Mot.Seq[1]) THEN
           BEGIN
             j:= 1;
             FOR k:= 1 TO (Lm - 1) DO
               IF (G_[x + k, y + k].Car=Mot.Seq[k + 1]) THEN Inc(j);
             IF (j=Lm) THEN
               BEGIN
                 Mot.Dir:= 3;
                 FOR k:= 1 TO Lm DO G_[x + (k - 1), y + (k - 1)].Ind:= 3
               END
           END
   END;
 
 PROCEDURE RechV1(VAR Mot: T_Mot; VAR G_: T_Grille);
   VAR j, k, Lm, x, X1, X2, Xk, y, Y1, Y2: Byte; Test: Boolean;
   BEGIN
     Lm:= Length(Mot.Seq);
     X1:= 1; X2:= DimG;
     Y1:= 1; Y2:= DimG - (Lm - 1);
     FOR x:= X1 TO X2 DO
       FOR y:= Y1 TO Y2 DO
         IF (G_[x, y].Car=Mot.Seq[1]) THEN
           BEGIN
             j:= 1;
             FOR k:= 1 TO (Lm - 1) DO
               IF (G_[x, y + k].Car=Mot.Seq[k + 1]) THEN Inc(j);
             IF (j=Lm) THEN
               BEGIN
                 Mot.Dir:= 2;
                 FOR k:= 1 TO Lm DO G_[x, y + (k - 1)].Ind:= 2
               END
           END
   END;
 
 PROCEDURE RechH1(VAR Mot: T_Mot; VAR G_: T_Grille);
   VAR j, k, Lm, x, X1, X2, Xk, y, Y1, Y2: Byte; Test: Boolean;
   BEGIN
     Lm:= Length(Mot.Seq);
     X1:= 1; X2:= DimG - (Lm - 1);
     Y1:= 1; Y2:= DimG;
     FOR x:= X1 TO X2 DO
       FOR y:= Y1 TO Y2 DO
         IF (G_[x, y].Car=Mot.Seq[1]) THEN
           BEGIN
             j:= 1;
             FOR k:= 1 TO (Lm - 1) DO
               IF (G_[x + k, y].Car=Mot.Seq[k + 1]) THEN Inc(j);
             IF (j=Lm) THEN
               BEGIN
                 Mot.Dir:= 1;
                 FOR k:= 1 TO Lm DO G_[x + (k - 1), y].Ind:= 1
               END
           END
   END;
 
 PROCEDURE RechMot;
  VAR k: Byte;
   BEGIN
     AffG; AffL;
     A_;
     FOR k:= 1 TO Nmot DO RechH1(ListeM[k], Grille);
     AffG; AffL;
     A_;
     FOR k:= 1 TO Nmot DO RechV1(ListeM[k], Grille);
     AffG; AffL;
     A_;
     FOR k:= 1 TO Nmot DO RechD1(ListeM[k], Grille);
     AffG; AffL;
   END;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Initialisation de la liste des mots
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 PROCEDURE InitL(VAR L_: T_Liste);
   CONST C_Mot: ARRAY[1..Nmot] OF String
           = ('XANTHINES',  'XANTHIE',    'XIMENIE',
              'AIRELLES',   'ATOURS'   ,  'AMOUREUX',
              'TOUT',       'IMPORTANT',  'PASSIFS',
              'DEBUTANTS',  'STERER',     'LUGES',
              'RENTIERES',  'UN',         'COMPLEMENT',
              'REEXAMINE',  'CLAYONNAGE', 'BORDELAIS',
              'RILLETTES',  'CLAMEUR',    'NATURE',
              'FACILITE',   'ESSENIENS',  'SOLIDE',
              'HECTARE',    'HABILLEUR',  'PARTICULE',
              'ATH',        'TAXE',       'MATIN',
              'ESSES',      'ARABE',      'SATI',
              'NEGATON',    'NIVEAU',     'HEURE',
              'XIPHOIDIEN', 'XYLENE',     'XYLOCOPES');
   VAR k: Byte;
   BEGIN
     FOR k:= 1 TO Nmot DO
       WITH L_[k] DO BEGIN
                       Seq:= C_Mot[k]; Dir:= 0
                     END
   END;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Initialisation de la grille
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 PROCEDURE RempG(VAR G_: T_Grille);
   CONST List_Lign: ARRAY[1..DimG] OF String[DimG] =
           ('SENIHTNAXANTHIE', 'EBTEUOMYIITINTX', 'SAUOTOLMPRMOTUA',
            'SRTAUOPAHAEEUAT', 'EAGRCORAOESLNRM', 'CEEORTBOINCSLIS',
            'NUPTIISTDANTIEE', 'XEACLTETILICAFS', 'SNULLSEREITNERS',
            'TLEAEINENIVEAUE', 'EURMTNEMELPMOCN', 'RGUETSIALEDROBI',
            'EETUECLAYONNAGE', 'RSARSREEXAMINEN', 'STNATUBEDEDILOS');
   VAR x, y: Byte;
   BEGIN
     FOR y:= 1 TO DimG DO
       FOR x:= 1 TO DimG DO
         WITH G_[x, y] DO BEGIN
                            Car:= List_Lign[y][x]; Ind:= 0
                          END
   END;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Programme principal
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 BEGIN
   RempG(Grille); InitL(ListeM);
   RechMot;       ReadLn
 END.

[anapurna]

salut

bon je voulais pas donner la solution afin qu'il fournisse un minimum de boulots

dans ton programme tu risque de dépasser les limite du tableau
il faut borner la recherche dans les limite du tableau

voici ma fonction principale pour trouver le mots dans la grille

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
 
Function TForm1.TrouvMots(mot : String;li,co : Integer;Deplac : TDeplacement;G : TGrille): Boolean;
var
  S : String;
  i : Integer;
  Long,
  Posli,Posco : integer;
begin
  Result := False;
  i := 0;
  Long := Length(mot);
  While (i < Long) and not(Result) do
  begin
    Inc(i);
    Posco := co+Deplac.x*(i-1);
    Posli := li+Deplac.y*(i-1);
    if (Posco in [1..Max]) and (Posli in [1..Max]) then  // ici je verifie que je suis dans les limites 
    begin
      S:=S+G[Posco,Posli];
      if mot[i] <> G[Posco,Posli] Then
        break;
      Result :=  mot=S;
    end
    else break;
  end;
end;

et ici la boucle principal

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
 
  for li := low(G) to High(G) do
    begin
      for co := low(G[li]) to High(G[li]) do
      begin
        if upcase (G[co,li]) = upcase(mot[1]) then  // le premier caractère est identique 
        begin
          /////////////////////////////////
          // on a trouvé la 1ère lettre
          /////////////////////////////////
          dir := low(TabDir)-1;
          Found := False;
          While (dir <= High(TabDir)) and (Not(Found)) do  // recherche dans toutes les direction 
          begin
            Inc(Dir);
            Found := TrouvMots(mot,li,co,TabDir[dir],G);
            /////////////////////////////////////////////////////////
            if Found Then
            begin
              /////////////////////////////////////////////////////////
              // si trouvé on garde les celulles
              /////////////////////////////////////////////////////////
              SetLength(CellTMP,Long);
              For i:= 1 to long do
              begin
                CellTMP[i-1].co      := co+TabDir[dir].x*(i-1);
                CellTMP[i-1].li       := li+TabDir[dir].Y*(i-1);
                CellTMP[i-1].Sens := DetermineSens(dir);
              end;
              ColorieCell(CellTMP);
            end;
            /////////////////////////////////////////////////////////
          end; // Fin du while
          ////////////////////////////////////////////////////////////////////
        end; // If boolOk
      end;
    end;

a chacun sa méthode

[wiwaxia]

Re-bonjour,

... bon je voulais pas donner la solution afin qu'il fournisse un minimum de boulot ...

Du boulot, le primo-posteur en aura, car le programme-source ne cadre pas exactement avec la demande du problème; les directions de recherche, par exemple, ont été intentionnellement réduites à trois, et l'affichage a été conçu dans le but de faire ressortir les résultats de chacune des 3 sous-procédures.
Le nœud du programme, qui n'a rien d'évident, est la détection d'un mot donné, à partir d'une position et dans une direction données; là m'a paru se trouver la difficulté essentielle de l'algorithme. La comparaison raisonnée des 3 cas traités permet de passer au cas général.

... dans ton programme tu risque de dépasser les limite du tableau, il faut borner la recherche dans les limites du tableau ...

L'objection est plus sérieuse.
Réponse: non, comme en témoigne l'affichage des résultats, qui constitue une vérification indispensable du code proposé.
La recherche a été effectivement bornée dès le départ, comme l'indiquent par exemple les instructions de détection horizontale dextrograde d'un mot de longueur (Lm):

Code :

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

1
2
3
4
5
     Lm:= Length(Mot.Seq);
     X1:= 1; X2:= DimG - (Lm - 1);
     Y1:= 1; Y2:= DimG;
     FOR x:= X1 TO X2 DO
       FOR y:= Y1 TO Y2 DO ...

on a donc dans ce cas: x ≤ X2 = DimG - Lm + 1 ,
il subsiste bien à droite l'écart: DeltaX = DimG - x ≥ DimG - (DimG - Lm + 1) = Lm - 1
déterminant un espace suffisamment large pour accueillir la chaîne comportant (Lm) caractères.

Les instructions qui suivent

Code :

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

1
2
3
4
             j:= 1;
             FOR k:= 1 TO (Lm - 1) DO
               IF (G_[x + k, y].Car=Mot.Seq[k + 1]) THEN Inc(j);
             IF (j=Lm) THEN ...

ne provoquent pas de sortie d'intervalle, puisqu'elles impliquent:

k ≤ Lm - 1 , d'où: k + 1 ≤ Lm et
x + k ≤ (DimG - Lm + 1) + (Lm - 1) = DimG .

... À chacun sa méthode

Entièrement d'accord. Le recherche de l'algorithme le plus simple et le plus performant est une question toujours ouverte, c'est l'intérêt de tout échange que de confronter diverses versions.

[anapurna]

Salut

Au temps pour moi, je n'avais pas vu cette subtilité...
Effectivement tu ne parcours que la partie nécessaire de la matrice selon la direction voulue.

Voici les cases parcourues selon la recherche. Exemple pour un mot de 3 lettres :

Pour la recherche horizontale

Code X :

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

1
2
3
4
5
6
[X] [X] [X] [X] [n] [n] 
[X] [X] [X] [X] [n] [n] 
[X] [X] [X] [X] [n] [n] 
[X] [X] [X] [X] [n] [n] 
[X] [X] [X] [X] [n] [n] 
[X] [X] [X] [X] [n] [n]

Pour la recherche verticale

Code X :

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

1
2
3
4
5
6
[X] [X] [X] [X] [X] [X] 
[X] [X] [X] [X] [X] [X] 
[X] [X] [X] [X] [X] [X] 
[X] [X] [X] [X] [X] [X] 
[n] [n] [n] [n] [n] [n]
[n] [n] [n] [n] [n] [n]

Et pour la recherche diagonale

Code X :

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

1
2
3
4
5
6
[X] [X] [X] [X] [n] [n] 
[X] [X] [X] [X] [n] [n] 
[X] [X] [X] [X] [n] [n] 
[X] [X] [X] [X] [n] [n] 
[n] [n] [n] [n] [n] [n]
[n] [n] [n] [n] [n] [n]

Bien vu !