Contains Duplicate - Practice Coding Problems

Contains Duplicate - Problem

You're given an array of integers, and your task is to determine if any number appears more than once. This is a fundamental problem that tests your ability to efficiently detect duplicates in a dataset.

Goal: Return true if any value appears at least twice in the array, and false if every element is unique.

Example: In the array [1, 2, 3, 1], the number 1 appears twice, so we return true. But in [1, 2, 3, 4], all elements are distinct, so we return false.

This problem appears frequently in coding interviews and has multiple solution approaches with different time and space trade-offs. Master this problem to build a strong foundation in hash tables, sorting, and array manipulation!

Input & Output

example_1.py — Basic Duplicate

$ Input: [1,2,3,1]

› Output: true

💡 Note: The value 1 appears at indices 0 and 3, so we return true since there's a duplicate.

example_2.py — No Duplicates

$ Input: [1,2,3,4]

› Output: false

💡 Note: All elements are distinct (1, 2, 3, 4), so we return false as no duplicates exist.

example_3.py — Multiple Duplicates

$ Input: [1,1,1,3,3,4,3,2,4,2]

› Output: true

💡 Note: Multiple duplicates exist: 1 appears 3 times, 3 appears 3 times, 4 appears 2 times, and 2 appears 2 times. We return true upon finding the first duplicate.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
Note: The array can contain both positive and negative integers

Visualization

Tap to expand

Understanding the Visualization

Bouncer with perfect memory (Hash Set)

Remembers every face instantly - O(1) recognition time per person

Bouncer with written list (Brute Force)

Must scan entire list for each person - O(n) time per person

The result

Hash set approach is dramatically faster for large crowds

Key Takeaway

🎯 Key Insight: Hash sets provide O(1) average lookup time, making them perfect for duplicate detection. Like a bouncer with perfect memory, they recognize duplicates instantly!

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28 Apple 25

The optimal solution uses a hash set to track seen elements in O(n) time and O(n) space. As we iterate through the array, we check if each element already exists in our set. If it does, we've found a duplicate and return true immediately. This approach is faster than sorting O(n log n) and much more efficient than the brute force O(n²) nested loop approach.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set (Optimal)	O(n)	O(n)	Use a hash set to track seen elements in a single pass
Brute Force (Nested Loops)	O(n²)	O(1)	Compare every element with every other element in the array
Sorting + Linear Scan	O(n log n)	O(1) to O(n)	Sort the array first, then scan for adjacent duplicates

One-Pass Hash Set (Optimal) — Algorithm Steps

Initialize an empty hash set to store seen elements
Iterate through each element in the array
For each element, check if it already exists in the hash set
If it exists, return true (duplicate found)
If it doesn't exist, add it to the hash set
If we finish the loop without finding duplicates, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize empty set

Start with an empty hash set to track elements we've seen

Check and add elements

For each element, check if it's in the set. If not, add it.

Duplicate detected

When we encounter an element already in the set, we found our duplicate

Early termination

Return true immediately upon finding the first duplicate

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// Simple hash table implementation for integers
#define HASH_SIZE 10007

typedef struct Node {
    int key;
    struct Node* next;
} Node;

Node* hashTable[HASH_SIZE];

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

bool contains(int key) {
    int index = hash(key);
    Node* current = hashTable[index];
    while (current != NULL) {
        if (current->key == key) {
            return true;
        }
        current = current->next;
    }
    return false;
}

void insert(int key) {
    int index = hash(key);
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->key = key;
    newNode->next = hashTable[index];
    hashTable[index] = newNode;
}

bool containsDuplicate(int* nums, int numsSize) {
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    
    for (int i = 0; i < numsSize; i++) {
        if (contains(nums[i])) {
            return true;
        }
        insert(nums[i]);
    }
    return false;
}

int main() {
    int nums[1000];
    int size = 0;
    char ch;
    int num = 0;
    bool negative = false;
    bool reading = false;
    
    while ((ch = getchar()) != EOF && ch != ']') {
        if (ch >= '0' && ch <= '9') {
            num = num * 10 + (ch - '0');
            reading = true;
        } else if (ch == '-') {
            negative = true;
            reading = true;
        } else if (reading && (ch == ',' || ch == ']')) {
            nums[size++] = negative ? -num : num;
            num = 0;
            negative = false;
            reading = false;
        }
    }
    
    printf("%s\n", containsDuplicate(nums, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each element exactly once, and hash set operations (contains, add) are O(1) on average

✓ Linear Growth

Space Complexity

O(n)

In worst case, we store all n elements in the hash set (when no duplicates exist)

⚡ Linearithmic Space

128.5K Views

Very High Frequency

~15 min Avg. Time

3.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler