Maximum Ice Cream Bars

Maximum Ice Cream Bars - Problem

It is a sweltering summer day, and a boy wants to buy some ice cream bars.

At the store, there are n ice cream bars. You are given an array costs of length n, where costs[i] is the price of the ith ice cream bar in coins. The boy initially has coins coins to spend, and he wants to buy as many ice cream bars as possible.

Note: The boy can buy the ice cream bars in any order.

Return the maximum number of ice cream bars the boy can buy with coins coins.

You must solve the problem by counting sort.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Buy ice cream bars at costs [1,1,2,3] for total cost 7. Cannot afford the bar costing 4, so maximum count is 4.

Example 2 — Exact Budget

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

› Output: 0

💡 Note: All ice cream bars cost more than 5 coins, so we cannot buy any. Return 0.

Example 3 — All Affordable

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

› Output: 6

💡 Note: We can afford all ice cream bars: 1+1+2+3+5+6 = 18 ≤ 20. Buy all 6 bars.

Constraints

1 ≤ costs.length ≤ 10⁵
1 ≤ costs[i] ≤ 10⁵
1 ≤ coins ≤ 10⁸

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 f Facebook 8 M Microsoft 6

The key insight is to use greedy strategy: always buy the cheapest available ice cream first. Since the problem requires counting sort, we create a frequency array to sort costs in O(n) time, then greedily purchase from lowest to highest cost. Best approach is counting sort with Time: O(n + k), Space: O(k) where k is the cost range.

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

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

Try every possible subset of ice cream bars to see which gives the maximum count while staying within budget. This explores all 2^n combinations.

Counting Sort - Required Solution

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

Since ice cream costs are typically small integers, we can use counting sort to achieve O(n) sorting time. Create frequency array, then process from smallest to largest cost.

Sort First - Greedy Approach

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

Sort the ice cream costs in ascending order, then iterate through sorted array buying cheapest items first until we run out of money. This greedy approach is optimal.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

const int MOD = 1000000007;

void heapifyUp(int* heap, int idx) {
    int parent = (idx - 1) / 2;
    if (parent >= 0 && heap[parent] > heap[idx]) {
        int temp = heap[parent];
        heap[parent] = heap[idx];
        heap[idx] = temp;
        heapifyUp(heap, parent);
    }
}

void heapifyDown(int* heap, int size, int idx) {
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;
    int smallest = idx;
    
    if (left < size && heap[left] < heap[smallest]) {
        smallest = left;
    }
    if (right < size && heap[right] < heap[smallest]) {
        smallest = right;
    }
    
    if (smallest != idx) {
        int temp = heap[idx];
        heap[idx] = heap[smallest];
        heap[smallest] = temp;
        heapifyDown(heap, size, smallest);
    }
}

int solution(int* nums, int n, int k) {
    // Use frequency counting for optimal distribution
    int maxVal = 0;
    for (int i = 0; i < n; i++) {
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    // Create frequency array with extra space for increments
    int* freq = (int*)calloc(maxVal + k + 10, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        freq[nums[i]]++;
    }
    
    // Distribute increments optimally
    while (k > 0) {
        // Find minimum value with non-zero frequency
        int minVal = 0;
        while (minVal <= maxVal + k && freq[minVal] == 0) {
            minVal++;
        }
        
        int count = freq[minVal];
        if (k >= count) {
            freq[minVal] = 0;
            freq[minVal + 1] += count;
            k -= count;
        } else {
            freq[minVal] -= k;
            freq[minVal + 1] += k;
            k = 0;
        }
    }
    
    // Calculate final product
    long long result = 1;
    for (int i = 0; i <= maxVal + 1000; i++) {
        if (freq[i] > 0) {
            for (int j = 0; j < freq[i]; j++) {
                result = (result * (long long)i) % MOD;
            }
        }
    }
    
    free(freq);
    return (int)result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, n, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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