Mélangeur de mots
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.
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 ***********
********************************************************************
*/
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.