# Programming-Idioms

# 119
Implementation
Go

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please try to avoid dependencies to third-party libraries and frameworks.

Other implementations
import java.util.HashSet;
import java.util.List;
import java.util.Set;
Set<T> uniques = new HashSet<>(x);
x.clear();
import java.util.HashSet;
import java.util.ArrayList;
x = new ArrayList<T>(new HashSet<T>(x));
y := make(map[T]struct{}, len(x))
for _, v := range x {
y[v] = struct{}{}
}
x2 := make([]T, 0, len(y))
for _, v := range x {
if _, ok := y[v]; ok {
x2 = append(x2, v)
delete(y, v)
}
}
x = x2
import std.algorithm;
import std.array;
x = x.sort.uniq.array;
import std.container;
import std.array;
x = redBlackTree(x)[].array;
x = list(set(x))
import Data.List (sort)
nub \$ sort x
using System.Collections.Generic;
using System.Linq;
var uniques = x.Distinct().ToList();
\$x = array_unique(\$x);
uses classes;
var
list: TList;
begin
for i:= list.count-1 downto 0 do
if list.indexOf(list.items[i]) <> -1 then
list.delete(i);
end;
x.uniq!
use List::MoreUtils 'uniq';
@x = uniq(@x);
x.sort();
x.dedup();
import java.util.HashSet;
import java.util.Iterator;
final HashSet<T> seen = new HashSet<T>();
final Iterator<T> listIt = x.iterator();
while (listIt.hasNext()) {
final T curr = listIt.next();
if (seen.contains(curr)) {
listIt.remove();
} else {
}
}
seen := make(map[T]bool)
j := 0
for _, v := range x {
if !seen[v] {
x[j] = v
j++
seen[v] = true
}
}
x = x[:j]
x = [...new Set(x)];
x = Array.from(new Set(x));
const seen = new Set();
x = x.filter( v => {
if(seen.has(v))
return false;
return true;
});
x = x.distinct
Enum.uniq([1,26,3,40,5,6,6,7])
#include <algorithm>
#include <vector>
std::sort(x.begin(), x.end());
auto last = std::unique(x.begin(), x.end());
x.erase(last, x.end());
#include <string>
#include <unordered_set>
#include <vector>
std::vector<std::string> x = {"one", "two", "two", "one", "three"};
std::unordered_set<std::string> t;
for (auto e : x)
t.insert(e);
val duplicates = listOf("b", "a", "b", "c")
val noDuplicates = duplicates.toSet().toList()
(remove-duplicates x)
S = sets:from_list(X),
sets:to_list(S).
(distinct x)
(distinct x)
val duplicates = listOf("b", "a", "b", "c")
val noDuplicates = duplicates.distinct()
from collections import OrderedDict
x = list(OrderedDict(zip(x, x)))
x = x.toSet().toList();
x = x.Distinct.ToList