need to reduce numbers similar an array (c ++) - c++

Question

there are sorted in descending order of an array, it is necessary that two identical elements disappear, and instead enter a single 1 more
like this:
[12 8 8 6 4 3 3] => [12 9 6 5 ]
I tried to like this but goes completely nonsense:
vector<int> v(c, c + mn);
for ( i = 0; i < mn; i++)
{
if (v[i] == v[i + 1])
{
v[i]++;
v.erase(v.begin() + i + 1);
i = 0;
}
for (auto&x : v)std::cout << x << ".";
}
P.S.:sorry for bad english

Answer 1

You have to make sure that you do not go out of bounds:
do not go until the last element to compare it with the non existing next one
take into consideration that the removal of an item shrinks the size of the vector.
So some minor corrections get it to work:
vector<int> v{12,8,8,6,4,3,3};
for (int i = 0; i < v.size()-1; i++)
{
if (v[i] == v[i + 1])
{
v[i]++;
v.erase(v.begin() + i + 1);
i = 0;
}
}
for (auto&x : v)std::cout << x << ".";
Online demo
To avoid the multiple passes, you could also start from the end:
for (int i = v.size()-2; i >=0; i--)
{
if (v[i] == v[i + 1])
{
v[i]++;
v.erase(v.begin() + i + 1);
}
}
EDIT:
#knivil's comment pointed out that more than 2 identical elements (for example 3 consecutive 8 instead of 2) could lead to inconsistencies in the vector (the final result being no longer sorted). Here a modified version if these multiple repetitions would be a valid case here a modified version (assuming that for n repetitions, it's still 1 more and not n-1 more):
for (int i = 0; i < v.size()-1; i++)
{
if (v[i] == v[i + 1])
{
while (i+1<v.size() && v[i+1]==v[i])
v.erase(v.begin() + i + 1);
v[i]++;
i = 0;
}
}
for (auto&x : v)std::cout << x << ".";
With a new online demo.
I leave you as an exercise to make the single pass reverse version ;-)

Answer 2

One route is to use a hash map to basically look at the frequency of each element. Then use the frequency information to increment data.
std::vector<int> result;
std::unordered_map<int, int> hashMap;
bool update = false;
for(auto cur : v) {
hashMap[cur]++; // intialize hash map with data
}
do {
update = false;
for (auto cur : hashMap) {
if (cur.second == 2) { // Process duplicate case
hashMap[cur.first + 1]++; // add the +1 element
hashMap.erase(cur.first); // remove the original
update = true; // set flag to perform another pass
}
}
} while(update);
for (auto cur : hashMap)
result.push_back(cur.first);
std::sort(result.begin(), result.end(), std::greater<int>());
v = result;
Try it here.

Answer 3

Here is another approach to the problem.
I have one std::vector incremented holding the values that are incremented if duplicates are found.
The while loop runs as long as there are duplicates to be removed, increments the found duplicate and adds it to the incremented vector.
The vector is being sorted after each run to ensure the values are being removed properly and so that the output shows correctly.
#include <iostream> // std::cout
#include <vector> // std::vector
#include <functional> // std::greater
#include <algorithm> // std::sort
bool remove_duplicates(std::vector<int>& vec, std::vector<int>& incremented)
{ // return true if there is work, false otherwise
bool work_done { false };
for (int i = 1; i < vec.size(); ++i) {
if (vec[i] == vec[i - 1]) {
incremented.push_back(vec[i] + 1);
auto it = vec.begin() + i;
vec.erase(it - 1, it + 1);
work_done = true;
}
}
return work_done;
}
auto main() -> int
{
std::vector<int> v { 12, 8, 8, 6, 4, 3, 3 };
std::vector<int> incremented;
while (remove_duplicates(v, incremented)) {
for (const auto& i : incremented)
v.push_back(i);
std::sort(v.begin(), v.end(), std::greater<int>());
incremented.clear();
}
// print result
for (const auto& i : v)
std::cout << i << " ";
}
Output: 12 9 6 5
Hope this appears useful.