Remove duplicates from Sorted Array - c++

Question

Qus: Remove duplicates from Sorted Array
Given a sorted array, remove the duplicates in place such that each element appears only once and return the new length.
Note that even though we want you to return the new length, make sure to change the original array as well in place
Do not allocate extra space for another array, you must do this in place with constant memory.
I tried following code, can anyone help where I am going wrong??
#include<iostream>
#include<vector>
using namespace std;
int removeDuplicates(vector<int> &A) {
int m=A.size();
if(m<=1) return m;
vector<int> :: iterator i=A.begin();
vector<int> :: iterator j=A.begin()+1;
vector<int> :: iterator temp;
while(i!=A.end() && j!=A.end())
{
while(j!=A.end() && *i == *j)
{
temp=j;
j++;
A.erase(temp);
}
i=j;
j++;
}
return A.size();
}
int main()
{
vector<int> vec={0,0,0,0,0,0,0,4,4,7,7,7,7,9};
cout<<"ans="<<removeDuplicates(vec);
return 0;
}

Answer 1

When you increment j, then erase the element there, the elements starting at j+1 are moved down. You're skipping over an element by incrementing.
A better approach would be to simply copy the non-repeating elements from one iterator to the other and setting the new length at the end of the main loop. Your current approach is potentially O(n^2), too slow for practical use.

Answer 2

I think this is that you need. This func loops array from tail to head and counts same values. Then performs shift of already unique values on ununique one.
It doesn't change actual size of vector due process because it would probably involve reallocation of memory inside of vector.
int removeDuplicates(vector<int> &vec) {
int currentVal = vec.size() - 1;
int uniqueNumber = 0;
while (currentVal >= 0) {
++uniqueNumber;
int sameVal = currentVal;
while (sameVal > 0 && vec[sameVal - 1] == vec[currentVal])
--sameVal;
int shiftSize = uniqueNumber;
for (int k = 1; k < shiftSize; ++k) {
vec[sameVal + k] = vec[currentVal + k];
}
currentVal = sameVal - 1;
}
return uniqueNumber;
}

Answer 3

You are asked to use an array. Although vector is similar in many ways, it is not the same. Have a look at the example code below.
In addition you are asked to keep memory allocated the same. You cannot ensure that using vector, it's size can grow / shrink once you add / remove elements and when an element is removed the data in the array behind the vector will be reallocated and rewritten.
int main()
{
int arr[14] = {0,0,0,0,0,4,4,4,4,5,5,5,7,9};
int last_non_duplicate_index = 0;
int current_index = 0;
int size = 14;
int new_size = size;
bool is_last_value = false;
// you can use for interchangeably
while(!is_last_value)
{
current_index++; // move one position ahead
if(current_index < size) // out of bonds check
{
if(arr[last_non_duplicate_index] != arr[current_index]) // value at position of current index is different
{
last_non_duplicate_index++; // increase index of the last value which was not a duplicate by one
arr[last_non_duplicate_index] = arr[current_index]; // write at that index
// e.g. if last index was 0 -> increase it to 1 and rewrite whatsever under arr[1] (current index)
}
else // values are the same
{
new_size--; // devrease the size
}
}
else
{
is_last_value = true; // current_index >= size -> out of bonds
}
}
for (int i = 0; i < new_size; i++)
{
std::cout << "arr[" << i << "]" << " = " << arr[i] << std::endl;
}
std::cout << "New size: " << new_size << std::endl;
return 0;
}

Answer 4

#TC : O(n)
#SC : O(1)
def removeDuplicates(arr,n):
# If array has no elements or only one element, return n
if (n==0 and n==1):
return n
# arr = [1,2,2,3,4,4,4,5,5]
# When i = 0, j= 0 arr=[1,2,2,3,4,4,4,5,5], arr[0] != arr[1], hence arr[0] = arr[0] and j =1, Increment i
# When i = 1, j = 1 arr[j] =[1,2,2,3,4,4,4,5,5]. arr[1] == arr[2], hence increment i
# When i = 2, j = 1 arr[j] = [1,2,2,3,4,4,4,5,5] arr[2] != arr[3], hence arr[1] = arr[2] j = 2, increment i
# When i =3, j = 2 arr[j] = [1,2,3,3,4,4,4,5,5] arr[3] != arr[4], hence arr[2] = arr[3] and j = 3, Increment i
# When i = 4, j = 3 arr[j] =[1,2,3,3,4,4,4,5,5] arr[4] == arr[5], hence increment i
# When i = 5, j = 3 arr[j] = [1,2,3,3,4,4,4,5,5] arr[5] == arr[6], hence increment i
# When i = 6, j = 3 arr[j] = [1,2,3,4,4,4,4,5,5] arr[6] != arr[7], hence arr[3] = arr[6] and j = 4, Increment i
# When i = 7, j= 4 arr[j] = [1,2,3,4,4,4,5,5] arr[7] == arr[8], hence Increment i
# End of for loop
j = 0
for i in range(0,n-1):
if arr[i] != arr[i+1]:
arr[j] = arr[i]
j = j + 1
# Check for the last index element and copy it to a[j]. Increment the j and return j
# When j = 4 arr[j] = [1,2,3,4,5,4,4,5,5] increment j
# j = 5
arr[j] = arr[n-1]
j = j + 1
return j
if __name__=="__main__":
arr = [1,2,2,3,4,4,4,5,5]
#arr = [1,1,2]
#arr = [2,2,2,2,2]
n = len(arr)
print(removeDuplicates(arr,n))

Answer 5

You can do it using iterators like this:
#include<iostream>
#include<vector>
using namespace std;
int removeDuplicates(vector<int> &A) {
int m = A.size();
if(m <= 1) return m;
for (auto it1 = A.begin(); it1 != A.end(); it1++) {
for (auto it2 = it1 + 1; it2 != A.end();) {
if (*it1 == *it2) {
it2 = A.erase(it2);
} else {
it2++;
}
}
}
return A.size();
}
int main()
{
vector<int> vec = { 0, 0, 0, 0, 0, 0, 0, 4, 4, 7, 7, 7, 7, 9 };
cout << "ans=" << removeDuplicates(vec);
return 0;
}