Assign Cookies

Assign Cookies - Problem

Assume you are an awesome parent and want to give your children some cookies. But, you should give each child at most one cookie.

Each child i has a greed factor g[i], which is the minimum size of a cookie that the child will be content with; and each cookie j has a size s[j].

If s[j] >= g[i], we can assign the cookie j to the child i, and the child i will be content. Your goal is to maximize the number of your content children and output the maximum number.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Child with greed factor 1 can be satisfied with cookie of size 1. Children with greed factors 2 and 3 cannot be satisfied with remaining cookies.

Example 2 — Perfect Match

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

› Output: 2

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

Example 3 — No Satisfaction

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

› Output: 0

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

Constraints

1 ≤ g.length ≤ 3 × 10⁴
0 ≤ s.length ≤ 3 × 10⁴
1 ≤ g[i] ≤ 2³¹ - 1
1 ≤ s[j] ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

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

The key insight is to use a greedy approach: sort both arrays and always satisfy the least greedy child first with the smallest sufficient cookie. This leaves more options for greedier children. Best approach is Greedy Sort and Match: Time O(n log n + m log m), Space O(1).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2^n × m!) Space: O(n + m)

For each possible subset of children, try to assign cookies optimally using backtracking. This explores all possible ways to distribute cookies to children.

Greedy Sort and Match

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

Sort children by greed factor and cookies by size. Use two pointers to match each child with the smallest cookie that satisfies them, ensuring optimal distribution.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible subsets of children
For each subset, try to find a valid cookie assignment
Return the maximum number of children that can be satisfied

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all possible subsets of children to satisfy

Try Assignments

For each subset, try all cookie permutations

Find Maximum

Track the largest valid assignment found

Code -

solution.c — C

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

bool canAssign(int* children, int childrenSize, int* cookies, int cookiesSize, int pos) {
    if (pos == childrenSize) return true;
    
    for (int i = pos; i < cookiesSize; i++) {
        if (cookies[i] >= children[pos]) {
            int temp = cookies[pos];
            cookies[pos] = cookies[i];
            cookies[i] = temp;
            
            if (canAssign(children, childrenSize, cookies, cookiesSize, pos + 1)) {
                return true;
            }
            
            temp = cookies[pos];
            cookies[pos] = cookies[i];
            cookies[i] = temp;
        }
    }
    return false;
}

int solution(int* g, int gSize, int* s, int sSize) {
    int maxContent = 0;
    
    // Try all possible subsets of children
    for (int mask = 0; mask < (1 << gSize); mask++) {
        int children[20], childrenSize = 0;
        
        for (int i = 0; i < gSize; i++) {
            if (mask & (1 << i)) {
                children[childrenSize++] = g[i];
            }
        }
        
        if (childrenSize > sSize) continue;
        
        int cookies[20];
        int cookieSize = (sSize < childrenSize) ? sSize : childrenSize;
        for (int i = 0; i < cookieSize; i++) {
            cookies[i] = s[i];
        }
        
        if (canAssign(children, childrenSize, cookies, cookieSize, 0)) {
            maxContent = (childrenSize > maxContent) ? childrenSize : maxContent;
        }
    }
    
    return maxContent;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int g[20], s[20];
    int gSize = 0, sSize = 0;
    
    char* token = strtok(line1 + 1, ",]");
    while (token != NULL) {
        g[gSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    token = strtok(line2 + 1, ",]");
    while (token != NULL) {
        s[sSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(g, gSize, s, sSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × m!)

2^n subsets of children, each requiring up to m! permutations of cookies

⚠ Quadratic Growth

Space Complexity

O(n + m)

Arrays to track used cookies and recursive call stack

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler