Watch 10 video solutions for Classes More Than 5 Students, a easy level problem involving Database. This walkthrough by Frederik Müller has 6,425 views views. Want to try solving it yourself? Practice on FleetCode or read the detailed text solution.
Table: Courses
+-------------+---------+ | Column Name | Type | +-------------+---------+ | student | varchar | | class | varchar | +-------------+---------+ (student, class) is the primary key (combination of columns with unique values) for this table. Each row of this table indicates the name of a student and the class in which they are enrolled.
Write a solution to find all the classes that have at least five students.
Return the result table in any order.
The result format is in the following example.
Example 1:
Input: Courses table: +---------+----------+ | student | class | +---------+----------+ | A | Math | | B | English | | C | Math | | D | Biology | | E | Math | | F | Computer | | G | Math | | H | Math | | I | Math | +---------+----------+ Output: +---------+ | class | +---------+ | Math | +---------+ Explanation: - Math has 6 students, so we include it. - English has 1 student, so we do not include it. - Biology has 1 student, so we do not include it. - Computer has 1 student, so we do not include it.
Problem Overview: You are given a table that records which student belongs to which class. The task is to return all class names that have at least five students enrolled. The result should contain only the class identifier.
Approach 1: Using SQL Aggregation Functions (O(n) time, O(k) space)
This is a classic SQL aggregation problem. You group rows by the class column and count how many students appear in each group. The key operation is GROUP BY class, which forms a bucket of rows for every class. Then apply a HAVING COUNT(student) >= 5 filter to keep only classes with at least five students. The database engine performs a single pass through the rows, builds aggregated counts per class, and filters the results afterward.
The time complexity is O(n) where n is the number of records in the table. The database maintains counts for each unique class, which requires O(k) space where k is the number of distinct classes. This is the most natural and expected solution when working directly with relational data.
Approach 2: HashMap Simulation in Iterative Languages (O(n) time, O(k) space)
If the data is processed in an application layer (for example in Python or Java instead of pure SQL), you can simulate the same behavior using a HashMap. Iterate through each record and update a counter for the corresponding class. Each insertion or update in the hash map takes average O(1) time.
After counting all students, iterate over the map entries and collect the classes whose counts are greater than or equal to five. This mirrors the behavior of SQL's GROUP BY + HAVING pipeline. The overall time complexity remains O(n) because each record is processed once, and the space complexity is O(k) for storing counts of distinct classes. This approach is useful when solving the problem outside a database engine or during interviews that expect algorithmic implementations.
Recommended for interviews: Interviewers typically expect the SQL aggregation solution because the problem is tagged as a database query task. Writing GROUP BY with a HAVING COUNT filter shows strong understanding of relational querying. The HashMap approach demonstrates that you understand the underlying mechanics of aggregation, which can help when translating database logic into general programming languages.
| Approach | Time | Space | When to Use |
|---|---|---|---|
| SQL Aggregation (GROUP BY + HAVING) | O(n) | O(k) | Best when solving directly in SQL or database interview questions |
| HashMap Counting Simulation | O(n) | O(k) | Useful when implementing the logic in Python, Java, or other iterative languages |
