refactor 30

fishercoder1534 · fishercoder1534 · commit fe291d2c6eb9 · 2017-12-25T08:33:45.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_30.java b/src/main/java/com/fishercoder/solutions/_30.java
@@ -1,14 +1,18 @@
 package com.fishercoder.solutions;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 /**
- * You are given a string, s, and a list of words, words,
- * that are all of the same length.
- * Find all starting indices of substring(s) in s
- * that is a concatenation of each word in words exactly once and without any intervening characters.
+ * 30. Substring with Concatenation of All Words
+ *
+ * You are given a string, s, and a list of words, words, that are all of the same length.
+ * Find all starting indices of substring(s) in s that is a concatenation of each word in words exactly once and without any intervening characters.
 
  For example, given:
  s: "barfoothefoobarman"
@@ -19,60 +23,39 @@
  */
 public class _30 {
 
-    public List<Integer> findSubstring(String S, String[] L) {
-        ArrayList<Integer> res = new ArrayList();
-        if (S == null || L == null || S.length() == 0 || L.length == 0) {
-            return res;
+  public static class Solution1 {
+    public List<Integer> findSubstring(String s, String[] words) {
+      Map<String, Boolean> map = new HashMap<>();
+      for (String word : words) {
+        map.put(word, true);
+      }
+      List<Integer> result = new ArrayList<>();
+      int startIndex = 0;
+      for (int i = 0; i < s.length(); i++) {
+        startIndex = i;
+        Map<String, Boolean> clone = new HashMap<>(map);
+        for (int j = i +1; j < s.length(); j++) {
+          String word = s.substring(i, j);
+          if (clone.containsKey(word) && clone.get(word)) {
+            clone.put(word, false);
+            i = j+1;
+          } else {
+            break;
+          }
         }
-
-        HashMap<String, Integer> map = new HashMap();
-        for (int i = 0; i < L.length; i++) {
-            Integer val = map.get(L[i]);
-            if (val == null) {
-                map.put(L[i], 1);
-            } else {
-                map.put(L[i], val + 1);
-            }
+        boolean all = true;
+        for (String word : clone.keySet()) {
+          if (clone.get(word)) {
+            all = false;
+            break;
+          }
         }
-        HashMap<String, Integer> original = new HashMap();
-        original = (HashMap<String, Integer>) map.clone();
-
-		/* we use two start pointers, "start" means the real starting point,
-         * "tempStart" means the currently starting point for comparing, if one whole concatenation substring
-		 * is found, then we assign (tempStart + wordLen) to start, otherwise, start++. */
-        int start = 0;
-        int tempStart = 0;
-        int wordLen = L[0].length();
-        int wholeWordLen = wordLen * L.length;
-        for (; start <= S.length() - wholeWordLen; start++) {
-            map.clear();
-            map = (HashMap<String, Integer>) original.clone();
-            for (tempStart = start; tempStart < S.length(); tempStart += wordLen) {
-				/* assign start to tempStart, this is a very smart way of coding, learn and master it! */
-                if (map.size() == 0) {
-                    break;
-                }
-                if (tempStart + wordLen > S.length()) {
-                    break;
-                }
-                String sub = S.substring(tempStart, tempStart + wordLen);
-                Integer val = map.get(sub);
-
-                if (val == null) {
-                    break;
-                } else {
-                    if (val == 1) {
-                        map.remove(sub);
-                    } else {
-                        map.put(sub, val - 1);
-                    }
-                }
-            }
-            if (map.size() == 0) {
-                res.add(start);
-            }
+        if (all) {
+          result.add(startIndex);
         }
-        return res;
+      }
+      return result;
     }
+  }
 
 }
diff --git a/src/test/java/com/fishercoder/_30Test.java b/src/test/java/com/fishercoder/_30Test.java
@@ -0,0 +1,29 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._30;
+import com.fishercoder.solutions._735;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+public class _30Test {
+  private static _30.Solution1 solution1;
+  private static String[] words;
+  private static List<Integer> expected;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _30.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    words = new String[] {"foo", "bar"};
+    expected = Arrays.asList(0, 9);
+    assertEquals(expected, solution1.findSubstring("barfoothefoobarman", words));
+  }
+}
