Kotlin check list for duplicates

x = x.distinct[]

x = x.toSet[].toList[]

[distinct x]

#include #include

std::sort[x.begin[], x.end[]]; auto last = std::unique[x.begin[], x.end[]]; x.erase[last, x.end[]];

#include #include #include

std::vector x = {"one", "two", "two", "one", "three"}; std::unordered_set t; for [auto e : x] t.insert[e];

using System.Collections.Generic; using System.Linq;

var uniques = x.Distinct[].ToList[];

import std.container; import std.array;

x = redBlackTree[x][].array;

import std.algorithm; import std.array;

x = x.sort.uniq.array;

x = x.toSet[].toList[];

Enum.uniq[x]

S = lists:usort[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

seen := make[map[T]bool] j := 0 for _, v := range x { if !seen[v] { x[j] = v j++ seen[v] = true } } for i := j; i < len[x]; i++ { x[i] = nil } x = x[:j]

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.unique[]

import Data.List [sort]

nub $ sort x

x = Array.from[new Set[x]];

const seen = new Set[]; x = x.filter[ v => { if[seen.has[v]] return false; seen.add[v]; return true; }];

x = [...new Set[x]];

import java.util.HashSet; import java.util.ArrayList;

x = new ArrayList[new HashSet[x]];

import java.util.HashSet; import java.util.List; import java.util.Set;

Set uniques = new HashSet[x]; x.clear[]; x.addAll[uniques];

import java.util.HashSet; import java.util.Iterator;

final HashSet seen = new HashSet[]; final Iterator listIt = x.iterator[]; while [listIt.hasNext[]] { final T curr = listIt.next[]; if [seen.contains[curr]] { listIt.remove[]; } else { seen.add[curr]; } }

[remove-duplicates x]

local seen = {} for index,item in ipairs[x] do if seen[item] then table.remove[x, index] else seen[item] = true end end

@import Foundation;

[NSSet setWithArray:x].allObjects

$x = array_unique[$x];

uses classes;

var x: TList; begin for i:= x.count-1 downto 0 do if x.indexOf[x.items[i]] -1 then x.delete[i]; end;

use List::MoreUtils 'uniq';

@x = uniq[@x];

from collections import OrderedDict

x = list[OrderedDict[zip[x, x]]]

x = list[set[x]]

x.uniq!

x.sort[]; x.dedup[];

use itertools::Itertools;

let dedup: Vec = x.iter[].unique[].collect[];

x = x.distinct

[define [remove-duplicates l] [cond [[null? l] '[]] [[member [car l] [cdr l]] [remove-duplicates [cdr l]]] [else [cons [car l] [remove-duplicates [cdr l]]]]]] [remove-duplicates x]

x asSet.

x intersection: x asSet.

x = x.Distinct.ToList