Count Students Who Completed All Assignments - Problem

You are given a 2D integer array submissions where submissions[i] = [studentId, assignmentId] represents that a student submitted an assignment, and an integer totalAssignments representing the total number of assignments.

A student has completed all assignments if they have submissions for every assignment from 0 to totalAssignments - 1.

Return the number of students who completed all assignments.

Input & Output

Example 1 — Basic Case

$ Input: submissions = [[1,0],[1,1],[1,2],[2,0],[2,1],[3,0],[3,1],[3,2]], totalAssignments = 3

› Output: 2

💡 Note: Student 1 submitted {0,1,2} ✅, Student 2 submitted {0,1} ❌ missing 2, Student 3 submitted {0,1,2} ✅. Two students completed all 3 assignments.

Example 2 — No One Completed

$ Input: submissions = [[5,0],[5,2],[8,1],[8,2]], totalAssignments = 3

› Output: 0

💡 Note: Student 5 is missing assignment 1, Student 8 is missing assignment 0. Neither completed all 3 assignments.

Example 3 — Duplicate Submissions Ignored

$ Input: submissions = [[1,0],[1,0],[1,1],[2,0],[2,1]], totalAssignments = 2

› Output: 2

💡 Note: Student 1's duplicate submission for assignment 0 doesn't matter. Both students submitted assignments 0 and 1, completing all required.

Constraints

1 ≤ submissions.length ≤ 10⁴
1 ≤ totalAssignments ≤ 26
0 ≤ studentId ≤ 10⁴
0 ≤ assignmentId < totalAssignments
submissions[i].length == 2

Visualization

Tap to expand

Asked in

a Amazon 12 G Google 8 M Microsoft 6

The key insight is to group submissions by student ID using a hash map with sets for deduplication. The optimal approach uses a single pass to build a map of student → assignment set, then counts students whose set size equals totalAssignments. Time: O(n), Space: O(n).

Common Approaches

✓ Hash Map Grouping

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

Use a hash map where each key is a student ID and the value is a set of their submitted assignment IDs. Build the map in a single pass, then count students whose set size equals totalAssignments.

Per-Student Scan

⏱️ Time: O(n × s) Space: O(s + a)

For each unique student, scan all submissions to collect their unique assignments, then check if they completed all required assignments.

Hash Map Grouping — Algorithm Steps

Step 1: Create a hash map of student ID → set of assignment IDs
Step 2: Iterate through submissions, adding each assignment to the student's set
Step 3: Count students whose assignment set size equals totalAssignments
Step 4: Return the count

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Map

Process each [studentId, assignmentId] pair into the map

Grouped Result

Map: {1: {0,1,2}, 2: {0,1}, 3: {0,1,2}}

Count Complete

Count entries where set size == totalAssignments → 2

Code -

solution.c — C

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

#define MAX_STUDENTS 10001

int solution(int submissions[][2], int n, int totalAssignments) {
    // For each student, track which assignments they submitted using a bitmask
    // Since totalAssignments <= 26, a 32-bit int suffices
    int masks[MAX_STUDENTS];
    int active[MAX_STUDENTS];
    memset(masks, 0, sizeof(masks));
    memset(active, 0, sizeof(active));
    
    for (int i = 0; i < n; i++) {
        int sid = submissions[i][0];
        int aid = submissions[i][1];
        masks[sid] |= (1 << aid);
        active[sid] = 1;
    }
    
    int target = (1 << totalAssignments) - 1;
    int count = 0;
    
    for (int i = 0; i < MAX_STUDENTS; i++) {
        if (active[i] && (masks[i] & target) == target) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int submissions[10000][2];
    int n = 0;
    
    char *ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    ptr++;
    
    while (*ptr) {
        while (*ptr && *ptr != '[') {
            if (*ptr == ']' && (*(ptr+1) == '\0' || *(ptr+1) == '\n')) goto done;
            ptr++;
        }
        if (!*ptr) break;
        ptr++;
        
        int a = 0, b = 0;
        int neg = 0;
        if (*ptr == '-') { neg = 1; ptr++; }
        while (*ptr >= '0' && *ptr <= '9') { a = a * 10 + (*ptr - '0'); ptr++; }
        if (neg) a = -a;
        while (*ptr == ',' || *ptr == ' ') ptr++;
        neg = 0;
        if (*ptr == '-') { neg = 1; ptr++; }
        while (*ptr >= '0' && *ptr <= '9') { b = b * 10 + (*ptr - '0'); ptr++; }
        if (neg) b = -b;
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr) ptr++;
        
        submissions[n][0] = a;
        submissions[n][1] = b;
        n++;
    }
    
done:
    fgets(line, sizeof(line), stdin);
    int totalAssignments = atoi(line);
    
    printf("%d\n", solution(submissions, n, totalAssignments));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through submissions to build the map, then one pass through unique students to count

✓ Linear Growth

Space Complexity

O(n)

Hash map storing all student-assignment pairs

✓ Linear Space

28.0K Views

Medium Frequency

~10 min Avg. Time

450 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

Count Students Who Completed All Assignments - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Hash Map Grouping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler