Kth Smallest Amount With Single Denomination Combination

Kth Smallest Amount With Single Denomination Combination - Problem

Array Math Binary Search Bit Manipulation Combinatorics Number Theory Hard

The Coin Collection Challenge

Imagine you're a coin collector with infinite coins of different denominations. You can create amounts by using coins, but here's the twist: you can only use coins of the same denomination at a time.

Given an array coins representing different coin denominations and an integer k, find the k-th smallest amount that can be made using coins of any single denomination.

For example, with coins [3, 6, 9], you can make:
• Using denomination 3: amounts 3, 6, 9, 12, 15, 18, 21, ...
• Using denomination 6: amounts 6, 12, 18, 24, 30, ...
• Using denomination 9: amounts 9, 18, 27, 36, ...

The sorted sequence of all possible amounts is: [3, 6, 9, 12, 15, 18, ...]

Input & Output

example_1.py — Basic Case

$ Input: coins = [3, 6, 9], k = 5

› Output: 15

💡 Note: Possible amounts: 3×1=3, 3×2=6, 6×1=6, 3×3=9, 9×1=9, 3×4=12, 6×2=12, 3×5=15... Unique sorted: [3,6,9,12,15,...]. The 5th smallest is 15.

example_2.py — Small Values

$ Input: coins = [2, 4], k = 3

› Output: 6

💡 Note: Amounts from coin 2: 2,4,6,8,10... Amounts from coin 4: 4,8,12... Combined unique sorted: [2,4,6,8,10,12...]. The 3rd smallest is 6.

example_3.py — Single Coin

$ Input: coins = [5], k = 4

› Output: 20

💡 Note: Only one denomination 5, so amounts are 5,10,15,20,25... The 4th smallest is 20.

Visualization

Tap to expand

Understanding the Visualization

Set Up Race Tracks

Each coin creates its multiplication sequence (3→6→9..., 6→12→18...)

Binary Search Position

Guess a position and count how many hits occur at or before it

Count with Inclusion-Exclusion

Use floor(position/coin) for each track, subtract overlaps

Adjust Search Range

If count≥k search left, if count<k search right until exact position

Key Takeaway

🎯 Key Insight: Rather than generating all amounts, we binary search on the position and count how many 'hits' occur at or before each guessed position using simple division!

Time & Space Complexity

Time Complexity

⏱️

O(U × n + U log U)

U is upper bound, n is number of coins. Generate U×n multiples, then sort U unique values

⚡ Linearithmic

Space Complexity

O(U)

Store all unique amounts up to upper bound U

✓ Linear Space

Constraints

1 ≤ coins.length ≤ 20
1 ≤ coins[i] ≤ 10⁴
1 ≤ k ≤ 2 × 10⁹
All coin values are positive integers
You have infinite coins of each denomination

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 15

The optimal solution uses binary search on the answer combined with inclusion-exclusion principle. Instead of generating all amounts, we binary search the answer range and for each candidate value, count how many amounts ≤ that value exist across all denominations. The key insight is using floor(target/coin) to count multiples and inclusion-exclusion to handle duplicates from different coins with common multiples.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate and Sort)	O(U × n + U log U)	O(U)	Generate all possible amounts up to a large limit, then sort and find k-th
Binary Search on Answer (Optimal)	O(log(k × min(coins)) × 2^n)	O(1)	Binary search on the answer value, counting how many amounts ≤ mid exist

Brute Force (Generate and Sort) — Algorithm Steps

Estimate an upper bound for the k-th smallest amount
Generate all multiples of each coin up to this bound
Collect all unique amounts in a set to avoid duplicates
Convert to sorted list and return the k-th element (index k-1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Multiples

For each coin, generate multiples up to upper bound

Collect Unique

Add all multiples to a set to eliminate duplicates

Sort and Select

Sort all amounts and pick the k-th element

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    long long ia = *(const long long*)a;
    long long ib = *(const long long*)b;
    return (ia > ib) - (ia < ib);
}

long long findKthSmallest(int* coins, int coinsSize, int k) {
    // Find minimum coin
    int minCoin = coins[0];
    for (int i = 1; i < coinsSize; i++) {
        if (coins[i] < minCoin) minCoin = coins[i];
    }
    
    // Estimate upper bound and allocate array
    long long upperBound = (long long)k * minCoin;
    long long* amounts = malloc(upperBound * sizeof(long long));
    int count = 0;
    
    // Generate multiples (simplified - need to handle duplicates)
    for (int i = 0; i < coinsSize; i++) {
        long long multiple = coins[i];
        while (multiple <= upperBound && count < upperBound) {
            amounts[count++] = multiple;
            multiple += coins[i];
        }
    }
    
    // Sort and return k-th element
    qsort(amounts, count, sizeof(long long), compare);
    long long result = amounts[k-1];
    free(amounts);
    return result;
}

int main() {
    int coins[] = {3, 6, 9};
    int k = 5;
    printf("%lld\n", findKthSmallest(coins, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(U × n + U log U)

U is upper bound, n is number of coins. Generate U×n multiples, then sort U unique values

⚡ Linearithmic

Space Complexity

O(U)

Store all unique amounts up to upper bound U

✓ Linear Space

Constraints

1 ≤ coins.length ≤ 20
1 ≤ coins[i] ≤ 10⁴
1 ≤ k ≤ 2 × 10⁹
All coin values are positive integers
You have infinite coins of each denomination

28.5K Views

Medium Frequency

~35 min Avg. Time

890 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 (Generate and Sort) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler