Codestin Search App

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.

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

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!

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
✓ 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)	O(n² × √m)	O(1)	Check every possible pair in the range and find the minimum difference

Sieve + Single Pass (Optimal) — Algorithm Steps

Use Sieve of Eratosthenes to mark all primes up to 'right'
Collect all prime numbers in the range [left, right]
Scan through consecutive primes to find minimum difference
Return the first pair with minimum difference, or [-1, -1] if no pair exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Sieve Generation

Create sieve array to mark all primes up to 'right'

Prime Collection

Gather all primes within the specified range

Consecutive Scan

Check differences between adjacent primes only

Code -

solution.c — C

int* closestPrimes(int left, int right, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    result[0] = -1;
    result[1] = -1;
    
    if (right < 2) return result;
    
    // Sieve of Eratosthenes
    bool* sieve = (bool*)calloc(right + 1, sizeof(bool));
    for (int i = 2; i <= right; i++) sieve[i] = true;
    
    for (int i = 2; i * i <= right; i++) {
        if (sieve[i]) {
            for (int j = i * i; j <= right; j += i) {
                sieve[j] = false;
            }
        }
    }
    
    // Collect primes in range
    int* primes = (int*)malloc((right - left + 1) * sizeof(int));
    int count = 0;
    for (int i = left; i <= right; i++) {
        if (sieve[i]) {
            primes[count++] = i;
        }
    }
    
    if (count < 2) {
        free(sieve);
        free(primes);
        return result;
    }
    
    // Find minimum difference
    int minDiff = INT_MAX;
    for (int i = 0; i < count - 1; i++) {
        int diff = primes[i + 1] - primes[i];
        if (diff < minDiff) {
            minDiff = diff;
            result[0] = primes[i];
            result[1] = primes[i + 1];
        }
    }
    
    free(sieve);
    free(primes);
    return result;
}

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

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

Constraints

Visualization

Related Problems

Common Approaches

Sieve + Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler