Discussion :

[jack_x4]

Bonjour, je souhaite fabriquer une source qui permet d'afficher l'ensemble des solutions des mots comprenant les lettres de a à 99999999, mon problème se pause au niveau des boucles FOR lorsqu'il faut afficher le résultat pour des mots supérieures à une lettre car les constante de boucle ont pour valeurs 0 ce qui reviendrait à afficher le mot 99999999 au premier coup !

Voici le code source :

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
#include <stdio.h>
#include <string.h>
#include <conio.h>
 
 
int main (void)
{
   int i=0; // itération table reference
 
   unsigned long long compteur=0;
 
   int a,b,c,d,e,f,g,h=0;
   int lenth_ref=0;
 
   char generate[8]={NULL};
 
   char tabref[]="abcdefghijklmnopqrstuvwxyz0123456789"; //
 
 
// impression des caractères de la table de référence //
   printf("\ntable de reference: %s\n",tabref);
   lenth_ref = strlen(tabref) ; // lenth de la table de référence
   printf("table de %d caracteres\n",lenth_ref);
 
// Générateur de mots//
   printf("\nGenerateur de mots:\n");
   for(a=0;a<lenth_ref;a++)
   {
   for(b=0;b<lenth_ref;b++)
   {
   for(c=0;c<lenth_ref;c++)
   {
   for(d=0;d<lenth_ref;d++)
   {
   for(e=0;e<lenth_ref;e++)
   {
   for(f=0;f<lenth_ref;f++)
   {
   for(g=0;g<lenth_ref;g++)
   {
   for(h=0;h<lenth_ref;h++)
   {
   compteur++;
   generate[0]=tabref[h];
 
 
   printf("generate=%s\n",generate);
 
 
   getch();
   }}}}}}}}
   return(0);
}

[Mac LAK]

Si j'ai bien compté, ça va déjà te faire 3.512.479.453.920 ((37^8)-1) chaînes générées, soit quelques TERA-octets de données à stocker, et un paquet d'heures de calcul... Es-tu certain de ce que tu fais ?

De plus : tu ne termines pas ta chaîne "generate" par un zéro terminal (=> boum à l'affichage), et tu ne mets pas non plus à jour les AUTRES caractères de "generate" (seulement le premier).

EDIT : Au passage, tu peux calculer la longueur de ta chaine de référence ainsi :

Code :

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

#include <string.h>

Code :

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

1
2
    printf("\ntable de reference: %s\n",tabref);
    lenth_ref = strlen(tabref) ;

[jack_x4]

je ne souhaite pas stocker les informations générées !

juste stocker dans generate au coup par coup les mots générés. A chaque itération le contenu de generate est remis à jour, aucune sauvegarde de la totalité des mots générés

a
b
.....
zzzzzzzz


effectivement les autres caractères ne sont pas mis à jour ( les autres lettres, car je ne trouve pas le moyen d'afficher une lettre, premières boucle FOR, puis deux lettres, etc.

Soit, j'y arrive avec une lettre ou bien les 8 !

[ram-0000]

OK, tu ne veux pas les tocker mais les afficher.

3.512.479.453.920 possibilités (je te fais confiance Mac LAK) / 100 000 lignes/secondes (c'est pas mal déjà) 406 jours.

Il y a de fortes chances que tu aies une panne de courant avant la fin de ta boucle.

[jack_x4]

le sujet n'est pas un problème de durée mais un problème de construction de mon programme.

Je vous redéfinie mon sujet, comment puis-je faire un programme qui cré toutes les possibilité de a à zzzzzzzz en les affichant ?

[ram-0000]

OK pour le nombre de possibilités qui n'est pas un problème.

Je commencerai par générer tous les mots de 1 lettre puis tous les mots de 2 lettres etc.

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
char tabref[]="abcdefghijklmnopqrstuvwxyz0123456789";
 
   // mots de 1 lettre
   for(a=0;a<lenth_ref;a++)
   {
      generate[0] = tabref[a];
      generate[1] = 0;
      printf("generate=%s\n",generate);
   }
 
   // mots de 2 lettres
   for(a=0;a<lenth_ref;a++)
      for(b=0;b<lenth_ref;b++)
      {
         generate[0] = tabref[a];
         generate[1] = tabref[b];
         generate[2] = 0;
         printf("generate=%s\n",generate);
      }
 
...

[Mac LAK]

le sujet n'est pas un problème de durée mais un problème de construction de mon programme.

Sauf que tu n'en verras jamais le bout, c'est ça que l'on tente de t'expliquer... 100.000 lignes/seconde sur la console, déjà, c'est utopique (elle est au moins cent fois plus lente que ça...). J'ai refais le calcul, c'est en fait 2.901.713.047.668 chaînes au total (ce qui ne change pas grand-chose à l'affaire... ), c'est à dire Somme(i=1 -> i=8)[ 36 ^ i ] pour être exact.

Personnellement, je penche pour une durée d'exécution de l'ordre de 92 ANS... Tu verras la première chaîne à 6 caractères au bout d'environ 17 heures, pour te donner une idée.

Pour le reste, tu as plusieurs axes : intégrer le "\0" comme un caractère normal, et générer 8 boucles bourrines incluant ce caractère nul. Ainsi, tu vas effectivement avoir la génération qui t'intéresse, à condition de faire un continue sur les boucles sortant le zéro (algo de coupe), de façon à ne pas générer les lettres APRÈS le zéro (qui ne seraient pas affichées de toutes façons). Cette solution a l'avantage de t'apprendre les méthodes de coupe d'algorithme, et d'être faite via un seul bloc d'instructions de 8 boucles imbriquées. L'inconvénient est que le bloc est (relativement) complexe.

L'autre solution, déjà proposée par ram-0000, est de générer les chaînes avec une longueur déjà connue (de 1 à 8). Chaque bloc de génération est bien plus simple, forcément, mais tu devras en écrire 8 d'affilée (c'est là l'inconvénient).