Merge pull request #32 from Blazeboard/master

add some solutions in rust

Author: strengthen

Rust/1.rs

@@ -1,5 +1,20 @@
 __________________________________________________________________________________________________
+//runtime: 0ms, memory: 2.5MB
 
+impl Solution {
+    pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
+        use std::collections::HashMap;
+        let mut hash = HashMap::new();
+        for i in 0..nums.len() {
+            if !hash.contains_key(&(target - nums[i])) {
+                hash.insert(nums[i], i);
+            } else {
+                return vec![hash[&(target - nums[i])] as i32, i as i32];
+            }
+        }
+        return vec![];
+    }
+}
 __________________________________________________________________________________________________
 
 __________________________________________________________________________________________________

Rust/155.rs

@@ -1,5 +1,58 @@
 __________________________________________________________________________________________________
+//runtime: 4ms, memory: 5.9MB
 
+struct MinStack {
+    stack: Vec<i32>,
+    min_stack: Vec<i32>,
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl MinStack {
+
+    fn new() -> Self {
+        MinStack {
+            stack: Vec::new(),
+            min_stack: Vec::new(),
+        }
+    }
+    
+    fn push(&mut self, val: i32) {
+        self.stack.push(val);
+        if self.min_stack.is_empty() || val <= *self.min_stack.last().unwrap() {
+            self.min_stack.push(val);
+        }
+    }
+    
+    fn pop(&mut self) {
+        if self.min_stack.is_empty() {
+            return;
+        }
+        if self.stack.pop().unwrap() == *self.min_stack.last().unwrap() {
+            self.min_stack.pop();
+        }
+    }
+    
+    fn top(&self) -> i32 {
+        return *self.stack.last().unwrap();
+    }
+    
+    fn get_min(&self) -> i32 {
+        return *self.min_stack.last().unwrap();
+    }
+}
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * let obj = MinStack::new();
+ * obj.push(val);
+ * obj.pop();
+ * let ret_3: i32 = obj.top();
+ * let ret_4: i32 = obj.get_min();
+ */
 __________________________________________________________________________________________________
 
 __________________________________________________________________________________________________

Rust/206.rs

@@ -1,5 +1,35 @@
 __________________________________________________________________________________________________
+//runtime: 0ms, memory: 2.4MB
 
+// Definition for singly-linked list.
+// #[derive(PartialEq, Eq, Clone, Debug)]
+// pub struct ListNode {
+//   pub val: i32,
+//   pub next: Option<Box<ListNode>>
+// }
+//
+// impl ListNode {
+//   #[inline]
+//   fn new(val: i32) -> Self {
+//     ListNode {
+//       next: None,
+//       val
+//     }
+//   }
+// }
+impl Solution {
+    pub fn reverse_list(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let mut pre = None;
+        let mut cur = head;
+        while let Some(mut cur_node) = cur.take() {
+            let next_temp = cur_node.next.take();
+            cur_node.next = pre.take();
+            pre = Some(cur_node);
+            cur = next_temp;
+        }
+        pre
+    }
+}
 __________________________________________________________________________________________________
 
 __________________________________________________________________________________________________

Rust/21.rs

@@ -1,5 +1,42 @@
 __________________________________________________________________________________________________
+//runtime: 0ms, memory: 2MB
 
+// Definition for singly-linked list.
+// #[derive(PartialEq, Eq, Clone, Debug)]
+// pub struct ListNode {
+//   pub val: i32,
+//   pub next: Option<Box<ListNode>>
+// }
+//
+// impl ListNode {
+//   #[inline]
+//   fn new(val: i32) -> Self {
+//     ListNode {
+//       next: None,
+//       val
+//     }
+//   }
+// }
+impl Solution {
+    pub fn merge_two_lists(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        match (l1, l2) {
+            (Some(node1), None) => Some(node1),
+            (None, Some(node2)) => Some(node2),
+            (Some(mut node1), Some(mut node2)) => {
+                if node1.val < node2.val {
+                    let n = node1.next.take();
+                    node1.next = Solution::merge_two_lists(n, Some(node2));
+                    Some(node1)
+                } else {
+                    let n = node2.next.take();
+                    node2.next = Solution::merge_two_lists(n, Some(node1));
+                    Some(node2)
+                }
+            }
+            _ => None,
+        }
+    }
+}
 __________________________________________________________________________________________________
 
 __________________________________________________________________________________________________

Rust/26.rs

@@ -1,5 +1,23 @@
 __________________________________________________________________________________________________
+//runtime: 0ms, memory: 2.2MB
 
+impl Solution {
+    pub fn remove_duplicates(nums: &mut Vec<i32>) -> i32 {
+        if nums.len() == 0 {
+            return 0;
+        }
+        let mut i = 0;
+        for j in 0..nums.len() {
+            if nums[i] != nums[j] {
+                if j - i > 1 {
+                    nums[i + 1] = nums[j];
+                }
+                i += 1;
+            }
+        }
+        (i + 1) as i32
+    }
+}
 __________________________________________________________________________________________________
 
 __________________________________________________________________________________________________

Rust/283.rs

@@ -1,5 +1,20 @@
 __________________________________________________________________________________________________
+//runtime: 4ms, memory: 2.2MB
 
+impl Solution {
+    pub fn move_zeroes(nums: &mut Vec<i32>) {
+        let mut i = 0;
+        for j in 0..nums.len() {
+            if nums[j] != 0 {
+                nums[i] = nums[j];
+                i += 1;
+            }
+        }
+        for k in i..nums.len() {
+            nums[k] = 0;
+        }
+    }
+}
 __________________________________________________________________________________________________
 
 __________________________________________________________________________________________________

Rust/51.rs

@@ -1,5 +1,49 @@
 __________________________________________________________________________________________________
+//runtime: 4ms, memory: 2.2MB
 
+impl Solution {
+    pub fn solve_n_queens(n: i32) -> Vec<Vec<String>> {
+        let mut board = vec![vec!['.'; n as usize]; n as usize];
+        let mut solution = vec![];
+        backtrack(&mut board, &mut solution, n, 0);
+        solution
+    }
+}
+
+fn backtrack(board: &mut Vec<Vec<char>>, solution: &mut Vec<Vec<String>>, n:i32, row: i32) {
+    for column in 0..n {
+        if !collision(&board, n, row, column) {
+            board[row as usize][column as usize] = 'Q';
+            if row == n - 1 {
+                solution.push(board.iter().map(|vec| vec.iter().collect()).collect());
+            } else {
+                backtrack(board, solution, n, row + 1);
+            }
+            board[row as usize][column as usize] = '.';
+        }
+    }
+}
+
+fn collision(board: &Vec<Vec<char>>, n: i32, row: i32, column: i32) ->bool {
+    let mut up_row = row - 1;
+    let mut left_column = column - 1;
+    let mut right_column = column + 1;
+    while up_row >= 0 {
+        if board[up_row as usize][column as usize] == 'Q' {
+            return true;
+        }
+        if left_column >= 0 && board[up_row as usize][left_column as usize] == 'Q' {
+            return true;
+        }
+        if right_column < n && board[up_row as usize][right_column as usize] == 'Q' {
+            return true;
+        }
+        up_row -= 1;
+        left_column -= 1;
+        right_column += 1;
+    }
+    false
+}
 __________________________________________________________________________________________________
 
 __________________________________________________________________________________________________

Rust/66.rs

@@ -1,5 +1,26 @@
 __________________________________________________________________________________________________
+//runtime: 0ms, memory: 2.1MB
 
+impl Solution {
+    pub fn plus_one(mut digits: Vec<i32>) -> Vec<i32> {
+        let mut i = digits.len() - 1;
+        loop {
+            if digits[i] < 9 {
+                digits[i] += 1;
+                return digits;
+            }
+            digits[i] = 0;
+            if i > 0 {
+                i -= 1;
+            } else if i == 0 {
+                break;
+            }
+        }
+        digits = vec![0; digits.len() + 1];
+        digits[0] = 1;
+        return digits;
+    }
+}
 __________________________________________________________________________________________________
 
 __________________________________________________________________________________________________

Rust/7.rs

@@ -1,5 +1,23 @@
 __________________________________________________________________________________________________
+//runtime: 0ms, memory: 2.1MB
 
+impl Solution {
+    pub fn reverse(x: i32) -> i32 {
+        let mut temp = x;
+        let mut s: i32 = 0;
+        while temp != 0 {
+            match s.checked_mul(10) {
+                None => return 0,
+                Some(tem) => match tem.checked_add(temp % 10) {
+                    None => return 0,
+                    Some(tem1) => s = tem1,
+                }
+            }
+            temp /= 10;
+        }
+        s
+    }
+}
 __________________________________________________________________________________________________
 
 __________________________________________________________________________________________________

Rust/9.rs

@@ -1,5 +1,24 @@
 __________________________________________________________________________________________________
+//runtime: 4ms, memory: 2.1MB
 
+impl Solution {
+    pub fn is_palindrome(x: i32) -> bool {
+        if x < 0 {
+            return false;
+        }
+        let mut temp = x;
+        let mut s = 0;
+        while temp != 0 {
+            s = s * 10 + temp % 10;
+            temp /= 10;
+        }
+        if s == x {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
 __________________________________________________________________________________________________
 
 __________________________________________________________________________________________________