solve aylei#30

Author: aylei

README.md

@@ -6,7 +6,7 @@ Run `cargo test test_{id}` to test the solution for "question #id".
 
 Working in progress, to do:
 
-- [ ] auto generation of solution list
+- [ ] auto generation of solution list (when 100 problems solved)
 
 ## Usage
 

src/lib.rs

@@ -29,3 +29,4 @@ mod n0026_remove_duplicates_from_sorted_array;
 mod n0027_remove_element;
 mod n0028_implement_strstr;
 mod n0029_divide_two_integers;
+mod n0030_substring_with_concatenation_of_all_words;

src/n0029_divide_two_integers.rs

@@ -1,31 +1,31 @@
 /**
  * [29] Divide Two Integers
  *
- * Given two integers dividend and divisor, divide two integers without using multiplication, division and mod operator.
- * 
- * Return the quotient after dividing dividend by divisor.
- * 
- * The integer division should truncate toward zero.
- * 
- * Example 1:
- * 
- * 
- * Input: dividend = 10, divisor = 3
- * Output: 3
- * 
- * Example 2:
- * 
- * 
- * Input: dividend = 7, divisor = -3
- * Output: -2
- * 
- * Note:
- * 
- * 
- * 	Both dividend and divisor will be 32-bit signed integers.
- * 	The divisor will never be 0.
- * 	Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [-2^31,  2^31 - 1]. For the purpose of this problem, assume that your function returns 2^31 - 1 when the division result overflows.
- * 
+ * Given two integers dividend and divisor, divide two integers without using multiplication, division and mod operator.
+ * 
+ * Return the quotient after dividing dividend by divisor.
+ * 
+ * The integer division should truncate toward zero.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: dividend = 10, divisor = 3
+ * Output: 3
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: dividend = 7, divisor = -3
+ * Output: -2
+ * 
+ * Note:
+ * 
+ * 
+ * 	Both dividend and divisor will be 32-bit signed integers.
+ * 	The divisor will never be 0.
+ * 	Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [-2^31,  2^31 - 1]. For the purpose of this problem, assume that your function returns 2^31 - 1 when the division result overflows.
+ * 
  * 
  */
 pub struct Solution {}
@@ -34,7 +34,7 @@ pub struct Solution {}
 
 impl Solution {
     pub fn divide(dividend: i32, divisor: i32) -> i32 {
-        
+        0
     }
 }
 

src/n0030_substring_with_concatenation_of_all_words.rs

@@ -0,0 +1,132 @@
+/**
+ * [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.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input:
+ *   s = "barfoothefoobarman",
+ *   words = ["foo","bar"]
+ * Output: [0,9]
+ * Explanation: Substrings starting at index 0 and 9 are "barfoor" and "foobar" respectively.
+ * The output order does not matter, returning [9,0] is fine too.
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input:
+ *   s = "wordgoodgoodgoodbestword",
+ *   words = ["word","good","best","word"]
+ * Output: []
+ * 
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+struct Term {
+    expect: i32,
+    count: i32,
+}
+impl Term {
+    fn new(expect: i32, count: i32) -> Self {
+        Term{expect, count}
+    }
+    fn inc_expect(&mut self) {
+        self.expect += 1;
+    }
+    fn inc(&mut self) {
+        self.count += 1;
+    }
+    fn dec(&mut self) {
+        self.count -= 1;
+    }
+    fn exhausted(&self) -> bool {
+        self.count > self.expect
+    }
+    fn reset(&mut self) {
+        self.count = 0;
+    }
+}
+
+use std::collections::HashMap;
+use std::collections::hash_map::Entry;
+
+impl Solution {
+    pub fn find_substring(s: String, words: Vec<String>) -> Vec<i32> {
+        if words.len() < 1 { return vec![] }
+        let word_len = words[0].len();
+        if word_len < 1 { return vec![] }
+        let substr_len = word_len * words.len();
+        let mut map: HashMap<&str, Term> = HashMap::with_capacity(words.len());
+        for word in words.iter() {
+            map.entry(word).or_insert(Term::new(0, 0)).inc_expect();
+        }
+        let mut result: Vec<i32> = Vec::new();
+        // we can split terms in N ways, where N = word_len
+        for shift in 0..word_len {
+            let mut i = shift;
+            let mut j = shift;
+            // we do a sliding window for each round
+            while j + word_len - 1 < s.len() {
+                match map.entry(&s[j..j+word_len]) {
+                    Entry::Occupied(mut entry) => {
+                        entry.get_mut().inc();
+                        // term exhausted, shrink the window to release
+                        if entry.get().exhausted() {
+                            while i < j {
+                                let term = &s[i..i+word_len];
+                                map.entry(term).and_modify(|t| t.dec());
+                                i += word_len;
+                                if term == &s[j..j+word_len] { break }
+                            }
+                            j += word_len;
+                        } else {
+                            if j - i < (words.len() - 1) * word_len {
+                                j += word_len;
+                            } else {
+                                // matched!
+                                result.push(i as i32);
+                                // move the whole window, release the dropped term
+                                map.entry(&s[i..i+word_len]).and_modify(|t| t.dec());
+                                j += word_len; i += word_len;
+                            }
+                        }
+                    },
+                    // bad term, move over and do a reset
+                    Entry::Vacant(entry) => {
+                        map.iter_mut().for_each(|(_, v)| v.reset());
+                        j += word_len; i = j;
+                    },
+                }
+            }
+            map.iter_mut().for_each(|(_, v)| v.reset())
+        }
+        result
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_30() {
+        assert_eq!(Solution::find_substring("barfoothefoobarman".to_string(), vec!["foo".to_string(),"bar".to_string()]),
+                   vec![0, 9]);
+        assert_eq!(Solution::find_substring("wordgoodgoodgoodbestword".to_string(),
+                                            vec!["word".to_string(),"good".to_string(), "best".to_string(), "word".to_string()]),
+                   vec![]);
+        assert_eq!(Solution::find_substring("wordgoodgoodgoodbestword".to_string(),
+                                            vec!["word".to_string(),"good".to_string(), "best".to_string(), "good".to_string()]),
+                   vec![8]);
+        assert_eq!(Solution::find_substring("xxwordgoodgoodgoodbestword".to_string(),
+                                            vec!["word".to_string(),"good".to_string(), "best".to_string(), "good".to_string()]),
+                   vec![10]);
+    }
+}