Leetcode – Check If N and Its Double Exist Solution

Spread the love

Leetcode offers a variety of problems that test different aspects of programming and problem-solving skills. One of such intriguing problems is “Check If N and Its Double Exist”. While this may appear as a fairly straightforward problem, the catch often lies in solving it optimally and understanding the intricacies involved.

This comprehensive guide aims to delve into the problem, its constraints, possible ways to solve it, and the time and space complexities of those solutions.

Problem Statement

The problem can be stated as follows:

Given an array arr of integers, check if there exists two integers N and M such that N is the double of M (i.e. N = 2 * M).


Input: arr = [10, 2, 5, 3]
Output: true

Input: arr = [7, 1, 14, 11]
Output: true

Input: arr = [3, 1, 7, 11]
Output: false

Approaches to Solve the Problem

Brute-force Approach

The most straightforward approach to solving this problem would be to use two nested loops to iterate over each pair of integers in the array and check whether one is double the other.

Here is a Python code snippet to demonstrate this approach:

def checkIfExist(arr):
    for i in range(len(arr)):
        for j in range(len(arr)):
            if i != j and arr[i] == 2 * arr[j]:
                return True
    return False

Time Complexity: O(n^2)
Space Complexity: O(1)

Optimized Approach Using a Set

We can optimize the problem by iterating through the array once and using a set to keep track of the numbers and their doubles that we have seen so far.

Here is how to do it in Python:

def checkIfExist(arr):
    seen = set()
    for num in arr:
        if 2 * num in seen or (num % 2 == 0 and num // 2 in seen):
            return True
    return False

Time Complexity: O(n)
Space Complexity: O(n)

Why These Approaches Work

Brute-force Approach

This approach works because it explicitly checks every pair of numbers in the array to see if one is the double of the other. It does so by using two nested loops, which results in a time complexity of O(n^2).

Optimized Approach

The optimized approach works by exploiting the properties of sets in Python, which have an average time complexity of O(1) for search operations. By storing the numbers we’ve seen in a set, we can quickly look up their doubles or halves in constant time. This allows us to check the entire array in O(n) time while maintaining O(n) space complexity.

Edge Cases

  1. Array Contains Zero: The array can contain the number zero, which is the double of itself. In this case, it’s crucial to check that there are at least two zeros in the array to return True.
  2. Array Contains Negative Numbers: The array can also contain negative integers, so the function must be able to handle both positive and negative integers correctly.


While the “Check If N and Its Double Exist” problem might seem trivial at first glance, it actually serves as an excellent entry point for discussing algorithmic complexity and optimization techniques. It shows how a simple brute-force approach can be significantly optimized by using appropriate data structures, in this case, a set.

Leave a Reply