Maximum Average Pass Ratio - Practice Coding Problems

Maximum Average Pass Ratio - Problem

Imagine you're an academic advisor at a prestigious school with the power to strategically place brilliant students to maximize the overall success rate across all classes! 🎓

You have classes, where each class i currently has passi students who will pass out of totali total students. You also have extraStudents brilliant students who are guaranteed to pass any class they're assigned to.

Your mission: Assign these extra students to maximize the average pass ratio across all classes.

The pass ratio of a class = passing_students / total_students
The average pass ratio = sum of all pass ratios / number of classes

Key Insight: Adding a student to a class with a lower current ratio typically yields a bigger improvement than adding to a class with a higher ratio!

Return the maximum possible average pass ratio after optimally assigning all extra students.

Input & Output

example_1.py — Basic Case

$ Input: classes = [[1,2],[3,5],[2,2]], extraStudents = 2

› Output: 0.78333

💡 Note: Initially: 1/2=0.5, 3/5=0.6, 2/2=1.0. Adding students optimally: first to [1,2]→[2,3] (biggest improvement), then to [2,3]→[3,4]. Final: 3/4 + 3/5 + 2/2 = 2.35, average = 2.35/3 ≈ 0.78333

example_2.py — Single Class

$ Input: classes = [[2,4]], extraStudents = 1

› Output: 0.75000

💡 Note: Only one class [2,4] with ratio 2/4=0.5. Adding one student gives [3,5] with ratio 3/5=0.6. Since there's only one class, average equals this ratio: 0.6

example_3.py — No Improvement Needed

$ Input: classes = [[1,1],[2,2]], extraStudents = 2

› Output: 1.00000

💡 Note: Both classes already have 100% pass rate. Adding students doesn't improve ratios: [2,2] and [3,3] both have ratio 1.0. Average remains 1.0

Constraints

1 ≤ classes.length ≤ 10⁵
classes[i].length == 2
1 ≤ pass_i ≤ total_i ≤ 10⁵
1 ≤ extraStudents ≤ 10⁵
Answers within 10^-5 of the actual answer will be accepted

Visualization

Tap to expand

Understanding the Visualization

Calculate ROI

For each class, calculate the 'return on investment' - how much the pass ratio improves by adding one student

Invest Wisely

Always invest in the opportunity with the highest ROI (use a max heap to track this efficiently)

Update Opportunities

After each investment, recalculate the ROI for that class and update your priorities

Repeat

Continue until all your resources (extra students) are allocated optimally

Key Takeaway

🎯 Key Insight: The greedy approach works because improvement potential decreases as pass ratios increase. By always choosing the class with maximum improvement potential, we guarantee the optimal allocation of extra students to maximize the overall average pass ratio!

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a greedy approach with a priority queue (max heap). The key insight is to always assign each extra student to the class where adding them creates the maximum improvement in pass ratio. We calculate the improvement as (passes+1)/(total+1) - passes/total and use a max heap to efficiently find the class with highest improvement potential in O(log n) time per assignment.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Distributions)	O(k^n)	O(k)	Try all possible ways to distribute extra students among classes
Greedy with Priority Queue (Optimal)	O(k log n)	O(n)	Use max heap to always assign student to class with highest improvement potential

Brute Force (Try All Distributions) — Algorithm Steps

Generate all possible distributions of extraStudents among classes
For each distribution, calculate the resulting average pass ratio
Keep track of the maximum average pass ratio found
Return the maximum ratio

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with all extra students unassigned

Branch

For each class, try assigning 0 to all remaining students

Calculate

At each leaf, calculate the average pass ratio

Track Max

Keep track of the maximum ratio found

Code -

solution.c — C

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

double maxRatio = 0.0;

void generateDistributions(int classes[][2], int n, int remaining, int classIdx, int* currentDist) {
    if (classIdx == n) {
        if (remaining == 0) {
            double totalRatio = 0.0;
            for (int i = 0; i < n; i++) {
                double passes = classes[i][0] + currentDist[i];
                double total = classes[i][1] + currentDist[i];
                totalRatio += passes / total;
            }
            double avgRatio = totalRatio / n;
            if (avgRatio > maxRatio) {
                maxRatio = avgRatio;
            }
        }
        return;
    }
    
    for (int add = 0; add <= remaining; add++) {
        currentDist[classIdx] = add;
        generateDistributions(classes, n, remaining - add, classIdx + 1, currentDist);
    }
}

double maxAverageRatio(int classes[][2], int n, int extraStudents) {
    int* currentDist = (int*)calloc(n, sizeof(int));
    generateDistributions(classes, n, extraStudents, 0, currentDist);
    free(currentDist);
    return maxRatio;
}

int main() {
    printf("Brute force approach - too slow for practical use\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Where k is extraStudents and n is number of classes - we try all ways to distribute k items into n buckets

✓ Linear Growth

Space Complexity

O(k)

For storing the current distribution being tested

✓ Linear Space

89.3K Views

Medium-High Frequency

~18 min Avg. Time

1.8K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Distributions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler