# Fairly Distribute Money With Limits You are given an integer `amount` representing a total sum of money to distribute, and a list of `employees`. Each employee is described by: - `name` — a unique string identifier. - `limit` — a non-negative integer giving the maximum amount that person is allowed to receive. Distribute the entire `amount` (when possible) among the employees subject to these rules: 1. **Cap rule.** No employee may receive more than their `limit`. 2. **Even distribution.** The money is shared as evenly as possible among the employees who have not yet reached their cap. 3. **Redistribution.** When an employee hits their `limit`, any money they cannot accept is redistributed among the remaining employees who still have room — again, as evenly as possible. Return a mapping from each employee `name` to the integer amount they receive. ## Distribution semantics Because the amount is an integer and must be split as evenly as possible, distribute in **whole units** so that the result is deterministic: - At each step, consider only employees whose current allocation is still below their `limit` (the "active" set). - Give each active employee an equal whole-unit share of the remaining money. If the remaining money does not divide evenly across the active set, the leftover indivisible units (`remaining % active_count` of them) are handed out one extra unit at a time to the active employees **in ascending order of `name`** (lexicographic), so that the tie-break is fully specified. - Whenever an employee reaches their `limit`, they leave the active set and their unused share returns to the pool to be redistributed in the next step. - Stop when either all money is distributed or every employee has reached their `limit`. If the total of all limits is less than `amount`, every employee receives exactly their `limit` and `amount - sum(limits)` units remain undistributed (they are simply not assigned to anyone). ## Input / Output - `amount`: integer, `0 <= amount <= 10^9`. - `employees`: a list of `(name, limit)` pairs. Names are unique. `0 <= limit <= 10^9`. The list has between `1` and `10^5` employees. Return a dictionary (map) from `name` to the integer amount that name receives. Every employee name in the input must appear in the output, including those who receive `0`. ## Examples **Example 1** ``` amount = 100 employees = [("Alice", 50), ("Bob", 50), ("Carol", 50)] ``` Output: ``` {"Alice": 34, "Bob": 33, "Carol": 33} ``` Each person could take up to 50, so no cap binds. 100 split three ways is 33 each with 1 unit left over; the leftover unit goes to the lexicographically smallest name, `Alice`. **Example 2** ``` amount = 100 employees = [("Alice", 10), ("Bob", 100), ("Carol", 100)] ``` Output: ``` {"Alice": 10, "Bob": 45, "Carol": 45} ``` An even 3-way split would give each about 33, but `Alice` is capped at 10. `Alice` takes 10, then the remaining 90 is split evenly between `Bob` and `Carol`, giving 45 each. **Example 3** ``` amount = 5 employees = [("Alice", 1), ("Bob", 1)] ``` Output: ``` {"Alice": 1, "Bob": 1} ``` Total limits sum to 2, which is less than 5. Each gets their cap of 1, and 3 units remain undistributed.