Check If N and Its Double Exist

Check If N and Its Double Exist - Problem

Given an array arr of integers, check if there exist two indices i and j such that:

i != j
0 <= i, j < arr.length
arr[i] == 2 * arr[j]

Return true if such indices exist, otherwise return false.

Input & Output

Example 1 — Basic Double Found

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

› Output: true

💡 Note: We can find 10 and 5 where 10 == 2 * 5, so there exists i=0 and j=2 such that arr[i] == 2 * arr[j]

Example 2 — No Double Exists

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

› Output: false

💡 Note: No element in the array is exactly double another element: 3≠2×1, 3≠2×7, 3≠2×11, and no other pairs work

Example 3 — Zero Edge Case

$ Input: arr = [0,0]

› Output: true

💡 Note: We have two zeros, and 0 == 2 * 0, so arr[0] == 2 * arr[1] with different indices i=0, j=1

Constraints

2 ≤ arr.length ≤ 500
-10³ ≤ arr[i] ≤ 10³

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6 Apple 4

The key insight is to check if for any element, either its double or half exists elsewhere in the array. The optimal hash set approach achieves this in O(n) time by storing seen elements and checking for 2×num or num÷2. Time: O(n), Space: O(n).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Check All Pairs

⏱️ Time: O(n²) Space: O(1)

For each element in the array, check every other element to see if one is exactly double the other. This requires nested loops to examine all possible pairs.

Hash Set Optimization

⏱️ Time: O(n) Space: O(n)

Iterate through the array once, and for each element check if either its double (2×element) or its half (element÷2) already exists in a hash set. Add each element to the set as we process it.

Sort and Two Pointers

⏱️ Time: O(n log n) Space: O(n)

Sort the array while keeping track of original indices, then use two pointers to efficiently find if any element is exactly double another element. This approach trades some complexity for a different algorithmic pattern.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_SIZE 1000
#define HASH_SIZE 2003

struct HashNode {
    int key;
    bool exists;
    struct HashNode* next;
};

struct HashTable {
    struct HashNode* buckets[HASH_SIZE];
};

int hash(int key) {
    int h = key % HASH_SIZE;
    if (h < 0) h += HASH_SIZE;
    return h;
}

void insert(struct HashTable* table, int key) {
    int h = hash(key);
    struct HashNode* node = malloc(sizeof(struct HashNode));
    node->key = key;
    node->exists = true;
    node->next = table->buckets[h];
    table->buckets[h] = node;
}

bool contains(struct HashTable* table, int key) {
    int h = hash(key);
    struct HashNode* node = table->buckets[h];
    while (node) {
        if (node->key == key) {
            return node->exists;
        }
        node = node->next;
    }
    return false;
}

void initTable(struct HashTable* table) {
    for (int i = 0; i < HASH_SIZE; i++) {
        table->buckets[i] = NULL;
    }
}

bool checkIfExist(int* arr, int size) {
    struct HashTable table;
    initTable(&table);
    
    for (int i = 0; i < size; i++) {
        int num = arr[i];
        
        // Check if double of current number exists
        if (contains(&table, num * 2)) {
            return true;
        }
        
        // Check if current number is double of some previous number
        if (num % 2 == 0 && contains(&table, num / 2)) {
            return true;
        }
        
        insert(&table, num);
    }
    
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    int arr[MAX_SIZE];
    int size = 0;
    
    if (strcmp(line, "[]") == 0) {
        printf("false\n");
        return 0;
    }
    
    // Parse array
    char* ptr = line + 1; // Skip opening bracket
    while (*ptr && *ptr != ']') {
        if (*ptr == '-' || (*ptr >= '0' && *ptr <= '9')) {
            arr[size] = (int)strtol(ptr, &ptr, 10);
            size++;
        } else {
            ptr++;
        }
    }
    
    bool result = checkIfExist(arr, size);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

23.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