The Number of Seniors and Juniors to Join the Company

The Number of Seniors and Juniors to Join the Company - Problem

Database Hard

A company is looking to expand its team with a limited hiring budget of $70,000. The HR department has received applications from candidates with two different experience levels: Senior and Junior developers.

The company has a specific hiring strategy:

Priority to Seniors: First, hire the maximum number of senior developers possible within the budget
Fill remaining with Juniors: Use any leftover budget to hire as many junior developers as possible

Given a table of Candidates with their experience level and salary requirements, determine how many seniors and juniors the company can hire while staying within budget.

Table: Candidates

+-------------+------+
| Column Name | Type |
+-------------+------+
| employee_id | int  |
| experience  | enum |
| salary      | int  |
+-------------+------+

Where experience is either 'Senior' or 'Junior', and salary represents the monthly salary requirement.

Goal: Return the count of seniors and juniors that can be hired with the optimal budget allocation strategy.

Input & Output

example_1.sql — Basic Hiring

$ Input: Candidates table: | employee_id | experience | salary | |-------------|------------|--------| | 1 | Junior | 10000 | | 9 | Junior | 15000 | | 2 | Senior | 20000 | | 11 | Senior | 16000 | | 13 | Senior | 50000 |

› Output: | experience | accepted_candidates | |------------|--------------------| | Senior | 2 | | Junior | 2 |

💡 Note: We can hire 2 seniors with salaries $16k + $20k = $36k, leaving $34k. With the remaining budget, we hire 2 juniors with salaries $10k + $15k = $25k. Total budget used: $61k ≤ $70k.

example_2.sql — Budget Constraint

$ Input: Candidates table: | employee_id | experience | salary | |-------------|------------|--------| | 1 | Senior | 70000 | | 2 | Senior | 60000 | | 3 | Junior | 20000 |

› Output: | experience | accepted_candidates | |------------|--------------------| | Senior | 1 | | Junior | 0 |

💡 Note: We hire the cheapest senior ($60k), using the entire budget. No money remains for juniors.

example_3.sql — Only Juniors Affordable

$ Input: Candidates table: | employee_id | experience | salary | |-------------|------------|--------| | 1 | Senior | 80000 | | 2 | Senior | 90000 | | 3 | Junior | 30000 | | 4 | Junior | 25000 |

› Output: | experience | accepted_candidates | |------------|--------------------| | Senior | 0 | | Junior | 2 |

💡 Note: All seniors are too expensive ($80k+ > $70k budget). We hire both affordable juniors: $25k + $30k = $55k ≤ $70k.

Constraints

1 ≤ candidates.length ≤ 1000
1 ≤ employee_id ≤ 10⁶
experience is either 'Senior' or 'Junior'
1000 ≤ salary ≤ 10⁵
Budget is fixed at $70,000

Visualization

Tap to expand

Understanding the Visualization

Separate by Priority

Split candidates into seniors (premium) and juniors (regular) groups

Sort by Cost

Arrange both groups from cheapest to most expensive

Buy Premium First

Spend on cheapest seniors until budget runs low

Fill Cart with Regular

Use remaining budget on cheapest juniors

Key Takeaway

🎯 Key Insight: Greedy selection within priority groups maximizes total hires while respecting constraints

Asked in

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

The optimal solution uses a greedy approach with sorting. First, separate candidates by experience and sort each group by salary. Prioritize hiring the cheapest seniors until budget is exhausted, then use remaining budget for cheapest juniors. This guarantees maximum hires while respecting the hiring priority constraint.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Sorting (Optimal)	O(n log n)	O(1)	Sort candidates by salary within each group, greedily select cheapest first
Brute Force (All Combinations)	O(2^n)	O(2^n)	Try all possible combinations of seniors and juniors within budget

Greedy Sorting (Optimal) — Algorithm Steps

Separate candidates into seniors and juniors
Sort both groups by salary in ascending order
Greedily hire seniors starting from cheapest until budget exhausted
Use remaining budget to hire cheapest juniors
Return counts of each group hired

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Salary

Sort seniors and juniors by salary ascending

Hire Cheapest Seniors

Greedily hire seniors starting from lowest salary

Calculate Remaining

Determine leftover budget after senior hiring

Hire Cheapest Juniors

Use remaining budget for cheapest juniors

Code -

solution.c — C

// Optimal C Solution
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int employee_id;
    char experience[10];
    int salary;
} Candidate;

int compare_salary(const void* a, const void* b) {
    return *(int*)a - *(int*)b;
}

void solution(Candidate* candidates, int n, int* senior_result, int* junior_result) {
    const int budget = 70000;
    int senior_salaries[1000], junior_salaries[1000];
    int senior_count = 0, junior_count = 0;
    
    // Separate salaries by experience
    for (int i = 0; i < n; i++) {
        if (strcmp(candidates[i].experience, "Senior") == 0) {
            senior_salaries[senior_count++] = candidates[i].salary;
        } else {
            junior_salaries[junior_count++] = candidates[i].salary;
        }
    }
    
    // Sort salaries in ascending order
    qsort(senior_salaries, senior_count, sizeof(int), compare_salary);
    qsort(junior_salaries, junior_count, sizeof(int), compare_salary);
    
    int remaining_budget = budget;
    int hired_seniors = 0, hired_juniors = 0;
    
    // Hire seniors greedily
    for (int i = 0; i < senior_count; i++) {
        if (remaining_budget >= senior_salaries[i]) {
            remaining_budget -= senior_salaries[i];
            hired_seniors++;
        } else {
            break;
        }
    }
    
    // Hire juniors with remaining budget
    for (int i = 0; i < junior_count; i++) {
        if (remaining_budget >= junior_salaries[i]) {
            remaining_budget -= junior_salaries[i];
            hired_juniors++;
        } else {
            break;
        }
    }
    
    *senior_result = hired_seniors;
    *junior_result = hired_juniors;
}

int main() {
    // Parse input and call solution
    Candidate candidates[1000];
    int n = 0;
    int senior_result, junior_result;
    
    solution(candidates, n, &senior_result, &junior_result);
    
    printf("Senior: %d\nJunior: %d\n", senior_result, junior_result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting dominates the time complexity, where n is total candidates

⚡ Linearithmic

Space Complexity

O(1)

Only need variables to track counts and remaining budget

✓ Linear Space

42.3K Views

Medium Frequency

~15 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

Greedy Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler