Minimum Rounds to Complete All Tasks - Practice Coding Problems

Minimum Rounds to Complete All Tasks - Problem

You're working as a project manager and have a list of tasks with varying difficulty levels. Here's the challenge: to maximize efficiency, you can only complete tasks in groups during each work round.

The Rules:

Each round, you must complete either exactly 2 tasks OR exactly 3 tasks of the same difficulty level
You cannot mix difficulty levels within a round
You cannot complete just 1 task in a round

Given an array tasks where tasks[i] represents the difficulty level of task i, determine the minimum number of rounds needed to complete all tasks.

Goal: Return the minimum rounds required, or -1 if it's impossible to complete all tasks under these constraints.

Think about it: If you have only 1 task of a particular difficulty, you're stuck since you can't complete it alone!

Input & Output

example_1.py — Basic case with multiple difficulties

$ Input: [2,2,3,3,2,4,4,4,4,4]

› Output: 4

💡 Note: Tasks by difficulty: {2: 3 tasks, 3: 2 tasks, 4: 5 tasks}. For difficulty 2: 3 tasks = 1 round of 3. For difficulty 3: 2 tasks = 1 round of 2. For difficulty 4: 5 tasks = 1 round of 3 + 1 round of 2. Total: 1 + 1 + 2 = 4 rounds.

example_2.py — Impossible case

$ Input: [2,3,3]

› Output: -1

💡 Note: Difficulty 2 has only 1 task, but we need at least 2 tasks of the same difficulty to complete a round. Since we can't complete tasks individually, it's impossible to finish all tasks.

example_3.py — All same difficulty

$ Input: [5,5,5,5,5,5,5]

› Output: 3

💡 Note: All 7 tasks have difficulty 5. We can complete them in 3 rounds: 2 rounds of 3 tasks each (6 tasks) + 1 round of 2 tasks (1 task remaining). Wait, that's wrong - we'd have 1 task left over. Actually: 1 round of 3 + 2 rounds of 2 = 3 + 2 + 2 = 7 tasks in 3 rounds total.

Constraints

1 ≤ tasks.length ≤ 10⁵
1 ≤ tasks[i] ≤ 10⁹
Each round must complete exactly 2 or 3 tasks of the same difficulty level
Return -1 if it's impossible to complete all tasks

Visualization

Tap to expand

Understanding the Visualization

Count Cookie Types

Survey your inventory: How many cookies of each type do you have?

Check Feasibility

If any cookie type has exactly 1 cookie, you're stuck - ovens need at least 2!

Apply Magic Formula

For each cookie type with count n, minimum batches = (n + 2) ÷ 3

Sum Total Batches

Add up minimum batches needed for all cookie types

Key Takeaway

🎯 Key Insight: The mathematical formula (count + 2) ÷ 3 elegantly captures the optimal strategy of using as many groups of 3 as possible while handling remainders efficiently with groups of 2. This transforms a complex optimization problem into a simple arithmetic calculation!

Asked in

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

The optimal solution uses a frequency counting approach with mathematical optimization. First, count how many tasks exist for each difficulty level. If any difficulty has exactly 1 task, return -1 since it's impossible to complete. For each valid count, use the formula (count + 2) // 3 to find minimum rounds needed. This formula elegantly handles all cases: when count % 3 == 0 use count/3 rounds, when count % 3 == 1 or 2 use count/3 + 1 rounds. The key insight is maximizing groups of 3 while handling remainders optimally with groups of 2.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n × m)	O(k)	For each difficulty level, try all possible combinations of 2s and 3s
One-Pass Hash Table with Math (Optimal)	O(n)	O(k)	Count frequencies and apply mathematical formula in a single pass

Brute Force (Try All Combinations) — Algorithm Steps

Count frequency of each task difficulty level
For each difficulty level, check if count > 1 (if count = 1, return -1)
For each valid count, try all combinations: 0 groups of 3 + rest in 2s, 1 group of 3 + rest in 2s, etc.
Check if remaining tasks after using groups of 3 can be divided by 2
Keep track of minimum rounds needed
Sum up minimum rounds for all difficulty levels

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many tasks we have of each difficulty level

Check Validity

If any difficulty has exactly 1 task, return -1

Try Combinations

For each difficulty, try different numbers of groups of 3, fill rest with groups of 2

Find Minimum

Select the combination that gives minimum total rounds

Code -

solution.c — C

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

struct FreqNode {
    int difficulty;
    int count;
    struct FreqNode* next;
};

int minimumRounds(int* tasks, int tasksSize) {
    struct FreqNode* head = NULL;
    
    // Count frequencies
    for (int i = 0; i < tasksSize; i++) {
        struct FreqNode* current = head;
        int found = 0;
        
        while (current != NULL) {
            if (current->difficulty == tasks[i]) {
                current->count++;
                found = 1;
                break;
            }
            current = current->next;
        }
        
        if (!found) {
            struct FreqNode* newNode = malloc(sizeof(struct FreqNode));
            newNode->difficulty = tasks[i];
            newNode->count = 1;
            newNode->next = head;
            head = newNode;
        }
    }
    
    int totalRounds = 0;
    struct FreqNode* current = head;
    
    while (current != NULL) {
        int count = current->count;
        if (count == 1) {
            return -1;
        }
        
        int minRounds = INT_MAX;
        
        // Try all combinations of 3s and 2s
        for (int groupsOf3 = 0; groupsOf3 <= count / 3; groupsOf3++) {
            int remaining = count - (groupsOf3 * 3);
            
            if (remaining % 2 == 0) {
                int groupsOf2 = remaining / 2;
                int totalGroups = groupsOf3 + groupsOf2;
                if (totalGroups < minRounds) {
                    minRounds = totalGroups;
                }
            }
        }
        
        if (minRounds == INT_MAX) {
            return -1;
        }
        
        totalRounds += minRounds;
        current = current->next;
    }
    
    // Free memory
    while (head != NULL) {
        struct FreqNode* temp = head;
        head = head->next;
        free(temp);
    }
    
    return totalRounds;
}

int main() {
    int tasks[] = {2, 2, 3, 3, 2, 4, 4, 4, 4, 4};
    int size = sizeof(tasks) / sizeof(tasks[0]);
    printf("%d\n", minimumRounds(tasks, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n is number of tasks, m is maximum frequency of any difficulty level. For each difficulty, we try up to m/3 combinations.

✓ Linear Growth

Space Complexity

O(k)

k is the number of unique difficulty levels for storing frequency count

✓ Linear Space

58.8K Views

Medium-High 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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler