Merge branch 'master' into RegularExpressionMatching

Author: jayeshrdeotalu

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)
@@ -19,6 +20,7 @@
             * [Permutation](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/backtracking/Permutation.java)
             * [PowerSum](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/backtracking/PowerSum.java)
             * [SubsequenceFinder](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java)
+            * [WordPatternMatcher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/backtracking/WordPatternMatcher.java)
             * [WordSearch](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/backtracking/WordSearch.java)
           * bitmanipulation
             * [BitSwap](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/BitSwap.java)
@@ -267,6 +269,7 @@
             * [SumOfSubset](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/SumOfSubset.java)
             * [Tribonacci](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/Tribonacci.java)
             * [UniquePaths](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/UniquePaths.java)
+            * [UniqueSubsequencesCount](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java)
             * [WildcardMatching](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/WildcardMatching.java)
             * [WineProblem](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/WineProblem.java)
           * geometry
@@ -566,7 +569,9 @@
             * [NextSmallerElement](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/NextSmallerElement.java)
             * [PostfixToInfix](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/PostfixToInfix.java)
             * [PrefixToInfix](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/PrefixToInfix.java)
+            * [SortStack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/SortStack.java)
             * [StackPostfixNotation](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/StackPostfixNotation.java)
+            * [StackUsingTwoQueues](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/StackUsingTwoQueues.java)
           * strings
             * [AhoCorasick](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/AhoCorasick.java)
             * [Alphabetical](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/Alphabetical.java)
@@ -612,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)
@@ -621,6 +627,7 @@
             * [PermutationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/PermutationTest.java)
             * [PowerSumTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/PowerSumTest.java)
             * [SubsequenceFinderTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/SubsequenceFinderTest.java)
+            * [WordPatternMatcherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/WordPatternMatcherTest.java)
             * [WordSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/WordSearchTest.java)
           * bitmanipulation
             * [BitSwapTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/BitSwapTest.java)
@@ -702,6 +709,7 @@
               * [BoruvkaAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/BoruvkaAlgorithmTest.java)
               * [DijkstraAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/DijkstraAlgorithmTest.java)
               * [EdmondsBlossomAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/EdmondsBlossomAlgorithmTest.java)
+              * [FloydWarshallTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/FloydWarshallTest.java)
               * [FordFulkersonTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/FordFulkersonTest.java)
               * [HamiltonianCycleTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/HamiltonianCycleTest.java)
               * [KosarajuTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/KosarajuTest.java)
@@ -794,6 +802,7 @@
             * [SumOfSubsetTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/SumOfSubsetTest.java)
             * [TribonacciTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/TribonacciTest.java)
             * [UniquePathsTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/UniquePathsTests.java)
+            * [UniqueSubsequencesCountTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java)
             * [WildcardMatchingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/WildcardMatchingTest.java)
           * geometry
             * [GrahamScanTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/geometry/GrahamScanTest.java)
@@ -1027,7 +1036,9 @@
             * [NextSmallerElementTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/NextSmallerElementTest.java)
             * [PostfixToInfixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/PostfixToInfixTest.java)
             * [PrefixToInfixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/PrefixToInfixTest.java)
+            * [SortStackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/SortStackTest.java)
             * [StackPostfixNotationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/StackPostfixNotationTest.java)
+            * [StackUsingTwoQueuesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/StackUsingTwoQueuesTest.java)
           * strings
             * [AhoCorasickTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/AhoCorasickTest.java)
             * [AlphabeticalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/AlphabeticalTest.java)

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<String> words) {
+        // Create a mutable copy of the words list
+        List<String> 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;
+    }
+}

src/main/java/com/thealgorithms/backtracking/PowerSum.java

@@ -1,45 +1,51 @@
 package com.thealgorithms.backtracking;
 
-/*
- * Problem Statement :
- * Find the number of ways that a given integer, N , can be expressed as the sum of the Xth powers
- * of unique, natural numbers. For example, if N=100 and X=3, we have to find all combinations of
- * unique cubes adding up to 100. The only solution is 1^3+2^3+3^3+4^3. Therefore output will be 1.
+/**
+ * Problem Statement:
+ * Find the number of ways that a given integer, N, can be expressed as the sum of the Xth powers
+ * of unique, natural numbers.
+ * For example, if N=100 and X=3, we have to find all combinations of unique cubes adding up to 100.
+ * The only solution is 1^3 + 2^3 + 3^3 + 4^3. Therefore, the output will be 1.
+ *
+ * N is represented by the parameter 'targetSum' in the code.
+ * X is represented by the parameter 'power' in the code.
  */
 public class PowerSum {
 
-    private int count = 0;
-    private int sum = 0;
-
-    public int powSum(int n, int x) {
-        sum(n, x, 1);
-        return count;
+    /**
+     * Calculates the number of ways to express the target sum as a sum of Xth powers of unique natural numbers.
+     *
+     * @param targetSum The target sum to achieve (N in the problem statement)
+     * @param power The power to raise natural numbers to (X in the problem statement)
+     * @return The number of ways to express the target sum
+     */
+    public int powSum(int targetSum, int power) {
+        // Special case: when both targetSum and power are zero
+        if (targetSum == 0 && power == 0) {
+            return 1; // by convention, one way to sum to zero: use nothing
+        }
+        return sumRecursive(targetSum, power, 1, 0);
     }
 
-    // here i is the natural number which will be raised by X and added in sum.
-    public void sum(int n, int x, int i) {
-        // if sum is equal to N that is one of our answer and count is increased.
-        if (sum == n) {
-            count++;
-            return;
-        } // we will be adding next natural number raised to X only if on adding it in sum the
-          // result is less than N.
-        else if (sum + power(i, x) <= n) {
-            sum += power(i, x);
-            sum(n, x, i + 1);
-            // backtracking and removing the number added last since no possible combination is
-            // there with it.
-            sum -= power(i, x);
+    /**
+     * Recursively calculates the number of ways to express the remaining sum as a sum of Xth powers.
+     *
+     * @param remainingSum The remaining sum to achieve
+     * @param power The power to raise natural numbers to (X in the problem statement)
+     * @param currentNumber The current natural number being considered
+     * @param currentSum The current sum of powered numbers
+     * @return The number of valid combinations
+     */
+    private int sumRecursive(int remainingSum, int power, int currentNumber, int currentSum) {
+        int newSum = currentSum + (int) Math.pow(currentNumber, power);
+
+        if (newSum == remainingSum) {
+            return 1;
         }
-        if (power(i, x) < n) {
-            // calling the sum function with next natural number after backtracking if when it is
-            // raised to X is still less than X.
-            sum(n, x, i + 1);
+        if (newSum > remainingSum) {
+            return 0;
         }
-    }
 
-    // creating a separate power function so that it can be used again and again when required.
-    private int power(int a, int b) {
-        return (int) Math.pow(a, b);
+        return sumRecursive(remainingSum, power, currentNumber + 1, newSum) + sumRecursive(remainingSum, power, currentNumber + 1, currentSum);
     }
 }