refactor 269

fishercoder1534 · fishercoder1534 · commit 8a3750993e67 · 2018-11-13T07:41:04.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_269.java b/src/main/java/com/fishercoder/solutions/_269.java
@@ -1,6 +1,5 @@
 package com.fishercoder.solutions;
 
-
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
@@ -34,70 +33,68 @@
  There may be multiple valid order of letters, return any one of them is fine.
  */
 public class _269 {
+    public static class Solution1 {
 
-    /**reference: https://discuss.leetcode.com/topic/28308/java-ac-solution-using-bfs*/
-    public static String alienOrder(String[] words) {
-        Map<Character, Set<Character>> map = new HashMap();
-        Map<Character, Integer> degree = new HashMap<>();
-        String result = "";
-        if (words == null || words.length == 0) {
-            return result;
-        }
-        for (String s : words) {
-            for (char c : s.toCharArray()) {
-                degree.put(c, 0);//keeps overwriting it, the purpose is to create one entry
-                //for each letter in the degree map
+        /**
+         * reference: https://discuss.leetcode.com/topic/28308/java-ac-solution-using-bfs
+         */
+        public String alienOrder(String[] words) {
+            Map<Character, Set<Character>> map = new HashMap();
+            Map<Character, Integer> degree = new HashMap<>();
+            String result = "";
+            if (words == null || words.length == 0) {
+                return result;
             }
-        }
-        for (int i = 0; i < words.length - 1; i++) {
-            String cur = words[i];
-            String next = words[i + 1];
-            int length = Math.min(cur.length(), next.length());
-            for (int j = 0; j < length; j++) {
-                char c1 = cur.charAt(j);
-                char c2 = next.charAt(j);
-                if (c1 != c2) {
-                    Set<Character> set = new HashSet<>();
-                    if (map.containsKey(c1)) {
-                        set = map.get(c1);
-                    }
-                    if (!set.contains(c2)) {
-                        set.add(c2);
-                        map.put(c1, set);
-                        degree.put(c2, degree.get(c2) + 1);
+            for (String s : words) {
+                for (char c : s.toCharArray()) {
+                    degree.put(c, 0);//keeps overwriting it, the purpose is to create one entry
+                    //for each letter in the degree map
+                }
+            }
+            for (int i = 0; i < words.length - 1; i++) {
+                String cur = words[i];
+                String next = words[i + 1];
+                int length = Math.min(cur.length(), next.length());
+                for (int j = 0; j < length; j++) {
+                    char c1 = cur.charAt(j);
+                    char c2 = next.charAt(j);
+                    if (c1 != c2) {
+                        Set<Character> set = new HashSet<>();
+                        if (map.containsKey(c1)) {
+                            set = map.get(c1);
+                        }
+                        if (!set.contains(c2)) {
+                            set.add(c2);
+                            map.put(c1, set);
+                            degree.put(c2, degree.get(c2) + 1);
+                        }
+                        break;
                     }
-                    break;
                 }
             }
-        }
-        Queue<Character> queue = new LinkedList<>();
-        for (char c : degree.keySet()) {
-            if (degree.get(c) == 0) {
-                queue.add(c);
+            Queue<Character> queue = new LinkedList<>();
+            for (char c : degree.keySet()) {
+                if (degree.get(c) == 0) {
+                    queue.add(c);
+                }
             }
-        }
-        while (!queue.isEmpty()) {
-            char c = queue.remove();
-            result += c;
-            if (map.containsKey(c)) {
-                for (char c2 : map.get(c)) {
-                    degree.put(c2, degree.get(c2) - 1);
-                    if (degree.get(c2) == 0) {
-                        queue.add(c2);
+            while (!queue.isEmpty()) {
+                char c = queue.remove();
+                result += c;
+                if (map.containsKey(c)) {
+                    for (char c2 : map.get(c)) {
+                        degree.put(c2, degree.get(c2) - 1);
+                        if (degree.get(c2) == 0) {
+                            queue.add(c2);
+                        }
                     }
                 }
             }
+            if (result.length() != degree.size()) {
+                return "";
+            }
+            return result;
         }
-        if (result.length() != degree.size()) {
-            return "";
-        }
-        return result;
     }
 
-    public static void main(String... args) {
-        System.out.println("Hello world.");
-        String[] words = new String[]{"wrt", "wrf", "er", "ett", "rftt"};
-        String order = alienOrder(words);
-        System.out.print(order);
-    }
 }
diff --git a/src/test/java/com/fishercoder/_269Test.java b/src/test/java/com/fishercoder/_269Test.java
@@ -0,0 +1,24 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._269;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _269Test {
+    private static _269.Solution1 solution1;
+    private static String[] words;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _269.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        words = new String[]{"wrt", "wrf", "er", "ett", "rftt"};
+        assertEquals("wertf", solution1.alienOrder(words));
+    }
+
+}
