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