Group Students by Grade - Problem

You are given a list of student records, where each record contains a student's name and their grade level. Your task is to group all students by their grade level and return a dictionary/map where:

The key is the grade level (as a string)
The value is an array of student names in that grade

The students within each grade should maintain their original order from the input list.

Note: Grade levels can be any string (e.g., "K", "1st", "2nd", "Senior", etc.)

Input & Output

Example 1 — Basic Case

$ Input: students = [["Alice", "10"], ["Bob", "9"], ["Charlie", "10"], ["Diana", "9"]]

› Output: {"10": ["Alice", "Charlie"], "9": ["Bob", "Diana"]}

💡 Note: Alice and Charlie are in grade 10, Bob and Diana are in grade 9. Students maintain their original order within each grade.

Example 2 — Mixed Grade Formats

$ Input: students = [["Emma", "K"], ["Frank", "1st"], ["Grace", "K"]]

› Output: {"K": ["Emma", "Grace"], "1st": ["Frank"]}

💡 Note: Kindergarten students Emma and Grace grouped together, Frank is alone in 1st grade.

Example 3 — Single Student

$ Input: students = [["John", "Senior"]]

› Output: {"Senior": ["John"]}

💡 Note: Single student creates one group with one member.

Constraints

1 ≤ students.length ≤ 1000
Each student record contains exactly 2 elements: [name, grade]
Student names are non-empty strings
Grade levels are non-empty strings

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

The key insight is using a hash map to group students by grade level in a single pass. For each student, we check if their grade exists as a key - if not, create a new array; then append the student's name. The optimal approach is the hash map solution with Time: O(n) and Space: O(n).

Common Approaches

✓ Brute Force - Linear Search for Each Student

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

Iterate through each student and search through all existing grade groups to find where to add them. If no group exists for their grade, create a new one.

Hash Map - Direct Grade Lookup

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

Build a hash map where each grade is a key pointing to an array of student names. For each student, directly access their grade group in constant time.

Brute Force - Linear Search for Each Student — Algorithm Steps

Initialize empty result list of grade groups
For each student, search through all existing groups for matching grade
If found, add student to that group; if not found, create new group
Convert result to dictionary format

Visualization

Tap to expand

Step-by-Step Walkthrough

Process First Student

Alice (Grade 10) - no groups exist, create new group

Process Second Student

Bob (Grade 9) - search through 1 group, create new group

Process Third Student

Charlie (Grade 10) - search through 2 groups, find Grade 10, add to existing

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cjson/cJSON.h>

char* solution(char* studentsJson) {
    cJSON *json = cJSON_Parse(studentsJson);
    cJSON *result = cJSON_CreateObject();
    
    int size = cJSON_GetArraySize(json);
    for (int i = 0; i < size; i++) {
        cJSON *student = cJSON_GetArrayItem(json, i);
        char *name = cJSON_GetStringValue(cJSON_GetArrayItem(student, 0));
        char *grade = cJSON_GetStringValue(cJSON_GetArrayItem(student, 1));
        
        cJSON *gradeArray = cJSON_GetObjectItem(result, grade);
        if (!gradeArray) {
            gradeArray = cJSON_CreateArray();
            cJSON_AddItemToObject(result, grade, gradeArray);
        }
        cJSON_AddItemToArray(gradeArray, cJSON_CreateString(name));
    }
    
    char *output = cJSON_Print(result);
    cJSON_Delete(json);
    cJSON_Delete(result);
    return output;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char *result = solution(line);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each student (n), we search through up to n grade groups in worst case

✓ Linear Growth

Space Complexity

O(n)

Hash map stores all n students grouped by grade

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Group Students by Grade - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Linear Search for Each Student — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler