High Five

High Five - Problem

Given a list of the scores of different students, items, where items[i] = [IDi, scorei] represents one score from a student with IDi, calculate each student's top five average.

Return the answer as an array of pairs result, where result[j] = [IDj, topFiveAveragej] represents the student with IDj and their top five average. Sort result by IDj in increasing order.

A student's top five average is calculated by taking the sum of their top five scores and dividing it by 5 using integer division.

Input & Output

Example 1 — Basic Case

$ Input: items = [[1,91],[1,92],[2,93],[2,97],[1,60],[2,77],[1,65],[1,87],[1,100],[2,100],[2,76]]

› Output: [[1,87],[2,88]]

💡 Note: Student 1 has scores [91,92,60,65,87,100]. Top 5 are [100,92,91,87,65], average = (100+92+91+87+65)/5 = 87. Student 2 has scores [93,97,77,100,76]. Top 5 are [100,97,93,77,76], average = (100+97+93+77+76)/5 = 88.

Example 2 — Minimum Scores

$ Input: items = [[1,100],[1,90],[1,80],[2,85],[2,95]]

› Output: [[1,54],[2,36]]

💡 Note: Student 1 has only 3 scores [100,90,80], so we pad with zeros: (100+90+80+0+0)/5 = 54. Student 2 has only 2 scores [85,95], so we pad: (95+85+0+0+0)/5 = 36.

Example 3 — Single Student

$ Input: items = [[1,70],[1,80],[1,90],[1,85],[1,95],[1,75]]

› Output: [[1,85]]

💡 Note: Student 1 has 6 scores [70,80,90,85,95,75]. Top 5 are [95,90,85,80,75], average = (95+90+85+80+75)/5 = 85.

Constraints

1 ≤ items.length ≤ 1000
items[i].length == 2
1 ≤ ID_i ≤ 1000
0 ≤ score_i ≤ 100

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 f Facebook 6

The key insight is to group student scores by ID first, then efficiently find the top 5 scores for each student. The hash map approach with min-heap optimization provides the best balance of simplicity and efficiency. Time: O(n log 5 + k log k), Space: O(k × 5).

Common Approaches

✓ Two Pointers

⏱️ Time: N/A Space: N/A

Brute Force with Sorting

⏱️ Time: O(n × m log m) Space: O(n × m)

For each unique student ID, collect all their scores, sort them in descending order, take the top 5 scores, and calculate the average using integer division.

Hash Map with Partial Sorting

⏱️ Time: O(n log 5 + k log k) Space: O(k × 5)

Group scores by student ID using a hash map, but instead of sorting all scores, we can maintain only the top 5 scores for each student as we process the input.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int max(int a, int b) {
    return (a > b) ? a : b;
}

int min(int a, int b) {
    return (a < b) ? a : b;
}

void solution(int firstList[][2], int m, int secondList[][2], int n, int result[][2], int* resultSize) {
    *resultSize = 0;
    int i = 0, j = 0;
    
    while (i < m && j < n) {
        // Find intersection
        int start = max(firstList[i][0], secondList[j][0]);
        int end = min(firstList[i][1], secondList[j][1]);
        
        // If valid intersection exists
        if (start <= end) {
            result[*resultSize][0] = start;
            result[*resultSize][1] = end;
            (*resultSize)++;
        }
        
        // Move pointer of interval that ends first
        if (firstList[i][1] < secondList[j][1]) {
            i++;
        } else {
            j++;
        }
    }
}

int parseArray(char* line, int arr[][2]) {
    int count = 0;
    char* ptr = line;
    
    // Skip initial '['
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return 0;
    ptr++;
    
    while (*ptr) {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '[')) ptr++;
        if (!*ptr || *ptr == ']') break;
        
        // Read first number
        arr[count][0] = 0;
        int sign = 1;
        if (*ptr == '-') {
            sign = -1;
            ptr++;
        }
        while (*ptr >= '0' && *ptr <= '9') {
            arr[count][0] = arr[count][0] * 10 + (*ptr - '0');
            ptr++;
        }
        arr[count][0] *= sign;
        
        // Skip comma
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ',') ptr++;
        
        // Read second number
        arr[count][1] = 0;
        sign = 1;
        if (*ptr == '-') {
            sign = -1;
            ptr++;
        }
        while (*ptr >= '0' && *ptr <= '9') {
            arr[count][1] = arr[count][1] * 10 + (*ptr - '0');
            ptr++;
        }
        arr[count][1] *= sign;
        
        count++;
        
        // Skip to next interval or end
        while (*ptr && *ptr != '[' && *ptr != ']') ptr++;
        if (*ptr == ']') break;
    }
    
    return count;
}

int main() {
    char line1[10000], line2[10000];
    int firstList[1000][2], secondList[1000][2], result[2000][2];
    int m, n, resultSize;
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    m = parseArray(line1, firstList);
    n = parseArray(line2, secondList);
    
    solution(firstList, m, secondList, n, result, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("[%d,%d]", result[i][0], result[i][1]);
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

18.5K Views

Medium Frequency

~15 min Avg. Time

542 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