Minimum Rounds to Complete All Tasks - Practice Coding Problems

Minimum Rounds to Complete All Tasks - Problem

You are given a 0-indexed integer array tasks, where tasks[i] represents the difficulty level of a task.

In each round, you can complete either 2 or 3 tasks of the same difficulty level.

Return the minimum rounds required to complete all the tasks, or -1 if it is not possible to complete all the tasks.

Input & Output

Example 1 — Mixed Difficulties

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

› Output: 4

💡 Note: Difficulty 2: 3 tasks → 1 round of 3. Difficulty 3: 2 tasks → 1 round of 2. Difficulty 4: 5 tasks → 1 round of 3 + 1 round of 2 = 2 rounds. Total: 1+1+2=4

Example 2 — Perfect Groups

$ Input: tasks = [2,3,3]

› Output: -1

💡 Note: Difficulty 2: 1 task cannot be completed (need at least 2 tasks of same difficulty per round)

Example 3 — All Same Difficulty

$ Input: tasks = [5,5,5,5,5,5]

› Output: 2

💡 Note: 6 tasks of difficulty 5 can be completed in 2 rounds of 3 tasks each

Constraints

1 ≤ tasks.length ≤ 10⁵
1 ≤ tasks[i] ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Input

Array of task difficulties: [2,2,3,3,2,4,4,4,4,4]

Group by Difficulty

Count frequencies: diff2→3, diff3→2, diff4→5

Minimize Rounds

Use math to find minimum rounds: 1+1+2=4 total

Key Takeaway

🎯 Key Insight: Count frequency of each difficulty, then use greedy math to minimize rounds

Asked in

a Amazon 45 G Google 30 M Microsoft 25

The key insight is that tasks with frequency 1 are impossible to complete, while all other frequencies can be optimally handled using greedy math. Best approach is Frequency Count with Greedy Math: prefer groups of 3 over groups of 2 to minimize total rounds. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Try All Combinations	O(n × max_freq²)	O(n)	For each task difficulty, try all possible combinations of 2s and 3s
Frequency Count with Greedy Math	O(n)	O(n)	Count task frequencies, then use greedy math to minimize rounds

Brute Force - Try All Combinations — Algorithm Steps

Count frequency of each task difficulty
For each difficulty, try all combinations of 2s and 3s
Return minimum rounds or -1 if impossible

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many tasks of each difficulty

Try Combinations

For each difficulty, try all ways to group into 2s and 3s

Sum Minimum

Add up the minimum rounds for each difficulty

Code -

solution.c — C

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

int solution(int* tasks, int tasksSize) {
    // Simple frequency array for task difficulties
    int freq[100001] = {0};
    int maxTask = 0;
    
    for (int i = 0; i < tasksSize; i++) {
        freq[tasks[i]]++;
        if (tasks[i] > maxTask) maxTask = tasks[i];
    }
    
    int totalRounds = 0;
    
    for (int i = 0; i <= maxTask; i++) {
        int count = freq[i];
        if (count == 0) continue;
        if (count == 1) return -1;
        
        int minRounds = INT_MAX;
        // Try all combinations of 2s and 3s
        for (int threes = 0; threes <= count / 3; threes++) {
            int remaining = count - 3 * threes;
            if (remaining % 2 == 0) {
                int twos = remaining / 2;
                int rounds = threes + twos;
                if (rounds < minRounds) {
                    minRounds = rounds;
                }
            }
        }
        
        if (minRounds == INT_MAX) return -1;
        totalRounds += minRounds;
    }
    
    return totalRounds;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int tasks[10000];
    int tasksSize = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        tasks[tasksSize++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    int result = solution(tasks, tasksSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × max_freq²)

Count frequencies in O(n), then for each unique difficulty try O(max_freq²) combinations

✓ Linear Growth

Space Complexity

O(n)

Hash map to store frequency of each task difficulty

⚡ Linearithmic Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler