Remove duplicate elements

Given an Array, derive a sequence of elements in which all duplicates are removed.

There are basically three approaches seen here:

Put the elements into a hash table which does not allow duplicates. The complexity is O(n) on average, and O(n²) worst case. This approach requires a hash function for your type (which is compatible with equality), either built-in to your language, or provided by the user.
Sort the elements and remove consecutive duplicate elements. The complexity of the best sorting algorithms is O(n log n). This approach requires that your type be "comparable", i.e., have an ordering. Putting the elements into a self-balancing binary search tree is a special case of sorting.
Go through the list, and for each element, check the rest of the list to see if it appears again, and discard it if it does. The complexity is O(n²). The up-shot is that this always works on any type (provided that you can test for equality).

AutoHotkey

Built in Sort has an option to remove duplicates <lang AutoHotkey>a = 1,2,1,4,5,2,15,1,3,4 Sort, a, a, NUD`, MsgBox % a ; 1,2,3,4,5,15</lang>

We produce an array a with duplicates from a string; then index a second array b with the contents of a, so that duplicates make only one entry; then produce a string with the keys of b, which is finally output. <lang awk>$ awk 'BEGIN{split("a b c d c b a",a);for(i in a)b[a[i]]=1;r="";for(i in b)r=r" "i;print r}' a b c d</lang>

C

Since there's no way to know ahead of time how large the new data structure will need to be, we'll return a linked list instead of an array.

<lang c>#include <stdio.h>

include <stdlib.h>

struct list_node {int x; struct list_node *next;}; typedef struct list_node node;

node * uniq(int *a, unsigned alen)

{if (alen == 0) return NULL;
 node *start = malloc(sizeof(node));
 if (start == NULL) exit(EXIT_FAILURE);
 start->x = a[0];
 start->next = NULL;

 for (int i = 1 ; i < alen ; ++i)
    {node *n = start;
     for (;; n = n->next)
        {if (a[i] == n->x) break;
         if (n->next == NULL)
            {n->next = malloc(sizeof(node));
             n = n->next;
             if (n == NULL) exit(EXIT_FAILURE);
             n->x = a[i];
             n->next = NULL;
             break;}}}

 return start;}

int main(void)

  {int a[] = {1, 2, 1, 4, 5, 2, 15, 1, 3, 4};
   for (node *n = uniq(a, 10) ; n != NULL ; n = n->next)
       printf("%d ", n->x);
   puts("");
   return 0;}</lang>

C++

This version uses std::set, which requires its element type be comparable using the < operator. <lang cpp>#include <set>

include <iostream>

using namespace std;

int main() {

   typedef set<int> TySet;
   int data[] = {1, 2, 3, 2, 3, 4};

   TySet unique_set(data, data + 6);

   cout << "Set items:" << endl;
   for (TySet::iterator iter = unique_set.begin(); iter != unique_set.end(); iter++)
         cout << *iter << " ";
   cout << endl;

}</lang>

This version uses hash_set, which is part of the SGI extension to the Standard Template Library. It is not part of the C++ standard library. It requires that its element type have a hash function.

Works with: GCC

<lang cpp>#include <ext/hash_set>

include <iostream>

using namespace std;

int main() {

   typedef __gnu_cxx::hash_set<int> TyHash;
   int data[] = {1, 2, 3, 2, 3, 4};

   TyHash unique_set(data, data + 6);

   cout << "Set items:" << endl;
   for (TyHash::iterator iter = unique_set.begin(); iter != unique_set.end(); iter++)
         cout << *iter << " ";
   cout << endl;

}</lang>

This version uses unordered_set, which is part of the TR1, which is likely to be included in the next version of C++. It is not part of the C++ standard library. It requires that its element type have a hash function.

Works with: GCC

<lang cpp>#include <tr1/unordered_set>

include <iostream>

using namespace std;

int main() {

   typedef tr1::unordered_set<int> TyHash;
   int data[] = {1, 2, 3, 2, 3, 4};

   TyHash unique_set(data, data + 6);

   cout << "Set items:" << endl;
   for (TyHash::iterator iter = unique_set.begin(); iter != unique_set.end(); iter++)
         cout << *iter << " ";
   cout << endl;

}</lang>

Alternative method working directly on the array:

<lang cpp>#include <iostream>

include <iterator>
include <algorithm>

// helper template template<typename T> T* end(T (&array)[size]) { return array+size; }

int main() {

 int data[] = { 1, 2, 3, 2, 3, 4 };
 std::sort(data, end(data));
 int* new_end = std::unique(data, end(data));
 std::copy(data, new_end, std::ostream_iterator<int>(std::cout, " ");
 std::cout << std::endl;

}</lang>

C#

C# 2.0

Works with: MSVS version 2005 and .Net Framework 2.0

<lang csharp>int[] nums = { 1, 1, 2, 3, 4, 4 }; List<int> unique = new List<int>(); for (int i = 0; i < nums.Length; i++)

   if (!unique.Contains(nums[i]))
       unique.Add(nums[i]);</lang>

C# 3.0

Works with: MSVS version 2008 and .Net Framework 3.5

<lang csharp>int[] nums = {1, 1, 2, 3, 4, 4}; int[] unique = nums.Distinct().ToArray();</lang>

Clojure

Simply construct a set containing the original sequence, and create a seq on the set

<lang lisp>user> (def vdata [1 3 2 9 1 2 3 8 8 1 0 2]) user> (def lsdata '(1 3 2 9 1 2 3 8 8 1 0 2)) user> (seq (into #{} vdata)) (0 1 2 3 8 9) user> (seq (into #{} lsdata)) (0 1 2 3 8 9)</lang>

Common Lisp

To remove duplicates non-destructively:

<lang lisp>(remove-duplicates '(1 3 2 9 1 2 3 8 8 1 0 2)) > (9 3 8 1 0 2)</lang>

Or, to remove duplicates in-place:

<lang lisp>(delete-duplicates '(1 3 2 9 1 2 3 8 8 1 0 2)) > (9 3 8 1 0 2)</lang>

D

<lang d>void main() {

   int[] data = [1, 2, 3, 2, 3, 4];
   int[int] hash;
   foreach(el; data)
       hash[el] = 0;

}</lang>

E

<lang e>[1,2,3,2,3,4].asSet().getElements()</lang>

Erlang

Factor

<lang factor>USING: sets ; V{ 1 2 1 3 2 4 5 } prune .

V{ 1 2 3 4 5 }</lang>

Forth

Forth has no built-in hashtable facility, so the easiest way to achieve this goal is to take the "uniq" program as an example.

The word uniq, if given a sorted array of cells, will remove the duplicate entries and return the new length of the array. For simplicity, uniq has been written to process cells (which are to Forth what "int" is to C), but could easily be modified to handle a variety of data types through deferred procedures, etc.

The input data is assumed to be sorted.

<lang forth>\ Increments a2 until it no longer points to the same value as a1 \ a3 is the address beyond the data a2 is traversing.

skip-dups ( a1 a2 a3 -- a1 a2+n )

   dup rot ?do
     over @ i @ <> if drop i leave then
   cell +loop ;

\ Compress an array of cells by removing adjacent duplicates \ Returns the new count

uniq ( a n -- n2 )

  over >r             \ Original addr to return stack
  cells over + >r     \ "to" addr now on return stack, available as r@
  dup begin           ( write read )
     dup r@ <
  while
     2dup @ swap !    \ copy one cell
     cell+ r@ skip-dups
     cell 0 d+        \ increment write ptr only
  repeat  r> 2drop  r> - cell / ;</lang>

Here is another implementation of "uniq" that uses a popular parameters and local variables extension words. It is structurally the same as the above implementation, but uses less overt stack manipulation.

<lang forth>: uniqv { a n \ r e -- n }

   a n cells+ to e
   a dup to r
   \ the write address lives on the stack
   begin
     r e <
   while
     r @ over !
     r cell+ e skip-dups to r
     cell+
   repeat
   a - cell / ;</lang>

To test this code, you can execute:

<lang forth>create test 1 , 2 , 3 , 2 , 6 , 4 , 5 , 3 , 6 , here test - cell / constant ntest

.test ( n -- ) 0 ?do test i cells + ? loop ;

test ntest 2dup cell-sort uniq .test</lang>

output

Groovy

<lang groovy>def list = [1, 2, 3, 'a', 'b', 'c', 2, 3, 4, 'b', 'c', 'd'] assert list.size() == 12 println " Original List: ${list}"

// Filtering the List list.unique() assert list.size() == 8 println " Filtered List: ${list}"

list = [1, 2, 3, 'a', 'b', 'c', 2, 3, 4, 'b', 'c', 'd'] assert list.size() == 12

// Converting to Set def set = new HashSet(list) assert set.size() == 8 println " Set: ${set}"

// Converting to Order-preserving Set set = new LinkedHashSet(list) assert set.size() == 8 println "List-ordered Set: ${set}"</lang>

Output:

   Original List: [1, 2, 3, a, b, c, 2, 3, 4, b, c, d]
   Filtered List: [1, 2, 3, a, b, c, 4, d]
             Set: [1, d, 2, 3, 4, b, c, a]
List-ordered Set: [1, 2, 3, a, b, c, 4, d]

Haskell

<lang haskell>values = [1,2,3,2,3,4] unique = List.nub values</lang>

IDL

<lang idl>result = uniq( array[sort( array )] )</lang>

J

<lang j> ] a=: 4 5 ?@$ 13 NB. 4 by 5 matrix of numbers chosen from 0 to 12 4 3 2 8 0 1 9 5 1 7 6 3 9 9 4 2 1 5 3 2

  , a     NB. sequence of the same elements

4 3 2 8 0 1 9 5 1 7 6 3 9 9 4 2 1 5 3 2

  ~. , a  NB. unique elements

4 3 2 8 0 1 9 5 7 6</lang> The verb ~. removes duplicate items from any array (numeric, character, or other; vector, matrix, rank-n array). For example: <lang j> ~. 'chthonic eleemosynary paronomasiac' chtoni elmsyarp</lang> Or

<lang j> 0 1 1 2 0 */0 1 2 0 0 0 0 1 2 0 1 2 0 2 4 0 0 0

  ~. 0 1 1 2 0 */0 1 2

0 0 0 0 1 2 0 2 4</lang>

Java

Works with: Java version 1.5

<lang java5>import java.util.Set; import java.util.HashSet; import java.util.Arrays;

Object[] data = {1, 2, 3, "a", "b", "c", 2, 3, 4, "b", "c", "d"}; Set<Object> uniqueSet = new HashSet<Object>(Arrays.asList(data)); Object[] unique = uniqueSet.toArray();</lang>

JavaScript

<lang javascript>function unique(ary) {

   // concat() with no args is a way to clone an array
   var u = ary.concat().sort();
   for (var i = 1; i < u.length; ) {
       if (u[i-1] == u[i])
           u.splice(i,1);
       else
           i++;
   }
   return u;

}

var ary = [1, 2, 3, "a", "b", "c", 2, 3, 4, "b", "c", "d"]; unique(ary); // [1,2,3,4,'a','b','c','d']</lang>

Logo

Works with: UCB Logo

<lang logo>show remdup [1 2 3 a b c 2 3 4 b c d] ; [1 a 2 3 4 b c d]</lang>

MAXScript

<lang maxscript>uniques = #(1, 2, 3, "a", "b", "c", 2, 3, 4, "b", "c", "d") for i in uniques.count to 1 by -1 do (

   id = findItem uniques uniques[i]
   if (id != i) do deleteItem uniques i

)</lang>

Mathematica

Built-in function: <lang Mathematica>DeleteDuplicates[{0, 2, 1, 4, 2, 0, 3, 1, 1, 1, 0, 3}]</lang> gives back: <lang Mathematica>{0, 2, 1, 4, 3}</lang> Custom function (reordering of elements is possible): <lang Mathematica>NoDupes[input_List] := Split[Sort[input]]All, 1 NoDupes[{0, 2, 1, 4, 2, 0, 3, 1, 1, 1, 0, 3}]</lang> gives back: <lang Mathematica>{0, 1, 2, 3, 4}</lang>

Nial

<lang nial>uniques := [1, 2, 3, 'a', 'b', 'c', 2, 3, 4, 'b', 'c', 'd'] cull uniques =+-+-+-+-+-+-+-+-+ =|1|2|3|a|b|c|4|d| =+-+-+-+-+-+-+-+-+</lang>

Using strand form <lang nial>cull 1 1 2 2 3 3 =1 2 3</lang>

Objective-C

<lang objc>NSArray *items = [NSArray arrayWithObjects:@"A", @"B", @"C", @"B", @"A", nil];

NSSet *unique = [NSSet setWithArray:items];</lang>

OCaml

<lang ocaml>let uniq lst =

 let unique_set = Hashtbl.create (List.length lst) in
   List.iter (fun x -> Hashtbl.replace unique_set x ()) lst;
   Hashtbl.fold (fun x () xs -> x :: xs) unique_set []

let _ =

 uniq [1;2;3;2;3;4]</lang>

Perl

Library: List::MoreUtils MoreUtils

<lang perl>use List::MoreUtils qw(uniq);

my @uniq = uniq qw(1 2 3 a b c 2 3 4 b c d);</lang>

Without modules: <lang perl>my %seen; my @uniq = grep {!$seen{$_}++} qw(1 2 3 a b c 2 3 4 b c d);</lang>

Note: the following two solutions convert elements to strings in the result, so it will cause problems with references.

Alternately: <lang perl>my %hash = map { $_ => 1 } qw(1 2 3 a b c 2 3 4 b c d); my @uniq = keys %hash;</lang>

Alternately: <lang perl>my %seen; @seen{qw(1 2 3 a b c 2 3 4 b c d)} = (); my @uniq = keys %seen;</lang>

Perl 6

Works with: Rakudo version #23 "Lisbon"

<lang perl6>sub nub (@a) {

   my @b;
   none(@b) eqv $_ and push @b, $_ for @a;
   return @b;

}

my @unique = nub [1, 2, 3, 5, 2, 4, 3, -3, 7, 5, 6];</lang>

PHP

<lang php>$list = array(1, 2, 3, 'a', 'b', 'c', 2, 3, 4, 'b', 'c', 'd'); $unique_list = array_unique($list);</lang>

Pop11

<lang pop11>;;; Initial array lvars ar = {1 2 3 2 3 4};

Create a hash table

lvars ht= newmapping([], 50, 0, true);

Put all array as keys into the hash table

lvars i; for i from 1 to length(ar) do

  1 -> ht(ar(i))

endfor;

Collect keys into a list

lvars ls = []; appdata(ht, procedure(x); cons(front(x), ls) -> ls; endprocedure);</lang>

PowerShell

The common array for both approaches: <lang powershell>$data = 1,2,3,1,2,3,4,1</lang> Using a hash table to remove duplicates: <lang powershell>$h = @{} foreach ($x in $data) {

   $h[$x] = 1

} $h.Keys</lang> Sorting and removing duplicates along the way can be done with the Sort-Object cmdlet. <lang powershell>$data | Sort-Object -Unique</lang>

Prolog

<lang prolog>uniq(Data,Uniques) :- sort(Data,Uniques).</lang>

Example usage: <lang prolog>?- uniq([1, 2, 3, 2, 3, 4],Xs). Xs = [1, 2, 3, 4]</lang>

Python

If all the elements are hashable (this excludes list, dict, set, and other mutable types), we can use a set: <lang python>items = [1, 2, 3, 'a', 'b', 'c', 2, 3, 4, 'b', 'c', 'd'] unique = list(set(items))</lang>

If all the elements are comparable (i.e. <, >=, etc. operators; this works for list, dict, etc. but not for complex and many other types, including most user-defined types), we can sort and group: <lang python>import itertools items = [1, 2, 3, 'a', 'b', 'c', 2, 3, 4, 'b', 'c', 'd'] unique = [k for k,g in itertools.groupby(sorted(items))]</lang>

If both of the above fails, we have to use the brute-force method, which is inefficient: <lang python>items = [1, 2, 3, 'a', 'b', 'c', 2, 3, 4, 'b', 'c', 'd'] unique = [] for x in items:

   if x not in unique:
       unique.append(x)</lang>

R

<lang r>items <- c(1,2,3,2,4,3,2) unique (items)</lang>

Raven

<lang raven>[ 1 2 3 'a' 'b' 'c' 2 3 4 'b' 'c' 'd' ] as items items copy unique print

list (8 items)

0 => 1
1 => 2
2 => 3
3 => "a"
4 => "b"
5 => "c"
6 => 4
7 => "d"</lang>

Ruby

<lang ruby>ary = [1,1,2,1,'redundant',[1,2,3],[1,2,3],'redundant'] uniq_ary = ary.uniq

=> [1, 2, "redundant", [1, 2, 3]]</lang>

Scala

<lang scala>val list = List(1,2,3,4,2,3,4,99) val l2 = list.removeDuplicates // l2: scala.List[scala.Int] = List(1,2,3,4,99)</lang>

Scheme

<lang scheme>(define (remove-duplicates l)

 (do ((a '() (if (member (car l) a) a (cons (car l) a)))
      (l l (cdr l)))
   ((null? l) (reverse a))))

(remove-duplicates (list 1 2 1 3 2 4 5))</lang>

Some implementations provide remove-duplicates in their standard library.

SETL

<lang SETL>items := [0,7,6,6,4,9,7,1,2,3,2]; print(unique(items));</lang> Output in arbitrary order (convert tuple->set then set->tuple): <lang SETL>proc unique(items);

 return [item: item in {item: item in items}];

end proc;</lang>

Preserving source order <lang SETL>proc unique(items);

 seen := {};
 return [item: item in items, nps in {#seen} | #(seen with:= item) > nps];

end proc;</lang>

Smalltalk

<lang smalltalk>|aCollection| "Example of creating a collection" a := #( 1 1 2 'hello' 'world' #symbol #another 2 'hello' #symbol ). a asSet printNl.</lang>

Output:

Set (1 2 #symbol 'world' #another 'hello' )

Tcl

The concept of an "array" in Tcl is strictly associative - and since there cannot be duplicate keys, there cannot be a redundant element in an array. What is called "array" in many other languages is probably better represented by the "list" in Tcl (as in LISP). With the correct option, the lsort command will remove duplicates. <lang tcl>set result [lsort -unique $listname]</lang>

UnixPipes

Assuming a sequence is represented by lines in a file. <lang bash>bash$ # original list bash$ printf '6\n2\n3\n6\n4\n2\n' 6 2 3 6 4 2 bash$ # made uniq bash$ printf '6\n2\n3\n6\n4\n2\n'|sort -n|uniq 2 3 4 6 bash$</lang>

or

<lang bash>bash$ # original list bash$ printf '6\n2\n3\n6\n4\n2\n' 6 2 3 6 4 2 bash$ # made uniq bash$ printf '6\n2\n3\n6\n4\n2\n'|sort -u 2 3 4 6 bash$</lang>

Ursala

The algorithm is to partition the list by equality and take one representative from each class, which can be done by letting the built in partition operator, |=, use its default comparison relation. This works on lists of any type including character strings but the comparison is based only on structural equivalence. It's up to the programmer to decide whether that's a relevant criterion for equivalence or else specify a better one. <lang Ursala>#cast %s

example = |=hS& 'mississippi'</lang> output:

'mspi'

Vedit macro language

The input "array" is an edit buffer where each line is one element. <lang vedit>Sort(0, File_Size) // sort the data While(Replace("^(.*)\N\1$", "\1", REGEXP+BEGIN+NOERR)){} // remove duplicates</lang>