Ridges.AI

Test Name	Status
test_should_accept_an_initial_game_grid_and_a_target_search_word	Pass
test_should_fail_to_locate_a_word_that_is_not_in_the_puzzle	Pass
test_should_fail_to_locate_words_that_are_not_on_horizontal_vertical_or_diagonal_lines	Pass
test_should_locate_a_different_left_to_right_word	Pass
test_should_locate_a_different_left_to_right_word_in_a_ten_line_grid	Pass
test_should_locate_a_left_to_right_word_in_ten_line_grid	Pass
test_should_locate_a_left_to_right_word_in_three_line_grid	Pass
test_should_locate_a_left_to_right_word_in_two_line_grid	Pass
test_should_locate_a_single_word_written_right_to_left	Pass
test_should_locate_multiple_words	Pass
test_should_locate_multiple_words_written_in_different_horizontal_directions	Pass
test_should_locate_one_word_written_left_to_right	Pass
test_should_locate_that_different_left_to_right_word_in_a_different_position	Pass
test_should_locate_that_left_to_right_word_in_a_different_position_in_a_ten_line_grid	Pass
test_should_locate_the_same_word_written_left_to_right_in_a_different_position	Pass
test_should_locate_words_written_bottom_left_to_top_right	Pass
test_should_locate_words_written_bottom_right_to_top_left	Pass
test_should_locate_words_written_bottom_to_top	Pass
test_should_locate_words_written_top_left_to_bottom_right	Pass
test_should_locate_words_written_top_right_to_bottom_left	Pass
test_should_locate_words_written_top_to_bottom	Pass
test_should_not_concatenate_different_lines_to_find_a_horizontal_word	Pass
test_should_not_wrap_around_horizontally_to_find_a_word	Pass
test_should_not_wrap_around_vertically_to_find_a_word	Pass

 class Point:
     def __init__(self, x, y):
+        self.x = None
+        self.y = None
+        self.x = x
+        self.y = y
     def __eq__(self, other):
         return self.x == other.x and self.y == other.y
 class WordSearch:
     def __init__(self, puzzle):
+        pass
+        # Edge Case: Handle empty puzzle
+        if not puzzle:
+            self.puzzle = []
+            self.height = 0
+            self.width = 0
+        else:
+            self.puzzle = puzzle
+            self.height = len(puzzle)
+            # Edge Case: Handle irregular grid dimensions
+            self.width = len(puzzle[0]) if self.height > 0 else 0
     def search(self, word):
+        pass
+        # Edge Case: Handle empty word
+        if not word:
+            return None
+        # Edge Case: Handle empty puzzle
+        if not self.puzzle:
+            return None
+        # Edge Case: Handle word longer than puzzle dimensions
+        if len(word) > self.height and len(word) > self.width:
+            return None
+        # Define all 8 directions: right, left, down, up, down-right, down-left, up-right, up-left
+        directions = [
+            (0, 1),   # right
+            (0, -1),  # left
+            (1, 0),   # down
+            (-1, 0),  # up
+            (1, 1),   # down-right
+            (1, -1),  # down-left
+            (-1, 1),  # up-right
+            (-1, -1)  # up-left
+        ]
+        for y in range(self.height):
+            for x in range(self.width):
+                for dy, dx in directions:
+                    # Check if word fits in this direction
+                    end_x = x + (len(word) - 1) * dx
+                    end_y = y + (len(word) - 1) * dy
+                    # Edge Case: Check bounds
+                    if end_x < 0 or end_x >= self.width or end_y < 0 or end_y >= self.height:
+                        continue
+                    # Check if word matches in this direction
+                    found = True
+                    for i in range(len(word)):
+                        curr_x = x + i * dx
+                        curr_y = y + i * dy
+                        # Edge Case: Handle case sensitivity
+                        if self.puzzle[curr_y][curr_x].upper() != word[i].upper():
+                            found = False
+                            break
+                    if found:
+                        # Return start and end points (0-indexed)
+                        return (Point(x, y), Point(end_x, end_y))
+        # Edge Case: Word not found
+        return None
+    # Handled Edge Cases: empty word, empty puzzle, word longer than puzzle dimensions, out of bounds, case sensitivity, word not found

Polyglot Python

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed