Maximum Prime Difference - Practice Coding Problems

Maximum Prime Difference - Problem

You're given an integer array nums and need to find the maximum distance between the indices of any two prime numbers in the array.

A prime number is a natural number greater than 1 that has no positive divisors other than 1 and itself. For example, 2, 3, 5, 7, 11 are prime numbers.

The distance between two indices i and j is calculated as |i - j|. You need to find all prime numbers in the array and return the maximum distance between any pair of their indices.

Example: In array [4, 2, 9, 5, 3], the prime numbers are at indices 1 (value 2), 3 (value 5), and 4 (value 3). The maximum distance is between indices 1 and 4, which is 4 - 1 = 3.

Input & Output

example_1.py — Basic Case

$ Input: [4, 2, 9, 5, 3]

› Output: 3

💡 Note: Prime numbers are at indices 1 (value 2), 3 (value 5), and 4 (value 3). Maximum distance is between indices 1 and 4: 4 - 1 = 3.

example_2.py — Multiple Primes

$ Input: [2, 3, 5, 7, 11]

› Output: 4

💡 Note: All numbers are prime. Maximum distance is between indices 0 and 4: 4 - 0 = 4.

example_3.py — Single Prime

$ Input: [4, 6, 8, 2]

› Output: 0

💡 Note: Only one prime number (2 at index 3). Since we need at least two primes to calculate distance, return 0.

Constraints

1 ≤ nums.length ≤ 3 × 10⁵
1 ≤ nums[i] ≤ 10⁶
The array contains at least one prime number
Follow-up: Can you solve this in O(n) time complexity?

Visualization

Tap to expand

Understanding the Visualization

Identify Lighthouses

Scan the coastline and mark all lighthouse positions (prime numbers)

Find Endpoints

The maximum sailing distance is between the leftmost and rightmost lighthouses

Calculate Distance

Return the difference between last and first lighthouse positions

Key Takeaway

🎯 Key Insight: Maximum distance between any two points on a line is always between the endpoints - no need to check intermediate pairs!

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution leverages the key insight that the maximum distance between any two points on a line is always between the leftmost and rightmost points. Instead of comparing all pairs of prime indices, we only need to find the first and last prime numbers in the array and return their index difference. This reduces the time complexity from O(n²) to O(n) while maintaining O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Prime Pairs)	O(n² × √max)	O(n)	Find all primes and check distance between every pair
One-Pass Optimal Solution	O(n × √max)	O(1)	Find first and last prime indices in a single pass

Brute Force (Check All Prime Pairs) — Algorithm Steps

Create a helper function to check if a number is prime
Iterate through the array to find all prime numbers and their indices
For each pair of prime indices, calculate the absolute difference
Keep track of the maximum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Primes

Scan array and identify all prime numbers with their indices

Compare Pairs

Calculate distance between every pair of prime indices

Track Maximum

Keep updating the maximum distance found

Code -

solution.c — C

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

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 maximumPrimeDifference(int* nums, int numsSize) {
    int* primeIndices = malloc(numsSize * sizeof(int));
    int primeCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (isPrime(nums[i])) {
            primeIndices[primeCount++] = i;
        }
    }
    
    if (primeCount < 2) {
        free(primeIndices);
        return 0;
    }
    
    int maxDiff = 0;
    for (int i = 0; i < primeCount; i++) {
        for (int j = i + 1; j < primeCount; j++) {
            int diff = primeIndices[j] - primeIndices[i];
            if (diff > maxDiff) maxDiff = diff;
        }
    }
    
    free(primeIndices);
    return maxDiff;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    bool inNumber = false;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            inNumber = true;
        } else if (inNumber) {
            nums[size++] = num;
            num = 0;
            inNumber = false;
        }
    }
    if (inNumber) nums[size++] = num;
    
    printf("%d\n", maximumPrimeDifference(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × √max)

O(n × √max) to find all primes, then O(p²) to compare pairs where p is number of primes

⚠ Quadratic Growth

Space Complexity

O(n)

Store all prime indices in worst case

⚡ Linearithmic Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Prime Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler