melangeur qui marche po

  salut a tous !
 j'ai un projet a faire en C++ (en iut info 1année) c'est un melangeur de mot dans un texte .
il doit melanger les lettres à l'interieur de mots (si le mot fait plus de 3 caracteres il ne doit po melanger la premiere et derniere lettre de ce mot et il ne doit po toucher aux ponctuations du texte )apres avoir entré le texte .
je m' etais fais un bon petit algo mais lors du passage ne c++ et plus pressisément lorsque je le test et bin il marche pas
ca fait une semaine que je le bidouille que je le réécris différamment mais rien tjrs le meme résultat "ca marche pas "
alors voila  mon programme j'implore votre aide avant de petter un boulon (je precise c'est mon premier vrai programme )
(excusez la mise en forme j'ai copier le cpp d'emacs sous linux sous mon winc pour poster depuis window qui la lu en bloc note dc j'ai remis en forme vite fait y a p-e une parentèse qui manque ^^)



#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <time.h>

using namespace std;
string melangeur(string maChaine);
int main(){
  char monChar;
  string maChaine;
  cout<<"entrez votre phrase à mélangée :"<<endl;
 
  while(cin.good()){
 
      cin.get(monChar);
      maChaine.push_back(monChar);

    }
   melangeur( maChaine );
}

string melangeur(string maChaine){

  char stop ;
  string maChaineMelange;
  char recherche =' ';
  char recherche2='\0';
  int debut,fin,alea,i,j,b;

  srand(time(NULL));
  debut=0;
  
  while(fin!=stop){
 
    fin=maChaine.find(recherche ||recherche2,debut);
       if((fin-debut)<=1){
         maChaineMelange[debut]=maChaine[debut];
       }
       else
          {
            if((fin-debut)<=3){
               for(i=debut;i<fin;i++){
                 b=i;
                 alea=(rand()%(fin-debut+1))+debut;
                 maChaineMelange[i]=maChaine[alea];

                    for(j=debut;j<b;j++){
                       if(maChaineMelange[j]==maChaine[i]){
                         i--;
                       }
                     }
                  }
              }
              else
                 {
                    maChaineMelange[debut]=maChaine[debut];
                    maChaineMelange[fin-1] =maChaine[fin-1];
                       for(i=(debut+1);i<(fin-1);i++){
                         b=i;
                         alea=rand()%((fin-1)-(debut+1))+(debut+1);
                         maChaineMelange[i]=maChaine[alea];
             
                               for(j=(debut+1);j<b;j++){

                                    if(maChaineMelange[j]==maChaine[i]){
                                        i--;
                                    }
                               }
                         }
                 }

     }

    maChaineMelange[fin]=maChaine[fin];
    debut=fin+1;
      if(fin = = '\0'){
         fin=stop;
     }
   maChaineMelange[fin+1]='\0';
   cout<<maChaineMelange;

}


si vous voyez ce qui marche po ou se que j'utilise mal n'hesitez po a bien expliquer car je suis vraiment un debutant

Dsl, mais c'est vraiment incompréhensible pour celui qui n'a écrit ce code...
Mais je comprend pas pk c'est aussi compliqué. Le principe est bidon en soit.

Voila ce que je ferais:
Tu lis ta string caractère par caractère. Et tu détermines tout d'abord le nombre de caractère qui doivent etre changer d'après tes différentes règles. Imaginons qu'il y en est "n".

On va maintenant créer une permutation sur ces valeurs.
Tu déclares deux tableaux d'entiers de longueur "n" (avec l'allocation dynamique donc). Dans le premier, tu mets par exemple la position initiale d'un caractère, et dans le deuxième la position finale.

Puis enfin, tu déclares une string qui contiendra la chaine finale.
chaine_final = chaine_initial;

et apres, tu modifies tous les caractères dont les indices sont dans le premier tableau et tu les remplaces par les caractères donc les indices sont dans le deuxième tableau.

En fait, on applique juste une permutation mathématique.

Il reste juste à remplir ces deux tableaux qu'on a déclarer avec des valeurs aléatoire et de facon à ce qu'un nombre d'apparaisse qu'une fois.

bon, en espérant avoir pu t'aider. ++

dsl pour mon code mais ca fait a mon de trois mois que j'ai decouvert la programation et merci pour ton aide (pis je suis un boulet j'ai po mis de commentaire )
je comprend po bien ce que tu entend par allocation dinamique on m'a apris que les tableau doivent etre declaré avec des valeurs et po des variables n  or la longueur de ma chaine  depend du texte que l'utilisateur rentre dc c'est un peut chiant
et pis mon plus gros probleme c'est pour melanger les mot des texte en evitant d'utiliser la meme letre (avec le rand)

et pis les trois bloc ds la fonction melange c'est en 1 si le mot et plus petit que 1 genre l'utilisateur met deux espace ou une seul letre
en 2 c'est si lemot fait plus de 1 letre et jusqu'a trois je melange tt le mot et la derniere c'est pour melanger tt les autres mot ceux qui font plus de trois lettre et la fo que je melange tt le mot sauf la premier et derniere lettre
et aussi un truc chiant c'est la recherche des mot j'utilise la fct ma_chaine.find(le caracter recherché , le debut de la recherche )
mais je crois que ca marche pas comme je l'utilise pour rechercher soit un espace  soit le '\0' de fin de chaine parcque sinon la recherche prend jamais le dernier mot du texte
est que tu pourais me montrer pour que ca melanger just un mot pour que je comprenne stp

Bon voila, ce que ca donne pour mélanger un mot. Tu peux réutiliser les fonctions existe_deja, new_rand, permute. Elles ne changeront pas dans le programme final.

#include <iostream>
#include <string>

using namespace std;

bool existe_deja(const int * _tab, const int n, const int _entier) // retourne vrai si _entier est présent, false sinon
{
  for (int i=0; i<n; i++)
    if (_tab[i] == _entier) return true;
 
  return false;
}

int new_rand(const int * _tab, const int n, const int _taille_total) // le tableau et sa taille (en fait juste la partie qui nous intéresse)
{
  int h = rand()%(_taille_total-2) + 1; // un nombre aléatoire entre 1 et _taille_total - 1 (_taille_total = longueur du mot)
  while (existe_deja(_tab, n, h)) // tant que le nombre aléatoire est présent, on en cherche un autre
  {
    h = rand()%(_taille_total-2) + 1;
  }
 
  cout << h << endl;
  return h; // on renvoit un entier qui n'est pas deja présent dans le tableau.
}

string permute(const string & _mot, const int * tab, const int _n)
{
  string mot_final = _mot;
 
  for (int i=0 ; i<_n ; i++)
  {
    mot_final[tab[i]] = _mot[i]; // le tab[i] ème caractère de mot_final est le i ème caractère de _mot.
  }
 
  return mot_final;
}

int main(int argc, char *argv[])
{
  srand(time(NULL));
 
  string mot("jemelangeca");

  int n = mot.size();
 
  int * tab = new int[n]; // alloue dynamiquement (on connait pas la taille) un tableau d'entier
   
  for (int i=0; i<n; i++) // on va du premier au dernier caractère
  {
    // comme c'est un mot:
    if ((i==0) || (i==n-1)) // si c'est le premier ou le dernier caractère
      tab[i] = i; // on dit que le i ème caractère sera déplacé en i ème position, cad qu'il ne bouge pas.
    else
    {
      tab[i] = new_rand(tab, i, n); // on remplie le tableau au hasard en envoyant en paramètre les i ème premier entier
    } 
  }
 
  string mot_final = permute(mot, tab, n); // on permute la chaine mot a l'aide du tableau tab
 
  cout << mot_final << endl;
 
  delete[] tab; // on libère la mémoire
  system("PAUSE");
  return 0;
}

Si ta des questions ou des suggestions n'hésites pas.

Ah j'oublie le MAITRE MOT en programmation :

       LES FONCTIONS !!!!!!!!!!!

non sérieux, abuses en si tu veux, mais découpes ton programme en sous fonction, comme j'ai essayé de te le montrer. Ca rend un code compréhensible et corrigeable.

Aller bonne chance.

merci beaucoup je me met direct au boulot pour dechiffrer ton code
y des truc que je connais po encore ^^ dedans
c'est que j'avais po encore vu les tableaux dinamiques en cour et les truc comme
* _tab,*argv[]et pis je connais po n'on plus la fonctin .size()
je cherche et si je trouve po je post
encore merci

argv[] c'est juste habituel, ca sert a rien pour ton programme, mais normalement faut mettre ca pour récupérer des arguments éventuels.

Salut astrowars. Moi aussi je suis un Ninfo première année, et si tu es bien à Belfort, je pense que tu es aiguiller vers le mauvais chemin. Etant donné que l'on a toujours pas vu l'allocation dynamique, je doute qu'il en faut... Avis personnel rien ne t'oblige à m'écouter.
Voilà mon aide : change de méthode, il y a une (ou plusieurs) méthode qui permet de mélanger aléatoirement sans utiliser de tableaux, donc tu n'alloues pas la mémoire dynamiquement.

Ciao et bonne chance

Oui en effet, tu m'as fait réfléchir, et j'ai trouvé bcp plus simple:

#include <iostream>

using namespace std;

int get_rand_number(int _min, int _max)
{
  return rand()%(_max-_min) + _min;
}

int main(int argc, char *argv[])
{
  srand(time(NULL));

  string mot("jemelangeca");
  string final(mot);

  int n = mot.size();
 
  char ch;
 
  int n1, n2;
 
  for (int i=1; i<n-1 ; i++)
  {
    n1 = get_rand_number(1, n-1);
    n2 = get_rand_number(1, n-1);
   
    ch = final[n1];
   
    final[n1] = final[n2];
   
    final[n2] = ch;
  }
 
  cout << final << endl;
 
  system("PAUSE");
 
  return 0;
}


Ceci dit, perso, je trouve ca débile de vous apprendre les type string, et de ne pas connaitre l'allocation dynamique.

luhtor>roh fallait le laisser chercher, tu lui as maché son projet, il est en info, son rôle est de cherché la solution, surtout que le projet est loin d'être compliqé même pour un novice...