vector of substrings

Code:

---

#include <iostream>

int main(int argc, char *argv[])
{
    std::string data("111001001110111010101110111011101110111|101011000010001010101000100000101010101|101001001110011011101110111000101110111|101001001000001000100010101000101010001|111011101110111000101110111000101110111");
    std::vector<std::string> fontMap;
    // How to fill the above vector with substrings from data, separated at '|' ?
    return 0;
}

---

Edit: Suggest a solution using only std stuff, please!

strtok perhaps?

--
Mats

dang!
strtok is C specific, works on char* mess! *_*
please C++ natural solution :)

Quote:

---

Originally Posted by manav

dang!
strtok is C specific, works on char* mess! *_*
please C++ natural solution :)

---

Well, I guess you'd have to write something like strtok() then - I personally would use strtok() on a copy of the string you get from c_str() - because it works well and doesn't cause any real problems.

But if you are "under no circumstances allowed to use <cstring>", then you will have to wait for one of those guys that can drum up clever STL stuff that will solve this - I don't know enough STL to solve it that way.

--
Mats

you are always quick with help Mats, thanks :)
you are right, i need some STL specific solution, even i do not know much of it.

other wise a simple solution would be to use strtok or something similar to get substrings, convert them to std::string and just push_back to std::vector, but that seems too tedious, i was thinking something better . . .

Quote:

---

Originally Posted by manav

you are always quick with help Mats, thanks :)
you are right, i need some STL specific solution, even i do not know much of it.

other wise a simple solution would be to use strtok or something similar to get substrings, convert them to std::string and just push_back to std::vector, but that seems too tedious, i was thinking something better . . .

---

Not too tedious [subject to bugs]:

Code:

---

char *d = new char[strlen(data.c_str())+1];
strcpy(d, data.c_str());
char *p = strtok(d, "|");
while(p) {
  fontMap.push_back(string(p));
  p = strtok(NULL, "|");
}

---

--
Mats

thanks Mats, that seems simpler, i can wrap the code in my choice of function, which i *really* missed in std::string class, something like:

Code:

---

std::vector<std::string> split(std::string data, std::string delim) {
        std::vector<std::string> vec;
        char *d = new char[strlen(data.c_str())+1];
        strcpy(d, data.c_str());
        char *p = strtok(d, delim.c_str());
        while(p) {
                vec.push_back(string(p));
                p = strtok(NULL, "|");
        }
        delete[] d;
        return vec;
}

---

Quote:

---

Originally Posted by manav

thanks Mats, that seems simpler, i can wrap the code in my choice of function, which i *really* missed in std::string class, something like:

---

Probably want this:

Code:

---

p = strtok(NULL, delim.c_str());

---

