Discussion :

[Ekroz]

Bonjour,

J'aimerai savoir si il existe une fonction qui permettrait de générer toutes les possibilités d'une chaîne de caractères. Par exemple si je veux générer toutes les possibilités avec 4 majuscules suivi d'un nombre à 4 chiffres (que je choisis manuellement) qui apparaîtra sur toutes les chaînes comment faire ?

Exemple : AAAA1000, AAAB1000 etc...

[3DArchi]

MagicFunction() dans #include <soluce_exo.hpp> ?
As-tu un problème d'algo ou de code?

[Ekroz]

J'ai trouvé un algo qui marche bien mais en plein code il va générer des fois une chaîne de 3 majuscules au lieu de 4. Voilà le code :

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
#include <iostream>
 
using namespace std;
 
int main(int argc, char *argv[]) {
	const char ALL[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	int lg = 3;
	int i, x, y;
	char* buff = (char*) malloc(lg);
 
	do {
		realloc(buff, lg);
		int nChar[lg];
 
		for(i=0; i<=lg; i++) {
			buff[i] = ALL[0];
			nChar[i] = 0;
		}
 
		do {
			for(x = 0; x <= 27; x++) {
				buff[lg] = ALL[x];
				nChar[lg] = x;
				string final = buff;
				final = final+"1937";
				cout << final << endl;
			}
 
			for(y=lg; y>=0; y--) {
				if((nChar[y] == 27)&&(nChar[0]!= 27)) {
					nChar[y] = 0;
					nChar[y-1]++;
				}
 
				buff[y] = ALL[nChar[y]];
			}
		} while(nChar[0] != 27);
 
		lg++;
	} while(lg != 4);
	free(buff);
 
	system("PAUSE");
	return EXIT_SUCCESS;
}

[3DArchi]

Salut,
Beaucoup de chose ne vont pas. Le code que tu fourni ressemble plus à du C mis à part l'utilitation de cout qu'à du C++.
1/ En C++, on n'utilise pas malloc/free mais new/delete
2/ Tu fais des do/while à tout va sans que cela ne serve à quelque chose
3/ Tu as les chaînes de 3 caractère car lg est initialisé à 3 et la condition de sortie est while(lg != 4);
4/ En général, au lieu de while(lg != 4);, moi je préfère while(lg < 4);
5/ realloc(buff, lg); ne sert à rien. En plus son échec n'est pas géré.
6/ Dans les tableaux, les indices valides vont de 0 à (taille-1). Donc: buff[lg], nChar[lg], x <= 27 et y=lg ->
7/ En général, préféré const char ALL[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; à const char ALL[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
8/ Je ne comprend pas l'intérêt de la boucle for(x = 0; x <= 27; x++)

Précise ton algo en pseudo-code avant de passer à son codage, car j'ai l'impression qu'il y a des confusions.

[koala01]

Salut,

La récurisivité peut te venir en aide de manière efficace.

Le code à utiliser serait alors de l'ordre 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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/* une chaine de caractères comprenant les caractères de référence */
static const std::string letters="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
/* la fonction récursive
 * @ in-out tab: le tableau de chaines de caractères final
 *   in str: la chaine en cours de création
 *   in ind: l'index à utiliser dans la chaine "letters" 
 */
void  generate(std::vector<std::string>& tab, std::string str, size_t ind)
{
    /* il ne faut de toutes manières pas que l'index dépasse 
     * le nombre de caractères existant dans la chaine de référence
     */
    if(ind<26)
    {
        /* si la chaine créée contient 4 caractères, nous sommes
         * face au cas de base, et nous pouvons donc l'insérer dans
         * le tableau
         */
        if(str.size()==4)
        {
            tab.push_back(str);
        }
        else
        {
            /* sinon, nous appelons la récursivité avec la chaine telle
             * qu'elle est, mais en incrémentant la valeur de l'index (pour
             * etre sur d'arriver au final à la chaine ZZZZ)
             */
            generate(tab,str,val+1);
            /* nous rajoutons à la chaine le caractère de référence
             * pour nous permettre d'atteindre le second cas de base:
             * une chaine de caractères composée de 4 lettres
             */
            str+=letters[val];
            /* et nous appelons la récursivité pour cette chaines de
             * caractères
             */
            generate(tab,str,0);
        }
    }
}

L'utilisation pourrait se faire 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
16
17
18
19
20
21
22
23
24
25
26
27
28
int main()
{
    /* le tableau de possibilités
     */
    std::vector<std::string> tab;
    /* appelons la fonction de génération en passant une chaine vide
     */
    generate(tab,"",0);
    /* affichons le nombre de résultats (456976)
     */
    std::cout<<tab.size()<<std::endl;
    /* et, pourquoi pas, toutes les possibilités
     */
    for(size_t i=0;i<tab.size();++i)
    {
        std::cout<<tab[i]<<std::endl;
        /* comme cela fait énormément de résultats,
         * placons une pause portable tous les 20 possibilités
         */
        if((i+1)%20==0)
        {
            std::cout << "Appuyez sur entree pour continuer...";
            std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );
 
        }
    }
    return 0;
}

Par la suite, il "suffira" de rajouter les références numériques, en utilisant la classe stringstream