10

Author: kooshi

.idea/workspace.xml

@@ -12,10 +12,10 @@ mod weeklies;
 //mod p0007;
 //mod p0008;
 //mod p0009;
-//mod p0010;
+mod p0010;
 
 
 fn main() {
-    //let test = p0009::Solution::is_palindrome(121);
+    let test = p0010::Solution::is_match("".to_string(),".*".to_string());
     println!("{}","");
 }

src/main.rs

@@ -2,71 +2,53 @@
 pub(crate) struct Solution;
 
 enum Token {
-    Char(u8),
+    Char(char),
     Star(Box<Token>),
     Dot
 }
 
-#[derive(Clone)]
-enum Match {
-    None,
-    One(usize),
-    Star(StarMatch)
-}
-
-#[derive(Clone)]
-struct StarMatch {
-    index:usize,
-    length:usize,
+impl Token {
+    fn consumes(&self, c:&char) -> bool {
+        match self {
+            Token::Char(tc) => *tc == *c,
+            Token::Star(t) => t.consumes(c),
+            Token::Dot => true
+        }
+    }
 }
 
 impl Solution {
     pub fn is_match(s: String, p: String) -> bool {
-        let chars = s.as_bytes();
+        let chars:Vec<char> = s.chars().collect();
         let pattern = Solution::parse_pattern(p);
-        let mut matches = vec![Match::None; pattern.len()];
-
-        let mut token_i = 0;
-        let mut char_i = 0;
-        loop {
-            matches[token_i] = match &pattern[token_i] {
-                Token::Char(c) if c == chars[char_i]  => unimplemented!(),
-                Token::Star(t) => unimplemented!(),
-                Token::Dot => unimplemented!(),
-            }
-        }
 
-        unimplemented!()
+        Solution::matches(pattern.as_slice(), chars.as_slice())
     }
 
-    fn char(c: &char, i: &mut usize, chars: &Vec<char>) -> bool {
-        if chars[*i] == *c {
-            *i += 1;
-            true
-        } else {
-            false
-        }
-    }
 
-    fn dot(i: &mut usize) -> bool {
-        *i += 1;
-        true
+    fn matches(pattern: &[Token], chars: &[char]) -> bool {
+        for (i,t) in pattern.iter().enumerate() {
+            if let Token::Star(t) = t {
+                let mut ii = i;
+                if Solution::matches(&pattern[i + 1..], &chars[ii..]){
+                    return true;
+                }
+                while ii < chars.len() && t.consumes(&chars[ii]) {
+                    if Solution::matches(&pattern[i + 1..], &chars[ii+1..]){
+                        return true;
+                    }
+                    ii+=1;
+                }
+                return false;
+            } else if i>= chars.len() || !t.consumes(&chars[i]) {
+                return false;
+            }
+        }
+        pattern.len() == chars.len()
     }
 
-    // fn matcher(t: &Token, i: &mut usize, chars: &Vec<char>) -> Match {
-    //     match t {
-    //         Token::Char(c) => if *i >= chars.len() || !Solution::char(c, i, chars) { return false; }
-    //         Token::Dot => if *i >= chars.len() || !Solution::dot(i) { return false; }
-    //         Token::Star(t) => {
-    //             //TODO make less greedy
-    //             while Solution::matcher(t, i, chars) {}
-    //         }
-    //     }
-    //     return true
-    // }
-
 
-    fn parse_pattern<'a>(p: String) -> Vec<Token> {
+    fn parse_pattern(p: String) -> Vec<Token> {
         let mut pattern: Vec<Token> = Vec::with_capacity(p.len());
 
         for c in p.chars() {