daily

Author: kooshi

.idea/workspace.xml

@@ -0,0 +1,94 @@
+// Definition for a binary tree node.
+#[derive(Debug, PartialEq, Eq)]
+pub struct TreeNode {
+  pub val: i32,
+  pub left: Option<Rc<RefCell<TreeNode>>>,
+  pub right: Option<Rc<RefCell<TreeNode>>>,
+}
+
+impl TreeNode {
+  #[inline]
+  pub fn new(val: i32, left: Option<Rc<RefCell<TreeNode>>>, right: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
+    Some(Rc::new(RefCell::new( TreeNode {
+      val,
+      left,
+      right
+    })))
+  }
+}
+#[cfg(test)]
+mod tests {
+    use crate::dailies::d20_12_12::{Solution, TreeNode};
+    use std::rc::Rc;
+    use std::cell::RefCell;
+
+    #[test]
+    fn it_works() {
+        assert_eq!(2, Solution::subtree_with_all_deepest(
+            TreeNode::new(3,
+              TreeNode::new(5,
+                TreeNode::new(6, None, None),
+                TreeNode::new(2,
+                  TreeNode::new(7, None, None),
+                  TreeNode::new(4, None, None))),
+              TreeNode::new(1,
+                TreeNode::new(0, None, None),
+                TreeNode::new(8, None, None)))
+        ).unwrap().borrow().val);
+    }
+}
+
+
+struct Solution;
+
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn subtree_with_all_deepest(root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
+        if root.is_none() {
+            return root;
+        }
+        let mut deepest_leaves = Vec::new();
+        let mut max_depth = 0;
+        Solution::traverse(1, None, &root.unwrap(), &mut deepest_leaves, &mut max_depth);
+
+        //moveup on all leaves until they hit same value
+        let mut val = deepest_leaves[0].as_ref().unwrap().node.borrow().val;
+        while !deepest_leaves[1..].iter().all(|l|l.as_ref().unwrap().node.borrow().val == val) {
+            for i in 0..deepest_leaves.len() {
+                deepest_leaves[i] = deepest_leaves[i].as_ref().unwrap().parent.clone();
+            }
+            val = deepest_leaves[0].as_ref().unwrap().node.borrow().val;
+        }
+
+        Some(deepest_leaves[0].as_ref().unwrap().node.clone())
+    }
+
+    fn traverse(depth:u32, parent:Option<Rc<UpNode>>, node:&NodePointer, deepest_leaves:&mut Vec<Option<Rc<UpNode>>>, max_depth:&mut u32){
+        let this_node = Some(Rc::new(UpNode{node:node.clone(), parent }));
+        let node = node.borrow();
+        if node.left.is_none() && node.right.is_none(){
+            if depth >= *max_depth {
+                if depth > *max_depth {
+                    *max_depth = depth;
+                    deepest_leaves.clear();
+                }
+                deepest_leaves.push(this_node);
+            }
+            return;
+        }
+
+        if let Some(l) = &node.left {
+            Solution::traverse(depth + 1, this_node.clone(), l, deepest_leaves, max_depth);
+        }
+
+        if let Some(r) = &node.right {
+            Solution::traverse(depth + 1, this_node.clone(), r, deepest_leaves, max_depth);
+        }
+    }
+}
+type NodePointer = Rc<RefCell<TreeNode>>;
+struct UpNode {
+    node:NodePointer,
+    parent:Option<Rc<UpNode>>
+}

src/dailies/d20_12_12.rs

@@ -1,3 +1,4 @@
 //mod d20_12_9;
 //mod d20_12_10;
-//mod d20_12_11;
+//mod d20_12_11;
+mod d20_12_12;

src/dailies/mod.rs

@@ -10,11 +10,11 @@ mod dailies;
 //mod p0006;
 //mod p0007;
 //mod p0008;
-mod p0009;
+//mod p0009;
 //mod p0010;
 
 
 fn main() {
-    let test = p0009::Solution::is_palindrome(121);
+    //let test = p0009::Solution::is_palindrome(121);
     println!("{}","");
 }

src/main.rs

@@ -1,29 +1,42 @@
 
-
 pub(crate) struct Solution;
 
 enum Token {
-    Char(char),
+    Char(u8),
     Star(Box<Token>),
     Dot
 }
 
+#[derive(Clone)]
+enum Match {
+    None,
+    One(usize),
+    Star(StarMatch)
+}
+
+#[derive(Clone)]
+struct StarMatch {
+    index:usize,
+    length:usize,
+}
+
 impl Solution {
     pub fn is_match(s: String, p: String) -> bool {
+        let chars = s.as_bytes();
         let pattern = Solution::parse_pattern(p);
-        let chars: Vec<char> = s.chars().collect();
-        let mut i = 0;
+        let mut matches = vec![Match::None; pattern.len()];
 
-        for t in pattern {
-            if !Solution::matcher(&t, &mut i, &chars) {
-                return false;
+        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!(),
             }
         }
-        if i == chars.len() {
-            true
-        } else {
-            false
-        }
+
+        unimplemented!()
     }
 
     fn char(c: &char, i: &mut usize, chars: &Vec<char>) -> bool {
@@ -40,17 +53,17 @@ impl Solution {
         true
     }
 
-    fn matcher(t: &Token, i: &mut usize, chars: &Vec<char>) -> bool {
-        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 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> {