Given a sorted array, remove the duplicates in place such that each element appear only once

and return the new length.

Do not allocate extra space for another array, you must do this in place with constant memory.

For example, Given input array A = [1,1,2],

Your function should return length = 2, and A is now [1,2].

```#include <iostream>
#include <assert.h>
#include <vector>
#include <algorithm>
using namespace std;

class Solution
{
public:
int removeDuplicates(char *a, size_t len)
{
assert(a);
size_t index = 1;
int first = 0;
int second = 1;
while (second < len){
if (a[second] != a[first]){
a[index++] = a[second];
first = second;
}
second++;
}
return index;
}
};```

len是数组元素的个数

first为第一个元素下标，second为第二个元素下标（如果数组只有一个元素，则不会进入循环，而是直接返回1）

index为复制后数组的个数

```class Solution
{
public:
int removeDuplicates(char a[], size_t len)
{
return distance(a, unique(a, a + len));
}
};```

```template <class ForwardIterator>
ForwardIterator unique ( ForwardIterator first, ForwardIterator last );```
` distance (InputIterator first, InputIterator last);`

```class Solution
{
public:
int removeDuplicates(char a[], size_t len)
{
return _removeDuplicates(a,a+len,a)-a;
}
template<class T1,class T2>
T2 _removeDuplicates(T1 first, T1 last, T2 output)
{
while (first != last){
*output++ = first;
first = upper_bound(first,last,*first);
}
return output;
}
};```

```template <class ForwardIterator, class T>
ForwardIterator upper_bound ( ForwardIterator first, ForwardIterator last,
const T& value );```

================================================================

Follow up for ”Remove Duplicates”: What if duplicates are allowed at most twice?

For example, Given sorted array A = [1,1,1,2,2,3],

Your function should return length = 5, and A is now [1,1,2,2,3]

```class Solution2
{
public:
int removeDuplicates(int a[], size_t len)
{
return _removeDuplicates(a,a+len,a)-a;
}
template<class T1,class T2>
T2 _removeDuplicates(T1 first, T1 last, T2 output)
{
T1 tmp = first;
while (first != last){
if ((tmp!=first-1)&&(*tmp == *(first - 1))){
*output++ = *(first - 1);
}
*output++ = *first;
tmp = first;
first = upper_bound(first,last,*first);
}
return output;
}
};```

```class Solution2
{
public:
int removeDuplicates(int *a,size_t len)
{
size_t index = 2;
for (int i = 2; i < len ; ++i){
if (a[i] != a[index - 2])
a[index++] = a[i];
}
return index;
}
};```

```class Solution2
{
public:
int removeDuplicates(int *a, size_t len)
{
int index = 0;
for (int i = 0; i < len ; ++i){
if (i>0 && i<len-1 && a[i] == a[i - 1] && a[i] == a[i + 1])
continue;
a[index++] = a[i];
}
return index;
}
};```