(Or create a "const char *cdelim = delim.c_str();" and use that.

--
Mats

oops! right! i missed it on the second call to strtok! *embarrased*

My solution:

Code:

---

        StringVector Split(const Strings::CStringEx& strToSplit, const Strings::CStringEx& strSplitWhat)
        {
                ppnew< std::vector<Strings::CStringEx> > pVector;
                UINT nLastIndex = 0;
                INT nIndex = 0;
                while (nIndex != -1)
                {
                        nIndex = strToSplit.Find(strSplitWhat, nLastIndex);
                        if (nIndex > -1)
                        {
                                //Strings::CStringEx strTemp = strToSplit.Mid(nLastIndex, nIndex - nLastIndex - 1);
                                //const TCHAR* str = strTemp;
                                pVector->push_back( strToSplit.Mid(nLastIndex, nIndex - nLastIndex) );
                                nLastIndex = (UINT)nIndex + strSplitWhat.GetLength();
                        }
                }
                pVector->push_back( strToSplit.Mid(nLastIndex) );
                return pVector;
        }
        typedef std::vector<Strings::CStringEx> StringVector;

---

It should work on std::string, as well, if you could find proper functions to replace mid and find with.
Or alternatively, I could public my string class once it's finished.

Ok, I'll have a go.. Back in a few minutes.

--
Mats

geez! Mats!!
i take my words *back*, the pure C++ version is more #h#o#r#r#i#b#l#e#

anyways thanks sweet Elysia! :D

Quote:

---

Originally Posted by manav

i take my words *back*, the pure C++ version is more #h#o#r#r#i#b#l#e#

---

Horrible? This is exactly what strtok does, except that this doesn't destroy the input string.
You only need to call the function instead of copying the code.
I'll make it part of my String class sometime, but right now it's self-standing.

Quote:

---

Originally Posted by matsp

Ok, I'll have a go.. Back in a few minutes.
--
Mats

---

i will also go now, gotta watch a favorite TV show of mine! :D
bye Elysia!

Code:

---

#include <iostream>
#include <vector>
#include <string>

int main(int argc, char *argv[])
{
    std::string data("111001001110111010101110111011101110111|"
                    "101011000010001010101000100000101010101|"
                    "101001001110011011101110111000101110111|"
                    "101001001000001000100010101000101010001|"
                    "111011101110111000101110111000101110111");
    std::vector<std::string> fontMap;
    size_t pos = 0;
    size_t oldpos = 0;
   
    for(;;)
    {
      pos = data.find('|', oldpos);
      std::cout << "pos = " << pos << std::endl;
      if (pos == data.npos)
      {
        fontMap.push_back(data.substr(oldpos));
        break;
      }
      fontMap.push_back(data.substr(oldpos, pos-oldpos));
      oldpos = pos+1;
    }
    for(std::vector<std::string>::size_type i = 0; i < fontMap.size(); i++)
    {
      std::cout << fontMap[i] << std::endl;
    }
    return 0;
}

---

--
Mats

Code:

---

std::vector<std::wstring> split( const std::wstring& text, wchar_t delimiter )
{
        std::vector<std::wstring> result;

        std::wstring::size_type start = 0;
        std::wstring::size_type end  = text.find( delimiter, start );

        while( end != wstring::npos )
        {
                std::wstring token = text.substr( start, end - start );

                result.push_back( token );

                start = end + 1;
                end  = text.find( delimiter, start );
        }

        result.push_back( text.substr( start ) );

        return result;
}

---

Quote:

---

Originally Posted by nvoigt

Code:

---

std::vector<std::wstring> split( const std::wstring& text, wchar_t delimiter )
{
        std::vector<std::wstring> result;

        std::wstring::size_type start = 0;
        std::wstring::size_type end  = text.find( delimiter, start );

        while( end != wstring::npos )
        {
                std::wstring token = text.substr( start, end - start );

                result.push_back( token );

                start = end + 1;
                end  = text.find( delimiter, start );
        }

        result.push_back( text.substr( start ) );

        return result;
}

---

---

Yeah, that's better than mine.

--
Mats

Why not use boost::tokenizer?

It seems that stringstream could be used too.

Code:

---

#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <algorithm>
#include <iterator>

void break_up(const std::string& s, char at, std::vector<std::string>& out)
{
    std::stringstream stream(s);
    std::string word;
    while (getline(stream, word, at)) {
        out.push_back(word);
    }
}


int main(int argc, char *argv[])
{
    std::string data("111001001110111010101110111011101110111|101011000010001010101000100000101010101|"
                    "101001001110011011101110111000101110111|101001001000001000100010101000101010001|1"
                    "11011101110111000101110111000101110111");
    std::vector<std::string> fontMap;
    break_up(data, '|', fontMap);
    std::copy(fontMap.begin(), fontMap.end(), std::ostream_iterator<std::string>(std::cout, "\n"));
    return 0;
}

---

Quote:

---

Thank you, anon. You sure know how to recognize different types of trees from quite a long way away.

---

Thanks all, for such nice & neat examples :)

Dang!
This is just 31 lines Python code, which is driving me nuts, when I am trying to do it in C++ *_*

With the help of you people, I figured that how to do this simple thing in Pyhton, in C++:
fontMap='101010|001010|001011'.split('|')

Now I am again stuck, actually not really out of ideas, since, I honestly admit, that I can write the same program in asm also (I have done, similar stuff before), but, just seeing how convoluted it becomes, even when, I am trying to use a really high level language! :(

There is my code, for curious, and for those C++ legends, which will help me do the same code in C++, but in below 50 lines (I hope):

Code:

---

# aa.py

import sys

fontMap = "111001001110111010101110111011101110111|"\
"101011000010001010101000100000101010101|"\
"101001001110011011101110111000101110111|"\
"101001001000001000100010101000101010001|"\
"111011101110111000101110111000101110111".split('|')

W=4

if len(sys.argv) != 2:
        print "Usage\n\taa.py <number>"
        sys.exit(1)
else:
        number = sys.argv[1]


for row in fontMap:
        line = ''
        for d in number:
                if d not in '0123456789':
                        print 'Error: Only digits allowed!'
                        sys.exit(1)
                i1 = int(d) * W
                i2 = i1 + W
                line += row[i1:i2]
                if d == '9': line += ' '
        line = line.replace('0', ' ')
        line = line.replace('1', '@')
        print line

sys.exit(0)

---

Using anon's function:

Code:

---

std::vector<std::string> fontMap;
break_up(data, '|', fontMap);
for (int i = 0; i < fontMap.size(); i++)
{
    std::string line = fontMap[i];
}

---

I don't understand what the code (your python) is supposed to do, though, so... >_<

Yeah, I know that, anon, you, Mats and others gave me the solution, for, how to split a string into an substrings array.

Code:

---

fontMap = "111001001110111010101110111011101110111|"\
"101011000010001010101000100000101010101|"\
"101001001110011011101110111000101110111|"\
"101001001000001000100010101000101010001|"\
"111011101110111000101110111000101110111".split('|')


---

So the above part is taken care of! :)

Now, leave the argv check and usage part, and come to the for ... for (nested) loops.
I could use simple facilities of Python which are sorely lacking in vector, string etc in C++!
Double dang!! So much for the efficiency of C++ :(

STL's classes are lacking and difficult to use ;)
Still in the dark about what you're trying to do, however.

Quote:

---

Originally Posted by Elysia

STL's classes are lacking and difficult to use ;)
Still in the dark about what you're trying to do, however.

---

Well I am trying to print numbers, given on command line, in this format:

Code:

---

@@@  @  @@@ @@@ @ @ @@@ @@@ @@@ @@@ @@@
@ @ @@    @  @ @ @ @  @    @ @ @ @ @
@ @  @  @@@  @@ @@@ @@@ @@@  @ @@@ @@@
@ @  @  @    @  @  @ @ @  @ @ @  @
@@@ @@@ @@@ @@@  @ @@@ @@@  @ @@@ @@@

---

By the way my data in fontMap is put in that way, so as to avoid detection, of what the heck is in fontMap :D

Well, how about something like:

Code:

---

std::vector<Strings::CStringEx> fontMap;
break_up(data, '|', fontMap);
for (int i = 0; i < fontMap.size(); i++)
{
    Strings::CStringEx line = fontMap[i];
    line.Replace("1", "@");
    line.Replace("0", " ");
    for (uint32_t i = 0; i < line.GetLength(); i++)
        cout << line[i];
    cout << "\n";
}

---

=)
Or replace with your QString or whatever.
std::string is too lacking.

MuwaahhahhahHahaHAHhahHAAHAHhahahhhaaaaa!
You are so unbelievably *silly* X-(

That is not, not by faaaaaaaaaaar close, to, what I was doing!!!

Duh, I don't understand python.
Plus you're making is far too complex - far more than it needs to be.

Hurray! I made it, in C, less than 50 lines of code :)
Actually Python has indentation rule advantage, but in C only braces are taking 12 lines, here is my code at 49 lines :) (49 - 12 = 37, not bad, just six more than Python version)

Code:

---

#include <stdio.h>
#include <string.h>
#include <ctype.h>

const char *fontMap[] = {
"1110010011101110101011101110111011101110",
"1010110000100010101010001000001010101010",
"1010010011100110111011101110001011101110",
"1010010010000010001000101010001010100010",
"1110111011101110001011101110001011101110",
};

const int FONT_WIDTH = 4;
const int FONT_HEIGHT = 5;

int main(int argc, char *argv[])
{
    const char *number;
    int row, col, len, i1, i2;
   
    if (argc != 2)
    {
        printf("Usage\n\taa.py <number>\n");
        return 1;
    }
    number = argv[1];
    len = strlen(number);
    for (row=0; row<FONT_HEIGHT; row++)
    {
        for (col=0; col<len; col++)
        {
            if (! isdigit(number[col]))
            {
                printf("Error: Only digits allowed!\n");
                return 1;
            }
            i1 = (number[col]-'0') * FONT_WIDTH;
            i2 = i1 + FONT_WIDTH;
            while (i1 < i2)
            {
                putchar(fontMap[row][i1]=='0' ? ' ' : '@');
                i1++;
            }
        }
        putchar('\n');
    }
    return 0;
}

---

I shouldn't have to say this to you, but... Use better variable names!
And here's another one for you: http://cpwiki.sourceforge.net/Common...kes_and_errors

Edited! Thanks! I thought at least I should not post *BAD* examples for new programmers :)

Code:

---

#include <iostream>

const char fontMap[][5][4] =
{
        {
                "XXX",
                "X X",
                "X X",
                "X X",
                "XXX"
        },
        {
                " X ",
                "XX ",
                " X ",
                " X ",
                "XXX"
        },
        {
                "XXX",
                "  X",
                "XXX",
                "X  ",
                "XXX"
        },
        {
                "XXX",
                "  X",
                "XXX",
                "  X",
                "XXX"
        },
        {
                "X X",
                "X X",
                "XXX",
                "  X",
                "  X"
        },
        {
                "XXX",
                "X  ",
                "XXX",
                "  X",
                "XXX"
        },
        {
                "XXX",
                "X  ",
                "XXX",
                "X X",
                "XXX"
        },
        {
                "XXX",
                "  X",
                "  X",
                "  X",
                "  X"
        },
        {
                "XXX",
                "X X",
                "XXX",
                "X X",
                "XXX"
        },
        {
                "XXX",
                "X X",
                "XXX",
                "  X",
                "XXX",
        }
};

const int FONT_HEIGHT = 5;

using std::cout;

int main(int argc, char *argv[])
{
        if (argc != 2)
        {
                printf("Usage\n\taa.py <number>\n");
                return 1;
        }
        long number = strtol(argv[1], NULL, 10);
        if (number == 0 && argv[1][0] != '0')
        {
                cout << "Error: Only digits allowed!\n";
                return 1;
        }
        int length = strlen(argv[1]);
        for (int j = 0; j < FONT_HEIGHT; j++) // For every line of the font array
        {
                for (int i = 0; i < length; i++) // For every number of the command argument
                {
                        int number = argv[1][i] - '0';
                        cout << fontMap[number][j] << " ";
                }
                cout << "\n";
        }
        return 0;
}

---

Yes, it's longer, but wow is it easier to understand and use!

:&#112; pppppppp

Do you also mean that your version does exactly the same as my version?? :D

Yes it does. I took your version and modified it.

This is my output, for 5577:

Code:

---

@@@ @@@ @@@ @@@
@  @    @  @
@@@ @@@  @  @
  @  @  @  @
@@@ @@@  @  @

---

Post your output??

That's an entirely different issue. Your code was confusing as it is.
I'll do a few modifications and you'll see it will work fine.

123456789:

Code:

---

X  XXX XXX X X XXX XXX XXX XXX XXX
XX    X  X X X X  X    X X X X X
 X  XXX XXX XXX XXX XXX  X XXX XXX
 X  X    X  X  X X X  X X X  X
XXX XXX XXX  X XXX XXX  X XXX XXX

---

Honestly yours came out simpler and better, because you arranged the font map better!
But that was my point, I wanted to make it obfuscated, so that font map does not give away the looks of fonts! :(

Pfft.
Readability comes before obfuscation =)

Oh, and by the way I can change my font style from 'X' to '@' to '#' to 'M' by changing a single char in the code!

Can you?? :D

Yes, using search & replace.

How?

Search & replace in your IDE. Find X, replace with 'whatever'.

You are lucky that there is no other 'X' except in your font map :D

Well, all I do is tell the IDE to search and replace with the selection which is all the map.

How about doing this:

Code:

---

555 555 777 777
5  5    7  7
555 555  7  7
  5  5  7  7
555 555  7  7

---

I just had to change:

Code:

---

putchar(fontMap[row][i1]=='0' ? ' ' : number[col]);

---

:D

-_-
Let's stop playing.

:&#112; ok :D

Code:

---

#include <iostream>
#include <string>
#include <cctype>

int main(int argc, char *argv[])
{
        if (argc != 2)
        {
                std::cout << "Usage\n\taa.py <number>" << std::endl;
                return 1;
        }
        std::string fontMap[] = {
                std::string("###  #  ### ### # # ### ### ### ### ### "),
                std::string("# # ##    #  # # # #  #    # # # # # "),
                std::string("# #  #  ###  ## ### ### ###  # ### ### "),
                std::string("# #  #  #    #  #  # # #  # # #  # "),
                std::string("### ### ### ###  # ### ###  # ### ### ")
        };
        const int FONT_WIDTH = 4;
        const int FONT_HEIGHT = 5;
        std::string number(argv[1]);
        for (int row=0; row<FONT_HEIGHT; row++)
        {
                for (int col=0; col<number.length(); col++)
                {
                        if (! isdigit(number[col]))
                        {
                                std::cout << "Error: Only digits allowed!" << std::endl;
                                return 1;
                        }
                        int i1 = (number[col]-'0') * FONT_WIDTH;
                        int i2 = i1 + FONT_WIDTH;
                        while (i1 < i2)
                        {
                                std::cout << fontMap[row][i1];
                                i1++;
                        }
                }
                std::cout << std::endl;
        }
        return 0;
}

---