Force brute teste de strings

Version imprimable

Bonjour,

Je suis actuellement sur un projet qui consiste a forcer un md5. Cela �tant je ne connais pas le nombre de caract�re. Je dois donc retrouv� la chaine initial qui a permis de cr�er le md5. Je teste donc toutes les chaines de caract�res de 1 a N. Cependant mon code n'est vraiment pas optimis� puisque je fais N boucle for qui me permettent donc de tester pour toutes les chaines de caract�res de N boucle de longueur. Mais le projet sp�cifie que nous devons pouvoir choisir la longueur max que l'on va chercher.
Je vous demande donc comment je peux faire pour chang� mon code et avoir une longueur variable. Voici un bout de code qui vous permettra de mieux comprendre.
Code:

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(unsigned int j=0;j<tabLettre.size();j++) { Mot2=Mot1+tabLettre[j]; if (h1(Mot2)==h1(CODE)) { cout<<"hashage: "<<h1(Mot2)<<endl; return(0); } for(unsigned int k=0;k<tabLettre.size();k++) { Mot3=Mot2+tabLettre[k]; if (h1(Mot3)==h1(CODE)) { cout<<"hashage: "<<h1(Mot3)<<endl; return(0); } for(unsigned int l=0;l<tabLettre.size();l++) { Mot4=Mot3+tabLettre[l]; if (h1(Mot4)==h1(CODE)) { cout<<"hashage: "<<h1(Mot4)<<endl; return(0); } for(unsigned int m=0;m<tabLettre.size();m++) { Mot5=Mot4+tabLettre[m]; if (h1(Mot5)==h1(CODE)) { cout<<"hashage: "<<h1(Mot5)<<endl; return(0); }
Merci d'avance.

18/09/2019, 01h34
koala01
Citation:

Envoy� par cimestro

Bonjour,

Je suis actuellement sur un projet qui consiste a forcer un md5.

Attention!!! Ce projet pourrait te placer tr�s en porte � faux avec les lois sur le piratage informatique :aie:

Citation:

Cela �tant je ne connais pas le nombre de caract�re.

Tu n'en a -- a priori -- pas besoin, parce que MD5 agit comme une "somme de contr�le" : la m�me chaine de caract�res fournira toujours la m�me somme, et deux chaines de caract�res dans lesquelles un seul caract�re est diff�rents fourniront des sommes suffisamment diff�rentes pour que l'on ne puisse pas douter du fait qu'elles sont diff�rentes.

Par contre, "en cherchant bien", on peut "assez facilement" trouver plusieurs chaines (chacune �tant compos�es d'un nombre de caract�res potentiellement diff�rents) qui produiront la m�me somme (c'est ce que l'on appelle les "collisions"). Si tu trouvent deux chaines de caract�res produisant la m�me somme de contr�le, elles seront consid�r�es comme identiques, et ce, m�me si l'une des chaines de caract�res n'est compos�e que de 10 caract�res alors que l'autre en contient 1000.

Citation:

Je dois donc retrouv� la chaine initial qui a permis de cr�er le md5.

C'est malheureusement impossible, car, MD5 est un algorithme que l'on pourrait qualifier de "destructif": il n'y a aucun moyen de retrouver le contenu qui a permis de g�n�rer la somme de contr�le.

Citation:

Cependant mon code n'est vraiment pas optimis�

Ce qui est normal pour de la "force brute"... � d�faut de connaitre la chaine de caract�res d'origines :D

Citation:

Mais le projet sp�cifie que nous devons pouvoir choisir la longueur max que l'on va chercher.

Ben, pr�cises la, et arr�te toi quand tu atteint la taille indiqu�e ;)

Ceci dit, plus tu acceptera que la chaine de caract�res soit longue, plus tu auras de chance de tomber sur une chaine cr�ant une collision : avec une chaine de maximum 10 caract�res, les chances restent particuli�rement minces :aie: (� moins, bien sur, que la chaine d'origine n'ait contenu elle-m�me moins de dix caract�res :D )

Citation:

Je vous demande donc comment je peux faire pour chang� mon code et avoir une longueur variable.

Ben, a priori, tu devrais commencer par une boucle qui s'occupe de traiter les mots de 1 � maxLettres (cette deuxi�me valeur �tant introduite par l'utilisateur, sous une forme proche de
Code:

1 2 3 for(size_t tailleMot = 1; tailleMot < maxLettre; ++i){ /* ici dedans, il faut tester toutes les permutations possibles pour les mots de tailleMot lettres */ }
18/09/2019, 13h07
cimestro

La taille de la cha�ne initial me permettra de pouvoir tester la rapidit� entre mon programme et un autre programme. la est l�int�r�t de mon projet. Une programme s�quentiel contre un programme avec des threads.

les taille de ma cha�ne ne sera pas grande ( -10 caract�res) lorsque je trouverais une cha�ne qui correspond a mon md5 se sera forcement la cha�ne initial non?

Je comprends bien ce que tu veux faire dans la boucle mais je ne vois pas comment faire. C'est d'ailleurs a ce niveau la que je bloque. Je n'arrive pas a reproduire ce que j'ai fais avec des boucle for imbriqu� en une seul boucle for.

Merci
19/09/2019, 12h27
koala01
Citation:

Envoy� par cimestro

La taille de la cha�ne initial me permettra de pouvoir tester la rapidit� entre mon programme et un autre programme. la est l�int�r�t de mon projet.

Oh, � ce moment l�, on entre en phase de d�monstration, et les d�s sont "pip�s" : tu introduit une chaine de caract�res quelconque, mais tu sais exactement ce que tu as introduit :D

Partant de l�, tu connais forc�ment la taille de la chaine de caract�res d'origine, et tu peux donc travailler sur des chaines de caract�res de la taille en question ;)

Citation:

les taille de ma cha�ne ne sera pas grande ( -10 caract�res) lorsque je trouverais une cha�ne qui correspond a mon md5 se sera forcement la cha�ne initial non?

En toute honn�tet�, je ne pourrais m�me pas forc�ment te le garantir, ayant quelque peu oubli� le mode de fonctionnement de l'algorithme md5.

Mais, il faut te dire que, m�me si tu limites tes chaines de caract�res aux 26 lettres (majuscules et minuscules m�lang�es) de l'alphabet, chaque caract�re de la chaine de caract�res peut prendre 52 valeurs diff�rentes, et que, pour une taille donn�e, tu te trouve donc confront� � 52^{nombre de caract�res} chaines de caract�res diff�rentes.

Valeur � partir de laquelle il faut encore compter avec le paradoxe des anniversaires :aie:

Citation:

Je comprends bien ce que tu veux faire dans la boucle mais je ne vois pas comment faire. C'est d'ailleurs a ce niveau la que je bloque. Je n'arrive pas a reproduire ce que j'ai fais avec des boucle for imbriqu� en une seul boucle for.

Ben, en fait, c'est "relativement simple" : tu utilises cette boucle pour cr�er une chaine de caract�res avec tous des 'a', ce qui te donne:
- au premier passage, la chaine "a"
- au deuxi�me passage, la chaine "aa"
- ...
- au dixi�me passage, la chaine "aaaaaaaaaa"
A partir de l�, tu utilise ta chaine de caract�res un peu comme un compteur kilom�trique de voiture : tu fais syst�matiquement varier le dernier caract�re de la chaine, le faisant passer � b, puis � c, ... puis � zQuand le dernier caract�re vaut z tu le fait passer � A, et tu continue � le faire passer par les autres lettres de l'alphabet (en majuscules, cette fois)
Lorsqu'il atteint la derni�re valeur possible (Z si tu as bien suivi), tu travaille exactement de la m�me mani�re que lorsque tu passe de 9 � 10 : je passe � 0, je retiens 1, sauf que, en l'occurrence, tu repasse � a et que tu ajoute 1 � l'avant dernier, qui suivra exactement le m�me raisonnement avec l'ant�-penulti�me caract�re, qui suivra le m�me raisonnement avec celui qui le pr�c�de, et ce, jusqu'� ce que ta chaine de caract�res ne soit compos�e que de Z .

Si tu obtiens la m�me somme de contr�le � un moment donn�, c'est que tu as gagn� : tu as au minimum trouv� une collision possible qui fera l'affaire. Si tu en arrives � un point o� la chaine de caract�res n'est compos�e que de Z sans avoir retrouv� la bonne somme de contr�le, tu a perdu ;)

Je vais te laisser r�fl�chir � la logique � mettre en oeuvre pour utiliser ta chaine de caract�res comme un compteur, mais le raisonnement est l� ;)
19/09/2019, 21h48
cimestro

Merci de ta r�ponse encore une fois :D.

J'ai finalement fais une s�ance intensive sur mon code. Je suis parti sur ce que tu m'a dis et j'ai finalement r�ussi. J'ai donc fais une boucle for qui correspond a la taille de ma chaine. Dans celle-ci j'y est mis un while qui parcours tous mes char de teste et qui gr�ce a de nombreux compteur ( for(int i=0; i<TailleMot; i++)) qui me permette de faire une sorte de compteur kilom�trique comme tu m'a dis.

Merci beaucoup. Plus qu'a threader tous �a et le tour et jou�.

Sujet r�solu
20/09/2019, 18h09
koala01

Si tu me montre ton code, je te montre le mien, car je me suis amus�, juste apr�s mon intervention pr�c�dente, � voir comment je mettrais cette logique en place (sans toutefois calculer la somme md5 des diff�rentes chaines de caract�res) ;)
20/09/2019, 18h36
cimestro

Je te l'ai envoy� en message priv� parce que j'ai pas trop envie que tous les �tudiants de ma promo voit mon code. Plusieurs personne savent que j'avais post� sur le forum donc si je pouvais �vit� que tous mon code tourne :D.
21/09/2019, 00h06
koala01

Et, quand bien m�me, tous les �tudiants de ta promo verraient ton code, o� serait le probl�me:question: Crois tu vraiment avoir des connaissances en cryptoanalyse telles que ton code, � ton deuxi�me essais, m�rite le nobel d'informatique :question:

Bon je mets �a la en esp�rant que �a pourras aider des gens :D. Voila la methode que j'ai fais. J'ai essay� de commenter le plus possible. Si vous voyez des choses a am�liorer sans changer tous l'algo je suis preneur:

Code:

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
 
using namespace std;
#include <string.h>
#include <cmath>
#include <thread>
#include <pthread.h>
#include <atomic>
#include <iostream>
#include <stdio.h>
#include <time.h>
#include <vector>
 
int main()
{ 
	string CODE; // A MODIF AVEC UN HASH MD5 DE LA LIB CRYPTO
	cout<<"Entrez votre code"<<endl;
	cin>>CODE;
	float temps;
    clock_t t1, t2;
    t1 = clock();
	vector<char> tabLettre(0);
	char LettreMaj='A';
	char LettreMin='a';
	for (int i=0;i<26;i++)
	{
		tabLettre.push_back(LettreMaj);
		tabLettre.push_back(LettreMin);		
		LettreMin++;
		LettreMaj++;
	}		
	int TailleMAX=5;//Mis sur 5 parce que c'est long :)
	vector<char> modif(0);//Creation d'un vecteur qui va stocker des char qui permets donc de pouvoir suivre l'avancement dans le while
	vector<int> compteur(0);//Creation d'un compteur qui va permettre le bon fonctionnement de mon while ( changement de char arrivé a z)
	for(int tailleMot = 1; tailleMot <= TailleMAX; tailleMot++)
	{
		modif.push_back('A');//On rajoute une case au vecteur
		compteur.push_back(0);//On rajoute un compteur
		for(int i=0;i<tailleMot;i++)//On va initialiser au debut
		{
			compteur[i]=0;
			modif[i]='A';
		}
		while(1)
		{
			bool iteration=false;// variable bool permettant de ne pas changer tous le temps si seulement un z est present. Dans le mot par exemple azaa. sans cette variable la prochaine chaine serais baaa alors que l'on veut azab
			if(compteur[0]==52)//Si nous avons compteur[0]==52 alors cela veut dire que nous somme sur la chaine zzz ( nbr de char = tailleMot )
			{
				break;
			}
			string s=""; //Initialisation de s
			for (unsigned int i = 0; i < modif.size(); i++) //boucle pour transformer mon array en string
			{
				s = s + modif[i];
			}
			if (s==CODE)//condition de verification
			{
				cout<<"Trouvé :)"<<endl; 
				t2 = clock();
				temps = (float)(t2-t1)/CLOCKS_PER_SEC;
				printf("temps = %f\n", temps);
				return(0);
			}
			if(compteur[tailleMot-1]<52)//condition si nous avons une lettre différente de z sur le dernier char
			{
				compteur[tailleMot-1]=compteur[tailleMot-1]+1;//on autoincremente le compteur
				modif[tailleMot-1]=tabLettre[compteur[tailleMot-1]];//modif va aller chercher la valeurs de la compteur case de mon vector contenant les char de test
			}
			for(int z=(tailleMot-1);z>0;z=z-1)//boucle for qui va verifier si le compteur == 52. Si c'est le cas alors on va modifier la lettre de modif puis et on va verifier pour celui d'apres. Si nous avons une fois compteur different de 52 alors on mets iteration a true pour eviter le cas de azaz ou le deuxieme z serais remis a 'A'
			{
				if(compteur[z]>=52 && iteration==false)
				{		
					modif[z-1]=tabLettre[compteur[z-1]+1];//on remets a 0 les valeurs pour modif et pour les compteur
					compteur[z-1]=compteur[z-1]+1;
					modif[z]='A';
					compteur[z]=0;
				}
				else
				{
					iteration=true;
				}
			}
		}
	}
	exit(0);
}

Ton code est franchement pas mal, pour un d�butant, mais il laisse quand m�me beaucoup de place � l'am�lioration:

1- On n'utilise JAMAIS la directive using namespace std; : cette possibilit� a �t� rajout�e lorsque le commit� de normalisation du langage a d�cid� permettre l'utilisation des espaces de noms et, par voie de cons�quence, de placer les fonctionnalit�s issues de la biblioth�que standard dans l'espace de noms std.

A l'�poque, la base de code existante en C++ �tait d�j� importante, et il s'agissait de donner un moyen au d�veloppeurs de garder un code (�crit avant la normalisation) capable de compiler en ne n�cessitant "qu'un minimum" de modifications.

la directive using namespace n'a donc �t� propos�e que pour �viter aux d�veloppeurs d'avoir � parcourir leurs dizaines / centaines / milliers de fichiers � la recherche de tous les endroits du code o� il faudrait rajouter le fameux std::.

On ne peut d�cemment pas dire que le code que tu �crit aujourd'hui soit "assez vieux" pour m�riter d'utiliser ce "hack", car cela fait maintenant plus de vingt ans que les fonctionnalit�s de la biblioth�que standard sont plac�es dans l'espace de nom std ;)

2- Les fichiers "standards" qui portent l'extension .h (comme time.h stdio.h ou string.h) sont des fichiers d'en-t�te issus du C, et devraient �tre �vit�s. Si tu en as vraiment besoin (g�n�ralement pour te permettre de dialoguer avec une biblioth�que d�velopp�e en C), tu devrait utiliser les fichiers sp�cifiquement issu du C++, qui ne pr�sentent pas d'extension, et dont le nom est pr�fix� par la lettre c (ex : ctime, cstdio ou encore cstring).

Mais, a priori, tu n'en auras pas besoin, ne serait-ce que parce que l'on pr�f�rera utiliser les fonctionnalit�s similaires-- plus s�curisantes � l'emploi dans de nombreux cas -- issues directement du C++

Le fichier pthread.h est sensiblement dans la m�me veine : il fournit les fonctionnalit�s de threads posix expos�es par une biblioth�que nomm�e pthreads (que l'on retrouve sous windows), et fait au final double emploi avec les fonctionnalit�s issues du fichier <thread>

3- Pour en finir avec le chapitre des fichiers d'en-t�te: tu dois veiller � n'inclure � tout moment que les fichiers dont tu as vraiment besoin:

Tu n'as aucun besoin des fichiers d'en-t�te dont l'origine vient du C (string.h, cmath, pthread.h, stdio.h ) dans ton code actuel. Tu n'as donc aucune raison de les ajouter.

De plus, si tu veux travailler avec des chronos corrects, tu devrais utiliser les fonctionnalit�s expos�es par le fichier d'en-t�te chrono, au lieu d'utiliser les fonctionnalit�s issues du C.

Enfin, comme tu n'utilises pas les threads pour l'instant -- m�me si tu pr�vois d'y avoir recours par la suite -- tu n'as aucun besoin d'inclure le fichier d'en-t�te thread ;)

4- Ton code est suffisamment clair pour que tu aies pu t'�viter la peine d'y rajouter des commentaires. Il faut savoir que, � part lorsqu'ils poursuivent un but didactique, les commentaires qui paraphrasent le code (comprend : qui tentent d'expliquer ce que fait chaque ligne du code, ou presque ) sont plut�t nocifs qu'autre chose:

Un code doit pouvoir se lire comme un bon roman, sans avoir besoin d'explications suppl�mentaires. Et, pour ce faire, il n'y a pas de miracle, il faut

choisir correctement les noms de te (types de ) donn�es et de tes fonctions
respecter le SRP (Single Responsability Principle ou principe de la responsabilit� unique)
respecter la r�gle "une ligne == une instruction (ou d�claration d'une seule variable)
veiller � d�clarer tes donn�es au plus pr�s de leur utilisation

Hormis le SRP, tu avais presque r�ussi � respecter les trois autres r�gles. Il n'y a que pour t1 et t2 que tu te sois un peu fourvoy�:

t1 aurait sans doute gagn� � �tre appel� timeBegin ou n'importe quel autre nom de ton cru qui permette d'indiquer clairement qu'il s'agit du rep�re de temps utilis� pour repr�senter le d�but de ton chronom�tre. Quant � t2, vu que tu ne l'utilises pour la premi�re fois qu'au niveau de la ligne 58 de ton code, elle aurait pu s'appeler timeEnd (ou tout autre nom de ton cru) et �tre d�clar�e ... juste avant son utilisation.

5- Enfin, le SRP est sans doute, parmi les cinq principe SOLID, celui qu'il faut imp�rativement veiller � respecter en toute circonstances. Il est dommage que tu ne l'aies pas respect� ;)

Enfin, comme promis, voici le code que j'ai personnellement mis au point, avec les explications qui vont bien ;)

J'ai commenc� par me dire que, chaque fois que je changeais un caract�re dans ma cha�ne de caract�res, j'avais besoin de deux informations "conjointes" : le caract�re "suivant", celui par lequel je devais remplacer le caract�re "courant", et une information pour savoir si je devais effectuer le report sur "le caract�re d'� cot�".

J'aurais pu utiliser une std::pair<char, bool>, mais j'ai pr�f�r� cr�er une notion bien sp�cifique sous la forme de la structure
Code:

1 2 3 4 struct Result{ char nextChar; bool overlaps{false}; }
Gr�ce � cette structure, je me suis dit que je pouvais d�sormais cr�er une fonction qui me fournisse toutes les informations dont j'ai besoin pour me permettre de changer un caract�re particulier de ma chaine de caract�res et qui prendrait la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 Result nextCharacter(char current){ static const std::string maybe{"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"}; auto found = maybe.find(current) +1; Result temp; if(found == possible.size()){ found = 0; temp.overlaps = true; } temp.nextChar = found; return temp; }
Tu remarqueras que si je voulais rajouter les chiffres ou les caract�res sp�ciaux (tels que @,#,! et autres signes de ponctuation), je pourrais le faire tr�s facilement et dans n'importe quel ordre, pour autant que je me limite aux caract�res imprimables (ceux qui arrivent apr�s l'espace dans la table ASCII, celui-ci �tant compris dans le lot) ;)

Si je voulais pouvoir travailler avec n'importe quel caract�re ASCII, dont, entre autres, les caract�res non imprimables (ceux qui pr�sente un indice dans la table ASCII compris dans l'intervalle [0,32[ ), par exemple, pour traiter des fichiers binaires, je devrais sans doute faire autrement, mais bon...

Avec cette fonction, j'avais tout ce qu'il fallait pour cr�er une deuxi�me fonction capable de modifier la chaine de caract�res pour lui donner un air de compteur. Je lui ai donn� la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void rotate(std::string & str){ auto position = str.size() -1; bool again{false}; do{ auto result = nextCharacter(str[position]); again = result.overlaps; str[position]=result.nextChar; if(again){ --position; } } while(position >=0 && again) }
Et je me suis rendu compte que j'�tais peut-�tre bien un peu trop directif en te disant qu'il fallait faire tourner en priorit� le caract�re de droite, qui correspond au unit�s sur les nombres.

Car, soyons honn�te : pour nous que l'on passe par les chaines "aaa", "aab" ... "aaZ" ... "ZZZ" ou que l'on passe par les chaines "aaa","baa" ... "Zaa" ... "ZZZ", cela ne change absolument rien pour nous :aie: j'ai donc renomm� cette fonction en rotateRight, pour indiquer qu'elle parcoure la chaine de caract�res "de droite � gauche", et j'ai cr�� sa soeur jumelle capable de parcourir la chaine de caract�res ... de gauche � droite, en lui donnant la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void rotateLeft(std::string & str){ size_t position{0}; bool again{false}; do{ auto result = nextCharacter(str[position]); again = result.overlaps; str[position]=result.nextChar; if(again){ ++position; } }while(position < str.size() && again); }
Avec un avantage certain lorsque l'on voudra travailler sur plusieurs thread : chaque fonction pourra travailler � "un bout de la cha�ne", et elles pourront se rejoindre au milieu (si aucune des deux n'a trouv� la solution recherch�e, du moins)

Il ne me manquait plus que le moyen de g�n�rer la chaine de caract�res "de d�part" sur base du nombre de caract�res souhait�s. Non, en fait, je devais pouvoir g�n�rer deux cha�nes de caract�res � chaque fois : une repr�sentant la cha�ne de d�part, et l'autre repr�senant la condition de fin de la boucle. Et, pour repr�senter ces deux chaines de caract�res, j'ai de nouveau cr�� une structure � laquelle j'ai donn� la forme de
Code:

1 2 3 4 struct Strings{ std::string begin; std::string end; };
� laquelle j'ai adjoint une fonction capable de g�n�rer les deux chaines selon mes sp�cifications, et � laquelle j'ai donn� la forme de
Code:

1 2 3 4 5 6 Strings generateStrings(size_t size){ Strings temp; temp.begin.append(size, 'a'); temp.end.append(size,'Z'); return temp; }
Enfin aller vraiment jusqu'au bout des choses, vu que la seule responsabilit� de la fonction main() devrait �tre de servir de "point d'entr�e" au programme, j'ai cr�� une fonction qui s'assure de parcourir l'ensemble des chaines de caract�res compos�es d'un nombre bien pr�cis de caract�res sous la forme de
Code:

1 2 3 4 5 6 7 8 9 10 void computeStrings(size_t size){ auto strings = generateStrings(size); size_t count{0}; while(strings.begin != strings.end){ rotateRight(strings.begin); std::cout<<strings.begin<<"\n"; ++count; } std::cout<<"computed "<<count<<" strings of size "<<size<<"\n"; }
Cette fonction va afficher et compter toutes les chaines de caract�res qu'il est possible de g�n�rer.

Bien sur, tu peux en adapter le code pour ne pas afficher les chaines, ou pour ne pas afficher le d�compte final, ou pour faire "autre chose" (comme calculer la somme md5) avec chacune des chaines de caract�res obtenues, vu que mon code reste malgr� tout du domaine de la POC ;)

Si tu envisages de travailler avec plusieurs threads, c'est -- a priori -- au niveau de cette fonction qu'il faudra travailler ;)

Je pouvais d�sormais cr�er ma fonction principale en lui donnant la forme de
Code:

1 2 3 4 5 int main(){ for(size_t i = 1;i<=5;++i) computeStrings(i); return 0; }
de mani�re traiter toutes les chaines de caract�res dont le nombre de caract�res est compris entre 1 et 5 inclus. Bien, on pourrait adapter le code pour demander � l'utilisateur une limite haute et une limite basse concernant le nombre de caract�res des diff�rentes cha�nes, voir pour demander l'introduction d'une chaine de caract�res "t�moin", et tout ce que tu peux envisager d'autres ;)

Fier du travail accomplis (cela m'avait demand� royalement 20 minutes :aie:), je me suis rendu compte que la fonction nextCharacter, pour rapide qu'elle soit, risquait peut-�tre de pr�senter un probl�me de performance � cause de la recherche du caract�res dans la chaine appel�e maybe car il s'agit malgr� tout, dans le pire des cas, de parcourir les 52 caract�res de cette chaine pour trouver le caract�res 'Z', et que l'on pourrait donc rendre cette logique potentiellement plus efficace (il faudrait, pour bien faire, un benshmark pour s'en assurer :aie:)

Je me suis en outre rappel� que les lettres majuscules arrivaient avant les lettres minuscules dans la table ASCII, et qu'il y avait -- en outre -- "un certain nombre" de caract�res "particuliers" entre le 'Z' et le 'a'.

J'ai donc modifi� ma fonction nextCharacter pour lui donner la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Result nextCharacter(char current){ ++current; Result temp; if(current >'z'){ temp.overlaps = true; current = 'A'; }else if(current >'Z' && current <'a'){ current = 'a'; } temp.nextChar = current; return temp; }
Soyons bien clair : je n'ai absolument aucune preuve d'une meilleure efficacit� de cette fonction-ci. Je n'ai -- au mieux -- que l'intuition qu'elle pourrait s'av�rer plus efficace ;)

En outre, cette version m'oblige � adapter la logique de la fonction generateStrings, pour lui donner la forme de
Code:

1 2 3 4 5 6 Strings generateStrings(size_t size){ Strings temp; temp.begin.append(size, 'A'); temp.end.append(size,'z'); return temp; }
vu que les majuscules arrivent d�sormais avant les minuscules (ce qui ne nous pose malgr� tout, a priori, aucun probl�me ;) ).

21/09/2019, 12h25
cimestro

Merci beaucoup. JE prendrais le temps de regarder �a dans la journ�e. J'ai fini les threads sur mon algo qui on �t� assez simple a mettre en place par rapport a ce que je pensais :aie:. Je vais changer tous les points que tu me dis.