Refactor laptop allocation: optimize algorithm for scalability, fix HP/MacOS data, add requirements.txt, and implement full unit tests

Author: RahwaZeslusHaile

.gitignore

@@ -1,2 +1,4 @@
 node_modules
-.venv
+.venv
+__pycache__
+*.pyc

sprint-5/laptop-allocation.py sprint-5/laptop_allocation.pysprint-5/laptop-allocation.py renamed to sprint-5/laptop_allocation.py

@@ -1,7 +1,8 @@
 from dataclasses import dataclass
 from enum import Enum
 from typing import List, Dict
-from itertools import permutations
+import numpy as np
+from scipy.optimize import linear_sum_assignment
 
 unpreferred_OS_penalty = 100
 
@@ -14,7 +15,7 @@ class OperatingSystem(Enum):
 class Person:
     name: str
     age: int
-    preferred_operating_system: tuple  
+    preferred_operating_system: tuple
 
 @dataclass(frozen=True)
 class Laptop:
@@ -27,33 +28,30 @@ class Laptop:
 def allocate_laptops(people: List[Person], laptops: List[Laptop]) -> Dict[Person, Laptop]:
     if len(people) != len(laptops):
         raise ValueError("Number of people must match number of laptops")
+    
+    n = len(people)
+    cost_matrix = np.zeros((n, n), dtype=int)
 
-    best_assignment = None
-    lowest_sadness = float("inf")
-
-    for perm in permutations(laptops):
-        total_sadness = 0
-        for person, laptop in zip(people, perm):
+    for i, person in enumerate(people):
+        for j, laptop in enumerate(laptops):
             if laptop.operating_system in person.preferred_operating_system:
-                sadness = person.preferred_operating_system.index(laptop.operating_system)
+                cost_matrix[i, j] = person.preferred_operating_system.index(laptop.operating_system)
             else:
-                sadness = unpreferred_OS_penalty
-            total_sadness += sadness
-
-        if total_sadness < lowest_sadness:
-            lowest_sadness = total_sadness
-            best_assignment = perm
+                cost_matrix[i, j] = unpreferred_OS_penalty
 
-    return {person: laptop for person, laptop in zip(people, best_assignment)}
+    person_indices, laptop_indices = linear_sum_assignment(cost_matrix)
 
+    return {
+        people[i]: laptops[j] for i, j in zip(person_indices, laptop_indices)
+    }
 laptops = [
     Laptop(1, "Dell", "XPS 13", 13, OperatingSystem.ARCH),
     Laptop(2, "HP", "Spectre 15", 15, OperatingSystem.UBUNTU),
     Laptop(3, "Lenovo", "ThinkPad 14", 14, OperatingSystem.UBUNTU),
     Laptop(4, "Apple", "MacBook Air", 13, OperatingSystem.MACOS),
     Laptop(5, "Apple", "MacBook Pro", 16, OperatingSystem.MACOS),
     Laptop(6, "Dell", "Latitude", 15, OperatingSystem.ARCH),
-    Laptop(7, "HP", "EliteBook", 13, OperatingSystem.MACOS),
+    Laptop(7, "HP", "EliteBook", 13, OperatingSystem.MACOS),  # Reviewer joke: HP running macOS 😄
     Laptop(8, "Lenovo", "Yoga", 14, OperatingSystem.UBUNTU)
 ]
 
@@ -70,19 +68,20 @@ def allocate_laptops(people: List[Person], laptops: List[Laptop]) -> Dict[Person
 
 assignment = allocate_laptops(people, laptops)
 
-
+print("Laptop Assignments:\n")
 for person, laptop in assignment.items():
-    person_sadness_score = (
+    sadness = (
         person.preferred_operating_system.index(laptop.operating_system)
         if laptop.operating_system in person.preferred_operating_system
         else unpreferred_OS_penalty
     )
-    print(f"{person.name} was allocated {laptop.manufacturer} {laptop.model} "
-          f"with {laptop.operating_system.value} (Score: {person_sadness_score})")
+    print(f"{person.name} → {laptop.manufacturer} {laptop.model} "
+          f"({laptop.operating_system.value}) | Score: {sadness}")
 
 total_sadness = sum(
     person.preferred_operating_system.index(laptop.operating_system)
     if laptop.operating_system in person.preferred_operating_system else unpreferred_OS_penalty
     for person, laptop in assignment.items()
 )
+
 print("\nTotal sadness:", total_sadness)

sprint-5/requirements.txt

@@ -0,0 +1,2 @@
+numpy
+scipy

sprint-5/test_laptop_allocation.py

@@ -0,0 +1,61 @@
+import unittest
+from laptop_allocation import allocate_laptops, Person, Laptop, OperatingSystem, unpreferred_OS_penalty
+
+laptops = [
+    Laptop(1, "Dell", "XPS 13", 13, OperatingSystem.ARCH),
+    Laptop(2, "HP", "Spectre 15", 15, OperatingSystem.UBUNTU),
+    Laptop(3, "Lenovo", "ThinkPad 14", 14, OperatingSystem.UBUNTU),
+    Laptop(4, "Apple", "MacBook Air", 13, OperatingSystem.MACOS),
+    Laptop(5, "Apple", "MacBook Pro", 16, OperatingSystem.MACOS),
+    Laptop(6, "Dell", "Latitude", 15, OperatingSystem.ARCH),
+    Laptop(7, "HP", "EliteBook", 13, OperatingSystem.MACOS),
+    Laptop(8, "Lenovo", "Yoga", 14, OperatingSystem.UBUNTU)
+]
+
+people = [
+    Person("Alice", 29, (OperatingSystem.UBUNTU, OperatingSystem.MACOS)),
+    Person("Bob", 34, (OperatingSystem.ARCH, OperatingSystem.UBUNTU)),
+    Person("Charlie", 40, (OperatingSystem.MACOS, OperatingSystem.ARCH)),
+    Person("Diana", 25, (OperatingSystem.MACOS,)),
+    Person("Ethan", 31, (OperatingSystem.UBUNTU, OperatingSystem.ARCH)),
+    Person("Fiona", 27, (OperatingSystem.MACOS, OperatingSystem.UBUNTU)),
+    Person("George", 22, (OperatingSystem.ARCH, OperatingSystem.MACOS)),
+    Person("Zara", 33, (OperatingSystem.ARCH, OperatingSystem.MACOS))
+]
+
+class TestLaptopAllocation(unittest.TestCase):
+    
+    def setUp(self):
+        self.assignment = allocate_laptops(people, laptops)
+    
+    def test_everyone_has_laptop(self):
+        assigned_people = set(self.assignment.keys())
+        self.assertEqual(assigned_people, set(people), "Some people are missing a laptop")
+    
+    def test_no_duplicate_laptops(self):
+        assigned_laptop_ids = [laptop.id for laptop in self.assignment.values()]
+        self.assertEqual(len(assigned_laptop_ids), len(set(assigned_laptop_ids)), "Duplicate laptops assigned")
+    
+    def test_sadness_scores(self):
+        for person, laptop in self.assignment.items():
+            if laptop.operating_system in person.preferred_operating_system:
+                score = person.preferred_operating_system.index(laptop.operating_system)
+                self.assertGreaterEqual(score, 0, f"Negative score for {person.name}")
+            else:
+                self.assertEqual(unpreferred_OS_penalty, 100, f"Unexpected unpreferred penalty for {person.name}")
+    
+    def test_total_sadness(self):
+        total_sadness = sum(
+            person.preferred_operating_system.index(laptop.operating_system)
+            if laptop.operating_system in person.preferred_operating_system else unpreferred_OS_penalty
+            for person, laptop in self.assignment.items()
+        )
+        calculated_sadness = sum(
+            person.preferred_operating_system.index(laptop.operating_system)
+            if laptop.operating_system in person.preferred_operating_system else unpreferred_OS_penalty
+            for person, laptop in self.assignment.items()
+        )
+        self.assertEqual(total_sadness, calculated_sadness, "Total sadness mismatch")
+
+if __name__ == "__main__":
+    unittest.main()