First Unique Number - Practice Coding Problems

First Unique Number - Problem

Array Hash Table Design Queue Data Stream Medium

Design a data structure that efficiently tracks the first unique number in a dynamic stream of integers. Imagine you're processing a continuous flow of numbers and need to quickly identify which number appears exactly once and comes first in the order they were received.

Your task is to implement the FirstUnique class with three key methods:

• FirstUnique(int[] nums) - Initialize with an array of numbers
• int showFirstUnique() - Return the first number that appears exactly once, or -1 if no such number exists
• void add(int value) - Add a new number to the stream

The challenge is to maintain real-time efficiency as numbers are continuously added to the stream. This problem simulates real-world scenarios like finding the first unique visitor ID, tracking unique transactions, or identifying the first non-duplicate item in a processing queue.

Input & Output

example_1.py — Basic Operations

$ Input: FirstUnique([2, 3, 5]) showFirstUnique() → 2 add(5) showFirstUnique() → 2 add(2) showFirstUnique() → 3

› Output: 2, 2, 3

💡 Note: Initially [2,3,5] all appear once, so first unique is 2. Adding 5 makes it [2,3,5,5], but 2 is still first unique. Adding 2 makes it [2,3,5,5,2], now 2 appears twice, so first unique is 3.

example_2.py — No Unique Elements

$ Input: FirstUnique([7, 7, 7, 7, 7, 7]) showFirstUnique() → -1 add(7) showFirstUnique() → -1 add(3) showFirstUnique() → 3

› Output: -1, -1, 3

💡 Note: All elements are 7 (not unique), so return -1. Adding another 7 doesn't change this. Adding 3 gives us the first unique element.

example_3.py — Dynamic Stream

$ Input: FirstUnique([809]) showFirstUnique() → 809 add(809) showFirstUnique() → -1

› Output: 809, -1

💡 Note: Initially 809 appears once. After adding 809 again, it appears twice and is no longer unique, so return -1.

Visualization

Tap to expand

Track Frequency: Count how many times each dish is ordered2. Queue Management: Keep potentially unique dishes in order3. Lazy Cleanup: Remove non-unique dishes only when checking priority4. Efficient Service: First unique dish gets immediate priority💡 Key Insight: Combine frequency tracking with ordered queue for O(1) performance!

Understanding the Visualization

Order Tracking

Keep a count of each dish type and maintain a queue of potentially unique orders

New Order

When a new order arrives, update the count and add to queue if it's the first time

Find First Unique

Clean up the front of the queue by removing dishes that are no longer unique

Serve Priority

The dish at the front of the cleaned queue gets priority

Key Takeaway

🎯 Key Insight: The optimal solution brilliantly combines frequency counting (hash map) with order preservation (queue), using lazy cleanup to achieve O(1) amortized performance for real-time stream processing.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Both add() and showFirstUnique() are O(1) amortized. Each element is added/removed from queue at most once

✓ Linear Growth

Space Complexity

O(n)

Hash map stores up to n unique numbers, queue stores at most n elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁸
1 ≤ value ≤ 10⁸
At most 50000 calls will be made to showFirstUnique and add combined
Follow-up: Could you implement this with O(1) time complexity for both showFirstUnique() and add()?

Asked in

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

The optimal solution uses a hash map to track element frequencies combined with a queue to maintain insertion order. This achieves O(1) amortized time for both operations by lazy cleanup - elements are only removed from the queue when needed during queries, making it highly efficient for stream processing scenarios.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map + Queue (Optimal)	O(1)	O(n)	Use hash map for frequency tracking and queue to maintain order of unique elements
Brute Force (Linear Search Each Time)	O(n²)	O(n)	For each query, scan the entire array to find the first unique element

Hash Map + Queue (Optimal) — Algorithm Steps

Initialize a hash map for frequency counting and a queue for unique elements
For each number added, increment its frequency in the hash map
If frequency becomes 1, add to queue; if > 1, mark as non-unique
For showFirstUnique(), clean up the queue front (remove non-unique elements)
Return the front of cleaned queue or -1 if empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create frequency map and unique queue

Add element

Update frequency, add to queue if first occurrence

Query

Clean queue front, return first unique

Update

Maintain both structures efficiently

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct HashNode {
    int key;
    int value;
    struct HashNode* next;
} HashNode;

typedef struct {
    HashNode* table[HASH_SIZE];
    int* uniqueQueue;
    int front;
    int rear;
    int capacity;
} FirstUnique;

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

FirstUnique* firstUniqueCreate(int* nums, int numsSize) {
    FirstUnique* obj = malloc(sizeof(FirstUnique));
    memset(obj->table, 0, sizeof(obj->table));
    obj->capacity = numsSize + 1000;
    obj->uniqueQueue = malloc(obj->capacity * sizeof(int));
    obj->front = 0;
    obj->rear = 0;
    
    for (int i = 0; i < numsSize; i++) {
        firstUniqueAdd(obj, nums[i]);
    }
    
    return obj;
}

void putHash(HashNode** table, int key, int value) {
    int index = hash(key);
    HashNode* node = table[index];
    
    while (node) {
        if (node->key == key) {
            node->value = value;
            return;
        }
        node = node->next;
    }
    
    HashNode* newNode = malloc(sizeof(HashNode));
    newNode->key = key;
    newNode->value = value;
    newNode->next = table[index];
    table[index] = newNode;
}

int getHash(HashNode** table, int key) {
    int index = hash(key);
    HashNode* node = table[index];
    
    while (node) {
        if (node->key == key) {
            return node->value;
        }
        node = node->next;
    }
    return 0;
}

int firstUniqueShowFirstUnique(FirstUnique* obj) {
    while (obj->front < obj->rear && 
           getHash(obj->table, obj->uniqueQueue[obj->front]) > 1) {
        obj->front++;
    }
    
    return obj->front < obj->rear ? obj->uniqueQueue[obj->front] : -1;
}

void firstUniqueAdd(FirstUnique* obj, int value) {
    int count = getHash(obj->table, value) + 1;
    putHash(obj->table, value, count);
    
    if (count == 1) {
        obj->uniqueQueue[obj->rear++] = value;
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Both add() and showFirstUnique() are O(1) amortized. Each element is added/removed from queue at most once

✓ Linear Growth

Space Complexity

O(n)

Hash map stores up to n unique numbers, queue stores at most n elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁸
1 ≤ value ≤ 10⁸
At most 50000 calls will be made to showFirstUnique and add combined
Follow-up: Could you implement this with O(1) time complexity for both showFirstUnique() and add()?

32.0K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Map + Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler