Rotting oranges

Author: volodimyr

994.rotting_oranges/oranges.py

@@ -0,0 +1,81 @@
+# 994. Rotting oranges
+# Topics: 'Array', 'Breadth-First Search', 'Matrix'
+# Level: 'Medium'
+
+# You are given an m x n grid where each cell can have one of three values:
+
+#     0 representing an empty cell,
+#     1 representing a fresh orange, or
+#     2 representing a rotten orange.
+
+# Every minute, any fresh orange that is 4-directionally adjacent to a rotten orange becomes rotten.
+
+# Return the minimum number of minutes that must elapse until no cell has a fresh orange. If this is impossible, return -1.
+
+ 
+
+# Example 1:
+
+# Input: grid = [[2,1,1],[1,1,0],[0,1,1]]
+# Output: 4
+
+# Example 2:
+
+# Input: grid = [[2,1,1],[0,1,1],[1,0,1]]
+# Output: -1
+# Explanation: The orange in the bottom left corner (row 2, column 0) is never rotten, because rotting only happens 4-directionally.
+
+# Example 3:
+
+# Input: grid = [[0,2]]
+# Output: 0
+# Explanation: Since there are already no fresh oranges at minute 0, the answer is just 0.
+
+ 
+
+# Constraints:
+
+#     m == grid.length
+#     n == grid[i].length
+#     1 <= m, n <= 10
+#     grid[i][j] is 0, 1, or 2.
+
+from collections import deque
+from typing import List
+
+class Solution:
+    def orangesRotting(self, grid: List[List[int]]) -> int:
+        q = deque()
+        fresh = 0
+        for row in range (len(grid)):
+            for col in range (len(grid[row])):
+                if grid[row][col] == 2:
+                    q.append((row,col))
+                if grid[row][col] == 1:
+                    fresh+=1
+        if fresh == 0:
+            return 0
+        minutes = 0
+        ROWS, COLS = len(grid), len(grid[0])
+        while q:
+            rotten = False
+            for i in range (len(q)):
+                row, col = q.popleft()
+                directions = [[1, 0], [-1,0], [0, 1], [0,-1]]
+                for dr, dc in directions:
+                    if min(row+dr, col+dc) < 0:
+                        continue
+                    if row+dr == ROWS or col+dc == COLS:
+                        continue
+                    if grid[row+dr][col+dc] != 1:
+                        continue
+                    grid[row+dr][col+dc] = 2
+                    q.append((row+dr,col+dc))
+                    rotten = True
+                    fresh-=1
+            if rotten:
+                minutes+=1
+        if fresh > 0:
+            return -1
+        return minutes
+        

994.rotting_oranges/test_oranges.py

@@ -0,0 +1,101 @@
+from collections import deque
+from typing import List
+import unittest
+from oranges import Solution
+
+class TestOrangesRotting(unittest.TestCase):
+    
+    def setUp(self):
+        self.solution = Solution()
+    
+    def test_example_1(self):
+        """Standard case with rotting spreading"""
+        grid = [[2,1,1],[1,1,0],[0,1,1]]
+        self.assertEqual(self.solution.orangesRotting(grid), 4)
+    
+    def test_example_2(self):
+        """Impossible case - isolated fresh orange"""
+        grid = [[2,1,1],[0,1,1],[1,0,1]]
+        self.assertEqual(self.solution.orangesRotting(grid), -1)
+    
+    def test_no_fresh_oranges(self):
+        """No fresh oranges to rot"""
+        grid = [[0,2]]
+        self.assertEqual(self.solution.orangesRotting(grid), 0)
+    
+    def test_all_fresh_no_rotten(self):
+        """All fresh, no rotten oranges"""
+        grid = [[1,1,1],[1,1,1]]
+        self.assertEqual(self.solution.orangesRotting(grid), -1)
+    
+    def test_all_rotten(self):
+        """All oranges already rotten"""
+        grid = [[2,2],[2,2]]
+        self.assertEqual(self.solution.orangesRotting(grid), 0)
+    
+    def test_single_fresh(self):
+        """Single fresh orange next to rotten"""
+        grid = [[2,1]]
+        self.assertEqual(self.solution.orangesRotting(grid), 1)
+    
+    def test_single_rotten(self):
+        """Only one rotten orange, no fresh"""
+        grid = [[2]]
+        self.assertEqual(self.solution.orangesRotting(grid), 0)
+    
+    def test_single_fresh_alone(self):
+        """Single fresh orange, no rotten"""
+        grid = [[1]]
+        self.assertEqual(self.solution.orangesRotting(grid), -1)
+    
+    def test_empty_cells_only(self):
+        """Grid with only empty cells"""
+        grid = [[0,0],[0,0]]
+        self.assertEqual(self.solution.orangesRotting(grid), 0)
+    
+    def test_multiple_rotten_sources(self):
+        """Multiple rotten oranges spreading simultaneously"""
+        grid = [[2,1,1],[1,1,1],[1,1,2]]
+        self.assertEqual(self.solution.orangesRotting(grid), 2)
+    
+    def test_long_chain(self):
+        """Linear chain of oranges"""
+        grid = [[2,1,1,1,1,1]]
+        self.assertEqual(self.solution.orangesRotting(grid), 5)
+    
+    def test_isolated_groups(self):
+        """Fresh orange isolated by empty cells"""
+        grid = [[2,1,0,1]]
+        self.assertEqual(self.solution.orangesRotting(grid), -1)
+    
+    def test_large_grid(self):
+        """Larger grid with complex pattern"""
+        grid = [
+            [2,1,1,0,0],
+            [1,1,0,0,0],
+            [0,0,0,1,2],
+            [0,0,0,1,1]
+        ]
+        self.assertEqual(self.solution.orangesRotting(grid), 2)
+    
+    def test_square_grid(self):
+        """Rotten in center spreading outward"""
+        grid = [
+            [1,1,1],
+            [1,2,1],
+            [1,1,1]
+        ]
+        self.assertEqual(self.solution.orangesRotting(grid), 2)
+    
+    def test_corner_rotten(self):
+        """Rotten in corner"""
+        grid = [
+            [2,1,1],
+            [1,1,1],
+            [1,1,1]
+        ]
+        self.assertEqual(self.solution.orangesRotting(grid), 4)
+
+
+if __name__ == '__main__':
+    unittest.main()