[langage] Liste + Boucle

**Girzi** · 28/10/2006, 14h52

J'ai lu avec interet la partie "Qu'est-ce qu'une liste simple ?" de la Faq écrite par 2Eurocents.

Je voulais savoir s'il est possible de simplifier cette écriture quoique valide à l'aide d'une boucle ou d'une synthaxe particulière.

Code :

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

@a = ((a..z),(aa..zz),(aaa...zzz));

Je voulais savoir s'il est également possible d'inclure toutes les combinaisons alphabétique et numérique par l'intermédiaire du même procédé.

(aa,ab,ac ...,a1,a2,a3 ...)

Merci pour votre aide

**Woufeil** · 28/10/2006, 16h59

Bonjour !

Si tu veux toutes les combinaisons numériques, utilise \d. Pour toutes les combinaisons alphanumériques utilise \w

Sinon, pour quantifier le nombre de caractères que tu veux rechercher, utilise les accolades : \w{1,10} recherche de 1 à 10 alphanumériques

**Girzi** · 28/10/2006, 18h06

Pourrias tu me donner un exemple ?
Je ne comprends pas comment inclure cela dans une liste / array

\w contient toutes les combinaisons alphanumériques O_o ?

**GnuVince** · 28/10/2006, 20h41

Premièrement, tu peux facilement changer ton code pour ceci:

Code :

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

1
2
 
my @liste = ('a'..'zzz');

Pour ce qui est d'avoir des alphanumériques:

Code :

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

1
2
 
my @liste  = ('a1'..'z9');

Bonne chance.

**Girzi** · 28/10/2006, 22h29

merci pour ta réponse c'est exactement ce que je voulais savoir !

**Girzi** · 29/10/2006, 08h49

Maintenant si je voudraais inclure toutes les combinaisons avec les majuscules compris.

C'est à dire aAaA1, Aaaa1 etc ...

Si je fais ('A'..'ZZ9') je n'aurais que des combinaisons majuscules et non des combinaisons entre minuscule et majuscule.

Avez vous une autre astuce / tour de magie ?

Merci à vous

**GnuVince** · 29/10/2006, 15h23

Ça devient plus complexes, tu vas devoir écrire une fonction qui va générer les différentes combinaisons.

**Girzi** · 29/10/2006, 17h03

As tu une suggestion / approche à me donner pour construire cette fonction sans devoir passer par des tonnes de boucles ?

Merci

**Woufeil** · 31/10/2006, 11h44

Et bien, \w !!!

Un petit exemple :

Code :

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

1
2
chomp (my $var = <stdin>);
print "Cette chaine contient 4 alphanumériques" if ($var =~ m/\w{4}/);

Cette expression match A1z9 ou 3eT6 mais pas une chaine qui contient un espace. Je ne vois pas où est le problème...

**Girzi** · 31/10/2006, 12h37

Je me suis mal exprimé =]
Le but etait d'affichier toutes les combinaisons possibles.

$var =~ m/\w{4}/;

vérifie si la chaine a 4 caractères alphanumériques, mais ne m'affiche pas toutes les combinaisons possibles.

**Woufeil** · 31/10/2006, 14h25

Ah, ok

Personnelement, je verrais bien un truc comme ça, en utilisant l'autovivification des tables de hachage :

Code :

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

1
2
3
my %hash = ();
$hash{$_}++ foreach ('A'..'ZZ9');
$hash{$_}++ foreach ('a'..'zz');

Chaque clé de hash sera un des éléments que tu veux

€dit : je m'explique un peu mieux : cette technique à l'avantage d'être parfaitement lisible et extensible : on peut rajouter autant d'éléments que l'on veut. Elle a aussi comme énorme avantage de ne pas permettre les doublons : si dans il y a des caractères communs dans deux foreach, il n'y aura pas de double dans la table, la valeur de la clé déjà présente sera juste mise à jour. Ainsi, si dans le deuxième foreach j'avais mis 'a'..'zz9', il n'y aurait pas eu deux fois 1..9 dans la table.

