S3Q1 · Employee Task Analysis¶
⚡ Quick Reference
Function: process_employees(employee_list: list, request: str)
def process_employees(employee_list: list, request: str):
if request == "total_tasks_completed":
return sum(e["tasks_completed"] for e in employee_list)
if request == "most_efficient_employee":
best = max(employee_list,
key=lambda e: (e["tasks_completed"] / e["hours_worked"],
e["tasks_completed"]))
return best["employee_id"]
if request == "sort_by_hours_worked":
ranked = sorted(employee_list,
key=lambda e: (-e["hours_worked"],
-e["tasks_completed"]))
return [e["employee_id"] for e in ranked]
if request == "productive_team_members":
return [e["employee_id"] for e in employee_list
if e["tasks_completed"] >= 20]
Key rules:
- most_efficient_employee: primary = tasks/hours ratio (higher = better); tiebreaker = tasks_completed (higher = better)
- sort_by_hours_worked: descending hours; ties → descending tasks
- productive_team_members: tasks_completed >= 20, preserve original order
Problem Statement¶
Problem
Implement process_employees(employee_list, request) - four analytics operations on a list of employee dicts.
Sample data:
employee_list = [
{"employee_id": 1, "tasks_completed": 30, "hours_worked": 40},
{"employee_id": 2, "tasks_completed": 60, "hours_worked": 90},
{"employee_id": 3, "tasks_completed": 60, "hours_worked": 100},
{"employee_id": 4, "tasks_completed": 50, "hours_worked": 100},
{"employee_id": 5, "tasks_completed": 10, "hours_worked": 30},
]
Operation 1 - total_tasks_completed¶
30 + 60 + 60 + 50 + 10 = 210 ✓
Operation 2 - most_efficient_employee¶
Efficiency = tasks_completed / hours_worked. Ties → higher tasks_completed wins:
best = max(employee_list,
key=lambda e: (e["tasks_completed"] / e["hours_worked"],
e["tasks_completed"]))
return best["employee_id"]
| ID | tasks | hours | efficiency |
|---|---|---|---|
| 1 | 30 | 40 | 0.750 ← highest |
| 2 | 60 | 90 | 0.667 |
| 3 | 60 | 100 | 0.600 |
| 4 | 50 | 100 | 0.500 |
| 5 | 10 | 30 | 0.333 |
Most efficient: Employee 1 ✓
Operation 3 - sort_by_hours_worked¶
Sort descending by hours; ties broken by descending tasks:
ranked = sorted(employee_list,
key=lambda e: (-e["hours_worked"], -e["tasks_completed"]))
return [e["employee_id"] for e in ranked]
| ID | hours | tasks | key |
|---|---|---|---|
| 3 | 100 | 60 | (-100, -60) ← smallest key |
| 4 | 100 | 50 | (-100, -50) |
| 2 | 90 | 60 | (-90, -60) |
| 1 | 40 | 30 | (-40, -30) |
| 5 | 30 | 10 | (-30, -10) |
Result: [3, 4, 2, 1, 5] ✓
Operation 4 - productive_team_members¶
Keep employees with tasks_completed >= 20, in original order:
Employee 5 has 10 tasks → excluded. Result: [1, 2, 3, 4] ✓
Complete solution approaches¶
def process_employees(employee_list: list, request: str):
if request == "total_tasks_completed":
return sum(e["tasks_completed"] for e in employee_list)
if request == "most_efficient_employee":
return max(employee_list,
key=lambda e: (e["tasks_completed"] / e["hours_worked"],
e["tasks_completed"]))["employee_id"]
if request == "sort_by_hours_worked":
return [e["employee_id"] for e in
sorted(employee_list,
key=lambda e: (-e["hours_worked"], -e["tasks_completed"]))]
if request == "productive_team_members":
return [e["employee_id"] for e in employee_list
if e["tasks_completed"] >= 20]
def process_employees(employee_list: list, request: str):
if request == "total_tasks_completed":
total = 0
for e in employee_list:
total += e["tasks_completed"]
return total
if request == "most_efficient_employee":
best = employee_list[0]
best_eff = best["tasks_completed"] / best["hours_worked"]
for e in employee_list[1:]:
eff = e["tasks_completed"] / e["hours_worked"]
if eff > best_eff or (eff == best_eff and
e["tasks_completed"] > best["tasks_completed"]):
best = e
best_eff = eff
return best["employee_id"]
if request == "sort_by_hours_worked":
ranked = sorted(employee_list,
key=lambda e: (-e["hours_worked"], -e["tasks_completed"]))
return [e["employee_id"] for e in ranked]
if request == "productive_team_members":
result = []
for e in employee_list:
if e["tasks_completed"] >= 20:
result.append(e["employee_id"])
return result
def process_employees(employee_list: list, request: str):
eff = lambda e: (e["tasks_completed"] / e["hours_worked"],
e["tasks_completed"])
hrs = lambda e: (-e["hours_worked"], -e["tasks_completed"])
eid = lambda e: e["employee_id"]
ops = {
"total_tasks_completed": lambda el: sum(e["tasks_completed"] for e in el),
"most_efficient_employee": lambda el: eid(max(el, key=eff)),
"sort_by_hours_worked": lambda el: [eid(e) for e in sorted(el, key=hrs)],
"productive_team_members": lambda el: [eid(e) for e in el if e["tasks_completed"] >= 20],
}
return ops[request](employee_list)
Key takeaways¶
Negate values for descending sort
sorted(key=lambda e: (-e["hours_worked"], -e["tasks_completed"])) sorts descending by both criteria in one pass. Negating converts a descending requirement into an ascending one that sorted() handles natively.
Tuple key for multi-criteria max/sort
For most_efficient_employee, the key (ratio, tasks) handles both criteria - ratio is compared first; only when ratios are equal does tasks break the tie. One max() call handles everything.
productive_team_members - preserve original order
The problem asks for employees "in the order they are present in the list". A simple list comprehension with if e["tasks_completed"] >= 20 filters without sorting - original order is preserved.