438_Find_All_Anagrams_in_a_String

Author: qiyuangong

README.md

@@ -130,6 +130,7 @@ Remember solutions are only solutions to given problems. If you want full study
 | 421 | [Maximum XOR of Two Numbers in an Array](https://leetcode.com/problems/maximum-xor-of-two-numbers-in-an-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/421_Maximum_XOR_of_Two_Numbers_in_an_Array.py) | Check 0~32 prefix, check if there is x y in prefixes, where x ^ y = answer ^ 1, O(32n) and O(n) |
 | 422 | [Valid Word Square](https://leetcode.com/problems/valid-word-square/) ♥ | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/422_Valid_Word_Square.py) | Compare row with column, O(n^2) |
 | 434 | [Number of Segments in a String](https://leetcode.com/problems/number-of-segments-in-a-string/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/434_Number_of_Segments_in_a_String.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/434_Number_of_Segments_in_a_String.java) | 1. trim &split<br>2. Find segment in place |
+| 438 | [Find All Anagrams in a String](https://leetcode.com/problems/number-of-segments-in-a-string/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/438_Find_All_Anagrams_in_a_String.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/438_Find_All_Anagrams_in_a_String.java) | Build a char count list with 26-256 length. Note that this list can be update when going through the string. O(n) and O(1) |
 | 443 | [String Compression](https://leetcode.com/problems/string-compression/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/443_String_Compression.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/443_String_Compression.java) | Maintain curr, read, write and anchor (start of this char). |
 | 453 | [Number of Segments in a String](https://leetcode.com/problems/minimum-moves-to-equal-array-elements/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/453_Minimum_Moves_to_Equal_Array_Elements.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/453_Minimum_Moves_to_Equal_Array_Elements.java) | Each move is equal to minus one element in array, so the answer is the sum of all elements after minus min. |
 | 463 | [Island Perimeter](https://leetcode.com/problems/island-perimeter/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/463_Island_Perimeter.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/463_Island_Perimeter.java) | math, find the area, actual number, then find the digit |

java/438_Find_All_Anagrams_in_a_String.java

@@ -0,0 +1,53 @@
+class Solution {
+    public List<Integer> findAnagrams(String s, String p) {
+        // https://leetcode.com/problems/find-all-anagrams-in-a-string/discuss/92015/ShortestConcise-JAVA-O(n)-Sliding-Window-Solution
+        List<Integer> list = new ArrayList<>();
+        if (s == null || s.length() == 0 || p == null || p.length() == 0) return list;
+        int[] hash = new int[256]; //character hash
+        //record each character in p to hash
+        for (char c : p.toCharArray()) {
+            hash[c]++;
+        }
+        //two points, initialize count to p's length
+        int left = 0, right = 0, count = p.length();
+        while (right < s.length()) {
+            //move right everytime, if the character exists in p's hash, decrease the count
+            //current hash value >= 1 means the character is existing in p
+            if (hash[s.charAt(right++)]-- >= 1) count--; 
+            //when the count is down to 0, means we found the right anagram
+            //then add window's left to result list
+            if (count == 0) list.add(left);
+            //if we find the window's size equals to p, then we have to move left (narrow the window) to find the new match window
+            //++ to reset the hash because we kicked out the left
+            //only increase the count if the character is in p
+            //the count >= 0 indicate it was original in the hash, cuz it won't go below 0
+            if (right - left == p.length() && hash[s.charAt(left++)]++ >= 0) count++;
+        }
+        return list;
+    }
+    /*public List<Integer> findAnagrams(String s, String p) {
+        List<Integer> list = new ArrayList<Integer>();
+        int ls = s.length(), lp = p.length();
+        for (int i = 0; i <= ls - lp; i++) {
+            boolean flag = true;
+            String sub = s.substring(i, i + lp);
+            int[] charCnt = new int[256];
+            for (int j = 0; j < sub.length(); j++) {
+                charCnt[sub.charAt(j)]++;
+            }
+            for (int j = 0; j < lp; j++) {
+                charCnt[p.charAt(j)]--;
+            }
+            for (int j = 0; j < charCnt.length; j++) {
+                if (charCnt[j] != 0) {
+                    flag = false;
+                    break;
+                }
+            }
+            if (flag) {
+                list.add(i);
+            }
+        }
+        return list;
+    }*/
+}

python/438_Find_All_Anagrams_in_a_String.py

@@ -0,0 +1,68 @@
+class Solution(object):
+    def findAnagrams(self, s, p):
+        """
+        :type s: str
+        :type p: str
+        :rtype: List[int]
+        """
+        res = []
+        if s is None or p is None or len(s) == 0 or len(p) == 0:
+            return res
+        char_map = [0] * 256
+        for c in p:
+            char_map[ord(c)] += 1
+        left, right, count = 0, 0, len(p)
+        while right < len(s):
+            if char_map[ord(s[right])] >= 1:
+                count -= 1
+            char_map[ord(s[right])] -= 1
+            right += 1
+            if count == 0:
+                res.append(left)
+            if right - left == len(p):
+                if char_map[ord(s[left])] >= 0:
+                    count += 1
+                char_map[ord(s[left])] += 1
+                left += 1
+        return res
+
+    # def findAnagrams(self, s, p):
+    #     if len(s) < len(p):
+    #         return []
+    #     res = []
+    #     p_len = len(p)
+    #     bit_map = []
+    #     for _ in range(26):
+    #         bit_map.append(0)
+    #     for c in p:
+    #         bit_map[ord(c) - ord('a')] += 1
+    #     s_p = str(bit_map)
+    #     for i in range(26):
+    #         bit_map[i] = 0
+    #     for i in range(p_len - 1):
+    #         bit_map[ord(s[i]) - ord('a')] += 1
+    #     for i in range(p_len - 1, len(s)):
+    #         bit_map[ord(s[i]) - ord('a')] += 1
+    #         if i - p_len >= 0:
+    #             bit_map[ord(s[i - p_len]) - ord('a')] -= 1
+    #         if str(bit_map) == s_p:
+    #             res.append(i - p_len + 1)
+    #     return res
+
+    # def findAnagrams(self, s, p):
+    #     """
+    #     :type s: str
+    #     :type p: str
+    #     :rtype: List[int]
+    #     """
+    #     res = []
+    #     pCounter = collections.Counter(p)
+    #     sCounter = collections.Counter(s[:len(p)-1])
+    #     for i in range(len(p)-1,len(s)):
+    #         sCounter[s[i]] += 1   # include a new char in the char_map
+    #         if sCounter == pCounter:    # This step is O(1), since there are at most 26 English letters 
+    #             res.append(i-len(p)+1)   # append the starting index
+    #         sCounter[s[i-len(p)+1]] -= 1   # decrease the count of oldest char in the window
+    #         if sCounter[s[i-len(p)+1]] == 0:
+    #             del sCounter[s[i-len(p)+1]]   # remove the count if it is 0
+    #     return res