Algorithme d'un anagramme

Commenter

Contenu du snippet

Voici , un algorithme qui génère les anagrammes d'un mot que j'ai récupéré et adapté en java venant du site www.cppfr.com et donc codé en c++ à la base.
Les solutions sont affichées dans la console , à vous de jouer...

Source / Exemple : 


package algo;

public class AnagrammeAlgo {

	
	
	public AnagrammeAlgo(String  pmot)
	{
		 	char [] word; 
		    char [] solution; 
		    char [] TEMP=pmot.toCharArray();
		  
		    int n_arbre=1; 
		    int taille_solution=0; 
		    int long_anagram = TEMP.length; 
		  
		  
	
		    word = new char[long_anagram];
		    solution = new char[long_anagram];        // Là ou seront stockées les différentes solutions 
		    for (int m=0;m<long_anagram;m++) 
		    {	
		    	word[m]=TEMP[m]; 
		    }
		  
		    Arbre(word,0,long_anagram,solution,taille_solution);            // On rentre dans le premier étage de l'arbre 
		  
		    if (word !=null)
		    {
		    	word = null;
		    }
		    if (solution != null) 
		    {
		    	solution = null;
		    }
		    System.gc();

	}
	
	void Arbre(char [] word, int n, int lg, char [] solution, int taille_solution)    // Fonction recursive 
	{ 
	    char [] comb; 
	    int i,j,k,m; 
	    StringBuffer tmp ;
	    
	  
	    if (lg!=0) 
	    {  
	        comb = new char[lg];
	  
	        taille_solution++;        // On est descendu d'un étage dans l'arbre => taille de la solution +1 
	        for (i=0;i<lg;i++)        // Pour chaque lettre du nouveau mot on réalise autant d'arbre pour l'étage suivant 
	        { 
	            solution[n]=word[i];    // On ajoute la nouvelle lettre à la fin de la solution (n = étage) 
	            
	            tmp = new StringBuffer();
	            for (m=0;m<taille_solution;m++) 
	            {	
	            		tmp.append(solution[m]);
	            }
	            
	            System.out.println(tmp);   ///########## Les différentes combinaisons sortent ici !! BINGO ###########//
	  
	            k=0;                // ICI on définit la nouvelle combinaison COMB avec les lettres restantes 
	            for (j=0;j<lg;j++) 
	            { 
	                if (j!=i) 
	                { 
	                    comb[k] = word[j];    // Donc comb prend toutes les lettres restantes 
	                    k++; 
	                } 
	            } 
	  
	            Arbre(comb, n+1, lg-1, solution, taille_solution);    // Puis on descend d'un étage dans l'arbre en reinjectant le nouveau comb 
	        } 
	    } 
	    else taille_solution--;    // On remonte d'un étage dans l'arbre 
	} 

	
	

	
	
	public static void main(String[] args) {
			
		AnagrammeAlgo ana = new AnagrammeAlgo("lemot");
		
	}

}

Conclusion :


J'attends vos suggestions si vous prensez qu'il y a des améliorations à faire. (Car j'ai un peu adapté ce code à la va vite)

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (grapevine)