Sets

Sets

A set is a collection that stores unique elements—no duplicates allowed. Sets are perfect when you need to track distinct items or quickly check if something has already been there.

What You Need to Know

• Each element appears only once in a set. Adding a duplicate has no effect.
• Sets are unordered—there's no guaranteed order when you iterate through them.
• Sets provide fast membership checks: asking "is X in the set?" is very quick.
• You don't need to manage how the set stores data internally—it handles everything automatically.

Performance

Sets usually provide very fast operations:

Operation	Average case	What it means
Add	O(1)	Add an element, very fast
Remove	O(1)	Remove an element, very fast
Contains	O(1)	Check if element exists, very fast

You don't need to configure memory or settings—just use the set, and it handles everything behind the scenes.

Using Sets

JavaKotlinTypeScriptDartSwiftPython

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

Set<String> set = new HashSet<>();
set.add("apple");                  // Add element
set.add("banana");
set.add("apple");                  // Duplicate ignored
boolean contains = set.contains("apple"); // Check presence
set.remove("banana");              // Remove element

val set = mutableSetOf<String>()
set.add("apple")                   // Add element
set.add("banana")
set.add("apple")                   // Duplicate ignored
val contains = set.contains("apple") // Check presence
set.remove("banana")               // Remove element

const set = new Set<string>();
set.add("apple");                  // Add element
set.add("banana");
set.add("apple");                  // Duplicate ignored
const contains = set.has("apple"); // Check presence
set.delete("banana");              // Remove element

Set<String> set = <String>{};
set.add("apple");                  // Add element
set.add("banana");
set.add("apple");                  // Duplicate ignored
bool contains = set.contains("apple"); // Check presence
set.remove("banana");              // Remove element

var set = Set<String>()
set.insert("apple")                // Add element
set.insert("banana")
set.insert("apple")                // Duplicate ignored
let contains = set.contains("apple") // Check presence
set.remove("banana")               // Remove element

my_set = set()
my_set.add("apple")                # Add element
my_set.add("banana")
my_set.add("apple")                # Duplicate ignored
contains = "apple" in my_set       # Check presence
my_set.remove("banana")            # Remove element

Why Sets Are Useful

Sets make it easy to solve problems where you need to track unique items or avoid duplicates.

For example, suppose you want to remove duplicates from a list. Without a set, you'd have to check every element against all others, which can be slow. With a set, you can simply convert the list to a set and back, removing duplicates in one quick step:

JavaKotlinTypeScriptDartSwiftPython

import java.util.*;

public static List<Integer> removeDuplicates(List<Integer> list) {
    return new ArrayList<>(new HashSet<>(list));
}
// O(n) time, O(n) space

fun removeDuplicates(list: List<Int>): List<Int> {
    return list.toSet().toList()
}
// O(n) time, O(n) space

function removeDuplicates(list: number[]): number[] {
    return Array.from(new Set(list));
}
// O(n) time, O(n) space

List<int> removeDuplicates(List<int> list) {
    return list.toSet().toList();
}
// O(n) time, O(n) space

func removeDuplicates(_ list: [Int]) -> [Int] {
    return Array(Set(list))
}
// O(n) time, O(n) space

def remove_duplicates(lst: list[int]) -> list[int]:
    return list(set(lst))
# O(n) time, O(n) space

Sets are an essential tool when working with unique collections or when you need fast membership checks.