Find All Lonely Numbers in the Array - Practice Coding Problems

Find All Lonely Numbers in the Array - Problem

Find All Lonely Numbers in the Array

You are given an integer array nums. A number x is considered lonely when it satisfies two conditions:

1. It appears exactly once in the array
2. Neither of its adjacent numbers (x - 1 and x + 1) exist in the array

For example, if x = 5 appears once, it's lonely only if neither 4 nor 6 appear anywhere in the array.

Goal: Return all lonely numbers in nums. You may return the answer in any order.

Example: In array [10, 6, 5, 8], number 10 is lonely (appears once, no 9 or 11), but 5 is not lonely (appears once but 6 exists).

Input & Output

example_1.py — Basic Case

$ Input: nums = [10, 6, 5, 8]

› Output: [10, 8]

💡 Note: Number 10 appears once and neither 9 nor 11 exist. Number 8 appears once and neither 7 nor 9 exist. Number 6 appears once but 5 exists (adjacent). Number 5 appears once but 6 exists (adjacent).

example_2.py — No Lonely Numbers

$ Input: nums = [1, 3, 5, 3]

› Output: []

💡 Note: Number 1 appears once but no neighbors to check - however, since we have consecutive gaps, let's reconsider. Actually, 1 appears once and neither 0 nor 2 exist, so 1 should be lonely. Number 3 appears twice (not lonely). Number 5 appears once and neither 4 nor 6 exist, so 5 should be lonely. Correct output should be [1, 5].

example_3.py — Single Element

$ Input: nums = [7]

› Output: [7]

💡 Note: Number 7 appears once and neither 6 nor 8 exist in the array, making it lonely.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
Array may contain duplicate numbers
Important: A number must appear exactly once AND have no adjacent numbers to be lonely

Visualization

Tap to expand

Understanding the Visualization

Count Attendance

Build a guest list showing how many times each person appeared

Find Loners

Identify guests who came exactly once

Check Friends

For each loner, see if their close friends (±1) attended

Identify Antisocial

Guests who came alone AND whose friends didn't show are truly lonely

Key Takeaway

🎯 Key Insight: Use a hash map to efficiently check both frequency (must be 1) and neighbor existence (x±1 must not exist). The optimal solution processes each unique number only once.

Asked in

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

The optimal solution uses a hash map to count frequencies in O(n) time. A number is lonely if it appears exactly once and neither x-1 nor x+1 exist in the map. The one-pass approach is most efficient, building the frequency map first, then checking each unique key for loneliness conditions.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Build frequency map and identify lonely numbers in a single pass
Brute Force (Nested Loops)	O(n²)	O(1)	For each number, scan entire array to check frequency and neighbor existence
Two-Pass Hash Table	O(n)	O(n)	Build frequency map first, then check lonely conditions in second pass

One-Pass Hash Table (Optimal) — Algorithm Steps

Single pass: Build hash map counting frequency of each number
Iterate through unique keys in the hash map
For each key with frequency 1, check if x-1 exists in hash map
Check if x+1 exists in hash map
If neither adjacent number exists, add to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Frequency Map

Single pass to count all numbers

Iterate Unique Keys

Check each unique number only once

Apply Lonely Test

Verify frequency=1 and no neighbors

Collect Results

Gather all lonely numbers

Code -

solution.c — C

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

// Hash table implementation optimized for this problem
#define HASH_SIZE 100003

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

typedef struct {
    Node* table[HASH_SIZE];
    int* keys;
    int keyCount;
    int keyCapacity;
} HashMap;

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

HashMap* createHashMap() {
    HashMap* map = (HashMap*)malloc(sizeof(HashMap));
    for (int i = 0; i < HASH_SIZE; i++) {
        map->table[i] = NULL;
    }
    map->keyCapacity = 1000;
    map->keys = (int*)malloc(map->keyCapacity * sizeof(int));
    map->keyCount = 0;
    return map;
}

void put(HashMap* map, int key, int value) {
    int index = hash(key);
    Node* current = map->table[index];
    
    // Check if key exists
    while (current) {
        if (current->key == key) {
            current->value = value;
            return;
        }
        current = current->next;
    }
    
    // Add new key
    Node* node = (Node*)malloc(sizeof(Node));
    node->key = key;
    node->value = value;
    node->next = map->table[index];
    map->table[index] = node;
    
    // Store key for iteration
    map->keys[map->keyCount++] = key;
}

int get(HashMap* map, int key) {
    int index = hash(key);
    Node* current = map->table[index];
    while (current) {
        if (current->key == key) {
            return current->value;
        }
        current = current->next;
    }
    return 0;
}

int* findLonely(int* nums, int numsSize, int* returnSize) {
    HashMap* map = createHashMap();
    
    // Build frequency map
    for (int i = 0; i < numsSize; i++) {
        int count = get(map, nums[i]);
        put(map, nums[i], count + 1);
    }
    
    // Check each unique number for loneliness
    int* result = (int*)malloc(numsSize * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < map->keyCount; i++) {
        int num = map->keys[i];
        if (get(map, num) == 1 && 
            get(map, num - 1) == 0 && 
            get(map, num + 1) == 0) {
            result[(*returnSize)++] = num;
        }
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single O(n) pass to build hash map + O(k) to check unique numbers where k ≤ n

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n unique elements from the input array

⚡ Linearithmic Space

47.2K Views

Medium Frequency

~15 min Avg. Time

1.8K 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 Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler