Count Prime-Gap Balanced Subarrays - Practice Coding Problems

Count Prime-Gap Balanced Subarrays - Problem

Array Math Queue Sliding Window Number Theory Monotonic Queue Medium

Imagine you're analyzing data sequences where prime numbers serve as key landmarks. Your task is to find all contiguous subsequences (subarrays) that are "prime-gap balanced" - meaning they contain at least two prime numbers with a controlled gap between them.

Given an integer array nums and an integer k, count how many subarrays satisfy these conditions:

📊 Contains at least two prime numbers
📏 The difference between the largest and smallest prime in that subarray is ≤ k

Example: In array [2, 4, 3, 5, 7] with k = 4, the subarray [2, 4, 3, 5] is prime-gap balanced because it contains primes 2, 3, 5 and max(2,3,5) - min(2,3,5) = 5 - 2 = 3 ≤ 4.

Note: A prime number is a natural number > 1 with exactly two factors: 1 and itself.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2, 4, 3, 5, 7], k = 4

› Output: 6

💡 Note: Valid subarrays: [2,4,3] (primes: 2,3, gap=1≤4), [2,4,3,5] (primes: 2,3,5, gap=3≤4), [2,4,3,5,7] (primes: 2,3,5,7, gap=5>4 ❌), [4,3,5] (primes: 3,5, gap=2≤4), [4,3,5,7] (primes: 3,5,7, gap=4≤4), [3,5,7] (primes: 3,5,7, gap=4≤4). Count = 6.

example_2.py — Small Gap

$ Input: nums = [2, 8, 3, 9, 5], k = 2

› Output: 3

💡 Note: Valid subarrays: [2,8,3] (primes: 2,3, gap=1≤2), [8,3,9,5] (primes: 3,5, gap=2≤2), [3,9,5] (primes: 3,5, gap=2≤2). Other subarrays either have gap>2 or <2 primes.

example_3.py — No Valid Subarrays

$ Input: nums = [4, 6, 8, 9], k = 5

› Output: 0

💡 Note: Array contains no prime numbers (4=2×2, 6=2×3, 8=2×4, 9=3×3), so no subarray can have ≥2 primes.

Visualization

Tap to expand

Understanding the Visualization

Identify Peaks

Mark all prime numbers (peaks) in the array

Scan Sections

Use sliding window to examine each possible section

Measure Gaps

Check if elevation difference between highest and lowest peaks ≤ k

Count Valid

Increment counter for each section meeting the criteria

Key Takeaway

🎯 Key Insight: Precompute prime flags and use sliding window with early termination for optimal efficiency

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for generating subarrays × O(n) for prime checking and gap calculation

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
0 ≤ k ≤ 1000
All array elements are positive integers

Asked in

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

The optimal approach uses a sliding window technique with precomputed prime flags to efficiently track prime ranges. Key optimization: early termination when prime gap exceeds k, avoiding unnecessary subarray extensions. Time complexity: O(n² + n√M) where M is the maximum array value.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray for prime-gap balance condition
Sliding Window with Prime Tracking	O(n²)	O(n)	Use sliding window technique to efficiently track prime ranges in subarrays

Brute Force (Check All Subarrays) — Algorithm Steps

Generate all possible subarrays using nested loops
For each subarray, identify all prime numbers
Check if there are at least 2 primes
Calculate max_prime - min_prime and verify it's ≤ k
Count valid subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Use nested loops to create all possible contiguous subarrays

Find Primes

For each subarray, identify which elements are prime numbers

Check Balance

Verify if gap between max and min primes ≤ k

Code -

solution.c — C

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

int isPrime(int n) {
    if (n < 2) return 0;
    if (n == 2) return 1;
    if (n % 2 == 0) return 0;
    for (int i = 3; i <= sqrt(n); i += 2) {
        if (n % i == 0) return 0;
    }
    return 1;
}

int countPrimeGapBalanced(int* nums, int numsSize, int k) {
    int zelmoricad[2] = {numsSize, k};  // Store input midway
    
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            int primes[1000];
            int primeCount = 0;
            
            for (int idx = i; idx <= j; idx++) {
                if (isPrime(nums[idx])) {
                    primes[primeCount++] = nums[idx];
                }
            }
            
            if (primeCount >= 2) {
                int maxPrime = primes[0], minPrime = primes[0];
                for (int p = 1; p < primeCount; p++) {
                    if (primes[p] > maxPrime) maxPrime = primes[p];
                    if (primes[p] < minPrime) minPrime = primes[p];
                }
                if (maxPrime - minPrime <= k) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for generating subarrays × O(n) for prime checking and gap calculation

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
0 ≤ k ≤ 1000
All array elements are positive integers

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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 Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler