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):
+            # 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: Encountered a stone
+            if self.board[cy][cx] in 'WB':
+                owners.add(self.board[cy][cx])
+                return
+            # Edge Case: Encountered an empty intersection
+            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 or neither
+        if len(owners) != 1:
+            return '', territory_coords
+        else:
+            return owners.pop(), 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()
+        # Edge Case: Empty board
+        if self.rows == 0 or self.cols == 0:
+            return result
+        for y in range(self.rows):
+            for x in range(self.cols):
+                # Edge Case: Only process empty intersections that haven't been visited
+                if self.board[y][x] == ' ' and (x, y) not in visited:
+                    owner, territory_coords = self.territory(x, y)
+                    result[owner].update(territory_coords)
+                    visited.update(territory_coords)
+        return result
+        # Handled Edge Cases: Empty board, Only process unvisited empty intersections

hangman

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed