CareerCup

Manually like this.
Whenever you think of "have I seen it before" problems, think "hash tables."

h is hash table for elements in your array.

for(to=from=0; from < a.length; from++)
	if( h.exists(a[from]) ) continue; //if seen before, don't copy backwards 
	else h.insert(a[from]), a[to++] = a[from];  //else mark it seen, and copy back

a.length=to;  //<-- mutable object with public field for convenience

Should work.

Easiest way is to use NSOrderedSet

NSOrderedSet * s = [NSOrderedSet orderedSetWithArray:@[@2, @1, @3, @1, @2]];
    
NSArray * a = [s array];
    
NSLog(@"Array: %@", a);

Console output:

Array: (
    2,
    1,
    3
)

# Python

array = ["@2", "@1", "@3", "@1", "@2"]
result = []

for item in array:
    if item not in result:
        result.append(item)

print result

Didn't read all these this might have already been done this way, but here it is in Ruby

def removeDups (list)
		newL = [ ]
		h = new Hash(false)

		list.each do |e|
			if h[e] == false
				newL << e
				h[e] = true
			end
		end
		return newL
	end

public void removeDup(int[] a)
{
int N =a.length;
int r=0;
ArrayList<Integer> arrayList = new ArrayList<Integer>();
for(int i =0;i<N;i++)
{


if((r&(1<<a[i]))==(1<<a[i])) continue;
r+=(1<<a[i]);
arrayList.add(a[i]);
}
System.out.println(arrayList);
}

ArrayList<Integer> removeDup(int[] A){
	HashMap<Integer> map = new HashMap<Integer> ();
	ArrayList<Integer> ret = new ArrayList<Integer>();
	for(int i = 0; i<A.length; i++){
		if(!map.contains(A[i])){
			ret.add(A[i]);
			map.add(A[i]);
		}
	}
	return ret;
}

One way to solve it in java: 1. go through all the items in the list. 2. Check if the item is in a hashmap or set, if it's true, ignore it. Otherwise, put the item to the map and append it to an ArrayList

import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class Duplicator {
    
    public static List<Integer> uniqueArray(int[] list) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        List<Integer> array = new ArrayList<Integer>();
        for(int i = 0; i < list.length; i++) {
            if(!map.containsKey(list[i])) {
                map.put(list[i], 0);
                array.add(list[i]);
            }
        }

        return array;
    }

    public static void main(String[] args) {
        int[] list = {1, 2, 3, 2, 3, 5, 4, 1};
        List<Integer> array = uniqueArray(list);
        for(Integer item: array) {
            System.out.print(item + " ");
        }
    }
}

#include<iostream>
#include<conio.h>
#include<math.h>
#include<stdlib.h>

using namespace std; 
int removeDuplicate(int arr[],int len){
	long  positive = 0L;
	long  negative = 0L;
	int i, j =0;
	for(i=0;i<len;i++){
		if(arr[i]>=0){
			if(positive&1<<arr[i])
			 continue;
			 arr[j++]=arr[i];
			 positive=positive|1<<arr[i];
		}else{
			if(negative&1<<arr[i])
			 continue;
			 arr[j++]=arr[i];
			 negative=negative|1<<arr[i];
		}
	}
	return j;
}
int main(){
int arr[]={1,2,3,0,0,-1,-2,-3,-4,0,0,1,2,3,4,5,6,7,-1,-2,-3,-4,-5,-6,-7,4,5,6,7,8,-1,-2,-3,-4,-5,-6,-7,0,0,0,0,1,2,3,4,5,6,7,-1,-2,-3,-4,-5,-6,-7};
int len = sizeof(arr)/sizeof(arr[0]);
int arrlen = removeDuplicate(arr,len);
for(int i =0; i <arrlen; i++)
 cout<<arr[i]<<"   ";
return 0;
}

#include<iostream>
#include<conio.h>
#include<math.h>
#include<stdlib.h>

