• Status: Solved
  • Priority: Medium
  • Security: Public
  • Views: 395
  • Last Modified:

[Very Easy & urgent] remove a char from a string

I have a string in which some characters are repeated, I want to delete the repeated characters.

I have tried this:

       for (int l=0; l<strLettresChoisies.length(); l++)
           for (int m=0; m<strLettresChoisies.length(); m++)
               {
               if(tolower(strLettresChoisies[l])== tolower(strLettresChoisies[m]) )
                  {
                  char cLettreEffacer=tolower(strLettresChoisies[l]);
                  strLettresChoisies.remove(cLettreEffacer);
                  }
               }
also tried this:

       for (int l=0; l<strLettresChoisies.length(); l++)
           for (int m=0; m<strLettresChoisies.length(); m++)
               {
               if(tolower(strLettresChoisies[l])== tolower(strLettresChoisies[m]) )
                  {
                  char cLettreEffacer=tolower(strLettresChoisies[l]);
                  strLettresChoisies.erase(cLettreEffacer,1);
                  }
               }

But none of them makes the job!
Thanks!
0
philip_khalil
Asked:
philip_khalil
1 Solution
 
meow00Commented:
Hello ... would u mind posting the whole code ? Thanks !
0
 
philip_khalilAuthor Commented:
*** non-relevant personal information removed on request of Asker by Netminder, Site Admin ***

# include <iostream.h>
# include <conio.h>
# include <iomanip.h>
# include <fstream.h>
# include <windows.h>
# include <stdlib.h>
# include <string.h>
#include <algorithm>

//Fonction permettant de remplir les variables contenants les noms complets,
// les pointages et le nombre de nom complet entrés.
void RemplirNomPointage(int &iNbNomComplet, string strLesNomComplets[20],
                        int iLesPointages[20]);

//Fonction permettant de remplir la variable contenants les 30 mots
void RemplirMot(string strLesMot[30]);

//Fonction permettant de transférer vers le fichier les noms complets,
// les pointages et le nombre de nom complet entrés.
void EnregistrerNomPointage(int iNbNomComplet, string strLesNomComplets[20],
                            int iLesPointages[20]);

//---------------------------------------------------------------------------

void main(void)
{
//Déclaration des constantes
const int NB_MOT = 30;

//Déclaration des variables
string strLesNomComplets[20]; //(prénom + ", " + nom)
int iLesPointages[20];
int iNbNomComplet;
string strLesMots[NB_MOT];


//Remplir la variable des NomComplet (Prenom+""+Nom) et des pointages à partir
//du fichier
RemplirNomPointage(iNbNomComplet, strLesNomComplets, iLesPointages);

//Remplir la variable des mots du fichier
RemplirMot(strLesMots);




//*****************************************************************************
//*************************** Début du Code ***********************************
//*****************************************************************************
//------------------------- identification VARIABLES --------------------------
int iMembre=0, iNbLettres, iLongueur, iRestant, iTemp;
char cLettre;
bool bOK=0, bTrouve=0, bAjoute=0, bPasse=0, bRepete=0, bRecommencer=0;
//------------------------- identification CONSTANTES -------------------------
//const float cfMaxX=30;
string strPhrase="", strNomJoueur, strMotActuel, strMotComplet,
       strLettresChoisies="", strTemp;
//------------------------- LECTURE du Mot de Passe ---------------------------

gotoxy(19,10);
cout<<" Veuillez entrer votre nom :";
getline (cin, strNomJoueur);
while (strNomJoueur=="")
      {
      gotoxy(48,10);
      getline (cin, strNomJoueur);
      }
clrscr();

srand(unsigned(time(NULL)));
strMotComplet = strLesMots[rand()%30];


for (int i=0; i<strMotComplet.length()-1; i++)
   {
       strMotComplet[i] = tolower(strMotComplet[i]);
   }

iRestant = strMotComplet.length();
iLongueur = strMotComplet.length();
//----------------------- Affiche la potence ----------------------------------
cout<<"Bonne chance " <<strNomJoueur <<" " <<strMotComplet <<"\n\n"
    <<"\t\t\t\xC9\xCD\xCD\xCD\xBB\n"
    <<"\t\t\t\xBA\n"
    <<"\t\t\t\xBA\n"
    <<"\t\t\t\xBA\n"
    <<"\t\t\t\xBA\n"
    <<"\t\t\t\xBA\n"
    <<"\t\t\t\xBA\n"
    <<"\t\t     \xCD\xCD\xCD\xCA\xCD\xCD\xCD";


gotoxy(19,14);
cout<<"Votre mot contient " <<strMotComplet.length() <<" Lettre(s) tous sans accents";
//-------------- Affiche les espaces du nombre de lettres du mot --------------
gotoxy(19,16);
for (int p=0; p<strMotComplet.length(); p++)
cout<<"_ ";

gotoxy(19,20);
cout<<"Veuillez entrer une lettre :";

gotoxy(19,25);
cout<<"Lettre(s) choisie(s) :";

//--Manche continue tant que Mot n'est pas Complet et qu'il reste des membres--
while ( (iRestant!=0) && (iMembre<7) )
    {
//------------------------------------------------------------------------------
    for (int p=0; p<strLettresChoisies.length(); p++)
        {
            if (strMotComplet[0]==strLettresChoisies[p] && bRepete==0)                 //Boucle importante
               {
               strLettresChoisies[p]= toupper(strLettresChoisies[p]);
               gotoxy(19,16);
               cout<<strLettresChoisies[p];
               bRepete=1;
               }
        }

    gotoxy(47,20);
//---- Demande une lettre tant que l'usager n'en rentre d'autres caracteres ---
    cLettre = getche();
    cLettre = tolower(cLettre);

    if (cLettre >='a' && cLettre <='z')
       {
//--------------- Vérifie si la lettre n'a pas déjà été choisie ---------------

       for(int i=0; i<strLettresChoisies.length(); i++)
           {

           if (tolower(strLettresChoisies[i])==cLettre)                                                      
              {                                                                                              
              MessageBox(NULL, "Vous avez déjà choisi cette lettre!", "Attention", MB_OK|MB_ICONSTOP);      
              gotoxy(47,20);                                                                                
              cout<<" ";                                                                                    
              gotoxy(47,20);
              i =    strLettresChoisies.length(); //Finit la boucle
              //bRecommencer = 1;
              }
           }

//-------- Ajoute la lettre aux lettres déjà choisies et les affichent --------
       strLettresChoisies+=cLettre;
//------------------------ Efface la lettre répétée ---------------------------
       for (int l=0; l<strLettresChoisies.length(); l++)
           for (int m=0; m<strLettresChoisies.length(); m++)
               {
               if(tolower(strLettresChoisies[l])== tolower(strLettresChoisies[m]) )
                  {
                  char cLettreEffacer=tolower(strLettresChoisies[l]);
                  strLettresChoisies.erase(cLettreEffacer,1);
                  }
               }
       gotoxy(47,20);
       cout<<" ";
       gotoxy(41,25);
       cout <<strLettresChoisies;
//------------------ Vérification de la LETTRE dans le MOT --------------------
    bOK=0;
    for(int p=0; p<strMotComplet.length() && bTrouve==0 ; p++)
       {
//------------ Sort de la boucle si toutes les lettres sont trouvées ----------
       if (iRestant == 0)
          {
          bTrouve=1;
          //cout<<"\a"; //BEEP 1 fois
          //Sleep (400); //Attend 0.4 secondes
          //cout<<"\a\a\a";
          //Sleep (500);
          //cout<<"\a";
          //Sleep (700);
          //cout<<"\a";
          //Sleep (400);
          //cout<<"\a";
          }
//--------------------- Si la lettre se trouve dans le mot --------------------
       if (cLettre==tolower(strMotComplet[p]))
          {
          gotoxy(19+(p*2), 16);
          cout<< cLettre;
          iRestant--;
          bOK=1;  //Il y a au moins une bonne lettre si bOK = 1
          }
//Si la lettre ne s'y trouve pas et que tout le mot est vérifié: AJOUTE un MEMBRE
       else if ( cLettre!=strMotComplet[p] && p>=strMotComplet.length()-1 && bOK==0)
          {
          switch(iMembre)
              {
              case 0: gotoxy(5,3);
                      cout<<"\t\t\t\xC9\xCD\xCD\xCD\xBB";
                      gotoxy(5,4);
                      cout<<"\t\t\t\xBA   O";
                      iMembre++;
                      break;

              case 1: gotoxy(5,5);
                      cout<<"\t\t\t\xBA   \xCF";
                      iMembre++;
                      break;

              case 2: gotoxy(5,5);
                      cout<<"\t\t\t\xBA  \xD5\xCF";
                      iMembre++;
                      break;

              case 3: gotoxy(5,5);
                      cout<<"\t\t\t\xBA  \xD5\xCF\xB8";
                      iMembre++;
                      break;

              case 4: gotoxy(5,6);
                      cout<<"\t\t\t\xBA   \xBA";
                      iMembre++;
                      break;

              case 5: gotoxy(5,7);
                      cout<<"\t\t\t\xBA  /";
                      iMembre++;
                      break;

              case 6: gotoxy(5,3);
                      cout<<"\t\t\t\xC9\xCD\xCD\xCD\xBB   Oups!\a\a\a"; //BEEP 3 fois
                      gotoxy(5,7);
                      cout<<"\t\t\t\xBA  / \\";
                      iMembre++;
                      break;
              }

          }
       }
    }
}

using std::string;
strMotComplet[0]=toupper(strMotComplet[0]);
strMotComplet = "Le mot était : " + strMotComplet;

if (iMembre==7)
   MessageBox(0,strMotComplet.data(),"Désolé",MB_OK);
if (bTrouve==1)
   MessageBox(NULL, "Vous avez bien trouvé le mot!", "Bravo", MB_OK|MB_ICONSTOP);
clrscr();
//------------------------------ Pointage -------------------------------------
bAjoute=0;
for (int p=0; p<iNbNomComplet; p++)
   {
   if(strLesNomComplets[p] == strNomJoueur)    //Si l'enregistrement existe on incremente
       {
       iLesPointages[p]++;
       p = iNbNomComplet;
       bAjoute=1;
       }
   else if (p == iNbNomComplet-1 && bAjoute ==0)
       {
       strLesNomComplets[iNbNomComplet] = strNomJoueur;
       iLesPointages[iNbNomComplet]=0;
       iNbNomComplet++;
       bAjoute=1;
       }
   }
//------------------- Classement par ordre Alphanumérique ---------------------
for (int i=0; i<iNbNomComplet; i++)
    for (int p=0; p<iNbNomComplet; p++)
        if (strLesNomComplets[i]<strLesNomComplets[p])
        {
        strTemp= strLesNomComplets[i];
        strLesNomComplets[i] = strLesNomComplets[p];
        strLesNomComplets[p]= strTemp;
        iTemp= iLesPointages[i];
        iLesPointages [i] = iLesPointages [p];
        iLesPointages [p] = iTemp;
        }
//----------------------- Affiche les résultats valides -----------------------
for (int p=0; p<iNbNomComplet; p++)
    cout<<left<<setw(40)<<strLesNomComplets[p]<<" "<<iLesPointages[p]<<'\n';

cout<<"Pesez une touche pour terminer";

//*****************************************************************************
//***************************** Fin du Code ***********************************
//*****************************************************************************
//Fonction permettant transférer vers le ficheir les noms complets,
// les pointages et le nombre de nom complet entrés.
EnregistrerNomPointage(iNbNomComplet, strLesNomComplets, iLesPointages);
}


//---------------------------------------------------------------------------
//Section des fonctions, ne rien écrire dans cette section
//---------------------------------------------------------------------------

//Fonction permettant de remplir les variables contenants les noms complets,
// les pointages et le nombre de nom complet entrés.v
void RemplirNomPointage(int &iNbNomComplet, string strLesNomComplets[20],
                        int iLesPointages[20])
    {
    fstream Fichier;
    Fichier.open("c:\\temp\\NomPointage.bin", ios::in|ios::binary);
    Fichier.read((char*) &iNbNomComplet, sizeof(iNbNomComplet));
    for(int i=0; i<iNbNomComplet; i++)
        {
        char cMot[90];
        Fichier.read((char*) cMot, sizeof(cMot));
        strLesNomComplets[i] = cMot;
        Fichier.read((char*)&iLesPointages[i], sizeof(iLesPointages[i]));
        }
    Fichier.close();
    }

//Fonction permettant de remplir la variable contenants les 30 mots
void RemplirMot(string strLesMot[30])
    {
    fstream Fichier;
    Fichier.open("c:\\temp\\Mot.txt", ios::in);
    for(int i=0; i<30; i++)
        {
        Fichier>>strLesMot[i];
        }
    Fichier.close();
    }

//Fonction permettant transférer vers le fichier les noms complets,
// les pointages et le nombre de nom complet entrés.
void EnregistrerNomPointage(int iNbNomComplet, string strLesNomComplets[20],
                            int iLesPointages[20])
    {
    fstream Fichier;
    Fichier.open("c:\\temp\\NomPointage.bin", ios::out|ios::binary);
    Fichier.write((char*) &iNbNomComplet, sizeof(iNbNomComplet));
    for(int i=0; i<iNbNomComplet; i++)
        {
        char cMot[90];
        strcpy(cMot, strLesNomComplets[i].c_str());
        Fichier.write((char*) cMot, sizeof(cMot));
        Fichier.write((char*)&iLesPointages[i], sizeof(iLesPointages[i]));
        }
    Fichier.close();
    getch();
    }
0
 
AgariciCommented:
i get it you are using stl...
first i would suggest removing the '.h' from the include of the stl headers( i mean use '#include <string>' instead)

why dont you use the erase method of the string object?
so i would do something like this:

for( int i = 0,k,n =str.length()   ; i < n ; i++ )
{
 k = str.find_first_of( str[i], i+1 );
 if(k!=n)str.erase( k,1 );
 n = str.length() ;
}


hope this helps

A.

0
What does it mean to be "Always On"?

Is your cloud always on? With an Always On cloud you won't have to worry about downtime for maintenance or software application code updates, ensuring that your bottom line isn't affected.

 
AgariciCommented:
hmm...

ofcourse the above will erase only the first repeated letter, sorry
to erase all you will have to insert a while block like this:

for( int i = 0,k,n =str.length()   ; i < n ; i++ )
{
 k = str.find_first_of( str[i], i+1 );
 while(k!=n){
  str.erase( k,1 );
  k = str.find_first_of( str[i], k );
 }
  n = str.length() ;
}

A.
0
 
rstaveleyCommented:
Here's an STL-ish way to remove repeat characters:
--------8<--------
#include <iostream>
#include <string>
#include <algorithm>

int main()
{
      std::string str("Heeeelllllooooo WWoooooorlllddd");
      std::string::iterator end = unique(str.begin(),str.end());
      copy(str.begin(),end,std::ostream_iterator<char>(std::cout));
      std::cout << '\n';
}
--------8<--------
Sorry if I've misread your requirement :-)
0
 
AgariciCommented:

rstaveley:

very nice code! the problem is it only removes consecutive repeated characters ( i mean the 'l' and 'o' from 'World' are not removed and the string stil contains duplicate chars - and it seamed to me that philip_khalil wants to remove all duplicates from the string )

philip_khalil:

if you only want to transform "aaaabbbbaaaacccc" into "abac" (and not into "abc") you should use the solution rstaveley proposed, it is a (much) better solution.


A.
0

Featured Post

Independent Software Vendors: We Want Your Opinion

We value your feedback.

Take our survey and automatically be enter to win anyone of the following:
Yeti Cooler, Amazon eGift Card, and Movie eGift Card!

Tackle projects and never again get stuck behind a technical roadblock.
Join Now