From ecd75c0c2eb962b12eb1b03098ed246b521d1ac7 Mon Sep 17 00:00:00 2001 From: Hardik Pawar <97388607+Hardvan@users.noreply.github.com> Date: Tue, 8 Oct 2024 23:30:02 +0530 Subject: [PATCH] Add CrosswordSolver algorithm (#5626) --- DIRECTORY.md | 2 + .../backtracking/CrosswordSolver.java | 124 ++++++++++++++++++ .../backtracking/CrosswordSolverTest.java | 66 ++++++++++ 3 files changed, 192 insertions(+) create mode 100644 src/main/java/com/thealgorithms/backtracking/CrosswordSolver.java create mode 100644 src/test/java/com/thealgorithms/backtracking/CrosswordSolverTest.java diff --git a/DIRECTORY.md b/DIRECTORY.md index 1b69d17e3..7c6f284c9 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -10,6 +10,7 @@ * [AllPathsFromSourceToTarget](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/backtracking/AllPathsFromSourceToTarget.java) * [ArrayCombination](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/backtracking/ArrayCombination.java) * [Combination](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/backtracking/Combination.java) + * [CrosswordSolver](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/backtracking/CrosswordSolver.java) * [FloodFill](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/backtracking/FloodFill.java) * [KnightsTour](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/backtracking/KnightsTour.java) * [MazeRecursion](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/backtracking/MazeRecursion.java) @@ -616,6 +617,7 @@ * [AllPathsFromSourceToTargetTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/AllPathsFromSourceToTargetTest.java) * [ArrayCombinationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/ArrayCombinationTest.java) * [CombinationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/CombinationTest.java) + * [CrosswordSolverTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/CrosswordSolverTest.java) * [FloodFillTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/FloodFillTest.java) * [KnightsTourTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/KnightsTourTest.java) * [MazeRecursionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/MazeRecursionTest.java) diff --git a/src/main/java/com/thealgorithms/backtracking/CrosswordSolver.java b/src/main/java/com/thealgorithms/backtracking/CrosswordSolver.java new file mode 100644 index 000000000..cbd9f70f7 --- /dev/null +++ b/src/main/java/com/thealgorithms/backtracking/CrosswordSolver.java @@ -0,0 +1,124 @@ +package com.thealgorithms.backtracking; + +import java.util.ArrayList; +import java.util.List; + +/** + * A class to solve a crossword puzzle using backtracking. + * Example: + * Input: + * puzzle = { + * {' ', ' ', ' '}, + * {' ', ' ', ' '}, + * {' ', ' ', ' '} + * } + * words = List.of("cat", "dog") + * + * Output: + * { + * {'c', 'a', 't'}, + * {' ', ' ', ' '}, + * {'d', 'o', 'g'} + * } + */ +public final class CrosswordSolver { + private CrosswordSolver() { + } + + /** + * Checks if a word can be placed at the specified position in the crossword. + * + * @param puzzle The crossword puzzle represented as a 2D char array. + * @param word The word to be placed. + * @param row The row index where the word might be placed. + * @param col The column index where the word might be placed. + * @param vertical If true, the word is placed vertically; otherwise, horizontally. + * @return true if the word can be placed, false otherwise. + */ + public static boolean isValid(char[][] puzzle, String word, int row, int col, boolean vertical) { + for (int i = 0; i < word.length(); i++) { + if (vertical) { + if (row + i >= puzzle.length || puzzle[row + i][col] != ' ') { + return false; + } + } else { + if (col + i >= puzzle[0].length || puzzle[row][col + i] != ' ') { + return false; + } + } + } + return true; + } + + /** + * Places a word at the specified position in the crossword. + * + * @param puzzle The crossword puzzle represented as a 2D char array. + * @param word The word to be placed. + * @param row The row index where the word will be placed. + * @param col The column index where the word will be placed. + * @param vertical If true, the word is placed vertically; otherwise, horizontally. + */ + public static void placeWord(char[][] puzzle, String word, int row, int col, boolean vertical) { + for (int i = 0; i < word.length(); i++) { + if (vertical) { + puzzle[row + i][col] = word.charAt(i); + } else { + puzzle[row][col + i] = word.charAt(i); + } + } + } + + /** + * Removes a word from the specified position in the crossword. + * + * @param puzzle The crossword puzzle represented as a 2D char array. + * @param word The word to be removed. + * @param row The row index where the word is placed. + * @param col The column index where the word is placed. + * @param vertical If true, the word was placed vertically; otherwise, horizontally. + */ + public static void removeWord(char[][] puzzle, String word, int row, int col, boolean vertical) { + for (int i = 0; i < word.length(); i++) { + if (vertical) { + puzzle[row + i][col] = ' '; + } else { + puzzle[row][col + i] = ' '; + } + } + } + + /** + * Solves the crossword puzzle using backtracking. + * + * @param puzzle The crossword puzzle represented as a 2D char array. + * @param words The list of words to be placed. + * @return true if the crossword is solved, false otherwise. + */ + public static boolean solveCrossword(char[][] puzzle, List words) { + // Create a mutable copy of the words list + List remainingWords = new ArrayList<>(words); + + for (int row = 0; row < puzzle.length; row++) { + for (int col = 0; col < puzzle[0].length; col++) { + if (puzzle[row][col] == ' ') { + for (String word : new ArrayList<>(remainingWords)) { + for (boolean vertical : new boolean[] {true, false}) { + if (isValid(puzzle, word, row, col, vertical)) { + placeWord(puzzle, word, row, col, vertical); + remainingWords.remove(word); + if (solveCrossword(puzzle, remainingWords)) { + return true; + } + remainingWords.add(word); + removeWord(puzzle, word, row, col, vertical); + } + } + } + return false; + } + } + } + return true; + } +} diff --git a/src/test/java/com/thealgorithms/backtracking/CrosswordSolverTest.java b/src/test/java/com/thealgorithms/backtracking/CrosswordSolverTest.java new file mode 100644 index 000000000..542fd53fe --- /dev/null +++ b/src/test/java/com/thealgorithms/backtracking/CrosswordSolverTest.java @@ -0,0 +1,66 @@ +package com.thealgorithms.backtracking; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Arrays; +import java.util.List; +import org.junit.jupiter.api.Test; + +public class CrosswordSolverTest { + + @Test + public void testValidPlacement() { + char[][] puzzle = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}}; + assertTrue(CrosswordSolver.isValid(puzzle, "cat", 0, 0, true)); + assertTrue(CrosswordSolver.isValid(puzzle, "dog", 0, 0, false)); + assertFalse(CrosswordSolver.isValid(puzzle, "cat", 1, 2, false)); + } + + @Test + public void testPlaceAndRemoveWord() { + char[][] puzzle = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}}; + CrosswordSolver.placeWord(puzzle, "cat", 0, 0, true); + assertEquals('c', puzzle[0][0]); + assertEquals('a', puzzle[1][0]); + assertEquals('t', puzzle[2][0]); + + CrosswordSolver.removeWord(puzzle, "cat", 0, 0, true); + assertEquals(' ', puzzle[0][0]); + assertEquals(' ', puzzle[1][0]); + assertEquals(' ', puzzle[2][0]); + } + + @Test + public void testSolveCrossword() { + char[][] puzzle = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}}; + List words = Arrays.asList("cat", "dog", "car"); + assertTrue(CrosswordSolver.solveCrossword(puzzle, words)); + + /* Solved crossword: + * c d c + * a o a + * t g r + */ + + assertEquals('c', puzzle[0][0]); + assertEquals('a', puzzle[1][0]); + assertEquals('t', puzzle[2][0]); + + assertEquals('d', puzzle[0][1]); + assertEquals('o', puzzle[1][1]); + assertEquals('g', puzzle[2][1]); + + assertEquals('c', puzzle[0][2]); + assertEquals('a', puzzle[1][2]); + assertEquals('r', puzzle[2][2]); + } + + @Test + public void testNoSolution() { + char[][] puzzle = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}}; + List words = Arrays.asList("cat", "dog", "elephant"); // 'elephant' is too long for the grid + assertFalse(CrosswordSolver.solveCrossword(puzzle, words)); + } +}