v0.1.3: Made string matching generic, fixed writer_to_file()

Author: EbTech

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "contest-algorithms"
-version = "0.1.2"
+version = "0.1.3"
 authors = ["Aram Ebtekar"]
 edition = "2018"
 

src/arq_tree.rs

@@ -289,7 +289,7 @@ mod test {
         assert_eq!(pos, 2);
         assert_eq!(pos_zeros, -1);
     }
-    
+
     #[test]
     fn test_range_sum() {
         let mut arq = ArqTree::<AssignSum>::new(vec![(0, 1); 10]);
@@ -301,11 +301,11 @@ mod test {
 
         assert_eq!(arq.query(0, 9), (23, 10));
     }
-    
+
     #[test]
     fn test_supply_demand() {
         let mut arq = ArqTree::<SupplyDemand>::new(vec![(0, 0, 0); 10]);
-        
+
         arq.modify(1, 1, &(25, 100));
         arq.modify(3, 3, &(100, 30));
         arq.modify(9, 9, &(0, 20));

src/math/num.rs

@@ -14,7 +14,7 @@ pub fn fast_gcd(mut a: i64, mut b: i64) -> i64 {
 }
 
 /// Represents a fraction reduced to lowest terms
-#[derive(Clone, Copy, Eq, PartialEq, Debug)]
+#[derive(Clone, Copy, Eq, PartialEq, Debug, Hash)]
 pub struct Rational {
     pub num: i64,
     pub den: i64,
@@ -170,7 +170,7 @@ impl Div for Complex {
 /// [1, 2^31.5] will work. If MOD is not prime, ring operations are still valid
 /// but recip() and division are not. Note that the latter operations are also
 /// the slowest, so precompute any inverses that you intend to use frequently.
-#[derive(Clone, Copy, Eq, PartialEq, Debug)]
+#[derive(Clone, Copy, Eq, PartialEq, Debug, Hash)]
 pub struct Field {
     pub val: i64,
 }

src/scanner.rs

@@ -76,7 +76,7 @@ pub fn scanner_from_file(filename: &str) -> Scanner<io::BufReader<std::fs::File>
 }
 
 pub fn writer_to_file(filename: &str) -> io::BufWriter<std::fs::File> {
-    let file = std::fs::File::open(filename).expect("Output file not found");
+    let file = std::fs::File::create(filename).expect("Output file not found");
     io::BufWriter::new(file)
 }
 

src/string_proc.rs

@@ -1,29 +1,46 @@
 //! String processing algorithms.
 
 /// Data structure for Knuth-Morris-Pratt string matching against a pattern.
-pub struct Matcher<'a> {
+pub struct Matcher<'a, T> {
     /// The string pattern to search for.
-    pub pattern: &'a [u8],
+    pub pattern: &'a [T],
     /// KMP match failure automaton. fail[i] is the length of the longest
     /// proper prefix-suffix of pattern[0...i].
     pub fail: Vec<usize>,
 }
 
-impl<'a> Matcher<'a> {
+impl<'a, T: Eq> Matcher<'a, T> {
     /// Precomputes the automaton that allows linear-time string matching.
     ///
+    /// # Example
+    ///
+    /// ```
+    /// use contest_algorithms::string_proc::Matcher;
+    /// let utf8_string = "hello";
+    ///
+    /// let match_from_byte_literal = Matcher::new(b"hello");
+    ///
+    /// let match_from_bytes = Matcher::new(utf8_string.as_bytes());
+    ///
+    /// let vec_char: Vec<char> = utf8_string.chars().collect();
+    /// let match_from_chars = Matcher::new(&vec_char);
+    ///
+    /// let vec_int = vec![4, -3, 1];
+    /// let match_from_ints = Matcher::new(&vec_int);
+    /// ```
+    ///
     /// # Panics
     ///
     /// Panics if pattern is empty.
-    pub fn new(pattern: &'a [u8]) -> Self {
+    pub fn new(pattern: &'a [T]) -> Self {
         let mut fail = Vec::with_capacity(pattern.len());
         fail.push(0);
         let mut len = 0;
-        for &ch in &pattern[1..] {
-            while len > 0 && pattern[len] != ch {
+        for ch in &pattern[1..] {
+            while len > 0 && pattern[len] != *ch {
                 len = fail[len - 1];
             }
-            if pattern[len] == ch {
+            if pattern[len] == *ch {
                 len += 1;
             }
             fail.push(len);
@@ -33,17 +50,17 @@ impl<'a> Matcher<'a> {
 
     /// KMP algorithm, sets matches[i] = length of longest prefix of pattern
     /// matching a suffix of text[0...i].
-    pub fn kmp_match(&self, text: &[u8]) -> Vec<usize> {
+    pub fn kmp_match(&self, text: &[T]) -> Vec<usize> {
         let mut matches = Vec::with_capacity(text.len());
         let mut len = 0;
-        for &ch in text {
+        for ch in text {
             if len == self.pattern.len() {
                 len = self.fail[len - 1];
             }
-            while len > 0 && self.pattern[len] != ch {
+            while len > 0 && self.pattern[len] != *ch {
                 len = self.fail[len - 1];
             }
-            if self.pattern[len] == ch {
+            if self.pattern[len] == *ch {
                 len += 1;
             }
             matches.push(len);
@@ -151,7 +168,7 @@ impl<K: std::hash::Hash + Eq + Default> Trie<K> {
         node.count += 1;
 
         for ch in word {
-            node = { node }.branches.entry(ch).or_insert_with(Default::default);
+            node = { node }.branches.entry(ch).or_default();
             node.count += 1;
         }
     }
@@ -177,7 +194,7 @@ impl<K: std::hash::Hash + Eq + Default> Trie<K> {
 /// # Panics
 ///
 /// Panics if text is empty.
-pub fn palindromes(text: &[u8]) -> Vec<usize> {
+pub fn palindromes<T: Eq>(text: &[T]) -> Vec<usize> {
     let mut pal = Vec::with_capacity(2 * text.len() - 1); // only mutable var!
     pal.push(1);
     while pal.len() < pal.capacity() {
@@ -210,8 +227,8 @@ mod test {
 
     #[test]
     fn test_kmp() {
-        let text = "banana".as_bytes();
-        let pattern = "ana".as_bytes();
+        let text = b"banana";
+        let pattern = b"ana";
 
         let matches = Matcher::new(pattern).kmp_match(text);
 
@@ -220,8 +237,8 @@ mod test {
 
     #[test]
     fn test_suffix_array() {
-        let text1 = "bobocel".as_bytes();
-        let text2 = "banana".as_bytes();
+        let text1 = b"bobocel";
+        let text2 = b"banana";
 
         let sfx1 = SuffixArray::new(text1);
         let sfx2 = SuffixArray::new(text2);
@@ -261,7 +278,7 @@ mod test {
 
     #[test]
     fn test_palindrome() {
-        let text = "banana".as_bytes();
+        let text = b"banana";
 
         let pal_len = palindromes(text);