Closest Prime Numbers in Range - Practice Coding Problems

Closest Prime Numbers in Range - Problem

Given a range defined by two positive integers left and right, your task is to find the closest pair of prime numbers within this range.

You need to find two integers num1 and num2 such that:

left ≤ num1 < num2 ≤ right
Both num1 and num2 are prime numbers
num2 - num1 is minimized among all valid pairs

Return the array [num1, num2]. If multiple pairs have the same minimum difference, return the one with the smallest num1. If no such pair exists, return [-1, -1].

Example: In range [4, 6], we have primes 5. Since we need two different primes, return [-1, -1]. In range [4, 18], primes are [5, 7, 11, 13, 17]. The closest pairs are (5,7), (11,13) with difference 2. We return [5, 7] as it has smaller num1.

Input & Output

example_1.py — Basic Case

$ Input: left = 10, right = 19

› Output: [11, 13]

💡 Note: The primes in range [10, 19] are [11, 13, 17, 19]. The closest pairs are (11,13) and (17,19), both with difference 2. We return [11, 13] as it has the smaller first element.

example_2.py — No Valid Pair

$ Input: left = 4, right = 6

› Output: [-1, -1]

💡 Note: The only prime in range [4, 6] is 5. Since we need two different primes, no valid pair exists.

example_3.py — Large Gaps

$ Input: left = 20, right = 30

› Output: [23, 29]

💡 Note: The primes in range [20, 30] are [23, 29]. Only one pair exists: (23, 29) with difference 6.

Visualization

Tap to expand

Understanding the Visualization

Sieve Creation

Mark all prime numbers using the sieve algorithm

Range Filtering

Extract only the primes within our target range

Minimum Gap

Find the consecutive pair with smallest difference

Key Takeaway

🎯 Key Insight: The closest prime pair will always be consecutive primes in the sorted list, so we only need to check adjacent pairs rather than all possible combinations!

Time & Space Complexity

Time Complexity

⏱️

O(n log log n + k)

O(n log log n) for sieve where n=right, plus O(k) to scan k primes in range

⚡ Linearithmic

Space Complexity

O(n + k)

O(n) for sieve array, O(k) to store k primes in the range

⚡ Linearithmic Space

Constraints

1 ≤ left ≤ right ≤ 10⁶
Both left and right are positive integers
Important: If multiple pairs have the same minimum difference, return the one with the smallest num1 value

Asked in

G Google 42 a Amazon 38 f Meta 28 ⊞ Microsoft 24

The optimal approach uses the Sieve of Eratosthenes to efficiently find all primes up to the right boundary, then collects primes within the range and checks only consecutive prime pairs to find the minimum difference. This achieves O(n log log n) time complexity, which is much better than the brute force O(n² × √m) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n² × √m)	O(1)	Check every possible pair in the range and find the minimum difference
Sieve + Single Pass (Optimal)	O(n log log n + k)	O(n + k)	Use Sieve of Eratosthenes to find all primes, then scan consecutive pairs

Brute Force (Check All Pairs) — Algorithm Steps

Create a helper function to check if a number is prime
Iterate through all possible pairs (i, j) where left ≤ i < j ≤ right
For each pair, check if both numbers are prime
Keep track of the pair with minimum difference
Return the best pair found, or [-1, -1] if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Check All Pairs

Examine every (i,j) combination where i < j

Primality Test

Test if both numbers in the pair are prime

Track Minimum

Keep the pair with smallest difference

Code -

solution.c — C

bool isPrime(int n) {
    if (n < 2) return false;
    if (n == 2) return true;
    if (n % 2 == 0) return false;
    for (int i = 3; i * i <= n; i += 2) {
        if (n % i == 0) return false;
    }
    return true;
}

int* closestPrimes(int left, int right, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    result[0] = -1;
    result[1] = -1;
    int minDiff = INT_MAX;
    
    for (int i = left; i <= right; i++) {
        if (!isPrime(i)) continue;
        for (int j = i + 1; j <= right; j++) {
            if (!isPrime(j)) continue;
            int diff = j - i;
            if (diff < minDiff) {
                minDiff = diff;
                result[0] = i;
                result[1] = j;
                if (minDiff == 2) return result;
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × √m)

O(n²) pairs to check, each requiring O(√m) primality test where m is the largest number

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing the current best pair and loop variables

✓ Linear Space

Constraints

1 ≤ left ≤ right ≤ 10⁶
Both left and right are positive integers
Important: If multiple pairs have the same minimum difference, return the one with the smallest num1 value

42.8K Views

Medium-High Frequency

~25 min Avg. Time

1.3K 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

Brute Force (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler