Merge branch 'master' into refactor/LineSweep

Author: siriak

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

@@ -1,73 +1,73 @@
 package com.thealgorithms.dynamicprogramming;
 
-/*
-
- * Problem Statement: -
- * Find Longest Alternating Subsequence
-
- * A sequence {x1, x2, .. xn} is alternating sequence if its elements satisfy one of the following
- relations :
-
-   x1 < x2 > x3 < x4 > x5 < …. xn or
-   x1 > x2 < x3 > x4 < x5 > …. xn
+/**
+ * Class for finding the length of the longest alternating subsequence in an array.
+ *
+ * <p>An alternating sequence is a sequence of numbers where the elements alternate
+ * between increasing and decreasing. Specifically, a sequence is alternating if its elements
+ * satisfy one of the following relations:
+ *
+ * <ul>
+ *   <li>{@code x1 < x2 > x3 < x4 > x5 < ... < xn}</li>
+ *   <li>{@code x1 > x2 < x3 > x4 < x5 > ... > xn}</li>
+ * </ul>
+ *
+ * <p>This class provides a method to compute the length of the longest such subsequence
+ * from a given array of integers.
  */
 public final class LongestAlternatingSubsequence {
     private LongestAlternatingSubsequence() {
     }
 
-    /* Function to return longest alternating subsequence length*/
+    /**
+     * Finds the length of the longest alternating subsequence in the given array.
+     *
+     * @param arr an array of integers where the longest alternating subsequence is to be found
+     * @param n the length of the array {@code arr}
+     * @return the length of the longest alternating subsequence
+     *
+     * <p>The method uses dynamic programming to solve the problem. It maintains a 2D array
+     * {@code las} where:
+     * <ul>
+     *   <li>{@code las[i][0]} represents the length of the longest alternating subsequence
+     *   ending at index {@code i} with the last element being greater than the previous element.</li>
+     *   <li>{@code las[i][1]} represents the length of the longest alternating subsequence
+     *   ending at index {@code i} with the last element being smaller than the previous element.</li>
+     * </ul>
+     *
+     * <p>The method iterates through the array and updates the {@code las} array based on
+     * whether the current element is greater or smaller than the previous elements.
+     * The result is the maximum value found in the {@code las} array.
+     */
     static int alternatingLength(int[] arr, int n) {
-        /*
-
-                las[i][0] = Length of the longest
-                        alternating subsequence ending at
-                        index i and last element is
-                        greater than its previous element
-
-                las[i][1] = Length of the longest
-                        alternating subsequence ending at
-                        index i and last element is
-                        smaller than its previous
-                        element
-
-         */
         int[][] las = new int[n][2]; // las = LongestAlternatingSubsequence
 
+        // Initialize the dp array
         for (int i = 0; i < n; i++) {
             las[i][0] = 1;
             las[i][1] = 1;
         }
 
         int result = 1; // Initialize result
 
-        /* Compute values in bottom up manner */
+        // Compute values in a bottom-up manner
         for (int i = 1; i < n; i++) {
-            /* Consider all elements as previous of arr[i]*/
             for (int j = 0; j < i; j++) {
-                /* If arr[i] is greater, then check with las[j][1] */
+                // If arr[i] is greater than arr[j], update las[i][0]
                 if (arr[j] < arr[i] && las[i][0] < las[j][1] + 1) {
                     las[i][0] = las[j][1] + 1;
                 }
 
-                /* If arr[i] is smaller, then check with las[j][0]*/
+                // If arr[i] is smaller than arr[j], update las[i][1]
                 if (arr[j] > arr[i] && las[i][1] < las[j][0] + 1) {
                     las[i][1] = las[j][0] + 1;
                 }
             }
 
-            /* Pick maximum of both values at index i */
-            if (result < Math.max(las[i][0], las[i][1])) {
-                result = Math.max(las[i][0], las[i][1]);
-            }
+            // Pick the maximum of both values at index i
+            result = Math.max(result, Math.max(las[i][0], las[i][1]));
         }
 
         return result;
     }
-
-    public static void main(String[] args) {
-        int[] arr = {10, 22, 9, 33, 49, 50, 31, 60};
-        int n = arr.length;
-        System.out.println("Length of Longest "
-            + "alternating subsequence is " + alternatingLength(arr, n));
-    }
 }

src/main/java/com/thealgorithms/strings/Anagrams.java

@@ -10,141 +10,130 @@
  * also the word binary into brainy and the word adobe into abode.
  * Reference from https://en.wikipedia.org/wiki/Anagram
  */
-public class Anagrams {
+public final class Anagrams {
+    private Anagrams() {
+    }
 
     /**
-     * 4 approaches are provided for anagram checking. approach 2 and approach 3 are similar but
-     * differ in running time.
-     * OUTPUT :
-     * first string ="deal" second string ="lead"
-     * Output: Anagram
-     * Input and output is constant for all four approaches
-     * 1st approach Time Complexity : O(n logn)
-     * Auxiliary Space Complexity : O(1)
-     * 2nd approach Time Complexity : O(n)
-     * Auxiliary Space Complexity : O(1)
-     * 3rd approach Time Complexity : O(n)
-     * Auxiliary Space Complexity : O(1)
-     * 4th approach Time Complexity : O(n)
-     * Auxiliary Space Complexity : O(n)
-     * 5th approach Time Complexity: O(n)
-     * Auxiliary Space Complexity: O(1)
+     * Checks if two strings are anagrams by sorting the characters and comparing them.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     *
+     * @param s the first string
+     * @param t the second string
+     * @return true if the strings are anagrams, false otherwise
      */
-    public static void main(String[] args) {
-        String first = "deal";
-        String second = "lead";
-        // All the below methods takes input but doesn't return any output to the main method.
-        Anagrams nm = new Anagrams();
-        System.out.println(nm.approach2(first, second)); /* To activate methods for different approaches*/
-        System.out.println(nm.approach1(first, second)); /* To activate methods for different approaches*/
-        System.out.println(nm.approach3(first, second)); /* To activate methods for different approaches*/
-        System.out.println(nm.approach4(first, second)); /* To activate methods for different approaches*/
-    }
-
-    boolean approach1(String s, String t) {
+    public static boolean approach1(String s, String t) {
         if (s.length() != t.length()) {
             return false;
-        } else {
-            char[] c = s.toCharArray();
-            char[] d = t.toCharArray();
-            Arrays.sort(c);
-            Arrays.sort(d); /* In this approach the strings are stored in the character arrays and
-                               both the arrays are sorted. After that both the arrays are compared
-                               for checking anangram */
-
-            return Arrays.equals(c, d);
         }
+        char[] c = s.toCharArray();
+        char[] d = t.toCharArray();
+        Arrays.sort(c);
+        Arrays.sort(d);
+        return Arrays.equals(c, d);
     }
 
-    boolean approach2(String a, String b) {
-        if (a.length() != b.length()) {
+    /**
+     * Checks if two strings are anagrams by counting the frequency of each character.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * @param s the first string
+     * @param t the second string
+     * @return true if the strings are anagrams, false otherwise
+     */
+    public static boolean approach2(String s, String t) {
+        if (s.length() != t.length()) {
             return false;
-        } else {
-            int[] m = new int[26];
-            int[] n = new int[26];
-            for (char c : a.toCharArray()) {
-                m[c - 'a']++;
-            }
-            // In this approach the frequency of both the strings are stored and after that the
-            // frequencies are iterated from 0 to 26(from 'a' to 'z' ). If the frequencies match
-            // then anagram message is displayed in the form of boolean format Running time and
-            // space complexity of this algo is less as compared to others
-            for (char c : b.toCharArray()) {
-                n[c - 'a']++;
-            }
-            for (int i = 0; i < 26; i++) {
-                if (m[i] != n[i]) {
-                    return false;
-                }
+        }
+        int[] charCount = new int[26];
+        for (int i = 0; i < s.length(); i++) {
+            charCount[s.charAt(i) - 'a']++;
+            charCount[t.charAt(i) - 'a']--;
+        }
+        for (int count : charCount) {
+            if (count != 0) {
+                return false;
             }
-            return true;
         }
+        return true;
     }
 
-    boolean approach3(String s, String t) {
+    /**
+     * Checks if two strings are anagrams by counting the frequency of each character
+     * using a single array.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * @param s the first string
+     * @param t the second string
+     * @return true if the strings are anagrams, false otherwise
+     */
+    public static boolean approach3(String s, String t) {
         if (s.length() != t.length()) {
             return false;
         }
-        // this is similar to approach number 2 but here the string is not converted to character
-        // array
-        else {
-            int[] a = new int[26];
-            int[] b = new int[26];
-            int k = s.length();
-            for (int i = 0; i < k; i++) {
-                a[s.charAt(i) - 'a']++;
-                b[t.charAt(i) - 'a']++;
-            }
-            for (int i = 0; i < 26; i++) {
-                if (a[i] != b[i]) {
-                    return false;
-                }
+        int[] charCount = new int[26];
+        for (int i = 0; i < s.length(); i++) {
+            charCount[s.charAt(i) - 'a']++;
+            charCount[t.charAt(i) - 'a']--;
+        }
+        for (int count : charCount) {
+            if (count != 0) {
+                return false;
             }
-            return true;
         }
+        return true;
     }
 
-    boolean approach4(String s, String t) {
+    /**
+     * Checks if two strings are anagrams using a HashMap to store character frequencies.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * @param s the first string
+     * @param t the second string
+     * @return true if the strings are anagrams, false otherwise
+     */
+    public static boolean approach4(String s, String t) {
         if (s.length() != t.length()) {
             return false;
         }
-        // This approach is done using hashmap where frequencies are stored and checked iteratively
-        // and if all the frequencies of first string match with the second string then anagram
-        // message is displayed in boolean format
-        else {
-            HashMap<Character, Integer> nm = new HashMap<>();
-            HashMap<Character, Integer> kk = new HashMap<>();
-            for (char c : s.toCharArray()) {
-                nm.put(c, nm.getOrDefault(c, 0) + 1);
-            }
-            for (char c : t.toCharArray()) {
-                kk.put(c, kk.getOrDefault(c, 0) + 1);
+        HashMap<Character, Integer> charCountMap = new HashMap<>();
+        for (char c : s.toCharArray()) {
+            charCountMap.put(c, charCountMap.getOrDefault(c, 0) + 1);
+        }
+        for (char c : t.toCharArray()) {
+            if (!charCountMap.containsKey(c) || charCountMap.get(c) == 0) {
+                return false;
             }
-            // It checks for equal frequencies by comparing key-value pairs of two hashmaps
-            return nm.equals(kk);
+            charCountMap.put(c, charCountMap.get(c) - 1);
         }
+        return charCountMap.values().stream().allMatch(count -> count == 0);
     }
 
-    boolean approach5(String s, String t) {
+    /**
+     * Checks if two strings are anagrams using an array to track character frequencies.
+     * This approach optimizes space complexity by using only one array.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * @param s the first string
+     * @param t the second string
+     * @return true if the strings are anagrams, false otherwise
+     */
+    public static boolean approach5(String s, String t) {
         if (s.length() != t.length()) {
             return false;
         }
-        // Approach is different from above 4 aproaches.
-        // Here we initialize an array of size 26 where each element corresponds to the frequency of
-        // a character.
         int[] freq = new int[26];
-        // iterate through both strings, incrementing the frequency of each character in the first
-        // string and decrementing the frequency of each character in the second string.
         for (int i = 0; i < s.length(); i++) {
-            int pos1 = s.charAt(i) - 'a';
-            int pos2 = s.charAt(i) - 'a';
-            freq[pos1]++;
-            freq[pos2]--;
+            freq[s.charAt(i) - 'a']++;
+            freq[t.charAt(i) - 'a']--;
         }
-        // iterate through the frequency array and check if all the elements are zero, if so return
-        // true else false
-        for (int i = 0; i < 26; i++) {
-            if (freq[i] != 0) {
+        for (int count : freq) {
+            if (count != 0) {
                 return false;
             }
         }

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

@@ -0,0 +1,22 @@
+package com.thealgorithms.dynamicprogramming;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public class LongestAlternatingSubsequenceTest {
+
+    @ParameterizedTest
+    @MethodSource("provideTestCases")
+    void testAlternatingLength(int[] arr, int expected) {
+        assertEquals(expected, LongestAlternatingSubsequence.alternatingLength(arr, arr.length));
+    }
+
+    private static Stream<Arguments> provideTestCases() {
+        return Stream.of(Arguments.of(new int[] {1}, 1), Arguments.of(new int[] {1, 2}, 2), Arguments.of(new int[] {2, 1}, 2), Arguments.of(new int[] {1, 3, 2, 4, 3, 5}, 6), Arguments.of(new int[] {1, 2, 3, 4, 5}, 2), Arguments.of(new int[] {5, 4, 3, 2, 1}, 2),
+            Arguments.of(new int[] {10, 22, 9, 33, 49, 50, 31, 60}, 6), Arguments.of(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 2));
+    }
+}