Ridges.AI

Test Name	Status
test_a_stone_and_not_a_territory_on_5x5_board	Pass
test_black_corner_territory_on_5x5_board	Pass
test_invalid_because_x_is_too_high_for_5x5_board	Pass
test_invalid_because_x_is_too_low_for_5x5_board	Pass
test_invalid_because_y_is_too_high_for_5x5_board	Pass
test_invalid_because_y_is_too_low_for_5x5_board	Pass
test_one_territory_is_the_whole_board	Pass
test_open_corner_territory_on_5x5_board	Pass
test_two_region_rectangular_board	Pass
test_two_territory_rectangular_board	Pass
test_white_center_territory_on_5x5_board	Pass

 class Board:
     """Count territories of each player in a Go game
     """
     def __init__(self, board: list[str]):
+        pass
+        self.board = board
+        self.rows = len(board)
+        if self.rows > 0:
+            self.cols = len(board[0])
+        else:
+            self.cols = 0
     def territory(self, x: int, y: int) -> tuple[str, set[tuple[int, int]]]:
         """Find the owner and the territories given a coordinate on
                         second being a set of coordinates, representing
                         the owner's territories.
         """
+        pass
+        # Edge Case: Invalid coordinates (negative)
+        if x < 0 or y < 0:
+            raise ValueError('Invalid coordinate')
+        # Edge Case: Invalid coordinates (out of bounds)
+        if x >= self.cols or y >= self.rows:
+            raise ValueError('Invalid coordinate')
+        # Edge Case: Coordinate is not an empty intersection
+        if self.board[y][x] != ' ':
+            return ('', set())
+        visited = set()
+        territory_coords = set()
+        owners = set()
+        def dfs(cx, cy):
+            if (cx, cy) in visited:
+                return
+            # Edge Case: Out of bounds
+            if cx < 0 or cy < 0 or cx >= self.cols or cy >= self.rows:
+                return
+            # Edge Case: Already visited
+            if (cx, cy) in visited:
+                return
+            cell = self.board[cy][cx]
+            if cell == ' ':
+                visited.add((cx, cy))
+                territory_coords.add((cx, cy))
+                # Explore neighbors
+                dfs(cx+1, cy)
+                dfs(cx-1, cy)
+                dfs(cx, cy+1)
+                dfs(cx, cy-1)
+            else:
+                # It's a stone, add owner
+                owners.add(cell)
+        dfs(x, y)
+        # Determine owner
+        owner = ''
+        # Edge Case: Territory has no owners (open territory)
+        if len(owners) == 0:
+            owner = ''
+        # Edge Case: Territory is owned by one player
+        elif len(owners) == 1:
+            owner = list(owners)[0]
+        # Edge Case: Territory is contested (owners from both players)
+        else:
+            owner = ''
+        return (owner, territory_coords)
     def territories(self) -> dict[str, set[tuple[int, int]]]:
         """Find the owners and the territories of the whole board
                         , i.e. "W", "B", "".  The value being a set
                         of coordinates owned by the owner.
         """
+        pass
+        result = {"W": set(), "B": set(), "": set()}
+        visited = set()
+        for y in range(self.rows):
+            for x in range(self.cols):
+                # Edge Case: Only process empty intersections
+                if self.board[y][x] == ' ' and (x, y) not in visited:
+                    owner, territory_set = self.territory(x, y)
+                    result[owner].update(territory_set)
+                    visited.update(territory_set)
+        return result
+    # Handled Edge Cases: Invalid coordinates (negative), Invalid coordinates (out of bounds), Coordinate is not an empty intersection, Out of bounds, Already visited, Territory has no owners (open territory), Territory is owned by one player, Territory is contested (owners from both players), Only process empty intersections

hangman

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed