MÉLANGEUR DE MOTS mélangeur, mélanger, mot, texte, mots, Source N°34925

Information sur la source

Catégorie :Chaîne de caractères Classé sous : mélangeur, mélanger, mot, texte, mots Niveau : Débutant Date de création : 05/12/2005 Vu : 17 866

Auteur : mouflet

Ecrire un message privé

Note :
Aucune note

Commentaire sur cette source (6)

Ajouter un commentaire et/ou une note

Description

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

/*
********************************************************************************
*-------------------------------------------------------------------------------*
*--------------------------- 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 ***********
********************************************************************
*/

/*
********************************************************************************
*-------------------------------------------------------------------------------*
*---------------------------  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.

Sources de la même categorie

Toutes les sources de la catégorie Chaîne de caractères

Sources en rapport avec celle ci

Commentaires

Commentaire de dark_naruto25 le 05/12/2005 15:35:28

coucou mouflet, je doit dire que j'ai fais à peu près pareil mon mon projet aussi.
Seulement pour mélanger le mot, tu détermine la zone à mélanger et tu la mélange à 2 endroits différents, séparer par un si. Tu aurais pu déterminer la zone, mélanger la zone et c'est tout...
Commentaire de max12 le 05/12/2005 17:28:15 administrateur CS

Dommage l'utilisation de string, mais bon tu aurais pas reçu le ptit message que tous le monde se passe sans arrêt depuis des années sur l'étude de l'université de cambridge ? :P
Commentaire de MuPuF le 05/12/2005 20:25:21

cad ? j'y suis pas encore lol
Commentaire de Choudi le 10/12/2005 20:27:17

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.
Commentaire de Big cent le 25/04/2008 09:09:18

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.
Commentaire de klerdesign le 28/04/2008 22:06:55

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 :

[code]
<?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 );

?>
[/code]

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+

Ajouter un commentaire

Discussions en rapport avec ce code source

afficher les mots d'un fichier texte par cyrina84

Fichier texte par spike666

Recuperer des mots dans un fichier texte et les stocker dans un tableau. par amentag

detection de mots dans un chat texte par nou24

Enregistrer une ligne bien precise d'un texte par Slown

Lecture d'un fichier texte en C par toto000

mot apés mot par logant83

mot cliquable par naddoush

comparer des mots par Ricpperso

editbox par flatou