Commentçamarche.net
CodeS-SourceS
Rechercher un code, un tuto, une réponse

Mélangeur de mots

0/5 (8 avis)

Snippet vu 49 315 fois - Téléchargée 15 fois

Contenu du snippet

ce mélangeur de mots mélange un texte saisi par l'utilisateur en gardant la ponctuation (entrer, point, tabulation, ...).
son principe est assez simple : il mélange les caractères de chaque mot en gardant la première et la dernière lettre du mot s'il fait plus de trois lettres.

ce code source est prévu pour fonctionner sous linux, mais facilement adaptable sous windows.

Source / Exemple :

/*
********************************************************************************
*-------------------------------------------------------------------------------*
*---------------------------  mélangeur_de_mots.cpp  ---------------------------*
*-------------------------------------------------------------------------------*
* Description du programme : Mélange les caractères des mots d'un texte saisi   *
*                            si le mot fait plus de trois lettre, il garde la   *
*                            première et la dernière lettre du mot en place     *
* Ecrit par : mouflet                                                       *
* Date : 3/12/2005                                                              *
*                                                                               *
*********************************************************************************
*/

 

 


/*
************************************************************
****     DEBUT du code source mélangeur_de_mots.cpp     ****
************************************************************
*/




/*
*********************
* fichier d'en-tête *
*********************
*/

#include <iostream>
// inclusion de la bibliothèque pour la fonction rand() 
#include <cstdlib> 


using namespace std;



/*
 * Déclaration de fonction Randomize
 * Elle permet de mélanger les caractères à l'intérieur d'un mot
 * si celui ci fait plus de trois lettres,
 * sinon elle mélange tous les caractères du mot
 */
string Randomize(string Mot);






/*
 * Déclaration de la fonction decoupage
 * Elle permet de séparer les mots d'une chaine(d'un texte)
 * si il y a un caractère séparateur (espace, tabulation horizontal et vertical,
 * retour à la ligne, point, point virgule, ...)
*/
string decoupage(string chaineP);








/*
*****************************************************
************     FONCTION Principale    *************
*****************************************************
*/


int main()
{
  
  char car; // déclaration du caractère car 
  string chaineP ;   // déclaration de la chaine pour le texte initial 

  system("clear");

  srand(time(NULL));   // initialisation de la fonction de randomisation rand()
 
  cout << endl << "-----------------------------------" << endl << "*        mélangeur de mot         *" << endl << "-----------------------------------" << endl << endl;
  cout << endl << "Entrez votre texte a mélanger : " << endl << endl;

// boucle de lecture du texte caractère par caractère
  while(cin.good()){
   
    // lecture d'un caractère saisi par l'utilisateur
    cin.get(car);

    // le caractère saisi est mit à la suite de la chaine principale
    chaineP.push_back(car);
  
  }

  // teste si l'utilisateur à saisi un texte
  if( chaineP.length() < 2 ){
    
    cout << endl << "Pas de texte saisi !" << endl << endl;
    
  }else{
    
    // gestion d'erreur : évite le doublement du dernier caractère de la chaine
    chaineP[chaineP.length()-1] = ' ';

    cout << endl << endl << "---------- Résultat du mélange ----------";
    // affichage du texte mélangé
    cout << endl << endl << decoupage(chaineP) << endl << endl << "-------------------------------" << endl;
    
  }
}





/*
 *-------------------------------------------------------------*
 * Fonction    : Randomize                                     *
 *                                                             *
 * Paramètre   : string mot (paramètre chaine de caractères)   *
 *                                                             *
 * Retour      : string motM (paramètre chaine de caractères)  *
 *                                                             *
 * Description : fonction qui mélange les caractères d'un mot  *
 *-------------------------------------------------------------*
*/

string Randomize(string mot)
{
  
  int i, j;   // déclaration de variable pour les boucles
  int tbl[200];   // déclaration du tableau de nombre aléatoire
  int min, max;   // déclaration de variable local

  //déclaration de la chaine de caractère du mot mélangé (retour de fonction)
  string motM = "";
  
  bool ok;   // déclaration du booleen pour un test
  
  

  /*
   * Premier test sur la taille du mot pour répondre au
   * condition du résultat du problème :
   * si la taille du mot est supérieur à trois alors
   * on mélange uniquement les caractères à l'intérieur du mot
   */

  if(mot.length() > 3){   // test si le mot fait plus de trois lettre

    min = 1;   //  initialisation du minimum pour la fonction rand()
    max = mot.length()-2;   //  initialisation du maximum pour la fonction rand() 
    
    i = 0; // initialisation de i pour la boucle while

 // réalise une boucle tant que  i est inférieur ou égal à la taille du mot-2
    while(i <= (max - min) ){

      // pour la case i du tableau on randomise un nombre entre min et max
      // avec RAND_MAX une constante défini avec la fonction rand()
      tbl[i] = (int) ( min + ((float) rand() / RAND_MAX * (max - min + 1) ) );
      
      bool ok = true;   // affectation "vrai" du booleen
      
      if(i > 0){

	for(j = 0 ; j < i ; j++){   // pour toute les valeurs du tableau jusqu'à  i-1
	  
	  if(tbl[i] == tbl[j]){   // si le nombre randomisé est déjà dans le tableau
	    
	    ok = false;   // le booleen prend la valeur "faux"
	    
	  }
	}
      }

      if(ok){   // si le nombre randomisé n'est pas encore dans le tableau
	
	i++; // on continu
	
      }
    }
    
    motM.push_back(mot[0]);   // on ajoute la première lettre du mot initial au mot mélangé
    
    for(i = 0 ; i <= ( max - min ) ; i++){   //  pour chaque nombres du tableau

      // on ajoute une lettre (comprise entre la deuxième et l'avant dernière du mot initial)
      // au mot mélangé
      motM.push_back(mot[tbl[i]]);
      
    }

    // on ajoute la dernière lettre du mot au mot mélangé
    motM.push_back(mot[mot.length() - 1]);
    

    /*
     * Deuxième test sur la taille du mot :
     * si il fait moins (ou égal) de trois lettres alors
     * on mélange tous les caractères du mot
     */
  }else{
    
    min = 0;   // initialisation du minimum pour la fonction rand()
    max = mot.length() - 1;   // initialisation du maximum pour la fonction rand()
    
    i = 0;   // initialisation de i pour la boucle while

    // réalise une boucle tant que  i est infèrieur à la taille du mot-2
    while(i <= ( max - min ) ){

      // pour la case i du tableau on randomise un nombre entre min et max
      tbl[i] = (int) ( min + ((float) rand() / RAND_MAX * ( max - min + 1) ) );
      bool ok = true;   // affectation "vrai" du booleen
      
      if(i > 0){
	
	for( j = 0 ; j < i ; j++){   // pour toute les valeurs du tableau jusqu'à  i-1
	  
	  if(tbl[i] == tbl[j]){   // si le nombre randomisé est déjà dans le tableau
	    
	    ok = false;   // le booleen prend la valeur "faux"
	    
	  }
	}
      }
      if(ok)   // si le nombre randomisé n'est pas encore dans le tableau
	
	i++;   // on continu
      
    }
        
    for(i = 0 ; i <= (max - min) ; i++){   // pour chaque nombres du tableau

      // on ajoute une lettre (comprise entre la première et la dernière du mot initial)
      // au mot mélangé
      motM.push_back(mot[tbl[i]]);
      
    }
  }
  

  return motM; // retour du mot mélangé
}







/*
 *-----------------------------------------------------------------*
 * Fonction    : decoupage                                         *
 *                                                                 *
 * Paramètre   : string chaineP (paramètre chaine de caractères)   *
 *                                                                 *
 * Retour      : string chaineF (paramètre chaine de caractères)   *
 *                                                                 *
 * Description : fonction qui sépare les mots dans une chaine      *
 *-----------------------------------------------------------------*
*/

string decoupage(string chaineP)
{


  int i, j;   // déclaration de variable pour les boucles

  // déclaration des chaines de caractères pour le mot et le texte final
  string mot = "", chaineF = "";



  for(i = 0 ; i <= chaineP.length() ; i++){   // pour chaque caractères du texte saisi


    /*
     * Test si il y a  un caractère séparateur
     * (espace, tabulation, retour à la ligne, caractère défini par l'utilisateur)
     * affin de déterminer la fin d'un mot
     */
    if( (chaineP[i] == ' ' ) || (chaineP[i] == '\0' ) || (chaineP[i] == '\n' ) ||
        (chaineP[i] == '\t' ) || (chaineP[i] == '.' ) || (chaineP[i] == '\v' ) || 
        (chaineP[i] == '\f' ) || (chaineP[i] == ';' ) || (chaineP[i] == ':' ) ||
        (chaineP[i] == '!' ) || (chaineP[i] == '?' ) || (chaineP[i] == '\'' ) ||
        (chaineP[i] == '(' ) || (chaineP[i] == ')' ) || (chaineP[i] == '\\' ) ||
	(chaineP[i] == '|' ) || (chaineP[i] == '/' ) || (chaineP[i] == '[' ) ||
	(chaineP[i] == ']' ) || (chaineP[i] == '#' ) || (chaineP[i] == '§' ) |
	(chaineP[i] == '-' )|| (chaineP[i] == '{' ) || (chaineP[i] == '}' ) ){

      if(mot.length() > 0){   // test si le mot contient au moins un caractère

	chaineF = chaineF + Randomize(mot);   // on ajoute le mot mélangé au texte final
	mot = "";   // réinitialisation du mot

      }

      chaineF.push_back(chaineP[i]);   // ajoute les caractères spéciaux au texte final
   

   /*
    * si il n'y a pas de caractère séparateur alors
    * on ajoute les caractères pour former le mot
    * qui sera mélangé par la suite      
   */
    }else{

      // le caractère de la chaine principal est ajouter à la chaine comportant le mot  
      mot.push_back(chaineP[i]);
      
    }
  }
  


  /* 
   * Si le mot mélangé contient au moins un caractère (s'il existe) alors
   * il est ajouté a la chaine final.
   * La chaine finale va constituer a la fin le texte qui est mélangé
  */

  if(mot.length() > 0){   // si le mot contient au moins un caractère
    
    // le mot mélangé est ajouté à la suite du texte mélangé
    chaineF = chaineF + Randomize(mot); 
    
  }
  
  
  return chaineF;   // retour du texte mélangé
}



 


/*
********************************************************************
*************  FIN du code source mélangeur_de_mots.cpp  ***********
********************************************************************
*/

Conclusion :

me demander si vous voulez l'algorithme.

A voir également

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.