Remove duplicate elements: Difference between revisions
m
syntax highlighting fixup automation
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
|||
Line 14:
{{trans|Python}}
<
V unique = Array(Set(items))
print(unique)</
{{out}}
Line 25:
=={{header|360 Assembly}}==
{{trans|PL/I}}
<
REMDUP CSECT
USING REMDUP,R15 set base register
Line 72:
PG DC CL92' '
YREGS
END REMDUP</
{{out}}
<pre> 6 1 5 2 7 22 4 19 8 9 10 11 12</pre>
Line 80:
This routine works on arrays of bytes, and keeps track of which bytes it has seen in a 256-byte array.
<
jmp test
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Line 135:
nl: db 13,10,'$'
bufdef: db 127,0
buf:</
=={{header|ACL2}}==
<syntaxhighlight lang
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<
PROC PrintArray(INT ARRAY a INT size)
Line 202:
Test(src2,26)
Test(src3,1)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Remove_duplicate_elements.png Screenshot from Atari 8-bit computer]
Line 225:
=={{header|Ada}}==
{{works with|GNAT|GPL 2018}}
<
use Ada.Text_IO;
Line 239:
Put (e'img);
end loop;
end Duplicate;</
=={{header|Aime}}==
Using an index:
<
list(1, 2, 3, 1, 2, 3, 4, 1).ucall(i_add, 1, x, 0);
x.i_vcall(o_, 1, " ");
o_newline();</
{{out}}
<pre> 1 2 3 4</pre>
Order preserving solution:
<
for (, integer a in list(8, 2, 1, 8, 2, 1, 4, 8)) {
Line 258:
}
}
o_newline();</
{{out}}
<pre> 8 2 1 4</pre>
Line 264:
=={{header|ALGOL 68}}==
Using the associative array code from [[Associative_array/Iteration#ALGOL_68]]
<
# this example uses strings - for other types, the associative #
# array modes AAELEMENT and AAKEY should be modified as required #
Line 295:
# test the duplicate removal #
print( ( remove duplicates( ( "A", "B", "D", "A", "C", "F", "F", "A" ) ), newline ) )
</syntaxhighlight>
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="amazing hopper">
#include <hopper.h>
Line 316:
{"Final array:\n",y}, println
exit(0)
</syntaxhighlight>
{{out}}
<pre>
Line 334:
{{works with|GNU APL}}
The primitive monad ∪ means "unique", so:
<
1 2 3 4</
{{works with|APL2}}
{{works with|GNU APL}}
<
((⍳⍨w)=⍳⍴w)/w
1 2 3 4</
=={{header|AppleScript}}==
===Idiomatic===
<
on unique(x)
Line 353:
end repeat
return R
end unique</
----
===Idiomatic 2 (more robust)===
While it's quite common to see 'is in', 'is not in', 'contains', and 'does not contain' used in the above way for convenience when the scripter knows the code will only be used to check for simple objects, the commands actually compare ''sections of list'' rather than individual elements.
<
{1, 2, 3, {4, 5}} contains {4, 5} --> false
{1, 2, 3, {4, 5}} contains {{4, 5}} --> true</
If the search term presented is anything other than a list, it's silently coerced to one for the search.
<
So for robustness in case the elements sought may already be lists, or records, it's best to wrap them explicitly in list braces.
<
on unique(x)
Line 377:
end repeat
return R
end unique</
{{output}}
<
----
===Functional===
Line 391:
{{trans|Haskell}}
<
-- nub :: [a] -> [a]
Line 482:
set my text item delimiters to dlm
return lstParts
end splitOn</
{{Out}}
<
----
===AppleScriptObjC===
<
use framework "Foundation"
set aList to {1, 2, 3, "a", "b", "c", 2, 3, 4, "c", {b:"c"}, {"c"}, "c", "d"}
set orderedSet to current application's class "NSOrderedSet"'s orderedSetWithArray:(aList)
return orderedSet's array() as list</
{{output}}
<
=={{header|Applesoft BASIC}}==
<
110 L$(0) = "NOW"
120 L$(1) = "IS"
Line 539:
520 L$(N) = ""
530 N = N - 1
540 RETURN</
=={{header|Arturo}}==
<
print unique arr</
{{out}}
Line 553:
=={{header|AutoHotkey}}==
Built in Sort has an option to remove duplicates
<
Sort, a, a, NUD`,
MsgBox % a ; 1,2,3,4,5,15</
=={{header|AWK}}==
Line 563:
then produce a string with the keys of b,
which is finally output.
<
a b c d</
=={{header|BASIC256}}==
{{trans|True BASIC}}
<syntaxhighlight lang="basic256">
arraybase 1
max = 10
Line 598:
next i
end
</syntaxhighlight>
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
list$() = "Now", "is", "the", "time", "for", "all", "good", "men", \
\ "to", "come", "to", "the", "aid", "of", "the", "party."
Line 623:
IF j%>=i% l$(n%) = i$ : n% += 1
NEXT
= n%</
{{out}}
<pre>
Line 633:
The list contains atoms and also a few non-atomic expressions. The hash table needs atomic keys, so we apply the <code>str</code> function when searching and inserting elements.
<
(A=
Line 695:
& !C
&
)</
Only solution B produces a list with the same order of elements as in the input.
<pre>Solution A: 19 (4.4) 17 11 13 (1.1) (7.) 222 +11 7 5 3 2 0 cats (-100.2) +7
Line 702:
=={{header|Brat}}==
<
unique_array = some_array.unique</
=={{header|C}}==
Line 712:
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.
<
#include <stdlib.h>
Line 744:
printf("%d ", n->x);
puts("");
return 0;}</
{{out}}
Line 751:
===O(n^2) version, pure arrays===
<
#include <stdlib.h>
#include <stdbool.h>
Line 809:
free(b);
return 0;
}</
{{out}}
Line 816:
===Sorting method===
Using qsort and return uniques in-place:<
#include <stdlib.h>
Line 844:
return 0;
}</
{{out}}
Line 856:
=={{header|C sharp}}==
{{works with |C sharp|C#|2+}}
<
List<int> unique = new List<int>();
foreach (int n in nums)
if (!unique.Contains(n))
unique.Add(n);</
{{works with |C sharp|C#|3+}}
<
int[] unique = nums.Distinct().ToArray();</
=={{header|C++}}==
This version uses <tt>std::set</tt>, which requires its element type be comparable using the < operator.
<
#include <iostream>
using namespace std;
Line 882:
cout << *iter << " ";
cout << endl;
}</
This version uses <tt>hash_set</tt>, 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}}
<
#include <iostream>
using namespace std;
Line 901:
cout << *iter << " ";
cout << endl;
}</
This version uses <tt>unordered_set</tt>, 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}}
<
#include <iostream>
using namespace std;
Line 920:
cout << *iter << " ";
cout << endl;
}</
Alternative method working directly on the array:
<
#include <iterator>
#include <algorithm>
Line 938:
std::copy(data, new_end, std::ostream_iterator<int>(std::cout, " ");
std::cout << std::endl;
}</
Using sort, unique, and erase on a vector.
{{works with|C++11}}
<
#include <iostream>
#include <vector>
Line 955:
std::cout << std::endl;
return 0;
}</
=={{header|CafeOBJ}}==
Line 1,016:
=={{header|Ceylon}}==
<
<String|Integer>[] unique = HashSet { *data }.sequence();</
=={{header|Clojure}}==
<
(1 3 2 9 8 0)
user=></
=={{header|CoffeeScript}}==
{{trans|Kotlin}}
<
set = []
set.push i for i in data when not (i in set)
console.log data
console.log set</
{{out}}
<pre>[ 1, 2, 3, 'a', 'b', 'c', 2, 3, 4, 'b', 'c', 'd' ]
Line 1,041:
To remove duplicates non-destructively:
<
> (9 3 8 1 0 2)</
Or, to remove duplicates in-place:
<
> (9 3 8 1 0 2)</
=={{header|Crystal}}==
Line 1,053:
Copied and modified from the Ruby version.
<
p ary.uniq</
<pre>[1, 2, "a", [1, 2, 3]]</pre>
=={{header|D}}==
<
import std.stdio, std.algorithm;
Line 1,066:
.uniq
.writeln;
}</
{{out}}
<pre>[0, 1, 2, 3, 8, 9]</pre>
Using an associative array:
<
import std.stdio;
Line 1,079:
hash[el] = true;
hash.byKey.writeln;
}</
{{out}}
<pre>[8, 0, 1, 9, 2, 3]</pre>
Like code D#1, but with an array returned:
<
{
import std.stdio, std.algorithm, std.array;
Line 1,089:
auto a = [5,4,32,7,6,4,2,6,0,8,6,9].sort.uniq.array;
a.writeln;
}</
{{out}}
<pre>[0, 2, 4, 5, 6, 7, 8, 9, 32]</pre>
Line 1,096:
Generics were added in Delphi2009.
<
{$APPTYPE CONSOLE}
Line 1,119:
lIntegerList.Free;
end;
end.</
{{out}}
Line 1,130:
=={{header|Déjà Vu}}==
<
for item in [ 1 10 1 :hi :hello :hi :hi ]:
@item
!. keys set{</
{{out}}
<pre>[ 1 :hello 10 :hi ]</pre>
Line 1,139:
=={{header|E}}==
<
=={{header|ECL}}==
<
inNumbers := DATASET([{1},{2},{3},{4},{1},{1},{7},{8},{9},{9},{0},{0},{3},{3},{3},{3},{3}], {INTEGER Field1});
DEDUP(SORT(inNumbers,Field1));
</syntaxhighlight>
{{out}}
<pre>0
Line 1,159:
=={{header|Elena}}==
ELENA 5.0 :
<
import system'collections;
import system'routines;
Line 1,171:
console.printLine(unique.MapValues.asEnumerable())
}</
{{out}}
<pre>
Line 1,180:
Elixir has an <code>Enum.uniq</code> built-in function.
{{works with|Elixir|1.2}}
<
# Set approach
def uniq1(list), do: MapSet.new(list) |> MapSet.to_list
Line 1,206:
end)
|> fn{t,_} -> IO.puts "#{inspect fun}:\t#{t/1000000}\t#{inspect result}" end.()
end)</
{{out}}
Line 1,218:
=={{header|Erlang}}==
<
UniqueList = gb_sets:to_list(gb_sets:from_list(List)).
% Alternatively the builtin:
Unique_list = lists:usort( List ).
</syntaxhighlight>
=={{header|Euphoria}}==
<
function uniq(sequence s)
Line 1,241:
constant s = {1, 2, 1, 4, 5, 2, 15, 1, 3, 4}
? s
? uniq(s)</
{{out}}
Line 1,250:
=={{header|F Sharp|F#}}==
The simplest way is to build a set from the given array (this actually works for any enumerable input sequence type, not just arrays):
<
set [|1;2;3;2;3;4|]
</syntaxhighlight>
gives:
<
val it : Set<int> = seq [1; 2; 3; 4]
</syntaxhighlight>
=={{header|Factor}}==
<
V{ 1 2 1 3 2 4 5 } members .
V{ 1 2 3 4 5 }</
=={{header|Forth}}==
Line 1,273:
The input data is assumed to be sorted.
<
\ a3 is the address beyond the data a2 is traversing.
: skip-dups ( a1 a2 a3 -- a1 a2+n )
Line 1,291:
cell+ r@ skip-dups
cell 0 d+ \ increment write ptr only
repeat r> 2drop r> - cell / ;</
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.
<
a n cells+ to e
a dup to r
Line 1,306:
cell+
repeat
a - cell / ;</
To test this code, you can execute:
<
here test - cell / constant ntest
: .test ( n -- ) 0 ?do test i cells + ? loop ;
test ntest 2dup cell-sort uniq .test</
{{out}}
Line 1,322:
Fortran has no built-in hash functions or sorting functions but the code below implements the compare all elements algorithm.
<
program remove_dups
Line 1,349:
end program remove_dups
</syntaxhighlight>
Same as above but using 'ANY' to check if the input number already exists in the array of unique elements:
<
program remove_dups
implicit none
Line 1,376:
end program remove_dups
</syntaxhighlight>
{{out}}
Line 1,382:
=={{header|FreeBASIC}}==
<
Sub removeDuplicates(a() As Integer, b() As Integer)
Line 1,420:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 1,429:
=={{header|Frink}}==
The following demonstrates two of the simplest ways of removing duplicates.
<
b = [1, 5, 2, 6, 6, 2, 2, 1, 9, 8, 6, 5]
Line 1,439:
// Another way, using the "set" datatype and back to an array.
println[toArray[toSet[b]]
</syntaxhighlight>
{{out}} Note that sets are not guaranteed to be printed in any specific order.
Line 1,449:
=={{header|Futurebasic}}==
<
include "NSLog.incl"
Line 1,460:
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
Line 1,477:
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=1e2bb524d2278cd88bccdc21a1683296 Click this link to run this code]'''
<
Dim sString As String[] = Split("Now is the time for all the good men to come to the aid of the good party 1 2 1 3 3 3 2 1 1 2 3 4 33 2 5 4 333 5", " ")
Dim sFix As New String[]
Line 1,490:
Print sFix.Join(" ")
End</
Output:
<pre>
Line 1,497:
=={{header|GAP}}==
<
a := [ 1, 2, 3, 1, [ 4 ], 5, 5, [4], 6 ];
# [ 1, 2, 3, 1, [ 4 ], 5, 5, [ 4 ], 6 ]
Line 1,505:
# true
IsList(b);
# true</
=={{header|Go}}==
===Map solution===
<
import "fmt"
Line 1,527:
func main() {
fmt.Println(uniq([]int{1, 2, 3, 2, 3, 4})) // prints: [3 4 1 2] (but in a semi-random order)
}</
===Map preserving order===
It takes only small changes to the above code to preserver order. Just store the sequence in the map:
<
import "fmt"
Line 1,552:
func main() {
fmt.Println(uniq([]int{1, 2, 3, 2, 3, 4})) // prints: [1 2 3 4]
}</
===Float64, removing duplicate NaNs===
In solutions above, you just replace <code>int</code> with another type to use for a list of another type. (See [[Associative_arrays/Creation#Go]] for acceptable types.) Except a weird thing happens with NaNs. They (correctly) don't compare equal, so you have to special case them if you want to remove duplicate NaNs:
<
import (
Line 1,589:
func main() {
fmt.Println(uniq([]float64{1, 2, math.NaN(), 2, math.NaN(), 4})) // Prints [1 2 NaN 4]
}</
===Any type using reflection===
Go doesn't have templates or generics, but it does have reflection.
Line 1,598:
Note: due to details with how Go handles map keys that contain a NaN somewhere (including within a complex or even within a sub struct field) this version simply omits any NaN containing values it comes across and returns a bool to indicate if that happened. This version is otherwise a translation of the above order preserving map implementation, it does not for example call reflect.DeepEqual so elements with pointers to distinct but equal values will be treated as non-equal.
<
import (
Line 1,687:
//uniq(a)
//uniq(nil)
}</
{{out}}
<pre>
Line 1,700:
=={{header|Groovy}}==
<
assert list.size() == 12
println " Original List: ${list}"
Line 1,721:
def set = list as Set
assert set.size() == 8
println " Set: ${set}"</
{{out}}
Line 1,732:
{{trans|Modula-2}}
{{works with|PC-BASIC|any}}
<
10 ' Remove Duplicates
20 OPTION BASE 1
Line 1,760:
260 END
1000 DATA 1, 2, 2, 3, 4, 5, 5
</syntaxhighlight>
{{out}}
<pre>
Line 1,774:
===Usage===
<
[4,5,2,3]</
===Sorted result using Set===
Line 1,782:
O(n ln(n)). Requires there is a partial ordering of elements.
<
unique :: Ord a => [a] -> [a]
unique = Set.toList . Set.fromList</
===Unsorted result using Set===
Line 1,791:
O(n ln(n)). Retains original order. Requires there is a partial ordering of elements.
<
unique :: Ord a => [a] -> [a]
Line 1,798:
loop s [] = []
loop s (x : xs) | member x s = loop s xs
| otherwise = x : loop (insert x s) xs</
===Using filter===
Line 1,804:
O(n^2). Retains original order. Only requires that elements can be compared for equality.
<
unique :: Eq a => [a] -> [a]
unique [] = []
unique (x : xs) = x : unique (filter (x /=) xs)</
===Standard Library===
<
Data.List.nub :: Eq a => [a] -> [a]
Data.List.Unique.unique :: Ord a => [a] -> [a]</
=={{header|HicEst}}==
<
CHARACTER :: workspace*100
Line 1,825:
READ(Text=workspace, ItemS=individuals) nums ! convert to numeric
WRITE(ClipBoard) individuals, "individuals: ", nums ! 6 individuals: 0 1 2 3 8 9 0 0 0 0 0 0 </
=={{header|Icon}} and {{header|Unicon}}==
This solution preserves the original order of the elements.
<
every write(!noDups(args))
end
Line 1,843:
return a
}
end</
A sample run is:
<pre>
Line 1,857:
=={{header|IDL}}==
<
=={{header|Inform 7}}==
<
let result be a list of Ks;
repeat with X running through L:
add X to result, if absent;
decide on result.</
=={{header|IS-BASIC}}==
<
110 RANDOMIZE
120 NUMERIC ARR(1 TO 20),TOP
Line 1,894:
340 NEXT
350 LET REMOVE=UBOUND(A)-ST
360 END DEF</
{{out}}
Line 1,920:
=={{header|J}}==
The verb<code> ~. </code>removes duplicate items from ''any'' array (numeric, character, or other; vector, matrix, rank-n array). For example:
<
4 3 2 8 0 1 9 5 7 6
~. 'chthonic eleemosynary paronomasiac'
chtoni elmsyarp</
Or (since J defines an item of an n dimensional array as its n-1 dimensional sub arrays):
<
0 0 0
0 1 2
Line 1,935:
0 0 0
0 1 2
0 2 4</
=={{header|Java}}==
{{works with|Java|1.5}}
<
class Test {
Line 1,950:
System.out.printf("%s ", o);
}
}</
<pre>1 a 2 b 3 c d</pre>
{{works with|Java|8}}
<
class Test {
Line 1,963:
Arrays.stream(data).distinct().forEach((o) -> System.out.printf("%s ", o));
}
}</
<pre>1 2 3 a b c d</pre>
=={{header|JavaScript}}==
This uses the <code>===</code> "strict equality" operator, which does no type conversions (<code>4 == "4"</code> is true but <code>4 === "4"</code> is false)
<
// concat() with no args is a way to clone an array
var u = ary.concat().sort();
Line 1,983:
var uniq = unique(ary);
for (var i = 0; i < uniq.length; i++)
print(uniq[i] + "\t" + typeof(uniq[i]));</
<pre>1 - number
2 - number
Line 1,995:
Or, extend the prototype for Array:
<
var u = this.concat().sort();
for (var i = 1; i < u.length; ) {
Line 2,005:
return u;
}
var uniq = [1, 2, 3, "a", "b", "c", 2, 3, 4, "b", "c", "d"].unique();</
With reduce and arrow functions (ES6):
<
return this.sort().reduce( (a,e) => e === a[a.length-1] ? a : (a.push(e), a), [] )
}</
With sets and spread operator (ES6):
<
return [... new Set(this)]
}</
If, however, the array is homogenous, or we wish to interpret it as such by using JavaScript's Abstract Equality comparison (as in '==', see http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3) then it proves significantly faster to use a hash table.
Line 2,021:
For example, in ES 5:
<
var u = [],
dct = {},
Line 2,035:
return u;
}</
Or, to allow for customised definitions of equality and duplication, we can follow the Haskell prelude in defining a '''nub :: [a] -> [a] function''' which is a special case of '''nubBy :: (a -> a -> Bool) -> [a] -> [a]'''
Line 2,041:
{{trans|Haskell}}
<
'use strict';
Line 2,079:
]
})();</
{{Out}}
Line 2,088:
If it is acceptable to alter the ordering of elements, then
the builtin (fast) filter, '''unique''', can be used. It can be used for arrays with elements of any JSON type and returns the distinct elements in sorted order.
<
If all but the first occurrence of each element should be deleted, then the following function could be used. It retains the advantage of imposing no restrictions on the types of elements in the array and for that reason is slightly more complex than would otherwise be required.
<
# The hash table functions all expect the hash table to be the input.
Line 2,116:
| .[0];
</syntaxhighlight>
=={{header|Julia}}==
{{works with|Julia|0.6}}
<
@show unique(a) Set(a)</
{{out}}
Line 2,131:
(Inspired by the J version.)
<
(12 7 12 4 3
6 3 7 4 7
Line 2,161:
(0 0 0
0 1 2
0 2 4)</
=={{header|Klingphix}}==
<syntaxhighlight lang="klingphix">( )
( "Now" "is" "the" "time" "for" "all" "good" "men" "to" "come" "to" "the" "aid" "of" "the" "party." )
Line 2,179:
swap print drop nl
"End " input</
{{out}}
<pre>("Now", "is", "the", "time", "for", "all", "good", "men", "to", "come", "aid", "of", "party.")
Line 2,186:
=={{header|Kotlin}}==
{{trans|Java}}
<
val data = listOf(1, 2, 3, "a", "b", "c", 2, 3, 4, "b", "c", "d")
val set = data.distinct()
Line 2,192:
println(data)
println(set)
}</
{{out}}
<pre>[1, 2, 3, a, b, c, 2, 3, 4, b, c, d]
Line 2,198:
=={{header|Lang5}}==
<
: remove-duplicates
Line 2,205:
0 extract swap "2dup in if drop else append then" dip ;
[1 2 6 3 6 4 5 6] remove-duplicates .</
Built-in function:
<
[1 2 6 3 6 4 5 6] 's dress dup union .</
=={{header|Lasso}}==
<
x = array(3,4,8,1,8,1,4,5,6,8,9,6),
y = array
)
with n in #x where #y !>> #n do => { #y->insert(#n) }
// result: array(3, 4, 8, 1, 5, 6, 9)</
=={{header|Liberty BASIC}}==
LB has arrays, but here the elements are stored in a space-separated string.
<syntaxhighlight lang="lb">
a$ =" 1 $23.19 2 elbow 3 2 Bork 4 3 elbow 2 $23.19 "
print "Original set of elements = ["; a$; "]"
Line 2,239:
removeDuplicates$ =o$
end function
</syntaxhighlight>
Original set of elements = [ 1 $23.19 2 elbow 3 2 Bork 4 3 elbow 2 $23.19 ]
Line 2,246:
=={{header|Logo}}==
{{works with|UCB Logo}}
<
=={{header|Lua}}==
<
flags = {}
io.write('Unique items are:')
Line 2,258:
end
end
io.write('\n')</
{{out}}
<pre>Unique items are: 1 2 3 4 bird cat dog</pre>
Lua doesn't accept Not-a-Number (NaN) and nil as table key, we can handle them like this (Lua 5.3):
<
function rmdup(t)
Line 2,277:
end
print(table.concat(rmdup(items),' '))</
{{out}}
<pre>1 2 3 4 nan bird cat dog</pre>
Line 2,283:
=={{header|Maple}}==
This is simplest with a list, which is an immutable array.
<
L := [1, 2, 1, 2, 3, 3, 2, 1, "a", "b", "b", "a", "c", "b"]
> [op]({op}(L));
[1, 2, 3, "a", "b", "c"]</
That is idiomatic, but perhaps a bit cryptic; here is a more verbose equivalent:
<
[1, 2, 3, "a", "b", "c"]</
For an Array, which is mutable, the table solution works well in Maple.
<
> for u in A do T[u] := 1 end: Array( [indices]( T, 'nolist' ) );
[1, 2, 3, "c", "a", "b"]</
Note that the output (due to the Array() constructor) '''is''' in fact an Array.
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Built-in function:
<
gives back:
<
Delete duplicates and return sorted elements:
<
{{out|gives back:}}
<
=={{header|MATLAB}}==
MATLAB has a built-in function, "unique(list)", which performs this task.
<br \>Sample Usage:
<
ans =
1 2 3 4 5 6</
NOTE: The unique function only works for vectors and not for true arrays.
Line 2,320:
=={{header|Maxima}}==
<
[0, 2, 3, 4, 5, 6, 7, 8, 9]</
=={{header|MAXScript}}==
<
for i in uniques.count to 1 by -1 do
(
id = findItem uniques uniques[i]
if (id != i) do deleteItem uniques i
)</
=={{header|Microsoft Small Basic}}==
{{trans|Modula-2}}
<
' Set the data.
dataArray[1] = 1
Line 2,364:
TextWindow.WriteLine(resultArray[resultIndex])
EndFor
</syntaxhighlight>
=={{header|MiniScript}}==
<
d = {}
for i in items
d.push i
end for
print d.indexes</
{{out}}
<pre>["b", 1, "d", 3, "a", 4, "c", 2]</pre>
Line 2,379:
==={{header|mLite}}===
A bit like option 3, except copying each element as encountered, and checking to see if it has already been encountered
<
| (x eql a, a :: as) = true
| (x, _ :: as) = mem (x, as)
Line 2,394:
println ` implode ` remdup ` explode "the quick brown fox jumped over the lazy dog";
println ` remdup [1,2,3,4,4,3,2,1, "dog","cat","dog", 1.1, 2.2, 3.3, 1.1];
</syntaxhighlight>
{{out}}
<pre>the quickbrownfxjmpdvlazyg
Line 2,401:
=={{header|Modula-2}}==
{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}
<
MODULE RemoveDuplicates;
Line 2,451:
END;
END RemoveDuplicates.
</syntaxhighlight>
=={{header|MUMPS}}==
<p>We'll take advantage of the fact that an array can only have one index of any specific value. Sorting into canonical order is a side effect.
If the indices are strings containing the separator string, they'll be split apart.</p><
;L is the input listing
;S is the separator between entries
Line 2,465:
FOR SET I=$O(Z(I)) QUIT:I="" SET R=$SELECT($L(R)=0:I,1:R_S_I)
KILL Z,I
QUIT R</
Example:<pre>USER>W $$REMDUPE^ROSETTA("1,2,3,4,5,2,5,""HELLO"",42,""WORLD""",",")
1,2,3,4,5,42,"HELLO","WORLD"</pre>
Line 2,471:
=={{header|Nanoquery}}==
After executing, the list 'unique' will contain only the unique items.
<
unique = {}
Line 2,478:
unique.append(item)
end
end</
=={{header|Neko}}==
<syntaxhighlight lang="actionscript">/**
Remove duplicate elements, in Neko
*/
Line 2,504:
var show = function(k, v) $print(v, " ")
$hiter(dedup(original), show)
$print("\n")</
{{out}}
Line 2,513:
=={{header|Nemerle}}==
<
module RemDups
Line 2,523:
WriteLine(unique);
}
}</
=={{header|NetRexx}}==
This sample takes advantage of the NetRexx built-in <tt>Rexx</tt> object's indexed string capability (associative arrays). <tt>Rexx</tt> indexed strings act very like hash tables:
<
options replace format comments java crossref symbols nobinary
Line 2,574:
return wordlist.space
</syntaxhighlight>
{{out}}
<pre>
Line 2,588:
=={{header|NewLISP}}==
<
=={{header|Nial}}==
<
cull uniques
=+-+-+-+-+-+-+-+-+
=|1|2|3|a|b|c|4|d|
=+-+-+-+-+-+-+-+-+</
Using strand form
<
=1 2 3</
=={{header|Nim}}==
<
# Go through the list, and for each element, check the rest of the list to see
Line 2,625:
# Sort the elements and remove consecutive duplicate elements.
sort(items, system.cmp[int]) # O(n log n)
echo filterDup(items) # O(n)</
=={{header|Objeck}}==
<
use Structure;
Line 2,650:
}
}
</syntaxhighlight>
=={{header|Objective-C}}==
<
NSSet *unique = [NSSet setWithArray:items];</
=={{header|OCaml}}==
<
let unique_set = Hashtbl.create (List.length lst) in
List.iter (fun x -> Hashtbl.replace unique_set x ()) lst;
Line 2,664:
let _ =
uniq [1;2;3;2;3;4]</
Another solution (preserves order of first occurrence):
<
let seen = Hashtbl.create (List.length lst) in
List.filter (fun x -> let tmp = not (Hashtbl.mem seen x) in
Line 2,674:
let _ =
uniq [1;2;3;2;3;4]</
Solution reversing list order :
<
let rec tail_uniq a l =
match l with
| [] -> a
| hd::tl -> tail_uniq (hd::a) (List.filter (fun x -> x != hd) tl) in
tail_uniq [] l</
{{works with|OCaml|4.02+}}
<
=={{header|Octave}}==
<
input=[1 2 6 4 2 32 5 5 4 3 3 5 1 2 32 4 4];
output=unique(input);
</syntaxhighlight>
=={{header|Oforth}}==
Line 2,706:
=={{header|ooRexx}}==
<
uniqueData = .set~new~union(data)~makearray~sort
Line 2,713:
do item over uniqueData
say item
end</
{{out}}
<pre>Unique elements are
Line 2,729:
The following solutions only works if the value type is allowed as a key in a dictionary.
<
fun {Nub Xs}
Line 2,740:
in
{Show {Nub [1 2 1 3 5 4 3 4 4]}}</
=={{header|PARI/GP}}==
Sort and remove duplicates. Other methods should be implemented as well.
<
vecsort(v,,8)
};</
=={{header|Pascal}}==
<
const
Line 2,781:
for i := low(rArray) to last do
writeln (rArray[i]);
end.</
{{out}}
<pre>% ./RemoveDuplicates
Line 2,793:
{{libheader|List::MoreUtils}}
(this version even preserves the order of first appearance of each element)
<
my @uniq = uniq qw(1 2 3 a b c 2 3 4 b c d);</
It is implemented like this:
<
my @uniq = grep {!$seen{$_}++} qw(1 2 3 a b c 2 3 4 b c d);</
Note: the following two solutions convert elements to strings in the result, so if you give it references they will lose the ability to be dereferenced.
Alternately:
<
my @uniq = keys %hash;</
Alternately:
<
@seen{qw(1 2 3 a b c 2 3 4 b c d)} = ();
my @uniq = keys %seen;</
=={{header|Phix}}==
Standard builtin. The "STABLE" option preserves order of first occurence. Applies to any data type. The default option for unique(), "SORT", obviously produces sorted output, and there is one other recognised option, "PRESORTED", which can be used either to avoid an unnecessary sort, or to only remove adjacent duplicates.
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">unique</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Now is the time for all good men to come to the aid of the party."</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"STABLE"</span><span style="color: #0000FF;">))</span>
Line 2,821:
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">unique</span><span style="color: #0000FF;">({</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},</span><span style="color: #008000;">"STABLE"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">unique</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"chthonic eleemosynary paronomasiac"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"STABLE"</span><span style="color: #0000FF;">)</span>
<!--</
{{out}}
<pre>
Line 2,832:
=={{header|Phixmonti}}==
<
0 tolist var newlist
Line 2,845:
endfor
newlist print drop</
=={{header|PHP}}==
<
$unique_list = array_unique($list);</
=={{header|PicoLisp}}==
There is a built-in function
<
{{out}}
<pre>-> (2 4 6 1 3 5)</pre>
=={{header|PL/I}}==
<
remdup: Proc options(main);
declare t(20) fixed initial (6, 6, 1, 5, 6, 2, 1, 7,
Line 2,880:
put skip list ('Unique elements are:');
put edit ((t(k) do k = 1 to i)) (skip,20(f(3)));
end;</
{{out}}
<pre>Input:
Line 2,889:
=={{header|Pop11}}==
<
lvars ar = {1 2 3 2 3 4};
;;; Create a hash table
Line 2,901:
;;; Collect keys into a list
lvars ls = [];
appdata(ht, procedure(x); cons(front(x), ls) -> ls; endprocedure);</
=={{header|PostScript}}==
{{libheader|initlib}}
<
[10 8 8 98 32 2 4 5 10 ] dup length dict begin aload let* currentdict {pop} map end
</syntaxhighlight>
=={{header|PowerShell}}==
The common array for both approaches:
<
Using a hash table to remove duplicates:
<
foreach ($x in $data) {
$h[$x] = 1
}
$h.Keys</
Sorting and removing duplicates along the way can be done with the <code>Sort-Object</code> cmdlet.
<
Removing duplicates without sorting can be done with the <code>Select-Object</code> cmdlet.
<
=={{header|Prolog}}==
<
Example usage:
<
Xs = [1, 2, 3, 4]</
Because sort/2 is GNU prolog and not ISO here is an ISO compliant version:
<
member1(X,[_|T]) :- member1(X,T).
distinct([],[]).
distinct([H|T],C) :- member1(H,T),!, distinct(T,C).
distinct([H|T],[H|C]) :- distinct(T,C).</
Example usage:
<
Xs = [A, 1, 2, 3, 4]</
=={{header|PureBasic}}==
Task solved with the built in Hash Table which are called Maps in PureBasic
<
For i=0 To 9 ;Mark 10 items at random, causing high risk of duplication items.
Line 2,955:
ForEach MyElements()
Debug MyElements()
Next</
Output may look like this, e.g. duplicated items are automatically removed as they have the same hash value.
Number 0 is marked
Line 2,964:
=={{header|Python}}==
If all the elements are ''hashable'' (this excludes ''list'', ''dict'', ''set'', and other mutable types), we can use a <tt>set</tt>:
<
unique = list(set(items))</
or if we want to keep the order of the elements
<
unique = []
helperset = set()
Line 2,975:
if x not in helperset:
unique.append(x)
helperset.add(x)</
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:
<
items = [1, 2, 3, 'a', 'b', 'c', 2, 3, 4, 'b', 'c', 'd']
unique = [k for k,g in itertools.groupby(sorted(items))]</
If both of the above fails, we have to use the brute-force method, which is inefficient:
<
unique = []
for x in items:
if x not in unique:
unique.append(x)</
another way of removing duplicate elements from a list, while preserving the order would be to use OrderedDict module like so
<
from collections import OrderedDict as od
print(list(od.fromkeys([1, 2, 3, 'a', 'b', 'c', 2, 3, 4, 'b', 'c', 'd']).keys()))
</syntaxhighlight>
See also http://www.peterbe.com/plog/uniqifiers-benchmark and http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52560
Line 3,003:
One way to do this is to require an equality predicate, or perhaps a key function, in addition to a list to be pruned. For example, using itertools.groupby, at the cost of needing a sort and discarding order:
<
Line 3,024:
print (
nubByKey(k, xs)
)</
{{Out}}
<pre>['apple', 'aPPLE', 'Apple', 'orange', 'ORANGE', 'Orange', 'ampersand']
Line 3,033:
Or alternatively, using an equality predicate with a recursive function which scales less well, but does preserve order:
<
def nubByEq(eq, xs):
def go(yys, xxs):
Line 3,070:
print (
nubByEq(eq, xs)
)</
A briefer definition of which might be in terms of ''filter'':
<
def nubBy(p, xs):
def go(xs):
Line 3,086:
else:
return []
return go(xs)</
{{Out}}
Line 3,096:
=={{header|Qi}}==
<syntaxhighlight lang="qi">
(define remove-duplicates
[] -> []
Line 3,103:
(remove-duplicates [a b a a b b c d e])
</syntaxhighlight>
=={{header|Quackery}}==
Line 3,114:
a nest of strings sorted in descending order.
<
' sortwith nested
]'[ nested join do
Line 3,124:
drop ] is uniquewith ( [ --> [ )
' [ 1 2 3 5 6 7 8 1 2 3 4 5 6 7 ] uniquewith > echo</
{{out}}
Line 3,132:
=={{header|R}}==
<
unique (items)</
=={{header|Racket}}==
Using the built-in function
<syntaxhighlight lang="racket">
-> (remove-duplicates '(2 1 3 2.0 a 4 5 b 4 3 a 7 1 3 x 2))
'(2 1 3 2.0 a 4 5 b 7 x)
</syntaxhighlight>
Using a hash-table:
<syntaxhighlight lang="racket">
(define (unique/hash lst)
(hash-keys (for/hash ([x (in-list lst)]) (values x #t))))
</syntaxhighlight>
Using a set:
<syntaxhighlight lang="racket">
(define unique/set (compose1 set->list list->set))
</syntaxhighlight>
A definition that works with arbitrary sequences and allows
specification of an equality predicate.
<syntaxhighlight lang="racket">
(define (unique seq #:same-test [same? equal?])
(for/fold ([res '()])
([x seq] #:unless (memf (curry same? x) res))
(cons x res)))
</syntaxhighlight>
<pre>
-> (unique '(2 1 3 2.0 a 4 5 b 4 3 a 7 1 3 x 2))
Line 3,176:
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
Or just make a set of it.
<syntaxhighlight lang="raku"
=={{header|Raven}}==
<
items copy unique print
Line 3,193:
5 => "c"
6 => 4
7 => "d"</
=={{header|REBOL}}==
<
{{out}}
Line 3,202:
=={{header|Red}}==
<
>> unique items
== [1 "a" "c" 3 4 5]</
=={{header|REXX}}==
Line 3,218:
===version 1, using method 1===
<
$= '2 3 5 7 11 13 17 19 cats 222 -100.2 +11 1.1 +7 7. 7 5 5 3 2 0 4.4 2' /*item list.*/
say 'original list:' $
Line 3,228:
say
say 'modified list:' space(z) /*stick a fork in it, we're all done. */
say right( words(z), 17, '─') 'words in the modified list.'</
{{out|output|text= when using the default input list:}}
<pre>
Line 3,242:
Sorting of the list elements isn't necessary.
<
$= '2 3 5 7 11 13 17 19 cats 222 -100.2 +11 1.1 +7 7. 7 5 5 3 2 0 4.4 2' /*item list.*/
say 'original list:' $
Line 3,252:
say
say 'modified list:' space($) /*stick a fork in it, we're all done. */
say right( words(z), 17, '─') 'words in the modified list.'</
{{out|output|text= is identical to the 1<sup>st</sup> REXX version.}} <br><br>
===version 3, using method 3===
<
old = '2 3 5 7 11 13 17 19 cats 222 -100.2 +11 1.1 +7 7. 7 5 5 3 2 0 4.4 2'
say 'original list:' old
Line 3,266:
say
say 'modified list:' space(new) /*stick a fork in it, we're all done. */
say right( words(new), 17, '─') 'words in the modified list.'</
{{out|output|text= is identical to the 1<sup>st</sup> REXX version.}} <br><br>
===version 4, using method 1 (hash table) via REXX stems===
<
* 26.11.2012 Walter Pachl
* added: show multiple occurrences
Line 3,297:
If count.w>1 Then
Say right(count.w,3) w
End</
{{out}}
<pre>
Line 3,313:
=={{header|Ring}}==
<
list = ["Now", "is", "the", "time", "for", "all", "good", "men", "to", "come", "to", "the", "aid", "of", "the", "party."]
for i = 1 to len(list)
Line 3,325:
next
see nl
</syntaxhighlight>
Output:
<pre>
Line 3,333:
=={{header|Ruby}}==
Ruby has an <code>Array#uniq</code> built-in method, which returns a new array by removing duplicate values in self.
<
p ary.uniq # => [1, 2, "redundant", [1, 2, 3]]</
You can also write your own uniq method.
<
# used Hash
def uniq1
Line 3,362:
p ary.uniq1 #=> [1, 2, 3, 7, 6, 5, 4]
p ary.uniq2 #=> [1, 2, 3, 4, 5, 6, 7]
p ary.uniq3 #=> [1, 2, 3, 7, 6, 5, 4]</
A version without implementing class declarations:
<
pure = Array.new
for i in array
Line 3,378:
unique ["hi","hey","hello","hi","hey","heyo"] # => ["hi", "hey", "hello", "heyo"]
unique [1,2,3,4,1,2,3,5,1,2,3,4,5] # => [1,2,3,4,5]</
=={{header|Run BASIC}}==
<
for i = 1 to len(a$)
Line 3,394:
print "Dups:";a$
print "No Dups:";b$</
<pre>Dups:2 3 5 7 11 13 17 19 cats 222 -100.2 +11 1.1 +7 7. 7 5 5 3 2 0 4.4 2
No Dups:2 3 5 7 11 13 17 19 cats 222 -100.2 +11 1.1 +7 7. 0 4.4 </pre>
=={{header|Rust}}==
<
use std::hash::Hash;
Line 3,417:
remove_duplicate_elements_sorting(&mut sample_elements);
println!("After removal of duplicates : {:?}", sample_elements);
}</
{{out}}
<pre>
Line 3,425:
=={{header|Scala}}==
<
val l2 = list.distinct
// l2: scala.List[scala.Int] = List(1,2,3,4,99)
Line 3,432:
val arr2 = arr.distinct
// arr2: Array[Int] = Array(1, 2, 3, 4, 99)
</syntaxhighlight>
=={{header|Scheme}}==
<
(cond ((null? l)
'())
Line 3,443:
(cons (car l) (remove-duplicates (cdr l))))))
(remove-duplicates '(1 2 1 3 2 4 5))</
<
Alternative approach:
<
(do ((a '() (if (member (car l) a) a (cons (car l) a)))
(l l (cdr l)))
((null? l) (reverse a))))
(remove-duplicates '(1 2 1 3 2 4 5))</
<
The function 'delete-duplicates' is also available in srfi-1.
=={{header|Seed7}}==
<
const proc: main is func
Line 3,472:
end for;
writeln(dataSet);
end func;</
{{out}}
Line 3,480:
=={{header|SETL}}==
<
print(unique(items));</
Output in arbitrary order (convert tuple->set then set->tuple):
<
return [item: item in {item: item in items}];
end proc;</
Preserving source order
<
seen := {};
return [item: item in items, nps in {#seen} | #(seen with:= item) > nps];
end proc;</
<
seen := {};
return [item: item in items, nps in {#seen} | #(seen with:= item) > nps];
end proc;</
<
print(unique(items));</
Output in arbitrary order (convert tuple->set then set->tuple):
<
return [item: item in {item: item in items}];
end proc;</
=={{header|SETL4}}==
<syntaxhighlight lang="setl4">
set = new('set')
* Add all the elements of the array to the set.
add(set,array)
</syntaxhighlight>
=={{header|Sidef}}==
<
say ary.uniq.dump;
say ary.last_uniq.dump;</
{{out}}
<pre>[1, 2, 'redundant', [1, 2, 3]]
Line 3,523:
=={{header|Slate}}==
<
"==> {"Set traitsWindow" 1. 2. 3. 4}"</
=={{header|Smalltalk}}==
<
|a|
a := #( 1 1 2 'hello' 'world' #symbol #another 2 'hello' #symbol ).
a asSet.</
{{out}}
<pre>Set (1 2 #symbol 'world' #another 'hello' )</pre>
Line 3,541:
on my system. This can be avoided by using an ordered set (which has also O(n) complexity) as below:
{{works with|Smalltalk/X}}
<
a := #( 1 1 2 'hello' 'world' #symbol #another 2 'hello' #symbol ).
a asOrderedSet.</
{{out}}
<pre>OrderedSet(1 2 'hello' 'world' #symbol #another)</pre>
=={{header|Sparkling}}==
<
var t = {};
foreach(arr, function(key, val) {
Line 3,560:
return r;
}</
=={{header|SQL}}==
Line 3,566:
This is not a particularly efficient solution, but it gets the job done.
<syntaxhighlight lang="sql">
/*
This code is an implementation of "Remove duplicate elements" in SQL ORACLE 19c
Line 3,590:
select remove_duplicate_elements('3 9 1 10 3 7 6 5 2 7 4 7 4 2 2 2 2 8 2 10 4 9 2 4 9 3 4 3 4 7',' ') as res from dual
;
</syntaxhighlight>
{{out}}
Line 3,602:
Stata can report duplicate lines, or remove them. See '''[http://www.stata.com/help.cgi?duplicates duplicates]''' in Stata help.
<
. input x y
1 1
Line 3,626:
3. | 2 1 |
4. | 2 2 |
+-------+</
===Mata===
Line 3,632:
The '''[http://www.stata.com/help.cgi?mf_uniqrows uniqrows]''' function removes duplicate rows from a matrix.
<
: a=1,1\1,1\1,2\2,1\2,2\1,1\2,1\2,1\1,2\2,2
Line 3,657:
3 | 2 1 |
4 | 2 2 |
+---------+</
=={{header|Swift}}==
Requires elements to be hashable:
{{works with|Swift|1.2+}}
<
{{out}}
<pre>[2, 3, 1, 4]</pre>
Line 3,668:
Another solution (preserves order of first occurrence). Also requires elements to be hashable:
{{works with|Swift|1.2+}}
<
var seen = Set<T>(minimumCapacity: lst.count)
return lst.filter { x in
Line 3,677:
}
println(uniq([3,2,1,2,3,4]))</
{{out}}
<pre>[3, 2, 1, 4]</pre>
Only requires elements to be equatable, but runs in O(n^2):
<
var seen = [T]()
return lst.filter { x in
Line 3,693:
}
println(uniq([3,2,1,2,3,4]))</
{{out}}
<pre>[3, 2, 1, 4]</pre>
Line 3,701:
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 <code>lsort</code> command will remove duplicates.
<
Line 3,707:
{{trans|GW-BASIC}}
{{works with|QBasic}}
<
OPTION BASE 1
LET max = 10
Line 3,738:
NEXT i
END
</syntaxhighlight>
=={{header|TSE SAL}}==
<syntaxhighlight lang="tsesal">
//
// 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.
Line 3,779:
GotoBufferId( bufferI )
END
</syntaxhighlight>
{{out}} <pre>
Input
Line 3,803:
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
list_old="b'A'A'5'1'2'3'2'3'4"
Line 3,810:
PRINT list_old
PRINT list_new
</syntaxhighlight>
{{out}} (sorted)
<pre>
Line 3,817:
</pre>
or
<
$$ MODE TUSCRIPT
list_old="b'A'A'5'1'2'3'2'3'4"
Line 3,829:
PRINT list_old
PRINT list_new
</syntaxhighlight>
{{out}}
<pre>
Line 3,838:
=={{header|UnixPipes}}==
Assuming a sequence is represented by lines in a file.
<
bash$ printf '6\n2\n3\n6\n4\n2\n'
6
Line 3,852:
4
6
bash$</
or
<
bash$ printf '6\n2\n3\n6\n4\n2\n'|sort -nu
2
Line 3,862:
4
6
bash$</
=={{header|Ursala}}==
Line 3,872:
to decide whether that's a relevant criterion for equivalence or else
specify a better one.
<
example = |=hS& 'mississippi'</
{{out}}
<pre>'mspi'</pre>
Line 3,882:
Input list (variant : Long, Double, Boolean and Strings) :
Array(1.23456789101112E+16, True, False, True, "Alpha", 1, 235, 4, 1.25, 1.25, "Beta", 1.23456789101112E+16, "Delta", "Alpha", "Charlie", 1, 2, "Foxtrot", "Foxtrot", "Alpha", 235)
<syntaxhighlight lang="vb">
Option Explicit
Line 3,911:
ReDim Preserve Temp(cpt - 1)
Remove_Duplicate = Temp
End Function</
{{out}}
<pre> 1.23456789101112E+16
Line 3,929:
=={{header|VBScript}}==
Hash Table Approach
<syntaxhighlight lang="vb">
Function remove_duplicates(list)
arr = Split(list,",")
Line 3,945:
WScript.Echo remove_duplicates("a,a,b,b,c,d,e,d,f,f,f,g,h")
</syntaxhighlight>
{{Out}}
Line 3,953:
The input "array" is an edit buffer where each line is one element.
<
While(Replace("^(.*)\N\1$", "\1", REGEXP+BEGIN+NOERR)){} // remove duplicates</
=={{header|Vim Script}}==
<
=={{header|Visual FoxPro}}==
<
LOCAL i As Integer, n As Integer, lcOut As String
CLOSE DATABASES ALL
Line 3,986:
RETURN INT((tnHigh - tnLow + 1)*RAND() + tnLow)
ENDFUNC
</syntaxhighlight>
{{out}}
<pre>
Line 4,004:
=={{header|Vlang}}==
<
fn main() {
Line 4,019:
new_list.sort()
return new_list
}</
{{out}}
Line 4,027:
=={{header|Wart}}==
<
let exists (table)
collect+each x l
unless exists.x
yield x
exists.x <- 1</
{{out}}
Line 4,039:
=={{header|Wortel}}==
<
=={{header|Wren}}==
{{libheader|Wren-sort}}
<
// Using a map - order of distinct items is undefined.
Line 4,086:
System.print("Method 1: %(removeDuplicates1.call(a.toList))") // copy original each time
System.print("Method 2: %(removeDuplicates2.call(a.toList))")
System.print("Method 3: %(removeDuplicates3.call(a.toList))")</
{{out}}
Line 4,097:
=={{header|XBS}}==
<
set NewArray = [];
foreach(k,v as Array){
Line 4,111:
log(Arr);
RemoveDuplicates(Arr);
log(Arr);</
{{out}}
<pre>
Line 4,119:
=={{header|XPL0}}==
<
string 0; \use zero-terminated strings (not MSb terminated)
Line 4,142:
];
Text(0, Unique("Pack my box with five dozen liquor jugs."))</
{{out}}
Line 4,150:
=={{header|Yabasic}}==
<
do
Line 4,158:
loop
print r$</
=={{header|zkl}}==
Using built ins:
<
L(1,3,2,9,8,"8",0)
zkl: "1,3,2,9,1,2,3,8,8,1,0,2".unique()
,012389</
Where listUnique is brute force:
<
xs.reduce(fcn(us,s){us.holds(s) and us or us.append(s)},L()) }</
=={{header|Zoea}}==
<syntaxhighlight lang="zoea">
program: remove_duplicate_elements
input: [1,2,1,3,2,4,1]
output: [1,2,3,4]
</syntaxhighlight>
=={{header|Zoea Visual}}==
|