Mélangeur de mots

Soyez le premier à donner votre avis sur cette source.

Snippet vu 51 854 fois - Téléchargée 29 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

Ajouter un commentaire Commentaires
Messages postés
3
Date d'inscription
vendredi 29 avril 2011
Statut
Membre
Dernière intervention
4 mai 2011

si possible, pourriez vous traduire ce texte en javascript?
Messages postés
2
Date d'inscription
jeudi 11 novembre 2010
Statut
Membre
Dernière intervention
17 novembre 2010

salut!

Je ne connais rien à rien, mais je cherche un mélangeur de mots dans la phrase, et non un mélangeur de lettres dans le mot. Quelqu'un a une idée? Disons... sur windows...
aaaaaaargh!!
Matt
Messages postés
24
Date d'inscription
mardi 19 octobre 2004
Statut
Membre
Dernière intervention
16 mai 2008

Bonjour,
Il est beau ton code, mais comme je débute en C++, j'ai du mal à tout comprendre...
Je me contenterai donc d'une petite source en PHP, j'ai le même résultat avec ça :

<?php

// Mélange un mot
function melange( $m )
{
  $s = $m[0];
  $n = strlen($s);

  // Moins de 4 lettres : pas de mélange à faire
  if( $n < 4 )
    return $s;

  return $s[0] . str_shuffle( substr($s, 1, $n-2) ) . $s[$n-1];
}

$txtIn  = stripslashes( @$_REQUEST['texte'] );
$txtOut = preg_replace_callback('/\p{L}+/', 'melange', $txtIn );

?>


C'est bien C++, mais qu'est ce que c'est long...

Aïe, Aïe, Aïe, je sais je suis pas sur le bon forum.
1000 excuses,
A+
Messages postés
13
Date d'inscription
jeudi 24 mai 2007
Statut
Membre
Dernière intervention
11 décembre 2008

J'aimerais avoir l'algorithme de ce code et comment concatener deux chaines de caractères en algorithme car en C en c'est la fonction strcat et en algorithme je ne sais pas comment le faire donc si vous pouviez me donner une astuce cela sera le bienvenu.
Messages postés
1
Date d'inscription
samedi 10 décembre 2005
Statut
Membre
Dernière intervention
10 décembre 2005

salut mouflet... tu serais pas a l'iut de belfort par hazard? lool!!!
sinon dans ton code au lieu de mettre les caractère de séparation les uns après les autre tu aurais du utilisé la table ASCII et mettre :

int rep; //valeur de retour

if((caractere>65&&caractere<90)||(caractere>97&&caractere<122)||caractere<0){ //si le caractère est une lettre (majuscule, minuscule ou accentuée)
//renvoyer la valeur 0
rep = 0; //sinon renvoyer la valeur 1
}else{
rep = 1;
}

voila, j'aurais bien voulu te le dire avant la semaine dernière mais bon je sais pas qui tu es irl. enfin voila.
Afficher les 8 commentaires

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.