Check If N and Its Double Exist - Practice Coding Problems

Check If N and Its Double Exist - Problem

Check If N and Its Double Exist

You're given an array of integers, and you need to find if there exists a magical pair! Specifically, you need to determine if there are two different positions in the array where one element is exactly twice the value of another.

The Challenge:
Find two indices i and j such that:
• i ≠ j (different positions)
• 0 ≤ i, j < arr.length (valid indices)
• arr[i] == 2 * arr[j] (one is double the other)

Goal: Return true if such a pair exists, false otherwise.

Example: In [10, 2, 5, 3], we have 10 = 2 × 5, so return true!

Input & Output

example_1.py — Basic positive case

$ Input: [10, 2, 5, 3]

› Output: true

💡 Note: We can find two indices i=0 and j=2 where arr[0] = 10 and arr[2] = 5, and 10 = 2 × 5. The double relationship exists between elements at different positions.

example_2.py — No valid pairs

$ Input: [3, 1, 7, 11]

› Output: false

💡 Note: No element in the array is exactly double of any other element. We need to check: 3×2=6 (not in array), 1×2=2 (not in array), 7×2=14 (not in array), 11×2=22 (not in array).

example_3.py — Zero edge case

$ Input: [-2, 0, 10, -19, 4, 6, -8]

› Output: false

💡 Note: Even though we have both positive and negative numbers including zero, no element is exactly double of another. Note that 0 would need another 0 to form a valid pair (0 = 2 × 0), but there's only one zero.

Visualization

Tap to expand

Understanding the Visualization

Initialize the Registry

Start with an empty registration system (hash set) to track dancer heights

Process Each Dancer

As each dancer arrives, immediately check if their ideal partner is already registered

Check for Perfect Match

Look for someone exactly half their height OR double their height in the registry

If no match found, add them to registry. If match found, celebrate the perfect pair!

Key Takeaway

🎯 Key Insight: Transform the pair-finding problem into instant lookups by building a registry as we go, achieving optimal O(n) performance!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hash table operations

✓ Linear Growth

Space Complexity

O(n)

Hash set can store up to n elements in worst case

⚡ Linearithmic Space

Constraints

2 ≤ arr.length ≤ 500
-10³ ≤ arr[i] ≤ 10³
Array contains at least 2 elements
Elements can be negative, zero, or positive

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22 Apple 18

The optimal solution uses a hash set in a single pass through the array. For each element, we check if its double or half already exists in the set. This achieves O(n) time complexity and O(n) space complexity, making it the most efficient approach for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Build hash table and search simultaneously for optimal O(n) performance
Brute Force (Nested Loops)	O(n²)	O(1)	Check every pair of elements to see if one is double the other
Two Pointers (Sorted Array)	O(n log n)	O(n)	Sort array and use two pointers to find complementary pairs

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize an empty hash set to store seen elements
Iterate through each element in the array
For current element x, check if 2x or x/2 exists in the hash set
If either complement exists, return true immediately
Add current element to the hash set for future lookups
Return false if no valid pair is found after processing all elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with empty hash set

Initialize empty data structure to track seen elements

Process first element (10)

Check for 20 or 5 in hash set, then add 10

Process second element (2)

Check for 4 or 1 in hash set, then add 2

Process third element (5)

Check for 10 or 2.5 - found 10! Return true

Code -

solution.c — C

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

#define HASH_SIZE 100003

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

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

bool contains(HashNode* table[], int key) {
    int index = hash(key);
    HashNode* curr = table[index];
    while (curr) {
        if (curr->key == key) return true;
        curr = curr->next;
    }
    return false;
}

void insert(HashNode* table[], int key) {
    int index = hash(key);
    HashNode* node = malloc(sizeof(HashNode));
    node->key = key;
    node->next = table[index];
    table[index] = node;
}

bool checkIfExist(int* arr, int arrSize) {
    HashNode* table[HASH_SIZE] = {NULL};
    
    for (int i = 0; i < arrSize; i++) {
        int num = arr[i];
        if (contains(table, num * 2) || (num % 2 == 0 && contains(table, num / 2))) {
            return true;
        }
        insert(table, num);
    }
    return false;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hash table operations

✓ Linear Growth

Space Complexity

O(n)

Hash set can store up to n elements in worst case

⚡ Linearithmic Space

Constraints

2 ≤ arr.length ≤ 500
-10³ ≤ arr[i] ≤ 10³
Array contains at least 2 elements
Elements can be negative, zero, or positive

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler