Assign Cookies - Practice Coding Problems

Assign Cookies - Problem

You're a parent who wants to make your children happy by giving them cookies! 🍪 But there's a catch - you can only give each child at most one cookie.

Here's the situation:

Each child i has a greed factor g[i] - the minimum size cookie they'll be satisfied with
Each cookie j has a size s[j]
A child i will be content if they receive a cookie where s[j] >= g[i]

Your goal: Maximize the number of content children by optimally assigning cookies.

Example: If you have children with greed factors [1, 2, 3] and cookies with sizes [1, 1], you can only satisfy 2 children (those with greed factors 1 and 2) by giving them the cookies of size 1 each.

Input & Output

example_1.py — Basic Case

$ Input: g = [1,2,3], s = [1,1]

› Output: 1

💡 Note: You have 3 children with greed factors 1, 2, 3 and 2 cookies of size 1. Only one child (with greed factor 1) can be satisfied.

example_2.py — Perfect Match

$ Input: g = [1,2], s = [1,2,3]

› Output: 2

💡 Note: Both children can be satisfied. Child with greed 1 gets cookie of size 1, child with greed 2 gets cookie of size 2.

example_3.py — No Satisfaction Possible

$ Input: g = [5,6], s = [1,2,3]

› Output: 0

💡 Note: All children have greed factors larger than any available cookie size. No child can be satisfied.

Visualization

Tap to expand

Understanding the Visualization

Line up children by greed

Arrange children from least picky to most picky

Sort cookies by size

Arrange cookies from smallest to largest

Use greedy strategy

Give the smallest acceptable cookie to each child

Maximize happiness

This approach ensures maximum number of satisfied children

Key Takeaway

🎯 Key Insight: The greedy approach works because satisfying the least demanding child first with the smallest possible cookie preserves larger cookies for more demanding children later.

Time & Space Complexity

Time Complexity

⏱️

O(2^(m+n))

For each child-cookie pair, we have multiple choices leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion depth can go up to n children

⚡ Linearithmic Space

Constraints

1 ≤ g.length ≤ 3 × 10⁴
0 ≤ s.length ≤ 3 × 10⁴
1 ≤ g[i] ≤ 2³¹ - 1
1 ≤ s[j] ≤ 2³¹ - 1
Each child can receive at most one cookie

Asked in

a Amazon 45 G Google 38 f Facebook 32 🍎 Apple 28

The optimal solution uses a greedy approach with two pointers. After sorting both arrays, we assign the smallest suitable cookie to the least greedy child. This maximizes our chances of satisfying more children later. Time complexity: O(n log n + m log m) due to sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Assignments)	O(2^(m+n))	O(n)	Try every possible way to assign cookies to children
Two Pointers (Greedy Approach)	O(n log n + m log m)	O(1)	Sort both arrays and use greedy assignment with two pointers

Brute Force (Try All Assignments) — Algorithm Steps

For each child, try assigning each available cookie
If cookie satisfies child (s[j] >= g[i]), recursively solve for remaining children
Track the maximum number of satisfied children across all possibilities
Return the maximum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first child

Try assigning each available cookie

Recursive exploration

For each valid assignment, solve for remaining children

Track maximum

Keep track of the best solution found so far

Code -

solution.c — C

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

int backtrack(int* g, int gSize, int* s, int sSize, int childIdx, int* usedCookies) {
    if (childIdx == gSize) {
        return 0;
    }
    
    int maxSatisfied = backtrack(g, gSize, s, sSize, childIdx + 1, usedCookies);
    
    for (int cookieIdx = 0; cookieIdx < sSize; cookieIdx++) {
        if (!usedCookies[cookieIdx] && s[cookieIdx] >= g[childIdx]) {
            usedCookies[cookieIdx] = 1;
            int satisfied = 1 + backtrack(g, gSize, s, sSize, childIdx + 1, usedCookies);
            if (satisfied > maxSatisfied) {
                maxSatisfied = satisfied;
            }
            usedCookies[cookieIdx] = 0;
        }
    }
    
    return maxSatisfied;
}

int findContentChildren(int* g, int gSize, int* s, int sSize) {
    int* usedCookies = (int*)calloc(sSize, sizeof(int));
    int result = backtrack(g, gSize, s, sSize, 0, usedCookies);
    free(usedCookies);
    return result;
}

int main() {
    int g[] = {1, 2, 3};
    int s[] = {1, 1};
    printf("%d\n", findContentChildren(g, 3, s, 2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m+n))

For each child-cookie pair, we have multiple choices leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion depth can go up to n children

⚡ Linearithmic Space

Constraints

1 ≤ g.length ≤ 3 × 10⁴
0 ≤ s.length ≤ 3 × 10⁴
1 ≤ g[i] ≤ 2³¹ - 1
1 ≤ s[j] ≤ 2³¹ - 1
Each child can receive at most one cookie

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Assignments) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler