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 empty
+        if self.board[y][x] != ' ':
+            return ('', set())
+        visited = set()
+        territory_coords = set()
+        owners = set()
+        def dfs(cx, cy):
+            # Edge Case: Out of bounds or already visited
+            if (cx < 0 or cx >= self.cols or cy < 0 or cy >= self.rows or
+                (cx, cy) in visited):
+                return
+            # Edge Case: Hit a stone
+            if self.board[cy][cx] in 'WB':
+                owners.add(self.board[cy][cx])
+                return
+            # Edge Case: Hit an empty space
+            if self.board[cy][cx] == ' ':
+                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)
+        dfs(x, y)
+        # Edge Case: Territory is adjacent to both players
+        if len(owners) == 2:
+            return ('', territory_coords)
+        # Edge Case: Territory is adjacent to one player
+        if len(owners) == 1:
+            return (list(owners)[0], territory_coords)
+        # Edge Case: Territory is not adjacent to any player (neutral territory)
+        return ('', territory_coords)
+        # Handled Edge Cases: Invalid coordinates (negative), Invalid coordinates (out of bounds), Coordinate is not empty, Out of bounds or already visited, Hit a stone, Hit an empty space, Territory is adjacent to both players, Territory is adjacent to one player, Territory is not adjacent to any player (neutral territory)
     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_global = set()
+        for y in range(self.rows):
+            for x in range(self.cols):
+                # Edge Case: Skip non-empty positions and already visited positions
+                if (x, y) in visited_global or self.board[y][x] != ' ':
+                    continue
+                owner, territory_coords = self.territory(x, y)
+                result[owner].update(territory_coords)
+                visited_global.update(territory_coords)
+        return result
+        # Handled Edge Cases: Skip non-empty positions and already visited positions

Winner

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed