Maximum Ice Cream Bars - Practice Coding Problems

Maximum Ice Cream Bars - Problem

It's a scorching hot summer day, and a young boy walks into an ice cream shop with his hard-earned coins jingling in his pocket. 🍦

The shop displays n different ice cream bars, each with its own price tag. You're given an array costs where costs[i] represents the price of the i-th ice cream bar in coins.

The boy has exactly coins coins to spend and wants to maximize his happiness by buying as many ice cream bars as possible. Since he's smart about spending, he can choose to buy the ice cream bars in any order that gives him the best deal.

Your task: Return the maximum number of ice cream bars the boy can buy with his available coins.

Special Requirement: You must solve this problem using counting sort for optimal performance.

Input & Output

example_1.py — Basic Case

$ Input: costs = [1,3,2,4,1], coins = 7

› Output: 4

💡 Note: The boy can buy ice creams with costs [1,1,2,3] for a total of 7 coins. He cannot buy the ice cream with cost 4 as it would exceed his budget.

example_2.py — Insufficient Budget

$ Input: costs = [10,6,8,7,7,8], coins = 5

› Output: 0

💡 Note: The boy cannot buy any ice cream bars because even the cheapest one costs 6 coins, which exceeds his budget of 5 coins.

example_3.py — Buy All

$ Input: costs = [1,6,3,1,2,5], coins = 20

› Output: 6

💡 Note: The boy can buy all ice cream bars since the total cost (1+6+3+1+2+5 = 18) is less than his budget of 20 coins.

Constraints

costs.length == n
1 ≤ n ≤ 10⁵
1 ≤ costs[i] ≤ 10⁵
1 ≤ coins ≤ 10⁸
Must use counting sort for optimal solution

Visualization

Tap to expand

Understanding the Visualization

Count Available Options

Use counting sort to organize ice creams by price, counting how many are available at each price point

Start from Cheapest

Begin purchasing from the $1 section, then $2, then $3, etc.

Buy Until Budget Exhausted

At each price level, buy as many as your remaining budget allows

Stop When Unaffordable

Once you can't afford the current price level, you're done (all higher prices will also be unaffordable)

Key Takeaway

🎯 Key Insight: Greedy approach works perfectly here - always buy the cheapest available items first to maximize quantity. Counting sort makes this optimal by avoiding comparison-based sorting overhead.

Asked in

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

The optimal approach uses counting sort to achieve O(n + k) time complexity. First, create a frequency array to count occurrences of each cost. Then, greedily purchase ice creams starting from the lowest cost until the budget is exhausted. This satisfies the problem's requirement for counting sort while maximizing the number of bars purchased.

Common Approaches

Approach	Time	Space	Notes
✓ Counting Sort (Optimal)	O(n + k)	O(k)	Use counting sort to sort in O(n + k) time, then apply greedy strategy
Greedy with Regular Sorting	O(n log n)	O(1)	Sort costs in ascending order, then greedily pick cheapest bars first
Brute Force (Try All Combinations)	O(2^n)	O(2^n)	Generate all possible combinations of ice cream bars and find the maximum count within budget

Counting Sort (Optimal) — Algorithm Steps

Find the maximum cost to determine the range
Create a frequency array to count occurrences of each cost
Iterate through costs and populate frequency array
Starting from cost = 1, greedily buy ice creams
For each cost level, buy as many as possible within budget
Continue until budget is exhausted
Return total number of bars bought

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Create frequency array for each possible cost

Process by Price

Iterate through prices from 1 to max, buying greedily

Maximize Quantity

At each price level, buy as many as budget allows

Code -

solution.c — C

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

int maxIceCream(int* costs, int costsSize, int coins) {
    if (costsSize == 0) return 0;
    
    // Find the maximum cost to determine range for counting sort
    int maxCost = 0;
    for (int i = 0; i < costsSize; i++) {
        if (costs[i] > maxCost) {
            maxCost = costs[i];
        }
    }
    
    // Create frequency array for counting sort
    int* freq = (int*)calloc(maxCost + 1, sizeof(int));
    
    // Count frequency of each cost
    for (int i = 0; i < costsSize; i++) {
        freq[costs[i]]++;
    }
    
    // Greedily buy ice creams starting from cheapest
    int barsBought = 0;
    
    for (int cost = 1; cost <= maxCost; cost++) {
        if (freq[cost] > 0) { // If there are ice creams at this cost
            // Buy as many as possible at this price level
            int canBuy = freq[cost];
            if (coins / cost < canBuy) {
                canBuy = coins / cost;
            }
            barsBought += canBuy;
            coins -= canBuy * cost;
            
            if (coins < cost) { // Can't afford any more at this price
                break;
            }
        }
    }
    
    free(freq);
    return barsBought;
}

int main() {
    int costs[] = {1, 3, 2, 4, 1};
    int coins = 7;
    printf("%d\n", maxIceCream(costs, 5, coins));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + k)

n for counting frequencies + k for iterating through price range, where k is max cost

✓ Linear Growth

Space Complexity

O(k)

Frequency array of size k where k is the maximum cost

✓ Linear Space

41.2K Views

Medium Frequency

~15 min Avg. Time

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

Counting Sort (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler