Projet Genérateur combinaison. Validation Modèle physique . Avis Bienvenus

**Gilles57-H-G** · 12/12/2010, 01h09

Bonjour.
Je cherche à fabriquer un générateur de combinaisons Guématrique.

je suis arrivé grâce et avec l'aide de nombreuse personnes personnes présente sur ce Forum à un modèle physique prêt a être selon la courbe Merise "automatisé".

Cependant plusieurs points restent à valider

1:
J'utilise la Classe string, avec les objet string::iterator .
Les char*, associés à des boucles for classiques seraient ils plus rapide.

2:
j'ai besoin de connaitre chaque caractères, pour affecter la valeur d'une variable selon le schéma.
Si le caractere est un a, la variable vaut 1.
Si le caractère est un b, la variable vaut 2.
Si le caractère est un c, la variable vaut 3.
....
...
Si le caractère est un z la variable vaut 26.

Pour ce faire, et grâce à Steph_ng8
J'utilise cette "commande"

Code :

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

1
2
3
4
5
 
if ((*it0 >= 'a' /* 97 */) && (*it0 <= 'z' /* 122 */))
                val = *it0 - 'a' +1 /* 96 */;
                   else
                 val = 0;

*it étant le caractère à tester.

std::isalpha serait il plus rapide ?
Comment le mettre en place ?
Existe t'il un autre moyen plus rapide.

3:
La fonction reduit() calcule la réduction d'un nombre tel que:
183 = 1+8+3 = 12 =1+2 =3

Soit

Code :

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

reduit(183)

renvoie 3

La fonction :

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
int reduit (int a)
 {
 
  string chain = to_string(a);
 
   int t;
   t = chain.length();
   int ent;
   int res;
   res = 0;
   char car;
 
   int i;
 
  for(i=0; i<t; i++)
 
      {  
          car = chain[i] ; 
          ent = car - '0';  
 
          res = res + ent;       
                                 }
 
 if(res<10)
 
   return res; 
 
       else 
 
          return reduit(res);
 
                       }

Cette fonction appelle une autre fonction, pour transformer en string l'entier passé en paramètre.

Existe t-il un moyen plus rapide d'obtenir la réduction d'un entier selon le principe énoncé ci dessus.

Le code dans sa totalité :

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
 
#include <cstdlib>
#include <fstream>
#include "stdlib.h"
#include <stdio.h>
#include <sstream>
#include <cctype>    // pour tolower et toupper
#include <string>    
#include <iostream>  
#include <algorithm> // pour transform
#include <cstring>
 
//////////////////////////////////////////////////////
struct my_tolower
{ 
    char operator()(char c) const 
    {
        return std::tolower(static_cast<unsigned char>(c));
    } 
};
 
 
 
 
using namespace std;
 
 
template<typename T>
string to_string( const T & Value );
 
int reduit (int a);
 
 
int main(int argc, char *argv[])
{
 
    using namespace std;
 
    ofstream fichier("TextFile1.txt", ios::out | ios::trunc); 
 
 
    int val,val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11,valt,valr ; 
 
    int taille;
 
     string str;
     string chaine;
 
     long z;
     z = 0;
     valt = 0;
     cout<<"Entrez caracteres  (11 lettres en sortie)"<<endl;
     cin>> str;
 
    taille = str.length();
 
     transform(str.begin(), str.end(), str.begin(), my_tolower());
 
 
     for(int i1=0; i1 < taille; i1++)
		{
			for(int i2 = i1; i2 < taille; i2++)
			{
				if (stricmp(&str[i1], &str[i2]) > 0)
				{
					char tmp = str[i1];
					str[i1] = str[i2];
					str[i2] = tmp;
				 }
		   	 }
		 }
 
 
 
  string::iterator it0;
    string::iterator it1;
      string::iterator it2;
       string::iterator it3;
         string::iterator it4;
           string::iterator it5;
            string::iterator it6;
             string::iterator it7;
              string::iterator it8;
               string::iterator it9;
                string::iterator it10;
 
 
 
 
   for ( it10=str.begin() ; it10 < str.end(); it10++ )
    {  
    for ( it9=str.begin() ; it9 < str.end(); it9++ )
     {      
     for ( it8=str.begin() ; it8 < str.end(); it8++ )
      {     
      for ( it7=str.begin() ; it7 < str.end(); it7++ )
        {   
       for ( it6=str.begin() ; it6 < str.end(); it6++ )
        { 
        for ( it5=str.begin() ; it5 < str.end(); it5++ )
         { 
         for ( it4=str.begin() ; it4 < str.end(); it4++ )
          { 
          for ( it3=str.begin() ; it3 < str.end(); it3++ )
           { 
           for ( it2=str.begin() ; it2 < str.end(); it2++ )
            {
            for ( it1=str.begin() ; it1 < str.end(); it1++ )
             {
             for ( it0=str.begin() ; it0 < str.end(); it0++ )
             {
 
 
 
 
              if ((*it10 >= 'a' ) && (*it10 <= 'z' ))
                val10 = *it10 - 'a' +1 ;
                   else
                 val10 = 0;
 
              if ((*it9 >= 'a' ) && (*it9 <= 'z' ))
                val9 = *it9 - 'a' +1 ;
                   else
                 val9 = 0;
 
              if ((*it8 >= 'a' ) && (*it8 <= 'z' ))
                val8 = *it8 - 'a' +1 ;
                   else
                 val8 = 0;
 
              if ((*it7 >= 'a' ) && (*it7 <= 'z' ))
                val7 = *it7 - 'a' +1 ;
                   else
                 val7 = 0;
 
              if ((*it6 >= 'a' ) && (*it6 <= 'z' ))
                val6 = *it6 - 'a' +1 ;
                   else
                 val6 = 0;
 
              if ((*it5 >= 'a' ) && (*it5 <= 'z' ))
                val5 = *it5 - 'a' +1 ;
                   else
                 val5 = 0;
 
              if ((*it4 >= 'a' ) && (*it4 <= 'z' ))
                val4 = *it4 - 'a' +1 ;
                   else
                 val4 = 0;
 
              if ((*it3 >= 'a' ) && (*it3 <= 'z' ))
                val3 = *it3 - 'a' +1 ;
                   else
                 val3 = 0;
 
              if ((*it2 >= 'a' ) && (*it2 <= 'z' ))
                val2 = *it2 - 'a' +1 ;
                   else
                 val2 = 0;
 
           if ((*it1 >= 'a' ) && (*it1 <= 'z' ))
                val1 = *it1 - 'a' +1 ;
                   else
                 val1 = 0;
 
 
               if ((*it0 >= 'a' ) && (*it0 <= 'z' ))
                val = *it0 - 'a' +1 ;
                   else
                 val = 0;
 
            z = z +1;
 
 
 
 
 
     valt = valt += val += val1 += val2 += val3 += val4 += val5 += val6 += val7 += val8 += val9 += val10 ;  
 
      valr = reduit(valt);        
 
 
 
cout<<*it10<<*it9<<*it8<<*it7<<*it6<<*it5<<*it4<<*it3<<*it2<<*it1<<*it0<<" "<<"Valeur"<<" "<<valt<<" "<<"Valeur réduite"<<" "<<valr<<" ""Nombre de combinaisons"<<" "<<z<<endl;
fichier<<*it10<<*it9<<*it8<<*it7<<*it6<<*it5<<*it4<<*it3<<*it2<<*it1<<*it0<<" "<<"Valeur"<<" "<<valt<<" "<<"Valeur réduite"<<" "<<valr<<" ""Nombre de combinaisons"<<" "<<z<<endl;
 
                      valt = 0;
 
 
 
           }
          }
         }
        }
       }
      }
     }   
    }  
   }   
  }
 }
 
 
 
    system("PAUSE");
    return EXIT_SUCCESS;
}
 
 
 
/////////////////////////////////////////
 
int reduit (int a)
 {
 
  string chain = to_string(a);
 
   int t;
   t = chain.length();
   int ent;
   int res;
   res = 0;
   char car;
 
   int i;
 
  for(i=0; i<t; i++)
 
      {  
          car = chain[i] ; 
          ent = car - '0';  
 
          res = res + ent;       
                                 }
 
 if(res<10)
 
   return res; 
 
       else 
 
          return reduit(res);
 
 
 
                       }
 
 
 
template<typename T>
string to_string( const T & Value )
{
    // utiliser un flux de sortie pour créer la chaîne
    std::ostringstream oss;
    // écrire la valeur dans le flux
    oss << Value;
    // renvoyer une string
    return oss.str();
}

Ce code écrit les mots dans un fichier texte.

Pour contrôler la valeur des mot, il suffit de copier le mot, et de le coller dans ce logiciel :

http://mapage.noos.fr/pic-vert/numerus.html

Ce logiciel fait le travail inverse.

Merci

**3DArchi** · 12/12/2010, 09h39

Envoyé par Gilles57-H-G

Existe t-il un moyen plus rapide d'obtenir la réduction d'un entier selon le principe énoncé ci dessus.

Oui. Ne pas passer par une conversion std::string qui sera très couteuse. Utilises la division (/) et le modulo (%) pour construire ta réduction.

Envoyé par Gilles57-H-G

Le code dans sa totalité :[...]

Les 10 ou 11 boucles imbriquées me semblent, hmm..., maladroites.

A quoi sert le foncteur my_tolower ? std::transform(str.begin(), str.end(), str.begin(), std::tolower); ne suffit pas ?

Je ne suis pas sur d'avoir compris l'intérêt de ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
     for(int i1=0; i1 < taille; i1++)
		{
			for(int i2 = i1; i2 < taille; i2++)
			{
				if (stricmp(&str[i1], &str[i2]) > 0)
				{
					char tmp = str[i1];
					str[i1] = str[i2];
					str[i2] = tmp;
				 }
		   	 }
		 }

**koala01** · 12/12/2010, 11h57

Salut,

Pour commencer, il faut convertir le nom de la personne en valeur numérique.

Tu n'as pas vraiment le choix, tu dois, travailler au départ de la chaine sous une forme proche de

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
size_t valeurNom(std::string const & nom)
{
    /* on doit récupérer un entier non signé ( on ne devrait jamais avoir -1 ;)) */
    int ret;
    /* on passe tous les caractères qui composent la chaine en revue */
    for(size_t cpt=0;cpt<nom.size();++cpt)
    {
        /* on passe les caractères de valeur nulle (espaces et similaires) */
        if(isalpha(nom[cpt]))
        {
            /* on converti les caractères en minuscules (pour que A et a aient
             * une valeur égale )
             */
            size_t minuscule=std::tolower(nom[cpt]);
            /* on fait en sorte que la valeur soit comprise entre 0 et 26 */
            minuscule=minuscule-'a'+1; // si on fait simplement -'a', a == 0
            /* on additionne la valeur obtenue à la valeur qui sera renvoyée */
            ret+=minuscule;
        }
    }
    return ret;
}

La seconde étape est de prendre chacun des chiffre composant la valeur obtenue par cette étape, et de les additionner entre eux.

Cela peut se faire sur une simple boucle, sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
/* soit nombre = le nombre à réduire */
size_t ret = 0;
while(nombre > 0)
{
    ret += nombre % 10; // on ne prend que le reste de la division de nombre
                        // par 10 (ce qui correspond à l'unité )
    nombre /= 10;
}

Le problème, c'est que l'on souhaite limiter la valeur entre 1 et 9...

Or, cette boucle peut parfaitement nous donner un résultat (amplement) supérieur

Un simple exemple, la somme de "philippe" nous donne

Code :

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

1
2
3
4
5
6
7
 
    e = 5
    h = 8
    i = 9
    l = 12
    p = 16
    philippe = 16 + 8 +9 + 12 + 9 + 16 + 16 +5 = 91

et 9 + 1 donne ... 10

Il faut donc réexécuter la boucle tant que... le retour est plus grand que 10

Au final, cela ferait une boucle imbriquée (dont on fait une fonction pour l'occasion) proche de

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
size_t reduire(size_t origine)
{
    size_t ret = origine;
    while(ret >9)
    {
        size_t temp=0; 
        while(ret> 0)
        {
            temp += ret % 10;
            ret /= 10;
        }
        ret = temp;
    }
    return ret;
}

Le tout pourrait être utilisé sous la forme de

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
int main()
{
    std::cout "introduisez le nom de la personne ";
    std::string nom;
    std::cin >> nom;
    /* obtention de la valeur du nom */
    size_t temp=valeurNom(nom);
    /* on peut afficher cette valeur pour vérification */
    std::cout<<temp<<std::endl;
    /* réduction de la valeur */
    size_t final = reduire(temp);
    /* et l'afficher */
    std::cout<<final;
    return 0;
}

**Gilles57-H-G** · 12/12/2010, 12h34

Envoyé par koala01

Salut,

Pour commencer, il faut convertir le nom de la personne en valeur numérique.

Tu n'as pas vraiment le choix, tu dois, travailler au départ de la chaine sous une forme proche de

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
size_t valeurNom(std::string const & nom)
{
    /* on doit récupérer un entier non signé ( on ne devrait jamais avoir -1 ;)) */
    int ret;
    /* on passe tous les caractères qui composent la chaine en revue */
    for(size_t cpt=0;cpt<nom.size();++cpt)
    {
        /* on passe les caractères de valeur nulle (espaces et similaires) */
        if(isalpha(nom[cpt]))
        {
            /* on converti les caractères en minuscules (pour que A et a aient
             * une valeur égale )
             */
            size_t minuscule=std::tolower(nom[cpt]);
            /* on fait en sorte que la valeur soit comprise entre 0 et 26 */
            minuscule=minuscule-'a'+1; // si on fait simplement -'a', a == 0
            /* on additionne la valeur obtenue à la valeur qui sera renvoyée */
            ret+=minuscule;
        }
    }
    return ret;
}

La seconde étape est de prendre chacun des chiffre composant la valeur obtenue par cette étape, et de les additionner entre eux.

Cela peut se faire sur une simple boucle, sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
/* soit nombre = le nombre à réduire */
size_t ret = 0;
while(nombre > 0)
{
    ret += nombre % 10; // on ne prend que le reste de la division de nombre
                        // par 10 (ce qui correspond à l'unité )
    nombre /= 10;
}

Le problème, c'est que l'on souhaite limiter la valeur entre 1 et 9...

Or, cette boucle peut parfaitement nous donner un résultat (amplement) supérieur

Un simple exemple, la somme de "philippe" nous donne

Code :

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

1
2
3
4
5
6
7
 
    e = 5
    h = 8
    i = 9
    l = 12
    p = 16
    philippe = 16 + 8 +9 + 12 + 9 + 16 + 16 +5 = 91

et 9 + 1 donne ... 10

Il faut donc réexécuter la boucle tant que... le retour est plus grand que 10

Au final, cela ferait une boucle imbriquée (dont on fait une fonction pour l'occasion) proche de

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
size_t reduire(size_t origine)
{
    size_t ret = origine;
    while(ret >9)
    {
        size_t temp=0; 
        while(ret> 0)
        {
            temp += ret % 10;
            ret /= 10;
        }
        ret = temp;
    }
    return ret;
}

Le tout pourrait être utilisé sous la forme de

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
int main()
{
    std::cout "introduisez le nom de la personne ";
    std::string nom;
    std::cin >> nom;
    /* obtention de la valeur du nom */
    size_t temp=valeurNom(nom);
    /* on peut afficher cette valeur pour vérification */
    std::cout<<temp<<std::endl;
    /* réduction de la valeur */
    size_t final = reduire(temp);
    /* et l'afficher */
    std::cout<<final;
    return 0;
}

Ouah ! koala01
Tu m'as tout refait.
Merci.
je vais regarder ça cet après midi.
Merci encore.

**Gilles57-H-G** · 12/12/2010, 18h35

Nouvelle version (obsolète) :

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
 
#include <cstdlib>
#include <fstream>
#include "stdlib.h"
#include <stdio.h>
#include <sstream>
 
#include <string>    
#include <iostream>  
 
#include <cstring>
 
//////////////////////////////////////////////////////
 
 
 
using namespace std;
 
 
 
 
 size_t valeurNom(std::string const & nom);
 size_t reduire(size_t origine);
int main()
{ 
 
        ofstream fichier("Dimanche Matin.txt", ios::out | ios::trunc); 
 
 
    long z =  0;
    int taille;
    string mot;
    string str;
 
    cout<<"Entrez les caracteres"<<endl;
    cin>> str;
 
 
 
 
   taille = str.length();
 
 
 
 
     for(int i1=0; i1 < taille; i1++)
		{
			for(int i2 = i1; i2 < taille; i2++)
			{
				if (stricmp(&str[i1], &str[i2]) > 0)
				{
					char tmp = str[i1];
					str[i1] = str[i2];
					str[i2] = tmp;
				 }
		   	 }
		 }
 
 
 
  string::iterator it0;
    string::iterator it1;
      string::iterator it2;
       string::iterator it3;
         string::iterator it4;
           string::iterator it5;
            string::iterator it6;
             string::iterator it7;
              string::iterator it8;
               string::iterator it9;
                string::iterator it10;
 
 
 
 
   for ( it10=str.begin() ; it10 < str.end(); it10++ )
    {  
    for ( it9=str.begin() ; it9 < str.end(); it9++ )
     {      
     for ( it8=str.begin() ; it8 < str.end(); it8++ )
      {     
      for ( it7=str.begin() ; it7 < str.end(); it7++ )
        {   
       for ( it6=str.begin() ; it6 < str.end(); it6++ )
        { 
        for ( it5=str.begin() ; it5 < str.end(); it5++ )
         { 
         for ( it4=str.begin() ; it4 < str.end(); it4++ )
          { 
          for ( it3=str.begin() ; it3 < str.end(); it3++ )
           { 
           for ( it2=str.begin() ; it2 < str.end(); it2++ )
            {
            for ( it1=str.begin() ; it1 < str.end(); it1++ )
             {
             for ( it0=str.begin() ; it0 < str.end(); it0++ )
             {
 
 
 
            z = z +1;
 
 
 
			mot += *it10 ;
			mot += *it9 ;
			mot += *it8 ;
                        mot += *it7 ;
                        mot += *it6 ;
                        mot += *it5 ;
                        mot += *it4 ;
                        mot += *it3 ;
           	        mot += *it2 ;
			mot += *it1 ;
                        mot += *it0 ; 
 
 
    size_t temp=valeurNom(mot);
 
 
    size_t final = reduire(temp);
 
 cout<<mot<<" "<<"Valeur:"<<" "<<temp<<" "<<"Valeur réduite:"<<" "<<final<<" "<<"Nombre de combinasons :"<<" "<<z<<endl;
 fichier<<mot<<" "<<"Valeur:"<<" "<<temp<<" "<<"Valeur réduite:"<<" "<<final<<" "<<"Nombre de combinasons :"<<" "<<z<<endl;
 
      mot.clear() ;
 
 
           }
          }
         }
        }
       }
      }
     }   
    }  
   }   
  }
 }
 
 
 
 
 
 system("PAUSE");
    return EXIT_SUCCESS;
 
}
size_t valeurNom(std::string const & nom)
{
 
    int ret;
 
    for(size_t cpt=0;cpt<nom.size();++cpt)
    {
 
        if(isalpha(nom[cpt]))
        {
 
            size_t minuscule=std::tolower(nom[cpt]);
 
            minuscule=minuscule-'a'+1; 
 
            ret+=minuscule;
        }
    }
    return ret;
}
 
 
size_t reduire(size_t origine)
{
    size_t ret = origine;
    while(ret >9)
    {
        size_t temp=0; 
        while(ret> 0)
        {
            temp += ret % 10;
            ret /= 10;
        }
        ret = temp;
    }
    return ret;
}

**Gilles57-H-G** · 12/12/2010, 23h00

Projet Générateur Guématrique.

Version : Valeur réduite.

Modèle physique application console.
Main:

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
 
#include <cstdlib>
#include <fstream>
#include "stdlib.h"
#include <stdio.h>
#include <sstream>
 
#include <string>    
#include <iostream>  
 
#include <cstring>
 
//////////////////////////////////////////////////////
 
 
using namespace std;
 
 
 
 size_t valeurNom(std::string const & nom);
 size_t reduire(size_t origine);
 
void gene12 (string str, int v);
void gene11 (string str, int v);
void gene10 (string str, int v);
void gene9 (string str, int v);
void gene8 (string str, int v);
void gene7 (string str, int v);
void gene6 (string str, int v);
void gene5 (string str, int v);
void gene4 (string str, int v);
void gene3 (string str, int v);
void gene2 (string str, int v);
 
void geneT12 (string str, int v);
void geneT11 (string str, int v);
void geneT10 (string str, int v);
void geneT9 (string str, int v);
void geneT8 (string str, int v);
void geneT7 (string str, int v);
void geneT6 (string str, int v);
void geneT5 (string str, int v);
void geneT4 (string str, int v);
void geneT3 (string str, int v);
void geneT2 (string str, int v);
 
 
 
 
int main()
{ 
 
 
 
    int choix = 0 ;
    int longueur = 0;
    int mode = 0;
 
    string str;
    cout<<"                         Guematrie Ordinale "<<endl;
    cout<<endl;
    cout<<endl;
    cout<<"choisisez le mode :"<<endl;
    cout<<"                    1 pour valeur entiere"<<endl;
    cout<<"                    2 pour valeur reduite"<<endl;
    cin>>mode;
    cout<<"Entrez les caracteres"<<endl;
    cin>> str;
    cout<<"Entrez une valeur"<<endl;
    cin>> choix;
    cout<<"Entrez une longueur de sortie Min 2 Max 12"<<endl;
    cin>>longueur;
 
 
 
    switch (mode)
 
     {
            case 2 :
 
 
                switch (longueur)
                {
 
                 case 2: 
                 gene2 (str,choix);       
                      break; 
 
                  case 3: 
                  gene3 (str,choix);
                       break;
 
                  case 4: 
                  gene4 (str,choix);
                       break; 
 
                  case 5: 
                  gene5 (str,choix);   
                      break; 
 
                  case 6: 
                  gene6 (str,choix);
                      break; 
 
                  case 7: 
                  gene7 (str,choix);
                      break; 
 
                  case 8: 
                  gene8(str,choix);
                      break; 
 
                  case 9: 
                  gene9 (str,choix);
                      break; 
 
                   case 10: 
                  gene10 (str,choix);
                      break; 
 
                  case 11: 
                  gene11 (str,choix);
                      break; 
 
                   case 12: 
                   gene12 (str,choix);
                      break; 
 
                    default:      
                     break;   
 
 
                                       }
                   break;
 
                   case 1 :
                    switch (longueur)
                {
 
                 case 2: 
                 geneT2 (str,choix);       
                      break; 
 
                  case 3: 
                  geneT3 (str,choix);
                       break;
 
                  case 4: 
                  geneT4 (str,choix);
                       break; 
 
                  case 5: 
                  geneT5 (str,choix);   
                      break; 
 
                  case 6: 
                  geneT6 (str,choix);
                      break; 
 
                  case 7: 
                  geneT7 (str,choix);
                      break; 
 
                  case 8: 
                  geneT8(str,choix);
                      break; 
 
                  case 9: 
                  geneT9 (str,choix);
                      break; 
 
                   case 10: 
                  geneT10 (str,choix);
                      break; 
 
                  case 11: 
                  geneT11 (str,choix);
                      break; 
 
                   case 12: 
                   geneT12 (str,choix);
                      break; 
 
                    default:      
                     break;   
 
 
                                       }     
                   break;
 
                   default:      
                     break;
 
 
 
                                }
 
 
     system("PAUSE");
    return EXIT_SUCCESS;
 
                                            }

Les fonctions sont dans le message suivant.
Je me dois de vous dire :
Il peut être dangereux pour sa santé mentale de calculer la valeur de son nom ou de son prénom.

Ceci dit.

Ce code écrit les "mots" dans un fichier texte.
Pour contrôler le résultat en cas de modification, copier le "mot", collez le dans ce logiciel :
http://mapage.noos.fr/pic-vert/numerus.html

Ce logiciel fait le travail inverse.

Merci à Tous.

**Gilles57-H-G** · 12/12/2010, 12h24

Envoyé par 3DArchi

Oui. Ne pas passer par une conversion std::string qui sera très couteuse. Utilises la division (/) et le modulo (%) pour construire ta réduction.

Les 10 ou 11 boucles imbriquées me semblent, hmm..., maladroites.

A quoi sert le foncteur my_tolower ? std::transform(str.begin(), str.end(), str.begin(), std::tolower); ne suffit pas ?

Je ne suis pas sur d'avoir compris l'intérêt de ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
     for(int i1=0; i1 < taille; i1++)
		{
			for(int i2 = i1; i2 < taille; i2++)
			{
				if (stricmp(&str[i1], &str[i2]) > 0)
				{
					char tmp = str[i1];
					str[i1] = str[i2];
					str[i2] = tmp;
				 }
		   	 }
		 }

Bien pour la fonction

Code :

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

reduit()

, je vais essayer de modifier.

Les boucles servent à générer les combinaisons

( je cherche toutes les combinaisons avec le répétitions des caractères)

le récursif crée un blocage sur les combinaison trop importantes.

je cherche à créer des mot de 11 lettres avec "gendarmerie" par ex.

Il y a cette méthode, cela revient au même.
Il faut regarder le résultat sur le fichier texte créé par cette méthode.
la console n'affiche pas tout.

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
 
#include <cstdlib>
#include <fstream>
#include "stdlib.h"
#include <stdio.h>
#include <sstream>
#include <cctype>    // pour tolower et toupper
#include <string>    
#include <iostream>  
#include <algorithm> // pour transform
#include <cstring>
 
using namespace std;
 
int main()
{ 
 
        ofstream fichier("Dimanche Matin.txt", ios::out | ios::trunc); 
 
 
     string mot;
     int ii; 
     int a;
     int b;
     int c;
     int d;
     int e;
 
     a = 0;
     b = 0;
     c = 0;
     d = 0;
     e = 0;
 
     int taille;
 
     string chaine;
     chaine = "abcd";
 
     taille = chaine.length();
 
     string t1[taille];
     string t2[taille];
     string t3[taille];
     string t4[taille];
     string t5[taille];
 
 
         for (ii=0; ii<taille; ii++)
 
      {
                t1[ii] = chaine.substr(ii,1);
                t2[ii] = chaine.substr(ii,1);
                t3[ii] = chaine.substr(ii,1);
                t4[ii] = chaine.substr(ii,1);
                t5[ii] = chaine.substr(ii,1);
                                                         }
 
 
 
       while (e<taille)
 
          {
 
            for (a =0; a < taille; a++ )  
 
             { 
                cout<<t5[e]<<t4[d]<<t3[c] <<t2[b]<<t1[a]<<endl;   
                  fichier<<t5[e]<<t4[d]<<t3[c] <<t2[b]<<t1[a]<<endl;                                             
                                                            }
 
 
 
             b++;
 
 
 
                     if (b == taille) 
                       {
                         b= 0; 
                           c++; 
                                   }
 
 
                      if (c == taille) 
                        {
                           c= 0; 
                           d++; 
                                   }
 
 
                      if (d == taille) 
                        {
                           d= 0; 
                           e++; 
                                   }
 
 
 
 
 
                                                 }
 
 system("PAUSE");
    return EXIT_SUCCESS;
 
}

Pour ce qui est de :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
for(int i1=0; i1 < taille; i1++)
		{
			for(int i2 = i1; i2 < taille; i2++)
			{
				if (stricmp(&str[i1], &str[i2]) > 0)
				{
					char tmp = str[i1];
					str[i1] = str[i2];
					str[i2] = tmp;
				 }
		   	 }
		 }

C'est pour ranger dans l'ordre alphabétique.
Cela n'a pas d'influence notable sur la rapidité du programme, cette "commande" est utilisée une seule fois.
Au départ elle classe le string envoyé dans les fameuses boucles.
Merci.

Projet Genérateur combinaison. Validation Modèle physique . Avis Bienvenus

C++

Vue hybride

Discussions similaires

Partager

Partager