**Girzi** · 31/10/2006, 17h20

Je ne comprends pas bien ton code.
Il met toutes les possibilités en tant que clef des hachages ?

Sinon ce que je voulais faire ce réalise grâce à ce code : (extremement long)
Y a il moyen de l'optimiser / racourcir ?

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
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
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
@tab = ('a'..'z','A'..'Z',0..9,'@','#','$','%','+','-','*','/','\'','"','&');
 
# 1
 
$a = 0;
while($a <= $#tab )
{
print $tab[$a]."\n";
$a++;
}
 
# 2
 
$a = 0;
while($a <= $#tab )
{
   $b = 0;
   while ($b <= $#tab)
   {
   print $tab[$a].$tab[$b]."\n";
   $b++;
   }
$a++;
}
 
# 3
 
$a = 0;
while($a <= $#tab )
{
   $b = 0;
   while ($b <= $#tab)
   {
      $c = 0;
      while ($c <= $#tab)
      {
      print $tab[$a].$tab[$b].$tab[$c]."\n";
      $c++
      }   
   $b++;
   }
$a++;
}
 
# 4
 
$a = 0;
while($a <= $#tab )
{
   $b = 0;
   while ($b <= $#tab)
   {
      $c = 0;
      while ($c <= $#tab)
      {
         $d = 0;
         while ($d <= $#tab)
         {   
         print $tab[$a].$tab[$b].$tab[$c].$tab[$d]."\n";
         $d++;
         }
      $c++
      }
   $b++;
   }
$a++;
}
 
# 5
 
$a = 0;
while($a <= $#tab )
{
   $b = 0;
   while ($b <= $#tab)
   {
      $c = 0;
      while ($c <= $#tab)
      {
         $d = 0;
         while ($d <= $#tab)
         {   
            $e = 0;
            while($e <= $#tab)
            {         
            print $tab[$a].$tab[$b].$tab[$c].$tab[$d].$tab[$e]."\n";
            $e++;
            }
         $d++;
         }
      $c++
      }
   $b++;
   }
$a++;
}
 
# 6
 
$a = 0;
while($a <= $#tab )
{
   $b = 0;
   while ($b <= $#tab)
   {
      $c = 0;
      while ($c <= $#tab)
      {
         $d = 0;
         while ($d <= $#tab)
         {   
            $e = 0;
            while($e <= $#tab)
            {   
               $f = 0;
               while ($f <= $#tab)
               {
               print $tab[$a].$tab[$b].$tab[$c].$tab[$d].$tab[$e].$tab[$f]."\n";
               $f++;
               }
            $e++;
            }
         $d++;
         }
      $c++
      }
   $b++;
   }
$a++;
}
 
# 7
 
$a = 0;
while($a <= $#tab )
{
   $b = 0;
   while ($b <= $#tab)
   {
      $c = 0;
      while ($c <= $#tab)
      {
         $d = 0;
         while ($d <= $#tab)
         {   
            $e = 0;
            while($e <= $#tab)
            {   
               $f = 0;
               while ($f <= $#tab)
               {
                  $g = 0;
                  while($g <= $#tab)
                  {
                  print $tab[$a].$tab[$b].$tab[$c].$tab[$d].$tab[$e].$tab[$f].$tab[$g]."\n";
                  $g++;
                  }
               $f++;
               }
            $e++;
            }
         $d++;
         }
      $c++
      }
   $b++;
   }
$a++;
}
 
 
# 8
 
$a = 0;
while($a <= $#tab )
{
   $b = 0;
   while ($b <= $#tab)
   {
      $c = 0;
      while ($c <= $#tab)
      {
         $d = 0;
         while ($d <= $#tab)
         {   
            $e = 0;
            while($e <= $#tab)
            {   
               $f = 0;
               while ($f <= $#tab)
               {
                  $g = 0;
                  while($g <= $#tab)
                  {
                     $h = 0;
                     while ($h <= $#tab)
                     {
                     print $tab[$a].$tab[$b].$tab[$c].$tab[$d].$tab[$e].$tab[$f].$tab[$g].$tab[$h]."\n";
                     $h++;
                     }
                  $g++;
                  }
               $f++;
               }
            $e++;
            }
         $d++;
         }
      $c++
      }
   $b++;
   }
$a++;
}
 
# 9
 
$a = 0;
while($a <= $#tab )
{
   $b = 0;
   while ($b <= $#tab)
   {
      $c = 0;
      while ($c <= $#tab)
      {
         $d = 0;
         while ($d <= $#tab)
         {   
            $e = 0;
            while($e <= $#tab)
            {   
               $f = 0;
               while ($f <= $#tab)
               {
                  $g = 0;
                  while($g <= $#tab)
                  {
                     $h = 0;                     
                     while ($h <= $#tab)
                     {
                        $i = 0;
                        while ($i <= $#tab)
                        {
                        print $tab[$a].$tab[$b].$tab[$c].$tab[$d].$tab[$e].$tab[$f].$tab[$g].$tab[$h].$tab[$i]."\n";
                        $i++;
                        }
                     $h++;
                     }
                  $g++;
                  }
               $f++;
               }
            $e++;
            }
         $d++;
         }
      $c++
      }
   $b++;
   }
$a++;
}
 
# 10
 
$a = 0;
while($a <= $#tab )
{
   $b = 0;
   while ($b <= $#tab)
   {
      $c = 0;
      while ($c <= $#tab)
      {
         $d = 0;
         while ($d <= $#tab)
         {   
            $e = 0;
            while($e <= $#tab)
            {   
               $f = 0;
               while ($f <= $#tab)
               {
                  $g = 0;
                  while($g <= $#tab)
                  {
                     $h = 0;                     
                     while ($h <= $#tab)
                     {
                        $i = 0;
                        while ($i <= $#tab)
                        {
                           $j = 0;
                           while($j <= $#tab)
                           {
                           print $tab[$a].$tab[$b].$tab[$c].$tab[$d].$tab[$e].$tab[$f].$tab[$g].$tab[$h].$tab[$i].$tab[$j]."\n";
                           $j++;
                           }
                        $i++;
                        }
                     $h++;
                     }
                  $g++;
                  }
               $f++;
               }
            $e++;
            }
         $d++;
         }
      $c++
      }
   $b++;
   }
$a++;
}

**Woufeil** · 31/10/2006, 18h05

Non, mon code ne met pas toutes les possibilités comme clé de la table de hachage, c'est juste un code que tu peux adapter à volonté pour faire ça.
Tu voulais un modèle de fonction qui permette de générer un tableau contenant toutes les possibilités que tu veux, je te le donne

Si tu veux mettre toutes les lettres majuscule, tu as juste à mettre les caractères que tu veux dans le foreach et le hachage te garantit de ne pas avoir de doublons.

Mais en fait, je crois que je comprend pas bien ton problème et que je répond encore une fois à côté

Sur ce topic, je ne fais que ça, alors pourquoi pas continuer

Tu peux me redire ce que tu veux exactement ? C'est que je comprend très vite, mais il faut m'expliquer encore plus longtemps

**Girzi** · 31/10/2006, 19h11

Ce que je veux faire c'est génerer toutes les possibilités "d'assemblage" en fonction d'une liste.

Voici ma liste : @tab = ('a'..'z','A'..'Z',0..9,'@','#','$','%','+','-','*','/','\'','"','&');

J'ai realisé le bout de code (voir ma réponse pllus haut), seulement pour realiser cela j'ai du utiliser enormement de boucles.

Je veux realiser un code semblable mais plus optimisé, il existe surement une facon de realiser cet algorithme de manière plus simple mais je ne sais pas comment.

Merci pour votre aide

[langage] Liste + Boucle

Langage Perl

Discussions similaires

Partager

Partager