High Five - Practice Coding Problems

High Five - Problem

High Five - Calculate Top Five Average Scores

You're given a list of student test scores where each entry contains a student ID and their score. Your task is to calculate each student's top five average - the average of their five highest scores.

Input: items[i] = [ID_i, score_i] representing one score from student with ID_i
Output: Array of pairs [ID_j, topFiveAverage_j] sorted by student ID in increasing order

Important: Use integer division when calculating the average of the top 5 scores.

Example: If student 1 has scores [100, 90, 90, 90, 90, 80, 70], their top 5 scores are [100, 90, 90, 90, 90], so the average is (100+90+90+90+90)//5 = 92.

Input & Output

example_1.py — Basic case with multiple students

$ 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 = 435//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 = 443//5 = 88.

example_2.py — Single student case

$ Input: items = [[1,100],[1,90],[1,90],[1,90],[1,90],[1,80],[1,70]]

› Output: [[1,92]]

💡 Note: Student 1 has scores [100,90,90,90,90,80,70]. The top 5 scores are [100,90,90,90,90]. Average = (100+90+90+90+90)//5 = 460//5 = 92.

example_3.py — Edge case with exactly 5 scores

$ Input: items = [[1,85],[2,90],[1,88],[2,85],[1,92],[2,88],[1,95],[2,92],[1,90],[2,95]]

› Output: [[1,90],[2,90]]

💡 Note: Student 1: scores [85,88,92,95,90], all are top 5. Average = (85+88+92+95+90)//5 = 450//5 = 90. Student 2: scores [90,85,88,92,95], all are top 5. Average = (90+85+88+92+95)//5 = 450//5 = 90.

Constraints

1 ≤ items.length ≤ 1000
items[i].length == 2
1 ≤ ID_i ≤ 1000
0 ≤ score_i ≤ 100
Each student has at least 5 scores

Asked in

The optimal approach uses a hash table mapping student IDs to min-heaps of size 5. Process each score in one pass: if heap size < 5, add score; otherwise, if score > heap minimum, replace minimum. This achieves O(n) time and O(k) space complexity where k is the number of unique students.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table with Heap (Optimal)	O(n log 5) = O(n)	O(5k) = O(k)	Process each score immediately with hash table and heap in a single pass
Two-Pass Hash Table with Heap	O(n log 5) = O(n)	O(k * 5) = O(k)	Group scores by student, then use min-heap to efficiently find top 5
Brute Force (Group and Sort All)	O(n log n)	O(n)	Group all scores by student, sort each student's scores, then take top 5

One-Pass Hash Table with Heap (Optimal) — Algorithm Steps

Initialize a hash table mapping student ID to min-heap
For each score entry, get or create the student's min-heap
If heap size < 5, add the score to heap
If heap size = 5 and score > heap minimum, replace minimum with new score
After processing all entries, calculate averages and sort by student ID

Visualization

Tap to expand

Step-by-Step Walkthrough

Stream Processing

Process each [studentId, score] entry one by one

Dynamic Heap

Maintain min-heap for each student's top 5 scores

Real-time Update

Add score if heap not full, or replace minimum if new score is better

Final Calculation

Calculate averages from heaps and sort by student ID

Code -

solution.c — C

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

// Min-heap structure for each student
typedef struct {
    int data[5];
    int size;
} MinHeap;

// Hash table entry
typedef struct {
    int studentId;
    MinHeap heap;
} HashEntry;

void heapifyUp(MinHeap* heap, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (heap->data[idx] >= heap->data[parent]) break;
        int temp = heap->data[idx];
        heap->data[idx] = heap->data[parent];
        heap->data[parent] = temp;
        idx = parent;
    }
}

void heapifyDown(MinHeap* heap, int idx) {
    while (2 * idx + 1 < heap->size) {
        int minIdx = 2 * idx + 1;
        if (2 * idx + 2 < heap->size && heap->data[2 * idx + 2] < heap->data[minIdx]) {
            minIdx = 2 * idx + 2;
        }
        if (heap->data[idx] <= heap->data[minIdx]) break;
        int temp = heap->data[idx];
        heap->data[idx] = heap->data[minIdx];
        heap->data[minIdx] = temp;
        idx = minIdx;
    }
}

void heapPush(MinHeap* heap, int val) {
    heap->data[heap->size++] = val;
    heapifyUp(heap, heap->size - 1);
}

int heapPop(MinHeap* heap) {
    int min = heap->data[0];
    heap->data[0] = heap->data[--heap->size];
    if (heap->size > 0) heapifyDown(heap, 0);
    return min;
}

int heapSum(MinHeap* heap) {
    int sum = 0;
    for (int i = 0; i < heap->size; i++) {
        sum += heap->data[i];
    }
    return sum;
}

int** highFive(int** items, int itemsSize, int* itemsColSize, int* returnSize, int** returnColumnSizes) {
    // Simple hash table using array (assuming student IDs <= 1000)
    MinHeap studentHeaps[1001];
    int studentExists[1001] = {0};
    
    // Initialize heaps
    for (int i = 0; i <= 1000; i++) {
        studentHeaps[i].size = 0;
    }
    
    // Single pass: process each score immediately
    for (int i = 0; i < itemsSize; i++) {
        int studentId = items[i][0];
        int score = items[i][1];
        studentExists[studentId] = 1;
        
        MinHeap* heap = &studentHeaps[studentId];
        if (heap->size < 5) {
            heapPush(heap, score);
        } else if (score > heap->data[0]) {
            heapPop(heap);
            heapPush(heap, score);
        }
    }
    
    // Count unique students
    int uniqueStudents = 0;
    for (int i = 1; i <= 1000; i++) {
        if (studentExists[i]) uniqueStudents++;
    }
    
    // Allocate result
    int** result = (int**)malloc(uniqueStudents * sizeof(int*));
    *returnColumnSizes = (int*)malloc(uniqueStudents * sizeof(int));
    
    int resultIndex = 0;
    // Calculate results for each student in sorted order
    for (int studentId = 1; studentId <= 1000; studentId++) {
        if (!studentExists[studentId]) continue;
        
        MinHeap* heap = &studentHeaps[studentId];
        int sum = heapSum(heap);
        int average = sum / 5;
        
        result[resultIndex] = (int*)malloc(2 * sizeof(int));
        result[resultIndex][0] = studentId;
        result[resultIndex][1] = average;
        (*returnColumnSizes)[resultIndex] = 2;
        resultIndex++;
    }
    
    *returnSize = uniqueStudents;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log 5) = O(n)

Single pass through n score entries, each requiring O(log 5) = O(1) heap operations since heap size is constant.

⚡ Linearithmic

Space Complexity

O(5k) = O(k)

Where k is the number of unique students. We store exactly 5 scores per student (or fewer if student has less than 5 scores).

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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