using namespace std; 
int removeDuplicate(int arr[],int len){
	long  positive = 0L;
	long  negative = 0L;
	int i, j =0;
	for(i=0;i<len;i++){
		if(arr[i]>=0){
			if(positive&1<<arr[i])
			 continue;
			 arr[j++]=arr[i];
			 positive=positive|1<<arr[i];
		}else{
			if(negative&1<<arr[i])
			 continue;
			 arr[j++]=arr[i];
			 negative=negative|1<<arr[i];
		}
	}
	return j;
}
int main(){
int arr[]={1,2,3,0,0,-1,-2,-3,-4,0,0,1,2,3,4,5,6,7,-1,-2,-3,-4,-5,-6,-7,4,5,6,7,8,-1,-2,-3,-4,-5,-6,-7,0,0,0,0,1,2,3,4,5,6,7,-1,-2,-3,-4,-5,-6,-7};
int len = sizeof(arr)/sizeof(arr[0]);
int arrlen = removeDuplicate(arr,len);
for(int i =0; i <arrlen; i++)
 cout<<arr[i]<<"   ";
return 0;
}

class Program
    {
        static void Main(string[] args)
        {
string[] arr = { "@2", "@1", "@3", "@1", "@2" };
            string[] arr2 = iQ.myFunction(arr);
            foreach (string str in arr2)
                Console.Write("[" + str + "]");

            Console.ReadLine();
}

}

public string[] myFunction(string[] strArr) {
             List<string> strList = new List<string>();
             string[] tempStr = {};

             for (int i = 0; i < strArr.Length; i++) {

                 for (int j = i; j < strArr.Length; j++) { 
                     if(!strList.Contains(strArr[j]))
                        strList.Add(strArr[j]);
                                   
                 }
             
             }

             tempStr = strList.ToArray();
            
             return tempStr;
         }

#include<stdio.h>
#include<conio.h>
main()
{
	int i;
	int a[]={11,2,3,3,11,34,2,3,54,34,10,32,32,54};
	int b[10];
	for(i=0;i<14;i++)
	{
		b[a[i]]=0;
		}
		for(i=0;i<14;i++)
		{
			if(b[a[i]]==0)
			printf("%d ",a[i]);
			b[a[i]]=1;
		}
		getch();
}

#include<stdio.h>
#include<conio.h>
main()
{
	int i;
	int a[]={11,2,3,3,11,34,2,3,54,34,10,32,32,54};
	int b[10];
	for(i=0;i<14;i++)
	{
		b[a[i]]=0;
		}
		for(i=0;i<14;i++)
		{
			if(b[a[i]]==0)
			printf("%d ",a[i]);
			b[a[i]]=1;
		}
		getch();
}

- (NSMutableString *) removeDuplicates:(NSString *) string
        if(string && [string length] > 1){
            NSMutableString *stringMutable = [string mutableCopy];
            CFMutableBitVectorRef charExists = CFBitVectorCreateMutable(kCFAllocatorDefault,0);
            unsigned int index = 0;

            while( index < [stringMutable length])
            {
                if(CFBitVectorGetBitAtIndex(charExists,[stringMutable characterAtIndex:index]) == 0){
                    CFBitVectorFlipBitAtIndex(charExists,[stringMutable characterAtIndex:index]);
                    index++;
                } else {
                    [stringMutable deleteCharactersInRange:NSMakeRange(index,1)];
                }
                
            }
            NSLog(@"%@",stringMutable);
        } else {
            return string;
            NSLog(@"Nothing to be done here");
        }

}

Java:

public static void main(String args[]) {
ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("A");
list.add("C");
list.add("B");

ArrayList<String> newList = new ArrayList<String>();
for(String string : list){
if(!newList.contains(string)){
newList.add(string);
}
}
System.out.println(newList);
}

public static String[] getUniqueArray(String[] arr) {
		String[] buffer = new String[arr.length];
		Set<String> set = new HashSet<String>();
		for (int i = 0; i < arr.length; i++) {
			if (set.contains(arr[i]))
				continue;
			else {
				set.add(arr[i]);
				buffer[i] = arr[i];
			}
		}
		return buffer;
	}

<?php

function removeDup (array $list)
{
    for($i = 0;$i < count($list); $i++)
    {
        $tmp[$list[$i]]++;
    }
    foreach($tmp as $k=>$v)
    {
       $output[] = $k; 
    }
    return $output;
}

//Main
echo"Array (space btw elements)-> ";
$line = trim(fgets(STDIN));
echo"Result-> ".implode(",",removeDup(explode(" ",$line)))."\n";

?>

<?php

function removeDup (array $list)
{
    for($i = 0;$i < count($list); $i++)
    {
        $tmp[$list[$i]]++;
    }
    foreach($tmp as $k=>$v)
    {
       $output[] = $k; 
    }
    return $output;
}

//Main
echo"Array (space btw elements)-> ";
$line = trim(fgets(STDIN));
echo"Result-> ".implode(",",removeDup(explode(" ",$line)))."\n";

?>

<?php

function removeDup (array $list)
{
    for($i = 0;$i < count($list); $i++)
    {
        $tmp[$list[$i]]++;
    }
    foreach($tmp as $k=>$v)
    {
       $output[] = $k; 
    }
    return $output;
}

//Main
echo"Array (space btw elements)-> ";
$line = trim(fgets(STDIN));
echo"Result-> ".implode(",",removeDup(explode(" ",$line)))."\n";

?>

#include <stdio.h>
#include <unordered_set>
#include <list>

using namespace std;

void removeDups(list<int> & values)
{
    unordered_set<int> seenValues;
    list<int>::iterator iter = values.begin(); 
    
    while(iter != values.end())
    {
        if(seenValues.find(*iter) == seenValues.end())
        {
            seenValues.insert(*iter);
            iter ++;
        }
        else
        {
            iter = values.erase(iter);
        }    
    }
}

int main()
{
    list<int> values;
    values.push_back(1);
    values.push_back(1);
    values.push_back(4);
    values.push_back(6);
    values.push_back(5);
    values.push_back(4);
    values.push_back(5);
    values.push_back(0);
    values.push_back(6);
    values.push_back(7);
    values.push_back(7);
    values.push_back(7);
    
    removeDups(values);
    
    for(list<int>::iterator iter = values.begin(); iter != values.end(); iter ++)
    {
        printf("%d ",*iter);
    }
    
    return 0;
    
}

int Remove(std::vector<int> & v) {
  int k = -1;
  std::set<int> seen;
  for (int i = 0; i < v.size(); i++) {
    if (seen.count(v[i])) continue;
    seen.insert(v[i]);
    v[++k] = v[i];
  }
  return k + 1;
}

in perl:

my @array = (@3,@2,@1,@2,@1);
my %union;
my%intersection;

foreach (@array) {$union{$_}++ && $intersection{$_}++}

my @answers = keys %intersection;

This is a one-liner in Python.

from collections import OrderedDict
def dedupe(lst):
	return OrderedDict((x, 1) for x in lst).keys()

If you're not allowed imports, you can just iterate over the list, updating a normal dictionary as you go and for items not seen before you copy them into a separate list, which you return at the end.

#Objective-C

for(int i=0; i<[array count]; i++) {
[array removeObject:array[i] inRange:NSMakeRange(i+1,[array count]-i-1)];
}

Since I did not see a scala solution, thought I would add one :-)

I use a Set to determine what has already been seen, a list to collect what has been seen, and a recursion to solve the problem.

type ilist = List[Int]
def removeDups(l:ilist, sofar:ilist, seen:Set[Int]):ilist = {
  l match {
    case h::t   => if (seen.contains(h)) removeDups(t, sofar, seen)
                   else removeDups(t,h :: sofar, seen + h)
    case List() => sofar.reverse
  }
}

Execution on the provided data:

scala> val vals = List(2,1,3,1,2)
vals: List[Int] = List(2, 1, 3, 1, 2)

scala> removeDups(vals, Nil, Set.empty[Int])
res2: ilist = List(2, 1, 3)

Since I did not see a scala solution, thought I would add one :-)

I use a Set to determine what has already been seen, a list to collect what has been seen, and a recursion to solve the problem.

type ilist = List[Int]
def removeDups(l:ilist, sofar:ilist, seen:Set[Int]):ilist = {
  l match {
    case h::t   => if (seen.contains(h)) removeDups(t, sofar, seen)
                   else removeDups(t,h :: sofar, seen + h)
    case List() => sofar.reverse
  }
}

Execution on the provided data:

scala> val vals = List(2,1,3,1,2)
vals: List[Int] = List(2, 1, 3, 1, 2)

scala> removeDups(vals, Nil, Set.empty[Int])
res2: ilist = List(2, 1, 3)

this question is basically a question based on data structure knowledge:
linked hash map is the right data structure to use if orignal array cann't be modified :)

-(NSArray *)removeDuplicates:(NSArray *)uncheckedArray{
    NSMutableSet *checkList = [NSMutableSet set];
    NSMutableArray *uniqueArray  = [NSMutableArray array];
    for (id object in uncheckedArray) {
        BOOL isDuplicate = [checkList containsObject:object];
        if (!isDuplicate) {
            [checkList addObject:object];
            [uniqueArray addObject:object];
        }
    }
    return [uniqueArray copy];
}

int k=0,i=0;

a[k++]=a[i];

while(i<n)
{
if((a[i]!=a[i+1])&&(notcomesbefore()))
a[k++]=a[i+1];

i++;

}

notcomesbefore()
{
use hash table ..........//hash table is initialised to zero

if(hash array has value 1) //this value is already taken
return 0;

else
return 1;

}

List<Integer> numList = new ArrayList<Integer>();
		
for(int i = 0; i < a.length; i++)
{
    if(!numList.contains(a[i]))
    {
	   numList.add(a[i]);
    }   
}
		
System.out.println(numList);

+(NSArray*)removeDuplicates:(NSArray*)array
{
NSMutableOrderedSet *set = [[NSMutableOrderedSet alloc]init];
for (NSString *str in array) {
if (![set containsObject:str]) {
[set addObject:str];
}
}
return [set array];
}

I would like to use LinkedHashMap to hold values from array one by one, this way, no dups will be stored, while order will be maintained:

public void removeDup(String[] strArr){
LinkedHashMap<String, Integer> linkedhmap = new LinkedHashMap<String, Integer>();
for (int i=0; i<strArr.length; i++){
linkedhmap.put(strArr[i], 1);
}

Iterator iter = linkedhmap.keyset().iterator();
while (iter.hasNext()){
System.out.println(iter.next());
}
}

void RemoveDuplicate(int *a)
{
if(a==NULL)
  return;
int *q=a;
n=sizeof(a)/sizeof(a[0]);
int *tb=new int[n+1];
memset(t,0,sizeof(int)*(n+1));
vector<int>vec;
int cnt=0;
while(cnt<n)
{
	if(t[*q]==0)
	{
		t[*q]=1;
		vec.push_back(*q);
	}
	q++;
	cnt++;
}
vector<int>::iterator p=vec.begin();
while(p!=vec.end())
	cout<<*p++<<"\t";
cout<<endl;
delete [] t;
}

+(NSArray*)removeDuplicateNumbers
{
	NSArray *array = @[@"2",@"1",@"3",@"1",@"2"];
	NSMutableOrderedSet *set = [[NSMutableOrderedSet alloc]init];
	for (NSString *str in array) {
		if (![set containsObject:str]) {
			[set addObject:str];
		}		
	}
   return [set array];
}

This can be achieved using Hashset for example in C#, add items to HashSet from beginning to end and print them using either foreach loop or HashSet.elementAt():
for example:

for(int i = 0; i < HashSet.Count; i++){
	print(HashSet.elementAt(i));
}

I can think of 4 solutions as of now:
Solution 1: Time O(nlogn) Space O(1)
Sort the array using quicksort. Traverse the array if the consecutive values are same then remove it and keep shifting the corresponding further values.

Solution 2: Time O(n) Space O(n)
Use hashmap to store the value while traversing the array. If value is already present then remove the element,

Solution3: Time O(n2) Space O(1)
Use two for loops (Brute force method)

Solution 4: Time O(n) Space O(Max value in an array)
Find the largest element in the array ( considering @ can be ignored since its constant for all the values).
Create an array of that size. Iterate the given array and mark the corresponding index in the new array as visited. If value is already marked visited then it is the duplicate.

C#

public static int[] RemoveDuplicates(int[] arr)
{
    return (new HashSet<int>(arr)).ToArray();
}