Prime Subtraction Operation

Prime Subtraction Operation - Problem

Array Math Binary Search Greedy Number Theory Medium

You are given a 0-indexed integer array nums of length n.

You can perform the following operation as many times as you want:

Pick an index i that you haven't picked before, and pick a prime p strictly less than nums[i], then subtract p from nums[i].

Return true if you can make nums a strictly increasing array using the above operation and false otherwise.

A strictly increasing array is an array whose each element is strictly greater than its preceding element.

Input & Output

Example 1 — Possible Case

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

› Output: true

💡 Note: We can subtract prime 2 from 4 to get [2,9,6,10], then subtract prime 7 from 9 to get [2,2,6,10], but 2=2 violates strictly increasing. Actually, we need different approach: subtract 2 from 4→2, subtract 5 from 6→1, but then 9>1 so subtract more from 9. The greedy approach working right-to-left would determine feasibility.

Example 2 — Already Increasing

$ Input: nums = [6,8,11,12]

› Output: true

💡 Note: Array is already strictly increasing: 6 < 8 < 11 < 12, so no operations needed.

Example 3 — Impossible Case

$ Input: nums = [5,8,3]

› Output: false

💡 Note: We need 5 < something < 3, but after subtracting any prime from 8, we cannot make 8 less than 3 while keeping 5 less than the result.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to work backwards (right-to-left) through the array, making each element as small as possible while maintaining strictly increasing order. The greedy approach with pre-computed primes using Sieve of Eratosthenes provides the optimal solution. Time: O(max_val × log(log(max_val)) + n × log(π(max_val))), Space: O(max_val)

Common Approaches

✓ Brute Force Recursive

⏱️ Time: O(2^n) Space: O(n)

For each element, try subtracting every possible prime less than the current value, then recursively check if the remaining array can be made strictly increasing. This explores all possible combinations.

Greedy Right-to-Left

⏱️ Time: O(n × √max_val) Space: O(1)

Start from the rightmost element and work backwards. For each element, subtract the largest possible prime to make it as small as possible while still being greater than the next element. This greedy approach ensures optimal results.

Optimized with Sieve

⏱️ Time: O(max_val × log(log(max_val)) + n × log(π(max_val))) Space: O(max_val)

Use the Sieve of Eratosthenes to pre-compute all primes up to the maximum array value, then apply the greedy right-to-left approach. This optimization significantly reduces the time spent on prime checking.

Brute Force Recursive — Algorithm Steps

Generate all primes up to maximum array value
For each index, try all valid prime subtractions
Recursively check if remaining array can be sorted
Return true if any combination works

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with original array

Try Subtractions

For each element, try all valid prime subtractions

Recursive Check

Recursively verify if arrangement works

Code -

solution.c — C

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

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

int* getPrimes(int limit, int* count) {
    int* primes = malloc(limit * sizeof(int));
    *count = 0;
    for (int i = 2; i < limit; i++) {
        if (isPrime(i)) {
            primes[(*count)++] = i;
        }
    }
    return primes;
}

bool backtrack(int* arr, int len, int index) {
    if (index == len) return true;
    
    if (index == 0 || arr[index] > arr[index-1]) {
        if (backtrack(arr, len, index + 1)) return true;
    }
    
    int primeCount;
    int* primes = getPrimes(arr[index], &primeCount);
    for (int i = 0; i < primeCount; i++) {
        arr[index] -= primes[i];
        if (index == 0 || arr[index] > arr[index-1]) {
            if (backtrack(arr, len, index + 1)) {
                free(primes);
                return true;
            }
        }
        arr[index] += primes[i];
    }
    free(primes);
    return false;
}

bool solution(int* nums, int len) {
    int* copy = malloc(len * sizeof(int));
    memcpy(copy, nums, len * sizeof(int));
    bool result = backtrack(copy, len, 0);
    free(copy);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[100];
    int len = 0;
    char* token = strtok(line + 1, ",]");
    while (token) {
        nums[len++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    bool result = solution(nums, len);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

For each element, we try multiple prime subtractions, leading to exponential branching

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack depth proportional to array length

✓ Linear Space

12.4K Views

Medium Frequency

~25 min Avg. Time

287 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 Recursive — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler