Most Expensive Item That Can Not Be Bought - Problem

You are given two distinct prime numbers primeOne and primeTwo. Alice and Bob are visiting a market. The market has an infinite number of items, for any positive integer x there exists an item whose price is x.

Alice wants to buy some items from the market to gift to Bob. She has an infinite number of coins in the denomination primeOne and primeTwo. She wants to know the most expensive item she can not buy to gift to Bob.

Return the price of the most expensive item which Alice can not gift to Bob.

Input & Output

Example 1 — Small Primes

$ Input: primeOne = 3, primeTwo = 5

› Output: 7

💡 Note: Numbers that can't be made: 1, 2, 4, 7. We can make 3(1×3), 5(1×5), 6(2×3), 8(1×3+1×5), 9(3×3), 10(2×5), 11(2×3+1×5), etc. The largest impossible is 7.

Example 2 — Larger Primes

$ Input: primeOne = 2, primeTwo = 3

› Output: 1

💡 Note: With coins 2 and 3, we can make: 2, 3, 4(2+2), 5(2+3), 6(3+3), 7(2+2+3), etc. Only 1 cannot be made.

Example 3 — Edge Case

$ Input: primeOne = 7, primeTwo = 11

› Output: 59

💡 Note: Using formula: 7×11 - 7 - 11 = 77 - 18 = 59. The largest number that cannot be represented as a combination of 7 and 11 is 59.

Constraints

2 ≤ primeOne, primeTwo ≤ 10⁴
primeOne and primeTwo are distinct prime numbers

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

Brief HTML summary: The key insight is applying the Chicken McNugget theorem for coprime numbers. Since distinct primes are always coprime, the largest non-representable number is primeOne × primeTwo - primeOne - primeTwo. Best approach is mathematical formula: Time: O(1), Space: O(1)

Common Approaches

✓ Brute Force with Dynamic Programming

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

Use dynamic programming to mark all numbers that can be represented using the two prime denominations, then find the largest unmarked number.

Mathematical Formula (Chicken McNugget Theorem)

⏱️ Time: O(1) Space: O(1)

For two coprime numbers a and b, the largest number that cannot be expressed as ax + by (where x,y ≥ 0) is ab - a - b. Since both inputs are distinct primes, they are guaranteed to be coprime.

Brute Force with Dynamic Programming — Algorithm Steps

Create boolean array up to limit
Mark multiples of both primes as representable
Find largest false value

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create array, mark 0 as representable

Build Up

For each representable number, add both primes

Find Max

Scan backwards to find largest non-representable

Code -

solution.c — C

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

int solution(int primeOne, int primeTwo) {
    // For two coprime numbers, max non-representable is around p1*p2
    int limit = primeOne * primeTwo;
    bool* canMake = (bool*)calloc(limit + 1, sizeof(bool));
    
    // Mark 0 as representable (base case)
    canMake[0] = true;
    
    // For each number, try adding primeOne or primeTwo
    for (int i = 0; i <= limit; i++) {
        if (canMake[i]) {
            if (i + primeOne <= limit) {
                canMake[i + primeOne] = true;
            }
            if (i + primeTwo <= limit) {
                canMake[i + primeTwo] = true;
            }
        }
    }
    
    // Find largest number that cannot be made
    int result = 0;
    for (int i = limit; i > 0; i--) {
        if (!canMake[i]) {
            result = i;
            break;
        }
    }
    
    free(canMake);
    return result;
}

int main() {
    int primeOne, primeTwo;
    scanf("%d", &primeOne);
    scanf("%d", &primeTwo);
    
    int result = solution(primeOne, primeTwo);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array up to limit n

✓ Linear Growth

Space Complexity

O(n)

Boolean array of size n to track representable numbers

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~15 min Avg. Time

245 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

Most Expensive Item That Can Not Be Bought - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler