Removing extra whitespaces from a string

Question

I came across an interesting exercise. Basically I have to remove all excessive spaces from a string, and by excessive I mean all the spaces at the beginning of the string, at the end of the string, and there should not be more than two consecutive whitespaces.

This is what I tried

#include <iostream>
#include <string>
using namespace std;

string RemoveSpaces(string s) {
    auto it = s.begin();
    while(*it == ' ') { // removes spaces at the beginning
        if(*it == ' ') s.erase(it);
    }

    auto it2 = s.end(); // removes spaces at the end of a string
    it2--;

    while(*it2 == ' ') it2--;
    it2++;
    while(*it2 == ' ') {
        if(*it2 == ' ') s.erase(it2);
    }

    for(int i = 0; i < s.length() - 1; i++) { // this does NOT work
        if(s.at(i) == ' ' && s.at(i + 1) == ' ') {
            auto it3 = s.at(i);
            s.erase(it3);
        }
    }

    return s;
}

int main() {
    string s;
    getline(cin, s);

    string s1 = RemoveSpaces(s);

    cout << "|" << s << "|" << endl;
    cout << "|" << s1 << "|" << endl;

    return 0;
}

However this does not do what I expected it to do. My code successfully removes the spaces at the beginning and the end of a string, but I cannot go further than that. Can anyone help?

EDIT I fixed the problem. Here is the part of code that now deletes extra whitespaces between words, so that it leaves just one space between two words.

    auto it3= s.begin();

    for(int i = 0; i < s.length() - 1; i++) {
        if(s.at(i) == ' ' && s.at(i + 1) == ' ') {
            s.erase(s.begin()+i);
            i--;
        }

    }

Thank you all for helping me.

Answer 1

You could make use of std::stringstreams capabilities:

#include <string>
#include <sstream>

std::string RemoveSpaces(const std::string& str) {
    std::string out;                 // the result
    std::string word;                // used to extract words from str 
    std::istringstream ss(str);      // create an istringstream from str
    while(ss >> word) {              // extract a word
        if(!out.empty()) out += ' '; // add a space between words
        out += word;                 // add the extracted word 
    }
    return out;
}

Answer 2

#include <iostream>

std::string remove_excessive_spaces(const std::string& str)
{
    std::string ret;

    for(std::size_t i = str.find_first_not_of(' '); i < str.size(); i++)
    {
        if(str[i] != ' ' || ret[ret.size() - 1] != ' ')
        {
            ret.push_back(str[i]);
        }
    }

    return ret;
}


int main()
{
    std::string sentence("    some weird  sentence  xd    ");

    std::cout<<sentence<<"\n";
    std::cout<<remove_excessive_spaces(sentence)<<"\n";

    return 0;
}

Answer 3

I use this little chunk of code frequently when my simulations read input from the command line or text files to ensure the data is clean. It makes use of the STL's copy_if() with a custom predicate. It reduces all inner whitespace to a single space, and removes all leading and trailing whitespace.

/* Removes inner whitespace from str_in */
string remove_excess_spaces(string str_in){
    //predicate class to use with copy_if
    //determines if a character should be copied based on if there is
    //a space following a non-space character
    class copy_space{
    public:
        copy_space() : was_last_space(true) {};

        bool operator()(char c) {
            if(!isspace(c)){
                was_last_space = false;
                return true;
            }
            else{
                if(was_last_space) return false;

                was_last_space = true;
                return true;
            }
        }
    private:
        bool was_last_space;
    } pred;

    //copy into single-spaced string
    string str;
    str.resize(str_in.size());
    auto it = std::copy_if(str_in.begin(), str_in.end(), str.begin(), pred);

    //remove trailing empty spots
    str = str.substr(0, it - str.begin());

    //convert all remaining whitespace to ' '. Accounts for tabs, miscelaneous newlines, etc.
    std::replace_if(str.begin(), str.end(), isspace, ' ');

    //remove any trailing whitespace
    if(isspace(str[str.size() - 1]))
        str.erase(str.size() - 1, 1);

    return str;
}

Play around with a working example here!

Answer 4

The standard library already has a function for searching consecutive elements in a range: search_n. With this function you can find the positions where a range of more than 2 whitespaces start. you can then erase this ws and go on, finding more consecutive whitespaces:

inline auto remove_triple_spaces(std::string str)
{    
    for(auto r = std::search_n(str.begin(), str.end(), 3, ' '); r != str.end(); r = std::search_n(r, str.end(), 3, ' '))
    {
        r = str.erase(r); // returns new iterator pointing to the 2nd ws. the first got erased        
    }   
    return str;
}

Removing the leading and trailing whitespaces is called trim. you can do it with std::find_if coming from the beginning and once from the end:

inline auto trim_ws(std::string s)
{
    // erase all trailing ws (start from the end for performance)
    auto one_past_last_non_ws = std::find_if(s.rbegin(), s.rend(), [](char c){ return c != ' '; }).base();
    s.erase(one_past_last_non_ws, s.end());

    //erase all leading ws
    auto first_non_ws = std::find_if(s.begin(), s.end(), [](char c){ return c != ' '; });   
    s.erase(s.begin(), first_non_ws);

    return s;
}

You can now combine both functions:

#include <string>
#include <iostream>
#include <algorithm>

inline auto trim_ws(std::string s)
{
    // erase all trailing ws
    auto one_past_last_non_ws = std::find_if(s.rbegin(), s.rend(), [](char c){ return c != ' '; }).base();
    s.erase(one_past_last_non_ws, s.end());

    //erase all leading ws
    auto first_non_ws = std::find_if(s.begin(), s.end(), [](char c){ return c != ' '; });   
    s.erase(s.begin(), first_non_ws);

    return s;
}

inline auto remove_triple_spaces(std::string str)
{    
    for(auto r = std::search_n(str.begin(), str.end(), 3, ' '); r != str.end(); r = std::search_n(r, str.end(), 3, ' '))
    {
        r = str.erase(r); // returns new iterator pointing to the 2nd ws. the first got erased        
    }   
    return str;
} 

int main()
{
    std::string s(" h sdf    fd das fdsf sd fallo ");
    std::cout << s << "\n";
    std::cout << remove_triple_spaces(trim_ws(s)) << "!\n";
    return 0;
}

Answer 5

So many lines of code . . .

Here the C++ standard solution using nested std::regex. With that, we get a one-liner.

Please see:

#include <iostream>
#include <string>
#include <regex>

int main()
{
    // Test string
    std::string s("   abc de  fg   hi    jk     lm  ");

    // First remove leading and trailing spaces, then remove too many spaces in between
    s = std::regex_replace(std::regex_replace(s, std::regex("^ +| +$|(\S+)"), "$1"), std::regex(" {3,}"), "  ");

    // Show result
    std::cout << s << '\n' << std::string(s.size(), '^') << '\n';

    return 0;
}

This is really not complicated: The inner regex, replaces

• The begin of text followed by
• one or more spaces

OR

• One or more spaces followed by
• end of text

with the orignal rest text. And with this new text, we go into the second regex, where we simply replace 3 or more spaces by 2 spaces.

Should be understandable. And is ultra short.