Prime Subtraction Operation - Practice Coding Problems

Prime Subtraction Operation - Problem

Array Math Binary Search Greedy Number Theory Medium

You are given a 0-indexed integer array nums of length n. Your goal is to transform this array into a strictly increasing array using a special operation.

The Operation: You can pick any index i (that you haven't picked before) and subtract a prime number p from nums[i], where p < nums[i]. You can perform this operation as many times as needed.

Your Task: Return true if you can make the array strictly increasing, false otherwise.

A strictly increasing array means each element is greater than the previous element: nums[0] < nums[1] < nums[2] < ... < nums[n-1]

Example: For array [4, 9, 6, 10], you could subtract prime 2 from nums[1] to get [4, 7, 6, 10], then subtract prime 3 from nums[2] to get [4, 7, 3, 10]. But this won't work since 7 > 3. The key insight is working backwards!

Input & Output

example_1.py — Basic Case

$ Input: nums = [4, 9, 6, 10]

› Output: true

💡 Note: Work backwards: 6 ≥ 10? No. 9 ≥ 6? Yes, subtract prime 7: 9-7=2. 4 ≥ 2? Yes, but no prime < 4 makes 4-p < 2, but since 4 already needs to be < 2 which is impossible... Actually, let's be more careful: after making 9 → 2, we have [4,2,6,10]. Now 4 ≥ 2, so we need 4-p < 2, so p > 2. We can use p=3, giving us [1,2,6,10] which is strictly increasing.

example_2.py — Already Increasing

$ Input: nums = [1, 3, 5, 7]

› Output: true

💡 Note: The array is already strictly increasing, so no operations are needed. We can return true immediately.

example_3.py — Impossible Case

$ Input: nums = [2, 2]

› Output: false

💡 Note: We have 2 ≥ 2, so we need to subtract a prime from the first element. The only prime less than 2 is... none! There are no primes less than 2, so we cannot make the array strictly increasing.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
You can use each index at most once
Prime p must be strictly less than nums[i]

Visualization

Tap to expand

Understanding the Visualization

Scan Right to Left

Start from the rightmost tower and work backwards

Check Height Constraint

If current tower is too tall (≥ next tower), it needs adjustment

Apply Maximum Prime Reduction

Subtract the largest prime possible while keeping tower shorter than next

Verify Feasibility

If no prime reduction works, the task is impossible

Key Takeaway

🎯 Key Insight: Working backwards with greedy prime selection ensures each element becomes as small as possible, maximizing flexibility for subsequent decisions while maintaining the strictly increasing property.

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a greedy approach working backwards through the array. For each element from right to left, we subtract the largest possible prime that keeps the element smaller than the next one. This works because making elements as small as possible gives maximum flexibility for the remaining elements. Time complexity: O(n + M log log M) where M is the maximum element.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Prime Combinations)	O(k^n)	O(P + n)	Try all possible prime subtractions for each element using backtracking
Greedy (Work Backwards)	O(n + M log log M)	O(M)	Work backwards, making each element as small as possible while maintaining strictly increasing order

Brute Force (Try All Prime Combinations) — Algorithm Steps

Generate all prime numbers up to the maximum value in the array
Use backtracking to try all possible prime subtractions for each element
For each combination, check if the resulting array is strictly increasing
Return true if any valid combination is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with original array and generate all primes

Branch

For each element, try all valid prime subtractions

Check

At leaf nodes, verify if array is strictly increasing

Backtrack

If not valid, backtrack and try next combination

Code -

solution.c — C

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

int* sieve(int n, int* count) {
    bool* isPrime = (bool*)malloc((n + 1) * sizeof(bool));
    memset(isPrime, true, (n + 1) * sizeof(bool));
    isPrime[0] = isPrime[1] = false;
    
    for (int i = 2; i * i <= n; i++) {
        if (isPrime[i]) {
            for (int j = i * i; j <= n; j += i) {
                isPrime[j] = false;
            }
        }
    }
    
    int* primes = (int*)malloc(n * sizeof(int));
    *count = 0;
    for (int i = 2; i <= n; i++) {
        if (isPrime[i]) {
            primes[(*count)++] = i;
        }
    }
    
    free(isPrime);
    return primes;
}

bool backtrack(int index, int* current, int* primes, int primeCount, int* original, int n) {
    if (index == n) {
        for (int i = 1; i < n; i++) {
            if (current[i] <= current[i-1]) return false;
        }
        return true;
    }
    
    if (backtrack(index + 1, current, primes, primeCount, original, n)) {
        return true;
    }
    
    for (int i = 0; i < primeCount && primes[i] < original[index]; i++) {
        current[index] = original[index] - primes[i];
        if (backtrack(index + 1, current, primes, primeCount, original, n)) {
            return true;
        }
        current[index] = original[index];
    }
    
    return false;
}

bool primeSubtractionOperation(int* nums, int numsSize) {
    int maxVal = 0;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    int primeCount;
    int* primes = sieve(maxVal, &primeCount);
    
    int* original = (int*)malloc(numsSize * sizeof(int));
    memcpy(original, nums, numsSize * sizeof(int));
    
    bool result = backtrack(0, nums, primes, primeCount, original, numsSize);
    
    free(primes);
    free(original);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Where k is the average number of primes less than each element, and n is array length. We try all combinations.

✓ Linear Growth

Space Complexity

O(P + n)

P for storing primes, n for recursion stack depth

⚡ Linearithmic Space

31.2K Views

Medium Frequency

~25 min Avg. Time

847 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 (Try All Prime Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler