Removing items in list, python style and c++ style - c++

Question

I've been working on learning python and somehow came up with following codes:
for item in list:
while list.count(item)!=1:
list.remove(item)
I was wondering if this kind of coding can be done in c++. (Using list length for the for loop while decreasing its size) If not, can anyone tell me why?
Thanks!

Answer 1

I am not a big Python programmer, but it seems like the above code removes duplicates from a list. Here is a C++ equivalent:
list.sort();
list.unique();
As for modifying the list while iterating over it, you can do that as well. Here is an example:
for (auto it = list.begin(), eit = list.end(); it != eit; ) {
if (std::count(it, eit, *it) > 1)
it = list.erase(it);
else
++it;
}
Hope it helps.

Answer 2

In C++, you can compose something like this from various algorithms of the standard library, check out remove(), find(), However, the way your algorithm is written, it looks like O(n^2) complexity. Sorting the list and then scanning over it to put one of each value into a new list has O(n log n) complexity, but ruins the order.
In general, both for Python and C++, it is often better to copy or move elements to a temporary container and then swap with the original than modifying the original in-place. This is easier to get right since you don't step on your own feet (see delnan's comment) and it is faster because it avoids repeated reallocation and copying of objects.

Answer 3

Here's how I'd do it.
//If we will not delete an element of the list
for (std::list<MyType>::iterator it = MyList.begin(); it != MyList.end();++it)
{
//my operation here
}
//If we will delete an element of the list
for (std::list<MyType>::iterator it = MyList.begin(); it != MyList.end();)
{
std::list<MyType>::iterator itt = it;
++itt;
MyList.erase(it);
it = itt;
}
You can use the size of the list, but it is not comparable to [it] because [it].
Certain features of std:: data classes are enabled or disabled as a design decision. Sure, you can make your own function MyList[int i], but it will lead to a large speed gimp due to the nature of lists.

Answer 4

In C++ you can in some conditions remove elements from a container while iterating over it. This depends on the container and on the operation you want to do.
Currently there are different interpretations of your code snipplet in the different answers. My interpretation is, that you want to delete all the elements which exists more than once in the list.
Here is the solution in C++: it first counts the elements in another container (std::map) and removes the appropriate elements from the list afterwards.
#include <list>
#include <map>
#include <algorithm>
#include <iostream>
int main() {
std::list<int> li { 0, 1, 2, 3, 4, 5, 1, 2, 3, 2, 2 };
// Create count map: element -> count
std::map<int, int> cm;
std::for_each( li.begin(), li.end(), [&cm](int i) { ++cm[i]; } );
// Remove all elements from list with count > 1
std::for_each( cm.begin(), cm.end(),
[&li](std::pair<const int, int> const p) {
if( p.second > 1) {
li.remove( p.first );
}
} );
// Output all elements from remaining list
std::for_each( li.begin(), li.end(),
[](int i) { std::cout << i << std::endl; } );
return 0;
}

Answer 5

I don't know Python but someone said in a comment that a list is equivalent to a C++ vector and it is not sorted, so here goes....
std::vector<int> v{1, 2, 2, 2, 3, 3, 2, 2, 1};
v.erase(std::unique(v.begin(), v.end()), v.end());
v contains {1, 2, 3, 2, 1} after this code. If the goal is to remove all duplicates (not just consecutive duplicates) you'll have to sort the vector first: std::sort(v.begin(), v.end());

Answer 6

std::vector is the container in C++ that is most similar to Python's list, and here's the correct way to modify a vector while iterating it:
template <typename T>
void dedupe(std::vector<T> &vec) {
for (std::vector<T>::iterator it = vec.begin(); it != vec.end(); ) {
if (std::count(vev.begin(), vec.end(), *it) != 1) {
it = vec.erase(it);
} else {
++it;
}
}
}
It's not necessarily the most efficient way to dedupe, but it works.
Using list length for the for loop while decreasing its size
If you insist on using the length rather than the end(), then you can use an index instead of an iterator:
template <typename T>
void dedupe(std::vector<T> &vec) {
for (std::vector<T>::size_type pos = 0; pos != vec.size(); ) {
if (std::count(vec.begin(), vec.end(), vec[pos]) != 1) {
vec.erase(vec.begin() + pos);
} else {
++pos;
}
}
}
I'm assuming that the intention of your Python code is to remove all duplicates, by the way, and that the fact it doesn't is a bug. For example input [2,2,1,3,3,1,2,3], output [1,1,2,3]. If what you said is what you meant, then a direct translation of your code to C++ is:
template <typename T>
void dedupe(std::vector<T> &vec) {
for (std::vector<T>::size_type pos = 0; pos < vec.size(); ++pos) {
T item = vec[pos];
while (std::count(vec.begin(), vec.end(), item) != 1) {
vec.erase(std::find(vec.begin(), vec.end(), item));
}
}
}