7-23-2020

Author: safrannn

src/_0014_longest_common_prefix.rs

@@ -0,0 +1,30 @@
+struct Solution;
+
+impl Solution {
+    pub fn longest_common_prefix(strs: Vec<String>) -> String {
+        if strs.is_empty() {
+            return "".to_string();
+        }
+
+        let h_length_shortest: usize = strs.iter().map(|s| s.len()).min().unwrap_or(0);
+        let mut index: usize = 0;
+        'outer: for _i in 0..h_length_shortest {
+            let h_character: u8 = strs[0].as_bytes()[index];
+            for j in 1..strs.len() {
+                if strs[j].as_bytes()[index] != h_character {
+                    break 'outer;
+                }
+            }
+            index += 1;
+        }
+        strs[0][0..index].to_string()
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::longest_common_prefix(vec_string!["flower", "flow", "flight"]),
+        "fl".to_string()
+    );
+}

src/_0155_min_stack.rs

@@ -0,0 +1,39 @@
+use std::cmp::min;
+struct MinStack {
+    stack: Vec<(i32, i32)>,
+}
+
+impl MinStack {
+    /** initialize your data structure here. */
+    fn new() -> Self {
+        MinStack { stack: vec![] }
+    }
+    fn push(&mut self, x: i32) {
+        if self.stack.is_empty() {
+            self.stack.push((x, x));
+        } else {
+            self.stack.push((x, min(self.stack.last().unwrap().1, x)));
+        }
+    }
+    fn pop(&mut self) {
+        self.stack.pop();
+    }
+    fn top(&self) -> i32 {
+        self.stack.last().unwrap().0
+    }
+    fn get_min(&self) -> i32 {
+        self.stack.last().unwrap().1
+    }
+}
+
+#[test]
+fn test() {
+    let mut min_stack = MinStack::new();
+    min_stack.push(-2);
+    min_stack.push(0);
+    min_stack.push(-3);
+    assert_eq!(min_stack.get_min(), -3);
+    min_stack.pop();
+    assert_eq!(min_stack.top(), 0);
+    assert_eq!(min_stack.get_min(), -2);
+}

src/_0443_string_compression.rs

@@ -0,0 +1,48 @@
+struct Solution;
+
+impl Solution {
+    pub fn compress(chars: &mut Vec<char>) -> i32 {
+        if chars.is_empty() {
+            return 0;
+        }
+        let mut h_count: i32 = 0;
+        let mut h_char_current: char = chars[0];
+        let mut h_index: usize = 0;
+        let h_length: usize = chars.len();
+
+        for j in 0..=h_length {
+            if j == h_length || chars[j] != h_char_current {
+                chars[h_index] = h_char_current;
+                h_index += 1;
+                if j != h_length {
+                    h_char_current = chars[j];
+                }
+
+                if h_count == 1 {
+                    continue;
+                } else {
+                    let h_number_chars = h_count.to_string().chars().collect::<Vec<char>>();
+                    for v in h_number_chars.into_iter() {
+                        chars[h_index] = v;
+                        h_index += 1;
+                    }
+                    h_count = 1;
+                }
+            } else {
+                h_count += 1;
+            }
+        }
+        h_index as i32
+    }
+}
+
+#[test]
+fn test() {
+    let mut input: Vec<char> = [
+        "a", "b", "b", "b", "b", "b", "b", "b", "b", "b", "b", "b", "b",
+    ]
+    .iter()
+    .map(|s| s.chars().next().unwrap())
+    .collect();
+    assert_eq!(Solution::compress(&mut input), 4);
+}

src/lib.rs

@@ -18,6 +18,8 @@ mod _0007_reverse_integer;
 //
 mod _0009_palindrome_number;
 //
+mod _0014_longest_common_prefix;
+//
 mod _0015_3sum;
 //
 mod _0020_valid_parentheses;
@@ -54,6 +56,8 @@ mod _0127_word_ladder;
 //
 mod _0136_single_number;
 //
+mod _0155_min_stack;
+//
 mod _0169_majority_element;
 //
 mod _0189_rotate_array;
@@ -98,6 +102,8 @@ mod _0412_fizz_buzz;
 //
 mod _0415_add_strings;
 //
+mod _0443_string_compression;
+//
 mod _0448_find_all_numbers_disappeared_in_an_array;
 //
 mod _0496_next_greater_element_i;