CareerCup

Here is an solution to this problem. The code is in C#, it uses a Hashtable for fast lookup of values. A bool/bit array can be used for further optimization.

public static int[] RemoveDuplicates(int[] InputArray)
        {
            //Declare Hashtable for Array Member Duplicate Check
            Hashtable tab = new Hashtable();
            int i, indexPos = 0;

            //Duplicate Check Loop
            for (i = 0; i < InputArray.Length; i++)
            {
                //Check if the Array Member has not been added to Hash Table
                if (!tab.ContainsKey(InputArray[i]))
                {
                    //Add member
                    tab.Add(InputArray[i], 1);
                    InputArray[indexPos] = InputArray[i];
                    indexPos++;
                }
            }

            //Set unused porition of array with -1 as 
            for (i = indexPos; i < InputArray.Length; i++)
            {
                InputArray[i] = -1;                
            }

            return InputArray;
        }

this is a better solution for a array that does not allow duplicates and if any this code removes the duplicates.
import java.io.*;
import java.util.*;
class Array
{
public static void main(String...args)
{
int[] arr1={1,2,2,4,5,4,6,8};
TreeSet <Integer> ts=new TreeSet<Integer>();
for(int i=0;i<arr1.length;i++)
ts.add(new Integer(arr1[i]));
int size=ts.size();
int [] arr=new int[size];
Iterator <Integer>it=ts.iterator();
int j=0;
while(it.hasNext())
{
arr[j]=(Integer)it.next();
j++;
}
for(int x:arr)
{
System.out.println(x);
}
}
}

def rmdup_func(arr):
j = len(arr) - 1
i = 0
while i <= j:
for k in range(i):
if arr[i] == arr[k]:
arr[i], arr[j] = arr[j], arr[i]
j -= 1
i -= 1
break
i += 1
return j + 1

arr = [1, 2 , 3, 4, 4, 5, 2]
print arr
e = rmdup_func(arr)
print arr
print arr[:e]

def rmdup_func(arr):
    j = len(arr) - 1
    i = 0
    while i <= j:
        for k in range(i):
            if arr[i] == arr[k]:
                arr[i], arr[j] = arr[j], arr[i]
                j -= 1
                i -= 1
                break
        i += 1
    return j + 1

arr = [1, 2 , 3, 4, 4, 5, 2]
print arr
e = rmdup_func(arr)
print arr
print arr[:e]

for (int i = 0; i < inputList.Count - 1; i++)
{
int value = inputList[i];
for (int j = i + 1; j < inputList.Count; j++)
{
if (value == inputList[j])
inputList.RemoveAt(j);
}
}

create a binary search tree using the source array (ignore duplicates) Once the tree is done, do a in order traversal

create a binary search tree using the source array (ignore duplicates) Once the tree is done, do a pre-order traversal

void dedup(vector<int> &arr)
{
	set<int> uniqueArr;

	for (size_t i = 0; i < arr.size(); i++){
		uniqueArr.insert(arr[i]);
	}

	for (set<int>::iterator it = uniqueArr.begin(); it != uniqueArr.end(); it++){
		cout << *it << ", ";
	}
}