begin process at 2010 02 10 14:28:35
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Chaîne de caractères

 > MÉLANGEUR DE MOTS

MÉLANGEUR DE MOTS


 Information sur la source

 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

Source avec Zip RECHERCHE D'ANNAGRAMMES par Torin
GESTION DE CHAINE DE CARACTÉRE EN C++ AVEC NSTRING par xmustapha
Source avec Zip COMMENTER CODE C <=> ASM (WIN64) par BruNews
Source avec Zip GSTRING - GESTION DES CHAINES DE CARACTÈRES par Neokript
Source avec Zip ANALYSEUR SYNTAXIQUEV(0.1) par kohan95

 Sources en rapport avec celle ci

Source avec Zip RECHERCHE D'ANNAGRAMMES par Torin
Source avec Zip ANALYSEUR SYNTAXIQUEV(0.1) par kohan95
Source avec Zip Source avec une capture TRAITEMENT DE TEXTE par Cordok
Source avec Zip ANALYSE DES MOTS D'UN TEXTE par manta7
Source avec Zip Source avec une capture LOGICIEL D'ÉDITION DE FICHIERS TEXTE. par Benj35

Commentaires et avis

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 dans le forum

afficher les mots d'un fichier texte [ par cyrina84 ] Bonjours à tous les developpeurs icic présent, J'ai un probleme que je souffre depuis 3jours et j'espere que vous m'aidiez. Donc voila J'ai fichier te mélangeur de texte ? [ par semikoala ] Bonjour à tous, je recquiers votre aide apres avoir désespérément cherché une réponse introuvable !Je voudrais mélanger les mots d'un tex Fichier texte [ par spike666 ] Etant tres nul... et ne preférant pas chercher 3h des morceaux de codes pour finir sur un truc ki marchera pas je vais demander directement ce que je Recuperer des mots dans un fichier texte et les stocker dans un tableau. [ par amentag ] Bonjour.Je dispose d'un fichier texte contenant plusieurs mots (sous forme d'une liste) et j'aimerai les récuperer afin de les stocker dans un tableau probleme urgent en C [ par cyrina84 ] Bonjour, jai un probleme , c'est que j'ai des mots stockésdans une table de hacahge, et des séquences stockés dans une liste chainées. Le probleme c'e detection de mots dans un chat texte [ par nou24 ] Les amis je suis nouveau et j'espère rester longtemps dans ce forum. Je suis débutant en programmation mais j'ai des bonnes notions en programmation. urgent [ par cyrina84 ] salutà tousJai un probleme qui me bloque: jai une table de hachage chainé: un tableau de liste chainé#ifndef TABLE_HASH#define TABLE_HASH</s Instanciation JAVA (renommé et déplacé bar --> java) [ par baster200x ] bonjour tout le monde, j'ai un petit problème .... ben j'ai réalisé un programme de tel façon il prend un texte à partir d'un TextArea [ String text = Enregistrer une ligne bien precise d'un texte [ par Slown ] Bonjour.  Je voudrais savoir, si il était possible de pouvoir enregistrer une ligne (ou un mot) bien precise d'un fichier. Je m'explique: J'ai obtenu Lecture d'un fichier texte en C [ par toto000 ] Bonjour, j'ai un fichier texte avec un mot par ligne et je voudrai mettre ces mots dans un tableau de telle sorte que le premier mot soit dans la prem


Nos sponsors


Sondage...

CalendriCode

Février 2010
LMMJVSD
1234567
891011121314
15161718192021
22232425262728

Consulter la suite du CalendriCode

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,624 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales