feat(algorithms, greedy): minimimum moves to spread stones

Author: BrianLusina

algorithms/greedy/spread_stones/README.md

@@ -0,0 +1,13 @@
+# Minimum Moves to Spread Stones Over Grid
+
+Given a 2D grid of integers of size (3 × 3), where each value represents the number of stones in the given cell, return 
+the minimum number of moves required to place exactly one stone in each grid cell.
+
+## Constraints
+
+- Only one stone can be moved in one move.
+- Stone from a cell can only be moved to another cell if they are adjacent (share a side).
+- The sum of all stones in the grid must be equal to 9.
+- `grid.length`, `grid[i].length` == 3
+- 0 <= `grid[i][j]` <= 9
+

algorithms/greedy/spread_stones/__init__.py

@@ -0,0 +1,42 @@
+from typing import List
+from itertools import permutations
+
+
+def minimum_moves(grid: List[List[int]]) -> int:
+    """
+    This function finds the minimum number of moves required to place exactly one stone in each grid cell.
+
+    Args:
+        grid(list): 2D grid of integers of size (3 × 3), where each value represents the number of stones in the given
+        cell
+    Returns:
+        int: minimum number of moves required to place exactly one stone in each grid cell
+    """
+    # stores every stone beyond the first one in a cell, this becomes the source
+    surplus_list = []
+    # for every cell with 0 stones, this contains the coordinates of that cell. this becomes the target
+    empty_list = []
+
+    minimum_number_of_moves = float("inf")
+
+    # iterate through the grid and add the cell that has surplus stones multiple times to the surplus list, for example,
+    # if cell grid[1][1] has 3 stones, add it twice to the surplus list
+    for row in range(len(grid)):
+        for col in range(len(grid[row])):
+            if grid[row][col] == 0:
+                empty_list.append([row, col])
+            elif grid[row][col] > 1:
+                count = grid[row][col]
+                for c in range(count - 1):
+                    surplus_list.append([row, col])
+
+    # iterate through every possible permutation of the sources, trying every possible assignment to the targets
+    for perms in permutations(surplus_list):
+        # calculate the total number of moves for this permutation
+        total_moves = 0
+        for i in range(len(perms)):
+            total_moves += abs(perms[i][0] - empty_list[i][0]) + abs(perms[i][1] - empty_list[i][1])
+        # return the minimum number of moves
+        minimum_number_of_moves = min(minimum_number_of_moves, total_moves)
+
+    return minimum_number_of_moves

algorithms/greedy/spread_stones/test_minimum_moves_to_spread_stones.py

@@ -0,0 +1,24 @@
+import unittest
+from typing import List
+from parameterized import parameterized
+from algorithms.greedy.spread_stones import minimum_moves
+
+
+TEST_CASES = [
+    ([[0, 0, 1], [1, 0, 4], [1, 1, 1]], 6),
+    ([[0, 2, 1], [1, 1, 1], [1, 1, 1]], 1),
+    ([[0, 0, 0], [9, 0, 0], [0, 0, 0]], 15),
+    ([[6, 0, 0], [1, 0, 0], [1, 0, 1]], 11),
+    ([[0, 0, 0], [7, 0, 1], [0, 0, 1]], 10),
+]
+
+
+class MinimumMovesToSpreadStonesTestCase(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_something(self, grid: List[List[int]], expected: int):
+        actual = minimum_moves(grid)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()