Maximum Number of Groups Getting Fresh Donuts

Maximum Number of Groups Getting Fresh Donuts - Problem

There is a donut shop that bakes donuts in batches of batchSize. They have a rule where they must serve all of the donuts of a batch before serving any donuts of the next batch.

You are given an integer batchSize and an integer array groups, where groups[i] denotes that there is a group of groups[i] customers that will visit the shop. Each customer will get exactly one donut.

When a group visits the shop, all customers of the group must be served before serving any of the following groups. A group will be happy if they all get fresh donuts. That is, the first customer of the group does not receive a donut that was left over from the previous group.

You can freely rearrange the ordering of the groups. Return the maximum possible number of happy groups after rearranging the groups.

Input & Output

Example 1 — Basic Case

$ Input: batchSize = 3, groups = [1,2,3,1,2]

› Output: 4

💡 Note: Optimal arrangement [3,1,2,1,2]: Group 3 (remainder 0) is happy, group 1 starts fresh (remainder was 0), group 2 starts fresh (remainder was 1), group 1 starts fresh (remainder was 0), group 2 is not fresh (remainder was 1). Total: 4 happy groups.

Example 2 — Small Batch

$ Input: batchSize = 4, groups = [1,3,2,5,2,2,1,6]

› Output: 4

💡 Note: Groups with remainder 0 (like 4,8) are always happy. Groups with remainders that sum to batchSize can be paired strategically.

Example 3 — All Same Remainder

$ Input: batchSize = 2, groups = [1,1,1,1]

› Output: 2

💡 Note: All groups have remainder 1. First group is happy, second is not (remainder 1), third is happy (remainder 0 after second), fourth is not. Maximum: 2 happy groups.

Constraints

1 ≤ batchSize ≤ 9
1 ≤ groups.length ≤ 30
1 ≤ groups[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 8 M Microsoft 5

Brief HTML summary: The key insight is that only the remainder of each group size modulo batchSize matters. Groups are happy when they start with remainder 0. Best approach uses dynamic programming with memoization to explore all arrangements optimally. Time: O(batchSize^n), Space: O(batchSize^n)

Common Approaches

✓ Brute Force - Try All Permutations

⏱️ Time: O(n! × n) Space: O(n)

Try every possible permutation of groups, simulate the donut serving process for each permutation, and track the maximum number of happy groups achieved.

Dynamic Programming with Memoization

⏱️ Time: O(batchSize^n) Space: O(batchSize^n)

Recursively try different group arrangements while memoizing states based on remaining groups and current remainder to avoid recomputation.

Frequency Count with Greedy Pairing

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

Convert group sizes to remainders modulo batchSize, then greedily pair groups with complementary remainders that sum to batchSize.

Brute Force - Try All Permutations — Algorithm Steps

Step 1: Generate all permutations of the groups array
Step 2: For each permutation, simulate serving donuts and count happy groups
Step 3: Return the maximum count found across all permutations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orderings of groups

Simulate Each Order

Count happy groups for each permutation

Find Maximum

Return the highest count found

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int k) {
    int maxLen = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int currentSum = 0;
        for (int j = i; j < numsSize; j++) {
            currentSum += nums[j];
            if (currentSum == k) {
                int len = j - i + 1;
                if (len > maxLen) {
                    maxLen = len;
                }
            }
        }
    }
    
    return maxLen;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array - improved parsing logic
    int nums[1000];
    int numsSize = 0;
    
    // Find the opening bracket
    char* start = strchr(line, '[');
    if (start) {
        start++; // Move past the '['
        char* token = strtok(start, ",]");
        while (token != NULL && numsSize < 1000) {
            // Skip whitespace
            while (*token == ' ') token++;
            if (*token != '\0' && *token != ']') {
                nums[numsSize++] = atoi(token);
            }
            token = strtok(NULL, ",]");
        }
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to evaluate

✓ Linear Growth

Space Complexity

O(n)

Storage for current permutation and recursion stack

⚡ Linearithmic Space

12.9K Views

Medium Frequency

~35 min Avg. Time

423 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 Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler