Remove duplicate elements: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
| (20 intermediate revisions by 11 users not shown) | |||
Line 497:
{{output}}
<syntaxhighlight lang="applescript">{1, 2, 3, "a", "b", "c", 4, {b:"c"}, {"c"}, "d"}</syntaxhighlight>
=={{header|Arturo}}==
Line 553 ⟶ 510:
=={{header|ATS}}==
=== ATS2 implementation for values having an ''equality
This method runs no worse than O(n*n) in the number of elements. It is an example of the brute-force technique.
Line 655 ⟶ 612:
<pre> a c b e d</pre>
=== ATS2 implementation for
This method runs no worse than O(n*n) in the number of elements. It is another example of the brute-force technique.
This implementation can handle elements of linear type. I implement the predicate as a template function.
There are two interfaces: one for an array, and one for a linked list.
<syntaxhighlight lang="ats">
(* Remove duplicate elements.
This implementation is for elements that have an "equals" (or
"equivalence") predicate. It runs O(n*n) in the number of
elements. It uses a linked list and supports linear types.
The equality predicate is implemented as a template function. *)
#include "share/atspre_staload.hats"
staload UN = "prelude/SATS/unsafe.sats"
#define NIL list_vt_nil ()
#define :: list_vt_cons
(*------------------------------------------------------------------*)
(* Interfaces *)
extern fn {a : vt@ype}
array_remove_dups
{n : int}
{p_arr : addr}
(pf_arr : array_v (a, p_arr, n) |
p_arr : ptr p_arr,
n : size_t n)
:<!wrt> [m : nat | m <= n]
@(array_v (a, p_arr, m),
array_v (a?, p_arr + (m * sizeof a), n - m) |
size_t m)
extern fn {a : vt@ype}
list_vt_remove_dups
{n : int}
(lst : list_vt (a, n))
:<!wrt> [m : nat | m <= n]
list_vt (a, m)
extern fn {a : vt@ype}
remove_dups$eq :
(&a, &a) -<> bool
extern fn {a : vt@ype}
remove_dups$clear :
(&a >> a?) -< !wrt > void
(*------------------------------------------------------------------*)
(* Implementation of array_remove_dups *)
(* The implementation for arrays converts to a list_vt, does the
removal duplicates, and then writes the data back into the original
array. *)
implement {a}
array_remove_dups {n} {p_arr} (pf_arr | p_arr, n) =
let
var lst = array_copy_to_list_vt<a> (!p_arr, n)
var m : int
val lst = list_vt_remove_dups<a> lst
val m = list_vt_length lst
prval [m : int] EQINT () = eqint_make_gint m
prval @(pf_uniq, pf_rest) =
array_v_split {a?} {p_arr} {n} {m} pf_arr
val () = array_copy_from_list_vt<a> (!p_arr, lst)
in
@(pf_uniq, pf_rest | i2sz m)
end
(*------------------------------------------------------------------*)
(* Implementation of list_vt_remove_dups *)
(* The list is worked on "in place". That is, no nodes are copied or
moved to new locations, except those that are removed and freed. *)
fn {a : vt@ype}
remove_equal_elements
{n : int}
(x : &a,
lst : &list_vt (a, n) >> list_vt (a, m))
:<!wrt> #[m : nat | m <= n]
void =
let
fun {a : vt@ype}
remove_elements
{n : nat}
.<n>.
(x : &a,
lst : &list_vt (a, n) >> list_vt (a, m))
:<!wrt> #[m : nat | m <= n]
void =
case+ lst of
| NIL => ()
| @ (head :: tail) =>
if remove_dups$eq (head, x) then
let
val new_lst = tail
val () = remove_dups$clear<a> head
val () = free@{a}{0} lst
val () = lst := new_lst
in
remove_elements {n - 1} (x, lst)
end
else
let
val () = remove_elements {n - 1} (x, tail)
prval () = fold@ lst
in
end
prval () = lemma_list_vt_param lst
in
remove_elements {n} (x, lst)
end
fn {a : vt@ype}
remove_dups
{n : int}
(lst : &list_vt (a, n) >> list_vt (a, m))
:<!wrt> #[m : nat | m <= n]
void =
let
fun
rmv_dups {n : nat}
.<n>.
(lst : &list_vt (a, n) >> list_vt (a, m))
:<!wrt> #[m : nat | m <= n]
void =
case+ lst of
| NIL => ()
| head :: NIL => ()
| @ head :: tail =>
let
val () = remove_equal_elements (head, tail)
val () = rmv_dups tail
prval () = fold@ lst
in
end
prval () = lemma_list_vt_param lst
in
rmv_dups {n} lst
end
implement {a}
list_vt_remove_dups {n} lst =
let
var lst = lst
in
remove_dups {n} lst;
lst
end
(*------------------------------------------------------------------*)
implement
remove_dups$eq<Strptr1> (s, t) =
($UN.strptr2string s = $UN.strptr2string t)
implement
remove_dups$clear<Strptr1> s =
strptr_free s
implement
array_uninitize$clear<Strptr1> (i, s) =
strptr_free s
implement
fprint_ref<Strptr1> (outf, s) =
fprint! (outf, $UN.strptr2string s)
implement (* A demonstration with linear strings. *)
main0 () =
let
#define N 10
val data =
$list_vt{Strptr1}
(string0_copy "a", string0_copy "c", string0_copy "b",
string0_copy "e", string0_copy "a", string0_copy "a",
string0_copy "d", string0_copy "d", string0_copy "b",
string0_copy "c")
var arr : @[Strptr1][N]
val () = array_copy_from_list_vt<Strptr1> (arr, data)
prval pf_arr = view@ arr
val p_arr = addr@ arr
val [m : int]
@(pf_uniq, pf_abandoned | m) =
array_remove_dups<Strptr1> (pf_arr | p_arr, i2sz N)
val () = fprint_array_sep<Strptr1> (stdout_ref, !p_arr, m, " ")
val () = println! ()
val () = array_uninitize<Strptr1> (!p_arr, m)
prval () = view@ arr :=
array_v_unsplit (pf_uniq, pf_abandoned)
in
end
(*------------------------------------------------------------------*)
</syntaxhighlight>
{{out}}
<pre> a c b e d</pre>
=== ATS2 implementation for values having both ''order'' and ''equality'' predicates ===
Sort the elements and then keep only the first element of each run of equal elements.
Line 1,323 ⟶ 1,491:
a b c d</syntaxhighlight>
=={{header|BASIC}}==
==={{header|ANSI BASIC}}===
{{trans|Modula-2}}
{{works with|Decimal BASIC}}
<syntaxhighlight lang="basic">
100 REM Remove duplicate elements
110 DIM DataArray(1 TO 7), ResultArray(1 TO 7)
120 ! Set the data.
130 FOR I = 1 TO 7
140 READ DataArray(I)
150 NEXT I
160 ! Remove duplicates
170 LET ResultArray(1) = DataArray(1)
180 LET LastResultIndex = 1
190 LET Position = 1
200 DO WHILE Position < UBOUND(DataArray)
210 LET Position = Position + 1
220 LET IsNewNumber = -1
230 FOR ResultIndex = 1 TO LastResultIndex
240 IF DataArray(Position) = ResultArray(ResultIndex) THEN
250 LET IsNewNumber = 0
260 EXIT FOR
270 END IF
280 NEXT ResultIndex
290 IF IsNewNumber = -1 THEN
300 LET LastResultIndex = LastResultIndex + 1
310 LET ResultArray(LastResultIndex) = DataArray(Position)
320 END IF
330 LOOP
340 FOR ResultIndex = 1 TO LastResultIndex
350 PRINT ResultArray(ResultIndex)
360 NEXT ResultIndex
370 DATA 1, 2, 2, 3, 4, 5, 5
380 END
</syntaxhighlight>
{{out}}
<pre>
1
2
3
4
5
</pre>
==={{header|Applesoft BASIC}}===
<syntaxhighlight lang="basic">100 DIM L$(15)
110 L$(0) = "NOW"
120 L$(1) = "IS"
130 L$(2) = "THE"
140 L$(3) = "TIME"
150 L$(4) = "FOR"
160 L$(5) = "ALL"
170 L$(6) = "GOOD"
180 L$(7) = "MEN"
190 L$(8) = "TO"
200 L$(9) = "COME"
210 L$(10) = "TO"
220 L$(11) = "THE"
230 L$(12) = "AID"
240 L$(13) = "OF"
250 L$(14) = "THE"
260 L$(15) = "PARTY."
300 N = 15
310 GOSUB 400
320 FOR I = 0 TO N
330 PRINT L$(I) " " ;
340 NEXT
350 PRINT
360 END
400 REMREMOVE DUPLICATES
410 FOR I = N TO 1 STEP -1
420 I$ = L$(I)
430 FOR J = 0 TO I - 1
440 EQ = I$ = L$(J)
450 IF NOT EQ THEN NEXT J
460 IF EQ THEN GOSUB 500
470 NEXT I
480 RETURN
500 REMREMOVE ELEMENT
510 L$(I) = L$(N)
520 L$(N) = ""
530 N = N - 1
540 RETURN</syntaxhighlight>
==={{header|BASIC256}}===
{{trans|True BASIC}}
<syntaxhighlight lang="basic256">
Line 1,357 ⟶ 1,611:
</syntaxhighlight>
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> DIM list$(15)
Line 1,385 ⟶ 1,638:
Now is the time for all good men to come aid of party.
</pre>
==={{header|FreeBASIC}}===
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
Sub removeDuplicates(a() As Integer, b() As Integer)
Dim lb As Integer = LBound(a)
Dim ub As Integer = UBound(a)
If ub = -1 Then Return '' empty array
Redim b(lb To ub)
b(lb) = a(lb)
Dim count As Integer = 1
Dim unique As Boolean
For i As Integer = lb + 1 To ub
unique = True
For j As Integer = lb to i - 1
If a(i) = a(j) Then
unique = False
Exit For
End If
Next j
If unique Then
b(lb + count) = a(i)
count += 1
End If
Next i
If count > 0 Then Redim Preserve b(lb To lb + count - 1)
End Sub
Dim a(1 To 10) As Integer = {1, 2, 1, 4, 5, 2, 15, 1, 3, 4}
Dim b() As Integer
removeDuplicates a(), b()
For i As Integer = LBound(b) To UBound(b)
Print b(i); " ";
Next
Print
Print "Press any key to quit"
Sleep</syntaxhighlight>
{{out}}
<pre>
1 2 4 5 15 3
</pre>
==={{header|FutureBasic}}===
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
CFArrayRef array, unique
OrderedSetRef ordered
array = @[@"A", @"B", @"C", @"B", @"A", @"C", @"A", @"C", @"A", @"B", @"C"]
ordered = fn OrderedSetWithArray( array )
NSLog( @"%@", fn OrderedSetArray( ordered ) )
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
(
A,
B,
C
)
</pre>
==={{header|Gambas}}===
'''[https://gambas-playground.proko.eu/?gist=1e2bb524d2278cd88bccdc21a1683296 Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
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[]
Dim sTemp As String
For Each sTemp In sString
sTemp &= " "
If InStr(sFix.Join(" ") & " ", sTemp) Then Continue
sFix.Add(Trim(sTemp))
Next
Print sFix.Join(" ")
End</syntaxhighlight>
Output:
<pre>
Now is the time for all good men to come aid of party 1 2 3 4 33 5 333
</pre>
==={{header|GW-BASIC}}===
{{trans|Modula-2}}
{{works with|BASICA}}
{{works with|PC-BASIC|any}}
<syntaxhighlight lang="qbasic">
10 ' Remove Duplicates
20 OPTION BASE 1
30 LET MAXI% = 7
40 DIM D(7), R(7): ' data, result
50 ' Set the data.
60 FOR I% = 1 TO 7
70 READ D(I%)
80 NEXT I%
90 ' Remove duplicates.
100 LET R(1) = D(1)
110 LET LRI% = 1: ' last index of result
120 LET P% = 1: ' position
130 WHILE P% < MAXI%
140 LET P% = P% + 1
150 LET ISNEW = 1: ' is a new number?
160 LET RI% = 1: ' current index of result
170 WHILE (RI% <= LRI%) AND ISNEW
180 IF D(P%) = R(RI%) THEN LET ISNEW = 0
190 LET RI% = RI% + 1
200 WEND
210 IF ISNEW THEN LET LRI% = LRI% + 1: LET R(LRI%) = D(P%)
220 WEND
230 FOR RI% = 1 TO LRI%
240 PRINT R(RI%)
250 NEXT RI%
260 END
1000 DATA 1, 2, 2, 3, 4, 5, 5
</syntaxhighlight>
{{out}}
<pre>
1
2
3
4
5
</pre>
==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 PROGRAM "RemoveDu.bas"
110 RANDOMIZE
120 NUMERIC ARR(1 TO 20),TOP
130 LET TOP=FILL(ARR)
140 CALL WRITE(ARR,TOP)
150 LET TOP=REMOVE(ARR)
160 CALL WRITE(ARR,TOP)
170 DEF WRITE(REF A,N)
180 FOR I=1 TO N
190 PRINT A(I);
200 NEXT
210 PRINT
220 END DEF
230 DEF FILL(REF A)
240 LET FILL=UBOUND(A):LET A(LBOUND(A))=1
250 FOR I=LBOUND(A)+1 TO UBOUND(A)
260 LET A(I)=A(I-1)+RND(3)
270 NEXT
280 END DEF
290 DEF REMOVE(REF A)
300 LET ST=0
310 FOR I=LBOUND(A)+1 TO UBOUND(A)
320 IF A(I-1)=A(I) THEN LET ST=ST+1
330 IF ST>0 THEN LET A(I-ST)=A(I)
340 NEXT
350 LET REMOVE=UBOUND(A)-ST
360 END DEF</syntaxhighlight>
{{out}}
<pre>START
1 1 2 4 5 7 9 10 12 14 16 16 16 17 18 20 20 22 23 23
1 2 4 5 7 9 10 12 14 16 17 18 20 22 23
ok
START
1 2 4 5 5 5 7 8 9 9 10 10 10 12 14 15 17 17 18 20
1 2 4 5 7 8 9 10 12 14 15 17 18 20
ok
START
1 3 3 4 5 6 8 10 11 12 14 16 16 16 16 18 18 19 21 21
1 3 4 5 6 8 10 11 12 14 16 18 19 21
ok
START
1 3 3 4 5 5 7 9 11 13 13 14 16 17 17 18 19 19 20 21
1 3 4 5 7 9 11 13 14 16 17 18 19 20 21
ok
START
1 2 3 5 5 6 6 7 8 10 12 14 15 17 17 19 21 23 25 25
1 2 3 5 6 7 8 10 12 14 15 17 19 21 23 25
ok</pre>
==={{header|Liberty BASIC}}===
LB has arrays, but here the elements are stored in a space-separated string.
{{works sith|Just BASIC}}
<syntaxhighlight lang="lb">
a$ =" 1 $23.19 2 elbow 3 2 Bork 4 3 elbow 2 $23.19 "
print "Original set of elements = ["; a$; "]"
b$ =removeDuplicates$( a$)
print "With duplicates removed = ["; b$; "]"
end
function removeDuplicates$( in$)
o$ =" "
i =1
do
term$ =word$( in$, i, " ")
if instr( o$, " "; term$; " ") =0 and term$ <>" " then o$ =o$ +term$ +" "
i =i +1
loop until term$ =""
removeDuplicates$ =o$
end function
</syntaxhighlight>
{{out}}
<pre>
Original set of elements = [ 1 $23.19 2 elbow 3 2 Bork 4 3 elbow 2 $23.19 ]
With duplicates removed = [ 1 $23.19 2 elbow 3 Bork 4 ]
</pre>
==={{header|Microsoft Small Basic}}===
{{trans|Modula-2}}
<syntaxhighlight lang="microsoftsmallbasic">
' Set the data.
dataArray[1] = 1
dataArray[2] = 2
dataArray[3] = 2
dataArray[4] = 3
dataArray[5] = 4
dataArray[6] = 5
dataArray[7] = 5
resultArray[1] = dataArray[1]
lastResultIndex = 1
position = 1
While position < Array.GetItemCount(dataArray)
position = position + 1
isNewNumber = 1 ' logical 1
resultIndex = 1
While (resultIndex <= lastResultIndex) And isNewNumber = 1
If dataArray[position] = resultArray[resultIndex] Then
isNewNumber = 0
EndIf
resultIndex = resultIndex + 1
EndWhile
If isNewNumber = 1 Then
lastResultIndex = lastResultIndex + 1
resultArray[lastResultIndex] = dataArray[position]
EndIf
EndWhile
For resultIndex = 1 To lastResultIndex
TextWindow.WriteLine(resultArray[resultIndex])
EndFor
</syntaxhighlight>
==={{header|PureBasic}}===
Task solved with the built in Hash Table which are called Maps in PureBasic
<syntaxhighlight lang="purebasic">NewMap MyElements.s()
For i=0 To 9 ;Mark 10 items at random, causing high risk of duplication items.
x=Random(9)
t$="Number "+str(x)+" is marked"
MyElements(str(x))=t$ ; Add element 'X' to the hash list or overwrite if already included.
Next
ForEach MyElements()
Debug MyElements()
Next</syntaxhighlight>
Output may look like this, e.g. duplicated items are automatically removed as they have the same hash value.
Number 0 is marked
Number 2 is marked
Number 5 is marked
Number 6 is marked
==={{header|Run BASIC}}===
<syntaxhighlight lang="runbasic">a$ = "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"
for i = 1 to len(a$)
a1$ = word$(a$,i)
if a1$ = "" then exit for
for i1 = 1 to len(b$)
if a1$ = word$(b$,i1) then [nextWord]
next i1
b$ = b$ + a1$ + " "
[nextWord]
next i
print "Dups:";a$
print "No Dups:";b$</syntaxhighlight>
<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|True BASIC}}===
{{trans|GW-BASIC}}
{{works with|QBasic}}
{{works with|Decimal BASIC}}
<syntaxhighlight lang="basic">
OPTION BASE 1
LET max = 10
DIM dat(10), res(10)
FOR i = 1 TO max
READ dat(i)
NEXT i
DATA 1, 2, 1, 4, 5, 2, 15, 1, 3, 4
LET res(1) = dat(1)
LET count = 1
LET posic = 1
DO WHILE posic < max
LET posic = posic + 1
LET esnuevo = 1
LET indice = 1
DO WHILE (indice <= count) AND esnuevo = 1
IF dat(posic) = res(indice) THEN LET esnuevo = 0
LET indice = indice + 1
LOOP
IF esnuevo = 1 THEN
LET count = count + 1
LET res(count) = dat(posic)
END IF
LOOP
FOR i = 1 TO count
PRINT res(i);
NEXT i
END
</syntaxhighlight>
==={{header|VBA}}===
Hash Table Approach
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
Sub Main()
Dim myArr() As Variant, i As Long
myArr = Remove_Duplicate(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))
'return :
For i = LBound(myArr) To UBound(myArr)
Debug.Print myArr(i)
Next
End Sub
Private Function Remove_Duplicate(Arr As Variant) As Variant()
Dim myColl As New Collection, Temp() As Variant, i As Long, cpt As Long
ReDim Temp(UBound(Arr))
For i = LBound(Arr) To UBound(Arr)
On Error Resume Next
myColl.Add CStr(Arr(i)), CStr(Arr(i))
If Err.Number > 0 Then
On Error GoTo 0
Else
Temp(cpt) = Arr(i)
cpt = cpt + 1
End If
Next i
ReDim Preserve Temp(cpt - 1)
Remove_Duplicate = Temp
End Function</syntaxhighlight>
{{out}}
<pre> 1.23456789101112E+16
True
False
Alpha
1
235
4
1.25
Beta
Delta
Charlie
2
Foxtrot</pre>
==={{header|VBScript}}===
Hash Table Approach
<syntaxhighlight lang="vb">
Function remove_duplicates(list)
arr = Split(list,",")
Set dict = CreateObject("Scripting.Dictionary")
For i = 0 To UBound(arr)
If dict.Exists(arr(i)) = False Then
dict.Add arr(i),""
End If
Next
For Each key In dict.Keys
tmp = tmp & key & ","
Next
remove_duplicates = Left(tmp,Len(tmp)-1)
End Function
WScript.Echo remove_duplicates("a,a,b,b,c,d,e,d,f,f,f,g,h")
</syntaxhighlight>
{{Out}}
<pre>a,b,c,d,e,f,g,h</pre>
==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">data "Now", "is", "the", "time", "for", "all", "good", "men", "to", "come", "to", "the", "aid", "of", "the", "party.", ""
do
read p$
if p$ = "" break
if not instr(r$, p$) r$ = r$ + p$ + " "
loop
print r$</syntaxhighlight>
=={{header|BQN}}==
<syntaxhighlight lang="bqn">⍷ 2‿4‿9‿7‿3‿7‿4‿1‿9‿2‿5‿7‿2‿2‿8‿9‿6‿6‿5‿8</syntaxhighlight>
{{out}}
<pre>⟨ 2 4 9 7 3 1 5 8 6 ⟩</pre>
=={{header|Bracmat}}==
Line 1,897 ⟶ 2,554:
<syntaxhighlight lang="e">[1,2,3,2,3,4].asSet().getElements()</syntaxhighlight>
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
a[] = [ 1 2 1 4 5 2 15 1 3 4 ]
for a in a[]
found = 0
for b in b[]
if a = b
found = 1
break 1
.
.
if found = 0
b[] &= a
.
.
print b[]
</syntaxhighlight>
=={{header|ECL}}==
Line 1,915 ⟶ 2,592:
=={{header|Elena}}==
ELENA
<syntaxhighlight lang="elena">import extensions;
import system'collections;
Line 1,925 ⟶ 2,602:
auto unique := new Map<int, int>();
nums.forEach::(n){ unique[n] := n };
console.printLine(unique.MapValues.asEnumerable())
Line 1,932 ⟶ 2,609:
<pre>
1,2,3,4
</pre>
=={{header|Ecstasy}}==
<syntaxhighlight lang="java">
module RetainUniqueValues {
void run() {
Int[] array = [1, 2, 3, 2, 1, 2, 3, 4, 5, 3, 2, 1];
array = array.distinct().toArray();
@Inject Console console;
console.print($"result={array}");
}
}
</syntaxhighlight>
{{out}}
<pre>
result=[1, 2, 3, 4, 5]
</pre>
Line 2,138 ⟶ 2,833:
<pre>Unique list has 6 elements: 1 2 3 4 5 6</pre>
=={{header|Frink}}==
Line 2,202 ⟶ 2,852:
[1, 2, 5, 6, 8, 9]
[9, 8, 6, 5, 2, 1]
</pre>
Line 2,485 ⟶ 3,086:
Original List, filtered: [1, 2, 3, a, b, c, 4, d]
Set: [1, 2, 3, a, b, c, 4, d]</pre>
=={{header|Haskell}}==
===Usage===
<syntaxhighlight lang="haskell"> print $ unique [4, 5, 4, 2, 3, 3, 4]
Line 2,624 ⟶ 3,182:
decide on result.</syntaxhighlight>
=={{header|J}}==
Line 2,693 ⟶ 3,201:
0 1 2
0 2 4</syntaxhighlight>
=={{header|Jakt}}==
The array version preserves order based on first occurrence.
<syntaxhighlight lang="jakt">
fn deduplicated<T>(anon array: [T]) throws -> [T] {
mut existing_items: {T} = {}
mut result: [T] = []
for value in array {
if not existing_items.contains(value) {
existing_items.add(value)
result.push(value)
}
}
return result
}
fn deduplicated_set<T>(anon array: [T]) throws -> {T} {
mut result: {T} = {}
for value in array {
result.add(value)
}
return result
}
fn main() {
let array = [1, 2, 3, 3, 2, 5, 4]
println("{}", deduplicated(array))
println("{}", deduplicated_set(array))
}
</syntaxhighlight>
=={{header|Java}}==
There is more than 1 way to achieve this. The most logical approach will depend on your application.<br />
<syntaxhighlight lang="java">
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
</syntaxhighlight>
One way would be to add the values to a ''Set'' object, which only allows for unique values.
<syntaxhighlight lang="java">
int[] removeDuplicates(int[] values) {
/* use a LinkedHashSet to preserve order */
Set<Integer> set = new LinkedHashSet<>();
for (int value : values)
set.add(value);
values = new int[set.size()];
Iterator<Integer> iterator = set.iterator();
int index = 0;
while (iterator.hasNext())
values[index++] = iterator.next();
return values;
}
</syntaxhighlight>
Alternately, you could simply add the values to a mutable ''List'', checking if the list already contains the value before adding it.
<syntaxhighlight lang="java">
int[] removeDuplicates(int[] values) {
List<Integer> list = new ArrayList<>();
for (int value : values)
if (!list.contains(value)) list.add(value);
values = new int[list.size()];
int index = 0;
for (int value : list)
values[index++] = value;
return values;
}
</syntaxhighlight>
<pre>
[2, 1, 4, 1, 1, 3, 1, 3, 1, 4, 3, 2, 3, 4, 3, 2, 2, 3, 3, 3]
[2, 1, 4, 3]
[2, 4, 1, 4, 1, 4, 3, 1, 1, 3, 4, 4, 4, 4, 2, 1, 1, 2, 3, 2]
[2, 4, 1, 3]
</pre>
<br />
Alternate approaches
{{works with|Java|1.5}}
<syntaxhighlight lang="java5">import java.util.*;
Line 2,841 ⟶ 3,426:
<pre>[[4, 3, 2, 8, 0, 1, 9, 5, 7, 6], "chtoni elmsyarp"]</pre>
=={{header|Joy}}==
<syntaxhighlight lang="joy">DEFINE uniq == [[]] [[in] [swap pop] [cons] ifte] primrec.</syntaxhighlight>
=={{header|jq}}==
Line 2,975 ⟶ 3,563:
// result: array(3, 4, 8, 1, 5, 6, 9)</syntaxhighlight>
=={{header|
<syntaxhighlight lang="scheme">
{def removedup
{def removedup.loop
{lambda {:a :b}
{if {A.empty? :a}
then :b
else {removedup.loop {A.rest :a}
{if {= {A.in? {A.first :a} :b} -1}
then {A.addlast! {A.first :a} :b}
else :b}}}}}
{lambda {:s}
{S.replace (\[|\]|,) by space in
{A.disp
{removedup.loop {A.new :s} {A.new}}}}}}
-> removedup
{removedup 1 2 3 a b c 2 3 4 b c d}
-> 1 2 3 a b c 4 d
</syntaxhighlight>
=={{header|Logo}}==
Line 3,129 ⟶ 3,713:
if (id != i) do deleteItem uniques i
)</syntaxhighlight>
=={{header|MiniScript}}==
Line 3,788 ⟶ 4,337:
<syntaxhighlight lang="prolog">?- distinct([A, A, 1, 2, 3, 2, 3, 4],Xs).
Xs = [A, 1, 2, 3, 4]</syntaxhighlight>
=={{header|Python}}==
Line 4,175 ⟶ 4,705:
<pre>
Now is the time for all good men to come aid of party.
</pre>
=={{header|RPL}}==
We follow here a fourth way, which requires few words and take advantage of the (relative) speed of the <code>POS</code> function.
{{works with|Halcyon Calc|4.2.8}}
{| class="wikitable"
! RPL code
! Comment
|-
|
≪ → input
≪ { }
1 input SIZE '''FOR''' j
input j GET
'''IF''' DUP2 POS '''THEN''' DROP '''ELSE''' + '''END '''
'''NEXT'''
≫ ≫ ‘'''NODUP'''’ STO
|
'''NODUP''' ''( { a b a...c } -- { a b..c } ) ''
Initialize output list
Go through input list
If input[j] already in output list
then forget it else add it to output list
End loop
|}
{ 1 2 3 'a' 'b' 'c' 2 3 4 'b' 'c' 'd' } '''NODUP'''
{{out}}
<pre>
1: { 1 2 3 'a' 'b' 'c' 4 'd' }
</pre>
Line 4,225 ⟶ 4,785:
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]</syntaxhighlight>
=={{header|Rust}}==
Line 4,548 ⟶ 5,090:
With the correct option, the <code>lsort</code> command will remove duplicates.
<syntaxhighlight lang="tcl">set result [lsort -unique $listname]</syntaxhighlight>
=={{header|TSE SAL}}==
Line 4,723 ⟶ 5,228:
{{out}}
<pre>'mspi'</pre>
=={{header|Vedit macro language}}==
The input "array" is an edit buffer where each line is one element.
<syntaxhighlight lang="vedit">Sort(0, File_Size) // sort the data
Line 4,803 ⟶ 5,235:
=={{header|Vim Script}}==
<syntaxhighlight lang="vim">call filter(list, 'count(list, v:val) == 1')</syntaxhighlight>
Line 4,889 ⟶ 5,320:
=={{header|Wren}}==
{{libheader|Wren-sort}}
<syntaxhighlight lang="
// Using a map - order of distinct items is undefined.
Line 4,994 ⟶ 5,425:
Pack myboxwithfvedznlqurjgs.
</pre>
=={{header|zkl}}==
| |||