0620EasyArrayHash TableTwo PointersBinary SearchSorting

Twice Some Other Entry

Tracked in this browser only

Trains the technique from

LeetCode 1346Check If N and Its Double Exist

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A ledger holds arr, a list of signed adjustments. An adjustment can be negative, zero or positive, and the same amount can appear at more than one position.

Return true when the ledger holds two entries at different positions i and j such that arr[i] is exactly double arr[j], and false otherwise. Because the two positions have to differ, a ledger with a single zero in it does not qualify on that zero alone, while a ledger holding zero at two positions does.

Examples

Example 1

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

The entry 14 at position 2 is double the entry 7 at position 0, and the two positions differ.

Example 2

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

Doubling 3 gives 6 and doubling 1 gives 2, neither of which is in the ledger, so no pair works.

Example 3

Input: arr = [0, 0]
Output: true

Zero at position 1 is double the zero at position 0, and those are two different positions.

Example 4

Input: arr = [-2, -4]
Output: true

The entry -4 is double the entry -2.

Constraints

2 <= arr.length <= 500
-10^3 <= arr[i] <= 10^3

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def check_if_exist(arr: list[int]) -> bool:

Java

public boolean checkIfExist(int[] arr)

The intended approach

Time O(n) — one pass with constant-time set lookups.Space O(n) for the set of entries already read.

One left-to-right pass keeps the entries already read in a set. For the entry currently in hand there are two ways to complete a pair: its double appeared earlier, or its half appeared earlier. The half is only worth looking up when the entry is even, since an odd entry cannot be double anything whole. Both directions are covered because whichever member of a valid pair comes second will find the other one in the set. The entry joins the set after its own two lookups, which is what stops a single zero from matching itself.

Pythonentry point: check_if_exist

def check_if_exist(arr):
    # O(n) time, O(n) space. Walk the ledger once, holding the entries already
    # read in a set. For the entry in hand, the partner it needs is either
    # twice its own size, if the partner came later, or half its own size, if
    # the partner came earlier; halving only counts when the entry is even. The
    # entry is added to the set only after its own check, so a lone zero can
    # never pair with itself.
    seen = set()
    for value in arr:
        if 2 * value in seen:
            return True
        if value % 2 == 0 and value // 2 in seen:
            return True
        seen.add(value)
    return False

The obvious version

Try every ordered pair of distinct positions and report true as soon as the entry at the first position equals twice the entry at the second.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

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

How this problem was checked

Reference solution executed against 21 test cases — 21 passed
4 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in