Dave's Branch

2023-Oct-18/Dave/direction.py

@@ -0,0 +1,29 @@
+from enum import Enum, EnumMeta
+from point import Point
+
+
+class DirectValueMeta(EnumMeta):
+    # This allows us to unpack enum members directly, in the format:
+    # row, col = Direction.RIGHT
+    def __getattribute__(cls, name):
+        value = super().__getattribute__(name)
+        if isinstance(value, cls):
+            value = value.value
+        return value
+
+    # This allows us to iterate through enum members in a for loop and access
+    # the Point value directly
+    def __iter__(cls):
+        for value in super().__iter__():
+            yield value.value
+
+
+class Direction(Enum, metaclass=DirectValueMeta):
+    RIGHT = Point(0, 1)
+    DOWN = Point(1, 0)
+    UP = Point(-1, 0)
+    LEFT = Point(0, -1)
+    UP_LEFT = Point(-1, -1)
+    UP_RIGHT = Point(-1, 1)
+    DOWN_LEFT = Point(1, -1)
+    DOWN_RIGHT = Point(1, 1)

2023-Oct-18/Dave/main.py

@@ -0,0 +1,94 @@
+import random
+from word_grid import WordGrid
+from point import Point
+from direction import Direction
+from placement import Placement
+
+
+def main():
+    word_list = ["MEOW", "CAT", "WOOF", "DOG"]
+
+    word_search = generate_word_search(
+        rows=4, cols=4, word_list=word_list)
+
+    if word_search:
+        print(word_search)
+        print("Find these words:")
+        print(", ".join(word_list))
+    else:
+        print("Failed to generate word search.")
+
+
+def generate_word_search(rows: int, cols: int, word_list: list[str]) -> WordGrid | None:
+    word_search = WordGrid(rows, cols)
+
+    attempts = 0
+
+    while attempts < 10:
+        word_search.initialise_word_grid()
+        filled_word_search = place_words(
+            word_search=word_search, word_list=word_list)
+        if filled_word_search:
+            filled_word_search.fill_blank_space()
+            return filled_word_search
+        else:
+            attempts += 1
+            continue
+    else:
+        return None
+
+
+def place_words(word_search: WordGrid, word_list=list[str]) -> WordGrid | None:
+    filled_word_search = word_search
+
+    for word in word_list:
+        placements = get_all_legal_placements_for_word(
+            word_grid=filled_word_search, word=word
+        )
+        if placements:
+            position, direction = random.choice(placements)
+            filled_word_search.write_line(
+                position=position, orientation=direction, data=word
+            )
+        else:
+            return None
+
+    return filled_word_search
+
+
+def get_all_legal_placements_for_word(
+    word_grid: WordGrid, word: str
+) -> list[Placement] | None:
+    legal_placements = []
+
+    # Iterate through all possible grid locations and orientations
+    for row_index, row in enumerate(word_grid):
+        for col_index, col in enumerate(row):
+            for direction in Direction:
+                position = Point(row_index, col_index)
+
+                target_line = word_grid.read_line(
+                    position, direction, len(word))
+                if not target_line:
+                    continue
+
+                line_can_be_placed = is_legal_placement(
+                    target_line=target_line, line_to_write=word
+                )
+                if not line_can_be_placed:
+                    continue
+
+                legal_placements.append(Placement(position, direction))
+
+    return legal_placements
+
+
+def is_legal_placement(target_line: str, line_to_write: str) -> bool:
+    for target_char, char_to_write in zip(target_line, line_to_write):
+        if char_to_write != target_char and target_char != " ":
+            return False
+    return True
+
+
+if __name__ == "__main__":
+    main()

2023-Oct-18/Dave/placement.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from point import Point
+from direction import Direction
+
+
+@dataclass
+class Placement:
+    position: Point
+    direction: Direction
+
+    def __iter__(self):
+        yield self.position
+        yield self.direction

2023-Oct-18/Dave/point.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Point:
+    row: int
+    col: int
+
+    # This allows us to unpack a point with the syntax:
+    # row, col = point
+    def __iter__(self):
+        yield self.row
+        yield self.col

2023-Oct-18/Dave/word_grid.py

@@ -0,0 +1,76 @@
+import random
+import string
+from point import Point
+from direction import Direction
+
+
+class WordGrid:
+    def __init__(self, rows: int, cols: int):
+        self.rows = rows
+        self.cols = cols
+        self.initialise_word_grid()
+
+    def __repr__(self):
+        return self.get_stringified_word_grid()
+
+    def __iter__(self):
+        for row in self.word_grid:
+            yield row
+
+    def initialise_word_grid(self):
+        self.word_grid = [[" " for col in range(
+            self.cols)] for row in range(self.rows)]
+
+    def get_stringified_word_grid(self) -> str:
+        output = ""
+        for row in self.word_grid:
+            for char in row:
+                output += char + " "
+            output += "\n"
+        return output
+
+    def read_line(
+        self, position: Point, orientation: Direction, length: int
+    ) -> str | None:
+        result = ""
+
+        current_row, current_col = position
+        next_row, next_col = orientation
+        grid_rows = len(self.word_grid)
+        grid_cols = len(self.word_grid[0])
+
+        for i in range(length):
+            if not 0 <= current_row < len(self.word_grid):
+                return None
+
+            if not 0 <= current_col < len(self.word_grid[0]):
+                return None
+
+            result += self.word_grid[current_row][current_col]
+            current_row += next_row
+            current_col += next_col
+
+        return result
+
+    def write_line(self, position: Point, orientation: Direction, data: str) -> bool:
+        can_write_line = self.read_line(position, orientation, len(data))
+        if not can_write_line:
+            return False
+
+        current_row, current_col = position
+        next_row, next_col = orientation
+
+        for char in data:
+            self.word_grid[current_row][current_col] = char
+            current_row += next_row
+            current_col += next_col
+
+        return True
+
+    def fill_blank_space(self):
+        for row_index, row in enumerate(self.word_grid):
+            for col_index, char in enumerate(row):
+                if char == " ":
+                    self.word_grid[row_index][col_index] = random.choice(
+                        string.ascii_uppercase
+                    )