Merge branch 'master' into master

Author: inamcodes

pmd-exclude.properties

@@ -86,7 +86,7 @@ com.thealgorithms.others.MosAlgorithm=UselessMainMethod
 com.thealgorithms.others.PageRank=UselessMainMethod,UselessParentheses
 com.thealgorithms.others.PerlinNoise=UselessMainMethod,UselessParentheses
 com.thealgorithms.others.QueueUsingTwoStacks=UselessParentheses
-com.thealgorithms.others.Trieac=UselessMainMethod,UselessParentheses
+com.thealgorithms.datastructures.trees.TrieAutocomplete=UselessMainMethod,UselessParentheses
 com.thealgorithms.others.Verhoeff=UnnecessaryFullyQualifiedName,UselessMainMethod
 com.thealgorithms.recursion.DiceThrower=UselessMainMethod
 com.thealgorithms.searches.HowManyTimesRotated=UselessMainMethod

pom.xml

@@ -119,7 +119,7 @@
             <plugin>
                 <groupId>com.github.spotbugs</groupId>
                 <artifactId>spotbugs-maven-plugin</artifactId>
-                <version>4.9.8.3</version>
+                <version>4.10.2.0</version>
                 <configuration>
                     <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
                     <includeTests>true</includeTests>

…auto_completing_features_using_trie.java …tastructures/trees/TrieAutocomplete.javasrc/main/java/com/thealgorithms/others/Implementing_auto_completing_features_using_trie.java renamed to src/main/java/com/thealgorithms/datastructures/trees/TrieAutocomplete.java src/main/java/com/thealgorithms/others/Implementing_auto_completing_features_using_trie.java renamed to src/main/java/com/thealgorithms/datastructures/trees/TrieAutocomplete.java

@@ -1,8 +1,8 @@
-package com.thealgorithms.others;
+package com.thealgorithms.datastructures.trees;
 
 // Java Program to implement Auto-Complete
 // Feature using Trie
-class Trieac {
+class TrieAutocomplete {
 
     // Alphabet size (# of symbols)
     public static final int ALPHABET_SIZE = 26;

src/main/java/com/thealgorithms/dynamicprogramming/LongestPalindromicSubsequence.java

@@ -1,58 +1,42 @@
 package com.thealgorithms.dynamicprogramming;
 
 /**
- * Algorithm explanation
- * https://www.educative.io/edpresso/longest-palindromic-subsequence-algorithm
+ * Longest Palindromic Subsequence algorithm.
+ * A palindromic subsequence is a subsequence that reads the same forwards and backwards.
+ * This implementation finds the longest such subsequence by computing the LCS of the
+ * original string and its reverse.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Longest_palindromic_subsequence">Wikipedia</a>
  */
 public final class LongestPalindromicSubsequence {
     private LongestPalindromicSubsequence() {
     }
 
-    public static void main(String[] args) {
-        String a = "BBABCBCAB";
-        String b = "BABCBAB";
-
-        String aLPS = lps(a);
-        String bLPS = lps(b);
-
-        System.out.println(a + " => " + aLPS);
-        System.out.println(b + " => " + bLPS);
-    }
-
-    public static String lps(String original) throws IllegalArgumentException {
-        StringBuilder reverse = new StringBuilder(original);
-        reverse = reverse.reverse();
-        return recursiveLPS(original, reverse.toString());
+    /**
+     * Returns the longest palindromic subsequence of the given string.
+     *
+     * @param original the input string
+     * @return the longest palindromic subsequence
+     * @throws IllegalArgumentException if the input string is null
+     */
+    public static String lps(String original) {
+        if (original == null) {
+            throw new IllegalArgumentException("Input string must not be null");
+        }
+        String reverse = new StringBuilder(original).reverse().toString();
+        return recursiveLPS(original, reverse);
     }
 
     private static String recursiveLPS(String original, String reverse) {
-        String bestResult = "";
-
-        // no more chars, then return empty
-        if (original.length() == 0 || reverse.length() == 0) {
-            bestResult = "";
-        } else {
-            // if the last chars match, then remove it from both strings and recur
-            if (original.charAt(original.length() - 1) == reverse.charAt(reverse.length() - 1)) {
-                String bestSubResult = recursiveLPS(original.substring(0, original.length() - 1), reverse.substring(0, reverse.length() - 1));
-
-                bestResult = reverse.charAt(reverse.length() - 1) + bestSubResult;
-            } else {
-                // otherwise (1) ignore the last character of reverse, and recur on original and
-                // updated reverse again (2) ignore the last character of original and recur on the
-                // updated original and reverse again then select the best result from these two
-                // subproblems.
-
-                String bestSubResult1 = recursiveLPS(original, reverse.substring(0, reverse.length() - 1));
-                String bestSubResult2 = recursiveLPS(original.substring(0, original.length() - 1), reverse);
-                if (bestSubResult1.length() > bestSubResult2.length()) {
-                    bestResult = bestSubResult1;
-                } else {
-                    bestResult = bestSubResult2;
-                }
-            }
+        if (original.isEmpty() || reverse.isEmpty()) {
+            return "";
         }
-
-        return bestResult;
+        if (original.charAt(original.length() - 1) == reverse.charAt(reverse.length() - 1)) {
+            String bestSubResult = recursiveLPS(original.substring(0, original.length() - 1), reverse.substring(0, reverse.length() - 1));
+            return reverse.charAt(reverse.length() - 1) + bestSubResult;
+        }
+        String sub1 = recursiveLPS(original, reverse.substring(0, reverse.length() - 1));
+        String sub2 = recursiveLPS(original.substring(0, original.length() - 1), reverse);
+        return sub1.length() >= sub2.length() ? sub1 : sub2;
     }
 }

src/test/java/com/thealgorithms/dynamicprogramming/LongestPalindromicSubsequenceTest.java

@@ -0,0 +1,54 @@
+package com.thealgorithms.dynamicprogramming;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+public class LongestPalindromicSubsequenceTest {
+
+    @ParameterizedTest
+    @CsvSource({"BBABCBCAB, BACBCAB", "BABCBAB, BABCBAB", "A, A", "AA, AA", "AB, B"})
+    void testLpsKnownCases(String input, String expectedLps) {
+        assertEquals(expectedLps, LongestPalindromicSubsequence.lps(input));
+    }
+
+    @Test
+    void testLpsEmptyString() {
+        assertEquals("", LongestPalindromicSubsequence.lps(""));
+    }
+
+    @Test
+    void testLpsSingleCharacter() {
+        assertEquals("Z", LongestPalindromicSubsequence.lps("Z"));
+    }
+
+    @Test
+    void testLpsAllSameCharacters() {
+        assertEquals("AAAA", LongestPalindromicSubsequence.lps("AAAA"));
+    }
+
+    @Test
+    void testLpsAlreadyPalindrome() {
+        assertEquals("RACECAR", LongestPalindromicSubsequence.lps("RACECAR"));
+    }
+
+    @Test
+    void testLpsNoRepeatingCharacters() {
+        assertEquals(1, LongestPalindromicSubsequence.lps("ABCDE").length());
+    }
+
+    @Test
+    void testLpsNullThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> { LongestPalindromicSubsequence.lps(null); });
+    }
+
+    @Test
+    void testLpsResultIsActuallyPalindrome() {
+        String result = LongestPalindromicSubsequence.lps("BBABCBCAB");
+        String reversed = new StringBuilder(result).reverse().toString();
+        assertEquals(result, reversed);
+    }
+}