Sell Diminishing-Valued Colored Balls - Practice Coding Problems

Sell Diminishing-Valued Colored Balls - Problem

Array Math Binary Search Greedy Sorting Heap (Priority Queue) Medium

Imagine you're running a unique toy store where colored balls have a peculiar pricing system - each ball's value equals the current remaining inventory count of that color!

🎯 The Challenge: You have an inventory array where inventory[i] represents the number of balls of the i-th color. A customer wants to buy exactly orders balls total, and you need to maximize your revenue.

How the pricing works:

If you have 6 yellow balls, the first yellow ball sells for 6
After selling it, you have 5 yellow balls left, so the next yellow ball sells for 5
The value keeps decreasing as inventory depletes

You can sell balls in any order you want. Return the maximum total revenue modulo 10⁹ + 7.

Example: With inventory [2,5] and orders = 4:
Optimal strategy: Sell balls valued at 5, 4, 3, 2 → Total revenue = 14

Input & Output

example_1.py — Basic Case

$ Input: inventory = [2,5], orders = 4

› Output: 14

💡 Note: Sell balls with values 5, 4, 3, 2. Total revenue = 5+4+3+2 = 14. We sell 2 balls from color 1 (values 5,4) and 2 balls from color 0 (values 2,1, but we only need 2 more balls so we sell at values 3,2).

example_2.py — Large Inventory

$ Input: inventory = [3,5], orders = 6

› Output: 19

💡 Note: Sell all balls: from color 1 (5,4,3) and from color 0 (3,2,1). Total = 5+4+3+3+2+1 = 18. Wait, let me recalculate: we want to sell optimally, so we sell 5,4,3,3,2,1 = 18. Actually, optimal is 5,4,3,3,2,1 = 18.

example_3.py — Single Color

$ Input: inventory = [7], orders = 3

› Output: 18

💡 Note: Only one color with 7 balls. Sell 3 balls with values 7, 6, 5. Total revenue = 7+6+5 = 18.

Visualization

Tap to expand

Understanding the Visualization

Premium Selection

Always sell the most expensive available ball first (highest current inventory count)

Dynamic Pricing

After each sale, the remaining balls of that color become slightly less valuable

Optimal Strategy

Use binary search to find the perfect 'cutoff price' instead of simulating each sale

Key Takeaway

🎯 Key Insight: Greedy approach works because ball values decrease linearly. Binary search finds the optimal cutoff price, avoiding expensive simulation while maintaining perfect accuracy.

Time & Space Complexity

Time Complexity

⏱️

O(n log n + n log(max_inventory))

O(n log n) for sorting, O(n log(max_inventory)) for binary search with O(n) validation

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space after sorting in place

✓ Linear Space

Constraints

1 ≤ inventory.length ≤ 10⁵
1 ≤ inventory[i] ≤ 10⁹
1 ≤ orders ≤ min(2×10⁹, sum(inventory[i]))
Answer must be returned modulo 10⁹ + 7

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses binary search to find the cutoff price level efficiently. Instead of simulating each sale, we search for the lowest price we should sell balls at, then use arithmetic formulas to calculate revenue in O(1) time per color. Key insight: greedy selling from highest to lowest value is optimal since ball values decrease linearly.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Price Level	O(n log n + n log(max_inventory))	O(1)	Binary search to find the optimal price level to sell down to
Brute Force (Simulation)	O(orders × n)	O(1)	Simulate selling balls one by one, always picking the most valuable

Binary Search on Price Level — Algorithm Steps

Sort inventory in descending order
Binary search on the final price level (0 to max inventory)
For each candidate price level, calculate total balls sold
Check if we can fulfill exactly 'orders' balls
Calculate revenue efficiently using arithmetic formulas
Return the maximum revenue

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Inventory

Sort colors by inventory count in descending order

Binary Search

Search for the lowest price level to sell down to

Calculate Revenue

Use arithmetic formulas to compute total revenue efficiently

Code -

solution.c — C

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

const int MOD = 1000000007;

int compare(const void* a, const void* b) {
    return *(int*)b - *(int*)a;
}

long long countBalls(int* inventory, int size, int priceLevel) {
    long long balls = 0;
    for (int i = 0; i < size; i++) {
        if (inventory[i] > priceLevel) {
            balls += inventory[i] - priceLevel;
        }
    }
    return balls;
}

long long calculateRevenue(int* inventory, int size, int priceLevel) {
    long long revenue = 0;
    for (int i = 0; i < size; i++) {
        if (inventory[i] > priceLevel) {
            long long count = inventory[i] - priceLevel;
            revenue += count * (inventory[i] + priceLevel + 1) / 2;
        }
    }
    return revenue;
}

int maxProfit(int* inventory, int inventorySize, int orders) {
    qsort(inventory, inventorySize, sizeof(int), compare);
    
    int left = 0, right = inventory[0];
    
    while (left < right) {
        int mid = (left + right + 1) / 2;
        if (countBalls(inventory, inventorySize, mid) <= orders) {
            right = mid - 1;
        } else {
            left = mid;
        }
    }
    
    long long revenue = calculateRevenue(inventory, inventorySize, left);
    long long balls = countBalls(inventory, inventorySize, left);
    
    if (balls > orders) {
        revenue -= (balls - orders) * (left + 1);
    }
    
    return revenue % MOD;
}

int main() {
    int inventory[1000];
    int size = 0;
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " ");
    while (token != NULL) {
        inventory[size++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    int orders;
    scanf("%d", &orders);
    
    printf("%d\n", maxProfit(inventory, size, orders));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + n log(max_inventory))

O(n log n) for sorting, O(n log(max_inventory)) for binary search with O(n) validation

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space after sorting in place

✓ Linear Space

Constraints

1 ≤ inventory.length ≤ 10⁵
1 ≤ inventory[i] ≤ 10⁹
1 ≤ orders ≤ min(2×10⁹, sum(inventory[i]))
Answer must be returned modulo 10⁹ + 7

34.4K Views

High Frequency

~25 min Avg. Time

1.5K 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

Binary Search on Price Level — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler