refactor 49

fishercoder1534 · fishercoder1534 · commit 3d241cce78e7 · 2020-04-10T10:20:37.000-07:00
diff --git a/build.gradle b/build.gradle
@@ -22,5 +22,6 @@ repositories {
 dependencies {
     compile 'com.google.code.gson:gson:2.8.0'
     compile 'junit:junit:4.12'
+    compile group: 'org.apache.commons', name: 'commons-collections4', version: '4.0'
     testCompile group: 'junit', name: 'junit', version:'4.12'
 }
diff --git a/src/main/java/com/fishercoder/solutions/_49.java b/src/main/java/com/fishercoder/solutions/_49.java
@@ -10,34 +10,35 @@
  * 49. Group Anagrams
  *
  * Given an array of strings, group anagrams together.
-
- For example, given: ["eat", "tea", "tan", "ate", "nat", "bat"],
- Return:
-
- [
- ["ate", "eat","tea"],
- ["nat","tan"],
- ["bat"]
- ]
-
- Note: All inputs will be in lower-case.
+ *
+ * For example, given: ["eat", "tea", "tan", "ate", "nat", "bat"],
+ * Return:
+ * [
+ * ["ate", "eat","tea"],
+ * ["nat","tan"],
+ * ["bat"]
+ * ]
+ *
+ * Note:
+ *  All inputs will be in lowercase.
+ *  The order of your output does not matter.
  */
 
 public class _49 {
 
-  public static class Solution1 {
-    public List<List<String>> groupAnagrams(String[] strs) {
-      Map<String, List<String>> map = new HashMap<>();
-      for (String word : strs) {
-        char[] c = word.toCharArray();
-        Arrays.sort(c);
-        String key = new String(c);
-        if (!map.containsKey(key)) {
-          map.put(key, new ArrayList<>());
+    public static class Solution1 {
+        public List<List<String>> groupAnagrams(String[] strs) {
+            Map<String, List<String>> map = new HashMap<>();
+            for (String word : strs) {
+                char[] c = word.toCharArray();
+                Arrays.sort(c);
+                String key = new String(c);
+                if (!map.containsKey(key)) {
+                    map.put(key, new ArrayList<>());
+                }
+                map.get(key).add(word);
+            }
+            return new ArrayList<>(map.values());
         }
-        map.get(key).add(word);
-      }
-      return new ArrayList<>(map.values());
     }
-  }
 }
diff --git a/src/test/java/com/fishercoder/_49Test.java b/src/test/java/com/fishercoder/_49Test.java
@@ -1,34 +1,51 @@
 package com.fishercoder;
 
 import com.fishercoder.solutions._49;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+
+import org.apache.commons.collections4.CollectionUtils;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertTrue;
 
 public class _49Test {
-  private static _49.Solution1 solution1;
-  private static String[] words;
-  private static List<List<String>> expected;
-  private static List<List<String>> actual;
+    private static _49.Solution1 solution1;
+    private static String[] words;
+    private static List<List<String>> expected;
+    private static List<List<String>> actual;
 
-  @BeforeClass
-  public static void setup() {
-    solution1 = new _49.Solution1();
-  }
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _49.Solution1();
+    }
 
-  @Test
-  public void test1() {
-    words = new String[] {"eat", "tea", "tan", "ate", "nat", "bat"};
-    expected = new ArrayList<>();
-    expected.add(Arrays.asList("ate", "eat", "tea"));
-    expected.add(Arrays.asList("nat", "tan"));
-    expected.add(Arrays.asList("bat"));
-    actual = solution1.groupAnagrams(words);
-    assertEquals(expected.size(), actual.size());
-    assertEquals(expected.containsAll(actual), actual.containsAll(expected));
-  }
+    @Test
+    public void test1() {
+        words = new String[]{"eat", "tea", "tan", "ate", "nat", "bat"};
+        List<String> e1 = Arrays.asList("bat");
+        List<String> e2 = Arrays.asList("tan", "nat");
+        List<String> e3 = Arrays.asList("ate", "eat", "tea");
+        expected = Arrays.asList(e1, e2, e3);
+        actual = solution1.groupAnagrams(words);
+        assertEquals(expected.size(), actual.size());
+        assertEquals(expected.containsAll(actual), actual.containsAll(expected));
+        for (List<String> a : actual) {
+            switch (a.size()) {
+                case 1:
+                    assertTrue(CollectionUtils.isEqualCollection(e1, a));
+                    break;
+                case 2:
+                    assertTrue(CollectionUtils.isEqualCollection(e2, a));
+                    break;
+                case 3:
+                    assertTrue(CollectionUtils.isEqualCollection(e3, a));
+                    break;
+            }
+        }
+    }
 }
