1086. High Five - Detailed Explanation

Free Coding Questions Catalog
Boost your coding skills with our essential coding questions catalog. Take a step towards a better tech career now!

Problem Statement

You are given a list of score records for different students. Each record is a two-element list where the first element is the student id and the second element is a score. A student can have multiple scores. Your task is to calculate the average of the top five scores for each student and return the result in the form of a list of lists sorted by the student id in ascending order.

Example 1

  • 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]]
    
  • Explanation:
    • For student 1, the top five scores are: 91, 92, 87, 100, 65.
      The average is calculated as:
      ( \text{average} = \lfloor(91 + 92 + 87 + 100 + 65) / 5\rfloor = \lfloor435/5\rfloor = 87 ).

    • For student 2, the top five scores are: 93, 97, 77, 100, 76.
      The average is calculated as:
      ( \text{average} = \lfloor(93 + 97 + 77 + 100 + 76) / 5\rfloor = \lfloor443/5\rfloor = 88 ).

Constraints

  • The number of score records can vary.
  • Each record is of the form [student_id, score].
  • It is guaranteed that each student has at least five scores.

Hints for the Approach

  • Hint 1: Use a hash map (or dictionary) where the key is the student id and the value is a collection of scores. This allows you to group the scores for each student efficiently.
  • Hint 2: To get the top five scores quickly for each student, you can either:
    • Sort the scores in descending order and then pick the first five.
    • Or use a min-heap of size five to maintain the top five scores in one pass.
  • Hint 3: Once you have the top five scores for each student, compute the average (using integer division) and then return the results sorted by student id.

Approaches

Approach 1: Using Dictionary and Sorting

  1. Group Scores:
    Iterate over each score record and group scores by student id using a dictionary.

  2. Sort and Pick Top Five:
    For each student, sort their scores in descending order and take the first five scores.

  3. Compute Average:
    Calculate the average of these top five scores using integer division.

  4. Sort the Result:
    Finally, sort the output list by student id in ascending order.

Pseudocode

initialize dictionary: student_scores

for each record in items:
    student_id, score = record
    add score to student_scores[student_id]

result = []
for each student_id in student_scores:
    sort student_scores[student_id] in descending order
    top_five = first five elements of sorted list
    average = sum(top_five) // 5
    add [student_id, average] to result

sort result by student_id
return result

Approach 2: Using Dictionary and Min-Heap

  1. Group Scores with Min-Heap:
    Instead of storing all scores and then sorting, use a min-heap (priority queue) for each student. Maintain the heap such that it only contains the top five scores.

    • When adding a new score, if the heap’s size is less than five, simply add the score.
    • If the heap is full and the new score is greater than the smallest element in the heap, remove the smallest and add the new score.
  2. Compute Average:
    For each student, compute the average from the five scores present in the heap.

  3. Sort the Result:
    Output the result sorted by student id.

Pseudocode

initialize dictionary: student_heaps

for each record in items:
    student_id, score = record
    if student_id not in student_heaps:
         initialize a min-heap for student_id
    add score to student_heaps[student_id]
    if size of student_heaps[student_id] > 5:
         remove smallest element from student_heaps[student_id]

result = []
for each student_id in student_heaps:
    average = sum(student_heaps[student_id]) // 5
    add [student_id, average] to result

sort result by student_id
return result

Step-by-Step Walkthrough with Visual Example

Let’s walk through Approach 1 with the provided example:

Given items:

[[1, 91], [1, 92], [2, 93], [2, 97], [1, 60],
 [2, 77], [1, 65], [1, 87], [1, 100], [2, 100], [2, 76]]

Step 1: Group Scores by Student

  • Student 1: [91, 92, 60, 65, 87, 100]
  • Student 2: [93, 97, 77, 100, 76]

Step 2: Sort Scores in Descending Order and Pick Top Five

  • Student 1: Sorted scores → [100, 92, 91, 87, 65, 60]
    Top five: [100, 92, 91, 87, 65]

  • Student 2: Sorted scores → [100, 97, 93, 77, 76]
    Top five: [100, 97, 93, 77, 76]

Step 3: Compute the Average

  • Student 1: ( \text{average} = (100 + 92 + 91 + 87 + 65) // 5 = 435 // 5 = 87 )
  • Student 2: ( \text{average} = (100 + 97 + 93 + 77 + 76) // 5 = 443 // 5 = 88 )

Step 4: Sort the Output

Result sorted by student id:

[[1, 87], [2, 88]]

Code Implementation

Python Implementation

Python3
Python3

. . . .

Java Implementation

Java
Java

. . . .

Complexity Analysis

Approach 1 (Dictionary + Sorting)

  • Time Complexity:
    • Grouping scores: (O(n)) where (n) is the number of records.

    • Sorting scores for each student: If there are (m) students and each has (k) scores on average, then sorting takes (O(m \cdot k \log k)).

    • Overall, the time complexity is (O(n + m \cdot k \log k)).

  • Space Complexity:
    • (O(n)) for storing scores in the dictionary.

Approach 2 (Dictionary + Min-Heap)

  • Time Complexity:
    • Inserting each score into the min-heap is (O(\log 5)) (constant time since the heap size is capped at 5) for each record, leading to (O(n)) overall.
  • Space Complexity:
    • (O(n)) for the dictionary and the heaps.

Common Mistakes and Edge Cases

Common Mistakes

  • Not Removing Extra Scores:
    Failing to ensure that only the top five scores are used when a student has more than five scores.

  • Sorting Order:
    Sorting in the wrong order (ascending instead of descending) can lead to incorrect averages.

  • Integer Division Issues:
    Be mindful that the average is calculated using integer division.

Edge Cases

  • Exact Five Scores:
    When a student has exactly five scores, the solution should simply compute the average without any extra processing.

  • Multiple Students:
    Ensure the solution correctly sorts the output by student id.

  • Handling Ties:
    Although not a direct issue in this problem, be careful when there are duplicate scores or similar edge scenarios.

Alternative Variations

  • Top K Scores:
    What if you need to calculate the average of the top K scores, where K is a parameter?

  • Weighted Scores:
    A variation where scores have different weights.

  • Dynamic Updates:
    Consider scenarios where new scores are continuously added, and the average must be updated in real-time.

  • Top K Frequent Elements:
    Use heaps or dictionaries to find the most frequent elements.

  • Kth Largest Element in an Array:
    A problem that also benefits from min-heap usage.

  • Merge Intervals:
    Practice combining and sorting data for effective grouping.

TAGS
leetcode
CONTRIBUTOR
Design Gurus Team
-

GET YOUR FREE

Coding Questions Catalog

Design Gurus Newsletter - Latest from our Blog
Boost your coding skills with our essential coding questions catalog.
Take a step towards a better tech career now!
Explore Answers
What is the difference between program portfolio and project portfolio?
How to answer industry questions in an interview?
Master-level strategies for handling complex system design trade-offs
Related Courses
Image
Grokking the Coding Interview: Patterns for Coding Questions
Grokking the Coding Interview Patterns in Java, Python, JS, C++, C#, and Go. The most comprehensive course with 476 Lessons.
Image
Grokking Modern AI Fundamentals
Master the fundamentals of AI today to lead the tech revolution of tomorrow.
Image
Grokking Data Structures & Algorithms for Coding Interviews
Unlock Coding Interview Success: Dive Deep into Data Structures and Algorithms.
Image
One-Stop Portal For Tech Interviews.
Copyright © 2025 Design Gurus, LLC. All rights reserved.
;