How to restore consecutive enumeration

[serge]

Hello all

I am a bit stuck with the following task. I have an array of groups of numbers (I call them classes), that might look like this:

static const int arr[] = {1,1,3,3};
std::vector<int> classes( arr , arr + sizeof(arr) / sizeof( arr[ 0 ] ) );

or like this

static const int arr[] = {1,3,3,3,5,5,6,8};
std::vector<int> classes( arr , arr + sizeof(arr) / sizeof( arr[ 0 ] ) );

The groups of numbers are in an increasing order, but not numbered consecutively. So, would I would like to have is this

1,1,2,2

and

1,2,2,2,3,3,4,5

A loop like this

for ( int i = 1; i < classes.size(); i++ )
    if ( classes.at( i ) > classes.at( i - 1 ) )
      classes.at( i ) = classes.at( i - 1 ) + 1;

does not work, because it changes the preceding value in the group, thus destroying the group. How would you do it?

Thank you for your help!

[whiteflags]

I'm not really sure how the ordering works yet, but since the grouping is significant one way is to add another dimension.

typedef vector<int> group;
vector<group> classes;
{
   int a[] = {1,1,2,2};
   int b[] = {1,2,2,2,3,3,4,5};
   classes.push_back(group(a, a + sizeof(a) / sizeof(a[0])));
   classes.push_back(group(b, b + sizeof(b) / sizeof(b[0])));
}

C++11 has something called initializer lists that makes this a lot less tedious. It would not surprise me if this worked:

typedef vector<int> group;
vector<group> classes{ {1,1,2,2}, {1,2,2,2,3,3,4,5}};

[serge]

I think its more trivial than this. There is just one dimension (I provided two examples). I just need consecutive enumeration in the vector. I thought making a copy of the original vector (now temp) should solve the problem of overwriting the previous value:

static const int arr[] = {1,3,3,3,5,5,6,8};
std::vector<int> temp( arr , arr + sizeof(arr) / sizeof( arr[ 0 ] ) );

std::vector<int> classes( temp );
for ( int i = 1; i < classes.size(); i++ )
    if ( temp.at( i ) > temp.at( i - 1 ) )
        classes.at( i ) = temp.at( i - 1 ) + 1;

but somehow it does not.

[phantomotap]

O_o

You keep saying "consecutive enumeration", but I have no idea what you are really asking.

Do you just want to modify the values so that the values stored become consecutive?

Soma

[whiteflags]

And how is a list sorted in ascending order any less consecutive?

[serge]

O_o

You keep saying "consecutive enumeration", but I have no idea what you are really asking.

Do you just want to modify the values so that the values stored become consecutive?

Soma

Yes!! So vector: 1,3,3,3,5,5,6,8

has 5 subsequences of equal values {1}, {3,3,3}, {5,5}, {6}, {8}
therefore the correct values should read: 1,2,2,2,3,3,4,5

[phantomotap]

Yes!!

O_o

Look at your example code.

You've done nothing to account for the indices of a given group; you are only looking at any two indices.

Can you think of how you might account for the difference between the target value and current value?
Can you think of how you might find the indices--the first and last index--of a given group?

Soma

[serge]

And how is a list sorted in ascending order any less consecutive?

its increasing, but not consecutive, because the step size is not 1

[serge]

O_o

Look at your example code.

You've done nothing to account for the indices of a given group; you are only looking at any two indices.

Can you think of how you might account for the difference between the target value and current value?
Can you think of how you might find the indices--the first and last index--of a given group?

Soma

ok, I got it. I missed and else statement:

static const int arr[] = {1,3,3,3,5,5,6,8};
std::vector<int> temp( arr , arr + sizeof(arr) / sizeof( arr[ 0 ] ) );
 
std::vector<int> classes( temp );
for ( int i = 1; i < classes.size(); i++ )
    if ( temp.at( i ) > temp.at( i - 1 ) )
        classes.at( i ) = classes.at( i - 1 ) + 1;
    else
        classes.at( i ) = classes.at( i - 1 );

[grumpy]

Just out of curiosity, if the first element of your initial array is 42, what do you expect the first element to be after doing that?