-4

I'm trying to make a program wich will sort my inputed text by letters I want. For example, the input: Vvb Abv Abvgd Aaa should result in the following list:

  1. Aaa
  2. Abv
  3. Abvgd
  4. Vvb

I think I explained it so you can get it, I want to make custom list like: A,B,V,G,D... and to sort inputed text by that way, and to Aa is before Ab Just give me 1 example how to do it.

Here is my code, I tried to make by giving the points to each letter and then sort it by bubble sort but its not working good, is some situations the word which must be first has more points then that word witch must go before first

using namespace std;
string str = "";
int founded = 0;
int prezime = 0;

//---A---
string a1[20];
int af1 = 1;
int ap1[20];
//---B---

void bubble_sort(int arr[], int n, string arr2[])
{
    for (int i = 0; i < n; ++i)
    for (int j = 0; j < n - i - 1; ++j)
    if (arr[j] > arr[j + 1])
    {
        int temp = arr[j];
        string temp2 = a1[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
        arr2[j] = arr2[j + 1];
        arr2[j + 1] = temp2;
    }
}

int main()
{
    wcout << L"Type words:\n>";
    getline(cin, str);

    for (unsigned int araz = 0; araz < str.size(); araz++) {
        if (str[araz] == ' ') {
            founded = 0;
            af1++;
            continue;
        }
        if (founded == 0) {
            if (str[araz] == 'A') {
                founded = 1;
                ap1[af1] += 1;
                a1[af1] += str[araz];
            }
        }
        else {
            a1[af1] += str[araz];
        }
    }
    for (unsigned int araz2 = 1; araz2 < str.size(); araz2++) {
        int duzina = a1[araz2].length();
        if (duzina > 0) {
            if (a1[araz2][0] == 'A') {
                if (duzina > 1) {
                    if (a1[araz2][1] == 'a') ap1[araz2] += 2;
                    if (a1[araz2][1] == 'b') ap1[araz2] += 3;
                    if (a1[araz2][1] == 'v') ap1[araz2] += 4;
                    if (a1[araz2][1] == 'g') ap1[araz2] += 5;
                    if (a1[araz2][1] == 'd') ap1[araz2] += 6;
                    if (a1[araz2][1] == 'dj') ap1[araz2] += 7;
                    if (a1[araz2][1] == 'e') ap1[araz2] += 8;
                    if (a1[araz2][1] == 'zz') ap1[araz2] += 9;
                    if (a1[araz2][1] == 'z') ap1[araz2] += 10;
                    if (a1[araz2][1] == 'i') ap1[araz2] += 11;
                    if (a1[araz2][1] == 'j') ap1[araz2] += 12;
                    if (a1[araz2][1] == 'k') ap1[araz2] += 13;
                    if (a1[araz2][1] == 'l') ap1[araz2] += 14;
                    if (a1[araz2][1] == 'lj') ap1[araz2] += 15;
                    if (a1[araz2][1] == 'm') ap1[araz2] += 16;
                    if (a1[araz2][1] == 'n') ap1[araz2] += 17;
                    if (a1[araz2][1] == 'nj') ap1[araz2] += 18;
                    if (a1[araz2][1] == 'o') ap1[araz2] += 19;
                    if (a1[araz2][1] == 'p') ap1[araz2] += 20;
                    if (a1[araz2][1] == 'r') ap1[araz2] += 21;
                    if (a1[araz2][1] == 's') ap1[araz2] += 22;
                    if (a1[araz2][1] == 't') ap1[araz2] += 23;
                    if (a1[araz2][1] == 'c') ap1[araz2] += 24;
                    if (a1[araz2][1] == 'u') ap1[araz2] += 25;
                    if (a1[araz2][1] == 'f') ap1[araz2] += 26;
                    if (a1[araz2][1] == 'h') ap1[araz2] += 27;
                    if (a1[araz2][1] == 'c') ap1[araz2] += 28;
                    if (a1[araz2][1] == 'c') ap1[araz2] += 29;
                    if (a1[araz2][1] == 'dz') ap1[araz2] += 30;
                    if (a1[araz2][1] == 's') ap1[araz2] += 31;
                }
                if (duzina > 2) {
                    if (a1[araz2][2] == 'a') ap1[araz2] += 3;
                    if (a1[araz2][2] == 'b') ap1[araz2] += 4;
                    if (a1[araz2][2] == 'v') ap1[araz2] += 5;
                    if (a1[araz2][2] == 'g') ap1[araz2] += 6;
                    if (a1[araz2][2] == 'd') ap1[araz2] += 7;
                    if (a1[araz2][2] == 'dj') ap1[araz2] += 8;
                    if (a1[araz2][2] == 'e') ap1[araz2] += 9;
                    if (a1[araz2][2] == 'zz') ap1[araz2] += 10;
                    if (a1[araz2][2] == 'z') ap1[araz2] += 11;
                    if (a1[araz2][2] == 'i') ap1[araz2] += 12;
                    if (a1[araz2][2] == 'j') ap1[araz2] += 13;
                    if (a1[araz2][2] == 'k') ap1[araz2] += 14;
                    if (a1[araz2][2] == 'l') ap1[araz2] += 15;
                    if (a1[araz2][2] == 'lj') ap1[araz2] += 16;
                    if (a1[araz2][2] == 'm') ap1[araz2] += 17;
                    if (a1[araz2][2] == 'n') ap1[araz2] += 18;
                    if (a1[araz2][2] == 'nj') ap1[araz2] += 19;
                    if (a1[araz2][2] == 'o') ap1[araz2] += 20;
                    if (a1[araz2][2] == 'p') ap1[araz2] += 21;
                    if (a1[araz2][2] == 'r') ap1[araz2] += 22;
                    if (a1[araz2][2] == 's') ap1[araz2] += 23;
                    if (a1[araz2][2] == 't') ap1[araz2] += 24;
                    if (a1[araz2][2] == 'c') ap1[araz2] += 25;
                    if (a1[araz2][2] == 'u') ap1[araz2] += 26;
                    if (a1[araz2][2] == 'f') ap1[araz2] += 27;
                    if (a1[araz2][2] == 'h') ap1[araz2] += 28;
                    if (a1[araz2][2] == 'c') ap1[araz2] += 29;
                    if (a1[araz2][2] == 'c') ap1[araz2] += 30;
                    if (a1[araz2][2] == 'dz') ap1[araz2] += 31;
                    if (a1[araz2][2] == 's') ap1[araz2] += 32;
                }
                if (duzina > 3) {
                    if (a1[araz2][3] == 'a') ap1[araz2] += 4;
                    if (a1[araz2][3] == 'b') ap1[araz2] += 5;
                    if (a1[araz2][3] == 'v') ap1[araz2] += 6;
                    if (a1[araz2][3] == 'g') ap1[araz2] += 7;
                    if (a1[araz2][3] == 'd') ap1[araz2] += 8;
                    if (a1[araz2][3] == 'dj') ap1[araz2] += 9;
                    if (a1[araz2][3] == 'e') ap1[araz2] += 10;
                    if (a1[araz2][3] == 'zz') ap1[araz2] += 11;
                    if (a1[araz2][3] == 'z') ap1[araz2] += 12;
                    if (a1[araz2][3] == 'i') ap1[araz2] += 13;
                    if (a1[araz2][3] == 'j') ap1[araz2] += 14;
                    if (a1[araz2][3] == 'k') ap1[araz2] += 15;
                    if (a1[araz2][3] == 'l') ap1[araz2] += 16;
                    if (a1[araz2][3] == 'lj') ap1[araz2] += 17;
                    if (a1[araz2][3] == 'm') ap1[araz2] += 18;
                    if (a1[araz2][3] == 'n') ap1[araz2] += 19;
                    if (a1[araz2][3] == 'nj') ap1[araz2] += 20;
                    if (a1[araz2][3] == 'o') ap1[araz2] += 21;
                    if (a1[araz2][3] == 'p') ap1[araz2] += 22;
                    if (a1[araz2][3] == 'r') ap1[araz2] += 23;
                    if (a1[araz2][3] == 's') ap1[araz2] += 24;
                    if (a1[araz2][3] == 't') ap1[araz2] += 25;
                    if (a1[araz2][3] == 'c') ap1[araz2] += 26;
                    if (a1[araz2][3] == 'u') ap1[araz2] += 27;
                    if (a1[araz2][3] == 'f') ap1[araz2] += 28;
                    if (a1[araz2][3] == 'h') ap1[araz2] += 29;
                    if (a1[araz2][3] == 'c') ap1[araz2] += 30;
                    if (a1[araz2][3] == 'c') ap1[araz2] += 31;
                    if (a1[araz2][3] == 'dz') ap1[araz2] += 32;
                    if (a1[araz2][3] == 's') ap1[araz2] += 33;
                }
                if (duzina > 4) {
                    if (a1[araz2][4] == 'a') ap1[araz2] += 5;
                    if (a1[araz2][4] == 'b') ap1[araz2] += 6;
                    if (a1[araz2][4] == 'v') ap1[araz2] += 7;
                    if (a1[araz2][4] == 'g') ap1[araz2] += 8;
                    if (a1[araz2][4] == 'd') ap1[araz2] += 9;
                    if (a1[araz2][4] == 'dj') ap1[araz2] += 10;
                    if (a1[araz2][4] == 'e') ap1[araz2] += 11;
                    if (a1[araz2][4] == 'zz') ap1[araz2] += 12;
                    if (a1[araz2][4] == 'z') ap1[araz2] += 13;
                    if (a1[araz2][4] == 'i') ap1[araz2] += 14;
                    if (a1[araz2][4] == 'j') ap1[araz2] += 15;
                    if (a1[araz2][4] == 'k') ap1[araz2] += 16;
                    if (a1[araz2][4] == 'l') ap1[araz2] += 17;
                    if (a1[araz2][4] == 'lj') ap1[araz2] += 18;
                    if (a1[araz2][4] == 'm') ap1[araz2] += 19;
                    if (a1[araz2][4] == 'n') ap1[araz2] += 20;
                    if (a1[araz2][4] == 'nj') ap1[araz2] += 21;
                    if (a1[araz2][4] == 'o') ap1[araz2] += 22;
                    if (a1[araz2][4] == 'p') ap1[araz2] += 23;
                    if (a1[araz2][4] == 'r') ap1[araz2] += 24;
                    if (a1[araz2][4] == 's') ap1[araz2] += 25;
                    if (a1[araz2][4] == 't') ap1[araz2] += 26;
                    if (a1[araz2][4] == 'c') ap1[araz2] += 27;
                    if (a1[araz2][4] == 'u') ap1[araz2] += 28;
                    if (a1[araz2][4] == 'f') ap1[araz2] += 29;
                    if (a1[araz2][4] == 'h') ap1[araz2] += 30;
                    if (a1[araz2][4] == 'c') ap1[araz2] += 31;
                    if (a1[araz2][4] == 'c') ap1[araz2] += 32;
                    if (a1[araz2][4] == 'dz') ap1[araz2] += 33;
                    if (a1[araz2][4] == 's') ap1[araz2] += 34;
                }
                if (duzina > 5) {
                    if (a1[araz2][5] == 'a') ap1[araz2] += 6;
                    if (a1[araz2][5] == 'b') ap1[araz2] += 7;
                    if (a1[araz2][5] == 'v') ap1[araz2] += 8;
                    if (a1[araz2][5] == 'g') ap1[araz2] += 9;
                    if (a1[araz2][5] == 'd') ap1[araz2] += 10;
                    if (a1[araz2][5] == 'dj') ap1[araz2] += 11;
                    if (a1[araz2][5] == 'e') ap1[araz2] += 12;
                    if (a1[araz2][5] == 'zz') ap1[araz2] += 13;
                    if (a1[araz2][5] == 'z') ap1[araz2] += 14;
                    if (a1[araz2][5] == 'i') ap1[araz2] += 15;
                    if (a1[araz2][5] == 'j') ap1[araz2] += 16;
                    if (a1[araz2][5] == 'k') ap1[araz2] += 17;
                    if (a1[araz2][5] == 'l') ap1[araz2] += 18;
                    if (a1[araz2][5] == 'lj') ap1[araz2] += 19;
                    if (a1[araz2][5] == 'm') ap1[araz2] += 20;
                    if (a1[araz2][5] == 'n') ap1[araz2] += 21;
                    if (a1[araz2][5] == 'nj') ap1[araz2] += 22;
                    if (a1[araz2][5] == 'o') ap1[araz2] += 23;
                    if (a1[araz2][5] == 'p') ap1[araz2] += 24;
                    if (a1[araz2][5] == 'r') ap1[araz2] += 25;
                    if (a1[araz2][5] == 's') ap1[araz2] += 26;
                    if (a1[araz2][5] == 't') ap1[araz2] += 27;
                    if (a1[araz2][5] == 'c') ap1[araz2] += 28;
                    if (a1[araz2][5] == 'u') ap1[araz2] += 29;
                    if (a1[araz2][5] == 'f') ap1[araz2] += 30;
                    if (a1[araz2][5] == 'h') ap1[araz2] += 31;
                    if (a1[araz2][5] == 'c') ap1[araz2] += 32;
                    if (a1[araz2][5] == 'c') ap1[araz2] += 33;
                    if (a1[araz2][5] == 'dz') ap1[araz2] += 34;
                    if (a1[araz2][5] == 's') ap1[araz2] += 35;
                }
                if (duzina > 6) {
                    if (a1[araz2][6] == 'a') ap1[araz2] += 7;
                    if (a1[araz2][6] == 'b') ap1[araz2] += 8;
                    if (a1[araz2][6] == 'v') ap1[araz2] += 9;
                    if (a1[araz2][6] == 'g') ap1[araz2] += 10;
                    if (a1[araz2][6] == 'd') ap1[araz2] += 11;
                    if (a1[araz2][6] == 'dj') ap1[araz2] += 12;
                    if (a1[araz2][6] == 'e') ap1[araz2] += 13;
                    if (a1[araz2][6] == 'zz') ap1[araz2] += 14;
                    if (a1[araz2][6] == 'z') ap1[araz2] += 15;
                    if (a1[araz2][6] == 'i') ap1[araz2] += 16;
                    if (a1[araz2][6] == 'j') ap1[araz2] += 17;
                    if (a1[araz2][6] == 'k') ap1[araz2] += 18;
                    if (a1[araz2][6] == 'l') ap1[araz2] += 19;
                    if (a1[araz2][6] == 'lj') ap1[araz2] += 20;
                    if (a1[araz2][6] == 'm') ap1[araz2] += 21;
                    if (a1[araz2][6] == 'n') ap1[araz2] += 22;
                    if (a1[araz2][6] == 'nj') ap1[araz2] += 23;
                    if (a1[araz2][6] == 'o') ap1[araz2] += 24;
                    if (a1[araz2][6] == 'p') ap1[araz2] += 25;
                    if (a1[araz2][6] == 'r') ap1[araz2] += 26;
                    if (a1[araz2][6] == 's') ap1[araz2] += 27;
                    if (a1[araz2][6] == 't') ap1[araz2] += 28;
                    if (a1[araz2][6] == 'c') ap1[araz2] += 29;
                    if (a1[araz2][6] == 'u') ap1[araz2] += 30;
                    if (a1[araz2][6] == 'f') ap1[araz2] += 31;
                    if (a1[araz2][6] == 'h') ap1[araz2] += 32;
                    if (a1[araz2][6] == 'c') ap1[araz2] += 33;
                    if (a1[araz2][6] == 'c') ap1[araz2] += 34;
                    if (a1[araz2][6] == 'dz') ap1[araz2] += 35;
                    if (a1[araz2][6] == 's') ap1[araz2] += 36;
                }
                if (duzina >= 7) ap1[araz2] += 1;
                if (duzina >= 8) ap1[araz2] += 1;
                if (duzina >= 9) ap1[araz2] += 1;
                if (duzina >= 10) ap1[araz2] += 1;
                if (duzina >= 11) ap1[araz2] += 1;
                if (duzina >= 12) ap1[araz2] += 1;
                if (duzina >= 13) ap1[araz2] += 1;
                if (duzina >= 14) ap1[araz2] += 1;
                if (duzina >= 15) ap1[araz2] += 1;
                if (duzina >= 16) ap1[araz2] += 1;
                if (duzina >= 17) ap1[araz2] += 1;
                if (duzina >= 18) ap1[araz2] += 1;
                if (duzina >= 19) ap1[araz2] += 1;
                if (duzina >= 20) ap1[araz2] += 1;
            }
        }
    }

    int n = sizeof (ap1) / sizeof (ap1[0]);
    bubble_sort(ap1, n, a1);
    for (int i = 1; i < n; ++i) {
        //cout << ap1[i] << endl;
        //cout << a1[i] << endl;
        if (ap1[i] != 0) {
            cout << endl;
            cout << ap1[i];
            cout << a1[i] << endl;
        }
    }
    system("PAUSE");
    return 0;
}
niklasfi
  • 15,245
  • 7
  • 40
  • 54
Vuzimir Samp
  • 41
  • 1
  • 9
  • 1
    Did you try to do something? Do you have some code to show? The people here won't do your homework buddy – Astinog Sep 07 '15 at 06:50
  • You should better ask this on some coding forums. – VP. Sep 07 '15 at 06:53
  • 2
    You didn't explain you custom sort, you just gave an example of a generic sort and then you mention a custom list. – stefaanv Sep 07 '15 at 06:57
  • 1
    `I'm trying to make a program ` - Yes you are, we are not, provide code where you are stuck or get an error. Else you cannot expect someone to write all for you. – Blacktempel Sep 07 '15 at 06:57
  • 1
    [Don't use `system("PAUSE")`](http://stackoverflow.com/questions/1107705/systempause-why-is-it-wrong) – RamblingMad Sep 07 '15 at 07:18
  • Here u go code, in my post... @CoffeeandCode ahh ok, i can fix that later, but i have bigger problem with this ranking system... S – Vuzimir Samp Sep 07 '15 at 07:18
  • @VuzimirSamp Do you want to implement a [lexicographical sort](https://en.wikipedia.org/wiki/Lexicographical_order) with a permutated letter ordering? – niklasfi Sep 07 '15 at 07:19
  • @niklasfi Yeah, im trying to do something like that, to give points to letters by my order and then short them, but i always have problem with ranking system not working propertly – Vuzimir Samp Sep 07 '15 at 07:22
  • @stefaanv here is my code, u can see it now and i think u will get it, im trying to sort words by "Azbuka" – Vuzimir Samp Sep 07 '15 at 07:31
  • @Blacktempel Here is my code, and problem is in ranking system by letters, like some letters will give me more points and that whole word need to go first and it wont cuz some letters give more points :S – Vuzimir Samp Sep 07 '15 at 07:32

1 Answers1

3

I suggest you use std::sort form the <algorithm> header. It allows you to pass your own sorting operator. In this operator you have to define your ordering. Your ordering should look something like this:

char value(char inp){
  if (inp == 'A')
    return 0;
  if (inp == 'B')
    return 1;
  if (inp == 'V')
    return 2;
  if (inp == 'G')
    return 3;
  if (inp == 'D')
    return 4;
  ...
} 

struct comp {
  bool operator()(const std::string& s1, const std::string& s2) {
    for(size_t i = 0; i < std::min(s1.size(), s2.size()) && value(s1[i]) == value(s2[i]); ++i)
      ;
    if (value(s1[i]) == value(s2[i]))
      return s1.size() < s2.size();
    return value(s1[i]) < value(s2[i]);
  }
};

There is even std::lexicograpical_compare, which you can use:

bool value_lt(char v1, char v2){
  return v1 < v2;
}

struct comp {
  bool operator()(const std::string& s1, const std::string& s2) {
    return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(), value_lt);
  }
};

If what you are trying to do really is getting a better understanding of bubblesort, I suggest you try to figure it out with the standard ordering first, and then abstract the ordering away to make use of one of the comparisons I just outlined.

niklasfi
  • 15,245
  • 7
  • 40
  • 54