refactor: Anagrams (#5390)

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

@@ -10,141 +10,130 @@ import java.util.HashMap;
  * 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)
-     */
-    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) {
+    /**
+     * 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 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
+        Arrays.sort(d);
-                               both the arrays are sorted. After that both the arrays are compared
-                               for checking anangram */
-
         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
+        int[] charCount = new int[26];
-            // frequencies are iterated from 0 to 26(from 'a' to 'z' ). If the frequencies match
+        for (int i = 0; i < s.length(); i++) {
-            // then anagram message is displayed in the form of boolean format Running time and
+            charCount[s.charAt(i) - 'a']++;
-            // space complexity of this algo is less as compared to others
+            charCount[t.charAt(i) - 'a']--;
-            for (char c : b.toCharArray()) {
-                n[c - 'a']++;
         }
-            for (int i = 0; i < 26; i++) {
+        for (int count : charCount) {
-                if (m[i] != n[i]) {
+            if (count != 0) {
                 return false;
             }
         }
         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
+        int[] charCount = new int[26];
-        // array
+        for (int i = 0; i < s.length(); i++) {
-        else {
+            charCount[s.charAt(i) - 'a']++;
-            int[] a = new int[26];
+            charCount[t.charAt(i) - 'a']--;
-            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++) {
+        for (int count : charCount) {
-                if (a[i] != b[i]) {
+            if (count != 0) {
                 return false;
             }
         }
         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
+        HashMap<Character, Integer> charCountMap = new HashMap<>();
-        // 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);
+            charCountMap.put(c, charCountMap.getOrDefault(c, 0) + 1);
         }
         for (char c : t.toCharArray()) {
-                kk.put(c, kk.getOrDefault(c, 0) + 1);
+            if (!charCountMap.containsKey(c) || charCountMap.get(c) == 0) {
+                return false;
             }
-            // It checks for equal frequencies by comparing key-value pairs of two hashmaps
+            charCountMap.put(c, charCountMap.get(c) - 1);
-            return nm.equals(kk);
         }
+        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';
+            freq[s.charAt(i) - 'a']++;
-            int pos2 = s.charAt(i) - 'a';
+            freq[t.charAt(i) - 'a']--;
-            freq[pos1]++;
-            freq[pos2]--;
         }
-        // iterate through the frequency array and check if all the elements are zero, if so return
+        for (int count : freq) {
-        // true else false
+            if (count != 0) {
-        for (int i = 0; i < 26; i++) {
-            if (freq[i] != 0) {
                 return false;
             }
         }

src/test/java/com/thealgorithms/strings/AnagramsTest.java

@@ -1,23 +1,48 @@
 package com.thealgorithms.strings;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
-import org.junit.jupiter.api.Test;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
 public class AnagramsTest {
 
-    @Test
+    record AnagramTestCase(String input1, String input2, boolean expected) {
-    public void isAlphabetical() {
+    }
-        String input1 = "late";
+
-        Anagrams anagrams = new Anagrams();
+    private static Stream<AnagramTestCase> anagramTestData() {
-        assertTrue(anagrams.approach1(input1, "tale"));
+        return Stream.of(new AnagramTestCase("late", "tale", true), new AnagramTestCase("late", "teal", true), new AnagramTestCase("listen", "silent", true), new AnagramTestCase("hello", "olelh", true), new AnagramTestCase("hello", "world", false), new AnagramTestCase("deal", "lead", true),
-        assertTrue(anagrams.approach1(input1, "teal"));
+            new AnagramTestCase("binary", "brainy", true), new AnagramTestCase("adobe", "abode", true), new AnagramTestCase("cat", "act", true), new AnagramTestCase("cat", "cut", false));
-        assertTrue(anagrams.approach2(input1, "tale"));
+    }
-        assertTrue(anagrams.approach2(input1, "teal"));
+
-        assertTrue(anagrams.approach3(input1, "tale"));
+    @ParameterizedTest
-        assertTrue(anagrams.approach3(input1, "teal"));
+    @MethodSource("anagramTestData")
-        assertTrue(anagrams.approach4(input1, "tale"));
+    void testApproach1(AnagramTestCase testCase) {
-        assertTrue(anagrams.approach4(input1, "teal"));
+        assertEquals(testCase.expected(), Anagrams.approach1(testCase.input1(), testCase.input2()));
-        assertTrue(anagrams.approach5(input1, "teal"));
+    }
+
+    @ParameterizedTest
+    @MethodSource("anagramTestData")
+    void testApproach2(AnagramTestCase testCase) {
+        assertEquals(testCase.expected(), Anagrams.approach2(testCase.input1(), testCase.input2()));
+    }
+
+    @ParameterizedTest
+    @MethodSource("anagramTestData")
+    void testApproach3(AnagramTestCase testCase) {
+        assertEquals(testCase.expected(), Anagrams.approach3(testCase.input1(), testCase.input2()));
+    }
+
+    @ParameterizedTest
+    @MethodSource("anagramTestData")
+    void testApproach4(AnagramTestCase testCase) {
+        assertEquals(testCase.expected(), Anagrams.approach4(testCase.input1(), testCase.input2()));
+    }
+
+    @ParameterizedTest
+    @MethodSource("anagramTestData")
+    void testApproach5(AnagramTestCase testCase) {
+        assertEquals(testCase.expected(), Anagrams.approach5(testCase.input1(), testCase.input2()));
     }
 }