Creating implementation for idiom 119 : Deduplicate list

Idiom

# 119 Deduplicate list

Created by

Lead paragraph

Remove duplicates from the list x.
Explain if the original order is preserved.

New implementation

Language

Imports

Code

Documentation URL

Original attribution URL

Online runnable demo

Username

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating material.

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

Other implementations

(distinct x)

#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);

Demo

#include <algorithm>
#include <vector>

std::sort(x.begin(), x.end());
auto last = std::unique(x.begin(), x.end());
x.erase(last, x.end());

Demo
Doc

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

var uniques = x.Distinct().ToList();

import std.algorithm;
import std.array;

x = x.sort.uniq.array;

import std.container;
import std.array;

x = redBlackTree(x)[].array;

x = x.toSet().toList();

Demo
Origin

Enum.uniq(x)

Doc
Origin

S = lists:usort(X)

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]

Demo

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

Demo

import (
	"fmt"
	"slices"
)

slices.Sort(x)
x = slices.Compact(x)

Demo

func deduplicate[S ~[]T, T comparable](x S) S {
	seen := make(map[T]bool)
	j := 0
	for _, v := range x {
		if !seen[v] {
			x[j] = v
			j++
			seen[v] = true
		}
	}
	var zero T
	for i := j; i < len(x); i++ {
		// Avoid memory leak
		x[i] = zero
	}
	return x[:j]
}

Demo

seen := make(map[T]bool)
j := 0
for _, v := range x {
	if !seen[v] {
		x[j] = v
		j++
		seen[v] = true
	}
}
x = x[:j]

Demo

x.unique()

Demo
Doc

import Data.List (nub)

nub x

x = [...new Set(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;
});

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.add(curr);
  }
}

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

Set<T> uniques = new HashSet<>(x);
x.clear();
x.addAll(uniques);

import java.util.ArrayList;
import java.util.LinkedHashSet;

x = new ArrayList<>(new LinkedHashSet<>(x));

import java.util.Iterator;
import java.util.List;

Iterator<T> g;
T t;
int i, n;
for (i = 0, n = x.size(); i < n; ++i) {
    t = x.get(i);
    g = x.listIterator(i + 1);
    while (g.hasNext())
        if (g.next().equals(t)) {
            g.remove();
            --n;
        }
}

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

x = new ArrayList<T>(new HashSet<T>(x));

x = x.distinct()

Demo
Doc

x = x.toSet().toList()

Demo

(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);

def dedup(x):
  y = []
  for i in x:
    if not i in y:
      y.append(i)
  return y

x = list({*x})

a, b, n = 0, 0, len(x)
t = None
while a != n:
    t, b = x[a], a + 1
    while b != n:
        if x[b] == t:
            del x[b]
            n = n - 1
        else: b = b + 1
    a = a + 1

x = list(set(x))

from collections import OrderedDict

x = list(OrderedDict(zip(x, x)))

x.uniq!

use itertools::Itertools;

let dedup: Vec<_> = x.iter().unique().collect();

Demo
Doc

x.sort();
x.dedup();

Demo
Doc

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)

Origin

x intersection: x asSet.

x asSet.

x = x.Distinct.ToList

Preview