diff --git a/.gitignore b/.gitignore
index 4460fb5..175b063 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,4 @@
 *.rb
 *
 !*.rs
+!commit.sh
diff --git a/1006-clumsy-factorial.rs b/1006-clumsy-factorial.rs
new file mode 100644
index 0000000..714296b
--- /dev/null
+++ b/1006-clumsy-factorial.rs
@@ -0,0 +1,23 @@
+pub fn clumsy(n: i32) -> i32 {
+    if n == 1 { return 1 }
+    if n == 2 { return 2 }
+    let mut ret = n * (n-1) / (n-2) + n-3;
+    let mut tmp = 0;
+    for (i, num) in (1..=n-4).rev().enumerate() {
+        match i % 4 {
+            0 => { tmp = num },
+            1 => { tmp *= num },
+            2 => {
+                ret -= (tmp as f64 / num as f64).floor() as i32;
+                tmp = 0
+            },
+            3 => { ret += num },
+            _ => { },
+        }
+    }
+    ret - tmp
+}
+
+fn main() {
+    println!("{:?}", clumsy(2));
+}
diff --git a/1029-two-city-scheduling.rs b/1029-two-city-scheduling.rs
new file mode 100644
index 0000000..e03ad61
--- /dev/null
+++ b/1029-two-city-scheduling.rs
@@ -0,0 +1,11 @@
+pub fn two_city_sched_cost(costs: Vec<Vec<i32>>) -> i32 {
+    let n = costs.len();
+    let mut sorted_costs = costs.clone();
+    sorted_costs.sort_by(|a, b|(a[0]-a[1]).cmp(&(b[0]-b[1])));
+    &sorted_costs[0..n/2].iter().map(|e|e[0]).sum::<i32>() + &sorted_costs[n/2..].iter().map(|e|e[1]).sum::<i32>()
+}
+
+fn main() {
+    let costs = vec![[10,20],[30,200],[400,50],[30,20]].iter().map(|e|e.to_vec()).collect();
+    println!("{:?}", two_city_sched_cost(costs));
+}
diff --git a/1103-distribute-candies-to-people.rs b/1103-distribute-candies-to-people.rs
new file mode 100644
index 0000000..c42862c
--- /dev/null
+++ b/1103-distribute-candies-to-people.rs
@@ -0,0 +1,22 @@
+pub fn distribute_candies(candies: i32, num_people: i32) -> Vec<i32> {
+    let mut ret = vec![0; num_people as usize];
+    let mut candies = candies;
+    let mut tmp = 1;
+    while candies > 0 {
+        for i in 0..ret.len() {
+            if candies >= tmp {
+                ret[i] += tmp;
+                candies -= tmp;
+            } else {
+                ret[i] += candies;
+                candies = 0;
+            }
+            tmp += 1;
+        }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", distribute_candies(7, 4));
+}
diff --git a/1170-compare-strings-by-frequency-of-the-smallest-character.rs b/1170-compare-strings-by-frequency-of-the-smallest-character.rs
new file mode 100644
index 0000000..6ebc47d
--- /dev/null
+++ b/1170-compare-strings-by-frequency-of-the-smallest-character.rs
@@ -0,0 +1,27 @@
+pub fn num_smaller_by_frequency(queries: Vec<String>, words: Vec<String>) -> Vec<i32> {
+    pub fn string_to_value(s: String) -> i32 {
+        let mut cs = s.chars().collect::<Vec<char>>();
+        let min = cs.clone().into_iter().min().unwrap();
+        cs.retain(|c|*c == min);
+        cs.len() as i32
+    }
+    let mut ret = vec![];
+    for q in queries {
+        let q_value = string_to_value(q);
+        let mut tmp = 0;
+        for w in &words {
+            if string_to_value(w.clone()) > q_value { tmp += 1 }
+        }
+        ret.push(tmp)
+    }
+    ret
+}
+
+fn main() {
+    let queries = vec!["cbd".to_string()];
+    let words = vec!["zaaaz".to_string()];
+    println!("{:?}", num_smaller_by_frequency(queries, words));
+    let queries = vec!["bbb".to_string(),"cc".to_string()];
+    let words = vec!["a".to_string(),"aa".to_string(),"aaa".to_string(),"aaaa".to_string()];
+    println!("{:?}", num_smaller_by_frequency(queries, words));
+}
diff --git a/1184-distance-between-bus-stops.rs b/1184-distance-between-bus-stops.rs
new file mode 100644
index 0000000..e7b718d
--- /dev/null
+++ b/1184-distance-between-bus-stops.rs
@@ -0,0 +1,19 @@
+pub fn distance_between_bus_stops(distance: Vec<i32>, start: i32, destination: i32) -> i32 {
+    let left = vec![start, destination].into_iter().min().unwrap();
+    let right = vec![start, destination].into_iter().max().unwrap();
+    vec![distance[left as usize..right as usize].iter().sum::<i32>(),
+        distance[0..left as usize].iter().sum::<i32>() +
+        distance[right as usize..].iter().sum::<i32>()
+    ].into_iter().min().unwrap()
+}
+
+fn main() {
+    let distance = vec![1, 2, 3, 4];
+    let start = 0;
+    let destination = 1;
+    println!("{:?}", distance_between_bus_stops(distance, start, destination));
+    let distance = vec![7,10,1,12,11,14,5,0];
+    let start = 7;
+    let destination = 2;
+    println!("{:?}", distance_between_bus_stops(distance, start, destination));
+}
diff --git a/119-pascals-triangle-ii.rs b/119-pascals-triangle-ii.rs
new file mode 100644
index 0000000..be24dac
--- /dev/null
+++ b/119-pascals-triangle-ii.rs
@@ -0,0 +1,20 @@
+pub fn get_row(row_index: i32) -> Vec<i32> {
+    let mut ret = vec![vec![1], vec![1, 1]];
+    for i in 2..=row_index as usize {
+        let mut tmp = vec![];
+        for j in 1..ret[i-1].len() {
+            tmp.push(ret[i-1][j] + ret[i-1][j-1])
+        }
+        tmp.push(1);
+        tmp.insert(0, 1);
+        ret.push(tmp);
+    }
+    ret[row_index as usize].clone()
+}
+
+fn main() {
+    println!("{:?}", get_row(0));
+    println!("{:?}", get_row(1));
+    println!("{:?}", get_row(2));
+    println!("{:?}", get_row(3));
+}
diff --git a/122-best-time-to-buy-and-sell-stock-ii.rs b/122-best-time-to-buy-and-sell-stock-ii.rs
new file mode 100644
index 0000000..9f80953
--- /dev/null
+++ b/122-best-time-to-buy-and-sell-stock-ii.rs
@@ -0,0 +1,14 @@
+// 算法可以直接简化为只要今天比昨天大，就卖出，同时也可以买进（但不知道明天是否会涨呢？）。
+// 上帝视角： 扫描一遍 只要后一天比前一天大 就把这两天的差值加一下
+
+pub fn max_profit(prices: Vec<i32>) -> i32 {
+    let mut ret = 0;
+    for i in 0 .. prices.len() - 1 {
+        if prices[i+1] > prices[i] { ret += prices[i+1] - prices[i] }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", max_profit(vec![7,1,5,3,6,4]));
+}
diff --git a/1260-shift-2d-grid.rs b/1260-shift-2d-grid.rs
new file mode 100644
index 0000000..dd9261a
--- /dev/null
+++ b/1260-shift-2d-grid.rs
@@ -0,0 +1,16 @@
+pub fn shift_grid(grid: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
+    let grid_len = grid[0].len();
+    let mut a = grid.into_iter().flatten().collect::<Vec<i32>>();
+    let a_len = a.len();
+    a.rotate_right(k as usize % a_len);
+    a.chunks(grid_len).into_iter().map(|e|e.to_vec()).collect()
+}
+
+fn main() {
+    let grid = vec![vec![3,8,1,9],vec![19,7,2,5],vec![4,6,11,10],vec![12,0,21,13]];
+    let k = 4;
+    println!("{:?}", shift_grid(grid, k));
+    let grid = vec![vec![1]];
+    let k = 100;
+    println!("{:?}", shift_grid(grid, k));
+}
diff --git a/1338-reduce-array-size-to-the-half.rs b/1338-reduce-array-size-to-the-half.rs
new file mode 100644
index 0000000..21c5e6e
--- /dev/null
+++ b/1338-reduce-array-size-to-the-half.rs
@@ -0,0 +1,24 @@
+pub fn min_set_size(arr: Vec<i32>) -> i32 {
+    let arr_len = arr.len();
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    for e in arr {
+        mmp.entry(e).and_modify(|e|*e+=1).or_insert(1);
+    }
+    let mut mmp_vec: Vec<_> = mmp.iter().collect();
+    mmp_vec.sort_by(|b, a|a.1.cmp(&b.1));
+    let mut tmp = 0;
+    let mut ret = 0;
+    for p in mmp_vec {
+        tmp += p.1;
+        ret += 1;
+        if tmp >= arr_len / 2 { break }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", min_set_size(vec![3, 3, 3, 3, 5, 5, 5, 2, 2, 7]));
+    println!("{:?}", min_set_size(vec![7, 7, 7, 7, 7, 7]));
+    println!("{:?}", min_set_size(vec![1, 9]));
+}
diff --git a/1381-design-a-stack-with-increment-operation.rs b/1381-design-a-stack-with-increment-operation.rs
new file mode 100644
index 0000000..480f075
--- /dev/null
+++ b/1381-design-a-stack-with-increment-operation.rs
@@ -0,0 +1,45 @@
+struct CustomStack {
+    mmp: Vec<i32>,
+    max_size: i32,
+}
+
+impl CustomStack {
+
+    fn new(max_size: i32) -> Self {
+        CustomStack {
+            mmp: vec![],
+            max_size: max_size,
+        }
+    }
+
+    fn push(&mut self, x: i32) {
+        if self.mmp.len() < self.max_size as usize { self.mmp.push(x) }
+    }
+
+    fn pop(&mut self) -> i32 {
+        let len = self.mmp.len();
+        if len == 0 { return -1 }
+        self.mmp.remove(len - 1)
+    }
+
+    fn increment(&mut self, k: i32, val: i32) {
+        let index = vec![k as usize, self.mmp.len()].into_iter().min().unwrap();
+        for i in 0..index { self.mmp[i] += val }
+    }
+}
+
+fn main() {
+    let mut cus_stack = CustomStack::new(3);
+    cus_stack.push(1);
+    cus_stack.push(2);
+    cus_stack.pop();
+    cus_stack.push(2);
+    cus_stack.push(3);
+    cus_stack.push(4);
+    cus_stack.increment(5, 100);
+    cus_stack.increment(2, 100);
+    cus_stack.pop();
+    cus_stack.pop();
+    cus_stack.pop();
+    cus_stack.pop();
+}
diff --git a/1472-design-browser-history.rs b/1472-design-browser-history.rs
new file mode 100644
index 0000000..9d2f44d
--- /dev/null
+++ b/1472-design-browser-history.rs
@@ -0,0 +1,56 @@
+struct BrowserHistory {
+    his: Vec::<String>,
+    idx: usize,
+}
+
+impl BrowserHistory {
+
+    fn new(homepage: String) -> Self {
+        BrowserHistory {
+            his: vec![homepage.clone()],
+            idx: 0
+        }
+    }
+
+    fn visit(&mut self, url: String) {
+        self.his.truncate(self.idx + 1);
+        self.his.push(url.clone());
+        self.idx += 1;
+    }
+
+    fn back(&mut self, steps: i32) -> String {
+        let steps = steps as usize;
+        if self.idx < steps {
+            self.idx = 0;
+        } else {
+            self.idx -= steps;
+        }
+        // println!("{:?} {:?}", self.his, self.idx);
+        self.his[self.idx].clone()
+    }
+
+    fn forward(&mut self, steps: i32) -> String {
+        let steps = steps as usize;
+        if self.idx + steps < self.his.len() {
+            self.idx += steps;
+        } else {
+            self.idx = self.his.len() - 1;
+        }
+        // println!("{:?} {:?}", self.his, self.idx);
+        self.his[self.idx].clone()
+    }
+}
+
+fn main() {
+    let mut obj = BrowserHistory::new("leetcode.com".to_string());
+    obj.visit("google.com".to_string());
+    obj.visit("facebook.com".to_string());
+    obj.visit("youtube.com".to_string());
+    println!("{:?}", obj.back(1));
+    println!("{:?}", obj.back(1));
+    println!("{:?}", obj.forward(1));
+    obj.visit("linkedin.com".to_string());
+    println!("{:?}", obj.forward(2)); // linkedin
+    println!("{:?}", obj.back(2));
+    println!("{:?}", obj.back(7));
+}
diff --git a/1475-final-prices-with-a-special-discount-in-a-shop.rs b/1475-final-prices-with-a-special-discount-in-a-shop.rs
new file mode 100644
index 0000000..de56209
--- /dev/null
+++ b/1475-final-prices-with-a-special-discount-in-a-shop.rs
@@ -0,0 +1,19 @@
+pub fn final_prices(prices: Vec<i32>) -> Vec<i32> {
+    let mut ret = vec![];
+    'outer: for (i, n) in prices[0..prices.len()].iter().enumerate() {
+        for j in (i+1)..prices.len() {
+            if prices[j] <= *n {
+                ret.push(n - prices[j]);
+                continue 'outer;
+            }
+        }
+        ret.push(*n);
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", final_prices(vec![8,4,6,2,3]));
+    println!("{:?}", final_prices(vec![1,2,3,4,5]));
+    println!("{:?}", final_prices(vec![10,1,1,6]));
+}
diff --git a/1518-water-bottles.rs b/1518-water-bottles.rs
new file mode 100644
index 0000000..7424a55
--- /dev/null
+++ b/1518-water-bottles.rs
@@ -0,0 +1,21 @@
+pub fn num_water_bottles(num_bottles: i32, num_exchange: i32) -> i32 {
+    let mut current_nil_bottles = 0;
+    let mut num_bottles = num_bottles;
+    let mut ret = 0;
+    loop {
+        ret += num_bottles;
+        current_nil_bottles += num_bottles;
+        num_bottles = 0;
+        let tmp = current_nil_bottles / num_exchange;
+        if tmp > 0 {
+            num_bottles += tmp;
+            current_nil_bottles -= tmp * num_exchange;
+        }
+        if num_bottles == 0 && tmp == 0 { break }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", num_water_bottles(15, 4));
+}
diff --git a/1523-count-odd-numbers-in-an-interval-range.rs b/1523-count-odd-numbers-in-an-interval-range.rs
new file mode 100644
index 0000000..a66d398
--- /dev/null
+++ b/1523-count-odd-numbers-in-an-interval-range.rs
@@ -0,0 +1,15 @@
+impl Solution {
+    pub fn count_odds(low: i32, high: i32) -> i32 {
+        let mut ret = 0;
+
+        if low % 2 == 1 { ret += 1 }
+        if high % 2 == 1 { ret += 1 }
+
+        if ret == 2 {
+            ret += (high - low)/2 - 1
+        } else {
+            ret += (high - low)/2
+        }
+        ret
+    }
+}
diff --git a/1529-minimum-suffix-flips.rs b/1529-minimum-suffix-flips.rs
new file mode 100644
index 0000000..1981df8
--- /dev/null
+++ b/1529-minimum-suffix-flips.rs
@@ -0,0 +1,17 @@
+// 数学归纳法：每次遇到不同数位，结果+1
+// 如果target从0开始，结果初始为0，从1，结果初始为1
+
+pub fn min_flips(target: String) -> i32 {
+    let mut prev = target.chars().nth(0).unwrap();
+    let mut ret = prev as i32 - '0' as i32;
+    for c in target.chars().collect::<Vec<char>>() {
+        if c != prev { ret += 1 }
+        prev = c;
+    }
+    ret
+}
+
+fn main() {
+    let target = "10111".to_string();
+    println!("{:?}", min_flips(target));
+}
diff --git a/1544-make-the-string-great.rs b/1544-make-the-string-great.rs
new file mode 100644
index 0000000..15a9ea0
--- /dev/null
+++ b/1544-make-the-string-great.rs
@@ -0,0 +1,30 @@
+pub fn make_good(s: String) -> String {
+    if s.len() == 1 { return s }
+    let mut s = s.clone();
+    'outer: loop {
+        if s.len() == 1 { return s }
+        for i in 0..s.len() - 2 {
+            if (s.chars().nth(i).unwrap() as i32 - s.chars().nth(i+1).unwrap() as i32).abs() == 32 {
+                s.remove(i);
+                s.remove(i);
+                continue 'outer;
+            }
+        }
+        break;
+    }
+    if (s.chars().nth(s.len()-1).unwrap() as i32 - s.chars().nth(s.len()-2).unwrap() as i32).abs() == 32 {
+        s.remove(s.len()-1);
+        s.remove(s.len()-1);
+    }
+    s
+}
+
+fn main() {
+    println!("{:?}", make_good("leEeetcode".to_string()));
+    println!("{:?}", make_good("abBAcC".to_string()));
+    println!("{:?}", make_good("A".to_string()));
+    println!("{:?}", make_good("Aa".to_string()));
+    println!("{:?}", make_good("asLwGWlSAQq".to_string()));
+    println!("{:?}", make_good("XxDFOBKRrkbofdXxeEijJIcCsBikPgfxXFGpKIbSemGivrqqQQRVIgMEPBWpPwbpSCWqWQqwQwcsQqasLwGWlSAQq".to_string()));
+    // println!("{:?}", ('b' as i32 -'B' as i32).abs()); // 32
+}
diff --git a/1603-design-parking-system.rs b/1603-design-parking-system.rs
new file mode 100644
index 0000000..b039a85
--- /dev/null
+++ b/1603-design-parking-system.rs
@@ -0,0 +1,31 @@
+struct ParkingSystem {
+    current: Vec<i32>,
+    max: Vec<i32>
+}
+
+impl ParkingSystem {
+    fn new(big: i32, medium: i32, small: i32) -> Self {
+        ParkingSystem {
+            max: vec!(big, medium, small),
+            current: vec![0; 3]
+        }
+    }
+
+    fn add_car(&mut self, car_type: i32) -> bool {
+        let car_type = car_type as usize - 1;
+        if self.current.get(car_type).unwrap() + 1 > *self.max.get(car_type).unwrap() {
+            false
+        } else {
+            *self.current.get_mut(car_type).unwrap() += 1;
+            true
+        }
+    }
+}
+
+fn main() {
+    let mut obj = ParkingSystem::new(1, 1, 0);
+    println!("{:?}", obj.add_car(1));
+    println!("{:?}", obj.add_car(2));
+    println!("{:?}", obj.add_car(3));
+    println!("{:?}", obj.add_car(1));
+}
diff --git a/1652-defuse-the-bomb.rs b/1652-defuse-the-bomb.rs
new file mode 100644
index 0000000..43d6c4f
--- /dev/null
+++ b/1652-defuse-the-bomb.rs
@@ -0,0 +1,31 @@
+pub fn decrypt(code: Vec<i32>, k: i32) -> Vec<i32> {
+    if k == 0 { return vec![0; code.len()] }
+    let mut ret = vec![];
+    for i in 0..code.len() {
+        if k > 0 {
+            let tail = i + k as usize;
+            if tail <= code.len() - 1 {
+                ret.push(code[i+1..=tail].into_iter().sum::<i32>());
+            } else {
+                let tmp: i32 = &code[i+1..].into_iter().sum::<i32>() +
+                        &code[0..tail-code.len()+1].into_iter().sum::<i32>();
+                ret.push(tmp);
+            }
+        } else {
+            let head = i as i32 + k; // i =1 k = -2
+            if head >= 0 {
+                ret.push(code[head as usize..i].into_iter().sum::<i32>());
+            } else {
+                let tmp: i32 = &code[0..i].into_iter().sum::<i32>() +
+                        &code[(head + code.len() as i32) as usize..].into_iter().sum::<i32>();
+                ret.push(tmp);
+            }
+        }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", decrypt(vec![5, 7, 1, 4], 3));
+    println!("{:?}", decrypt(vec![2, 4, 9, 3], -2));
+}
diff --git a/1701-average-waiting-time.rs b/1701-average-waiting-time.rs
new file mode 100644
index 0000000..b65c859
--- /dev/null
+++ b/1701-average-waiting-time.rs
@@ -0,0 +1,19 @@
+pub fn average_waiting_time(customers: Vec<Vec<i32>>) -> f64 {
+    let mut time = 0f64;
+    let mut sum = 0f64;
+    for customer in &customers {
+        if customer[0] as f64 >= time {
+            sum += customer[1] as f64;
+            time = (customer[0] + customer[1]) as f64;
+        } else {
+            sum += time + (customer[1] - customer[0]) as f64;
+            time += customer[1] as f64;
+        }
+    }
+    sum as f64 / customers.len() as f64
+}
+
+fn main() {
+    println!("{:?}", average_waiting_time(vec![vec![1,2], vec![2,5], vec![4,3]]));
+    println!("{:?}", average_waiting_time(vec![vec![5,2], vec![5,4], vec![10,3], vec![20,1]]));
+}
diff --git a/1742-maximum-number-of-balls-in-a-box.rs b/1742-maximum-number-of-balls-in-a-box.rs
new file mode 100644
index 0000000..82abd77
--- /dev/null
+++ b/1742-maximum-number-of-balls-in-a-box.rs
@@ -0,0 +1,15 @@
+pub fn count_balls(low_limit: i32, high_limit: i32) -> i32 {
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    for i in low_limit ..= high_limit {
+        let a = i.to_string().chars().map(|e|e.to_string().parse::<i32>().unwrap()).sum::<i32>();
+        mmp.entry(a).and_modify(|e|*e += 1).or_insert(1);
+    }
+    mmp.into_values().into_iter().max().unwrap()
+}
+
+fn main() {
+    println!("{:?}", count_balls(1, 10));
+    println!("{:?}", count_balls(5, 15));
+    println!("{:?}", count_balls(19, 28));
+}
diff --git a/1784-check-if-binary-string-has-at-most-one-segment-of-ones.rs b/1784-check-if-binary-string-has-at-most-one-segment-of-ones.rs
new file mode 100644
index 0000000..67ed821
--- /dev/null
+++ b/1784-check-if-binary-string-has-at-most-one-segment-of-ones.rs
@@ -0,0 +1,18 @@
+pub fn check_ones_segment(s: String) -> bool {
+    if s == "1".to_string() { return true }
+    let cs = s.chars().collect::<Vec<char>>();
+    let mut prev_char = '1';
+    let mut change_times = 0;
+    for c in &cs[1..] {
+        if *c != prev_char { change_times += 1 }
+        prev_char = *c;
+    }
+    change_times <= 1
+}
+
+fn main() {
+    println!("{:?}", check_ones_segment("1001".to_string())); // false
+    println!("{:?}", check_ones_segment("110".to_string())); // true
+    println!("{:?}", check_ones_segment("1".to_string())); // true
+    println!("{:?}", check_ones_segment("10".to_string())); // true
+}
diff --git a/1807-evaluate-the-bracket-pairs-of-a-string.rs b/1807-evaluate-the-bracket-pairs-of-a-string.rs
new file mode 100644
index 0000000..f570709
--- /dev/null
+++ b/1807-evaluate-the-bracket-pairs-of-a-string.rs
@@ -0,0 +1,47 @@
+pub fn evaluate(s: String, knowledge: Vec<Vec<String>>) -> String {
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    for pair in knowledge {
+        mmp.insert(pair[0].clone(), pair[1].clone());
+    }
+    // println!("{:?}", mmp);
+    let mut ret = String::new();
+    let mut current_word = String::new();
+    let mut start = false;
+    for c in s.chars() {
+        if c == '('  {
+            start = true;
+            continue
+        }
+        if c == ')'  {
+            start = false;
+            let get = mmp.get(&current_word);
+            if get == None {
+                ret.push('?')
+            } else {
+                ret.push_str(get.unwrap())
+            }
+            current_word = String::new();
+            continue
+        }
+        if start {
+            current_word.push(c)
+        } else {
+            ret.push(c)
+        }
+    }
+    ret
+}
+
+fn main() {
+    println!(
+        "{:?}", 
+        evaluate(
+            "(name)is(age)yearsold(asd)".to_string(), 
+            vec![
+                vec!["name".to_string(), "bob".to_string()],
+                vec!["age".to_string(), "two".to_string()]
+            ]
+        )
+    );
+}
diff --git a/1829-maximum-xor-for-each-query.rs b/1829-maximum-xor-for-each-query.rs
new file mode 100644
index 0000000..e3b1f70
--- /dev/null
+++ b/1829-maximum-xor-for-each-query.rs
@@ -0,0 +1,18 @@
+pub fn get_maximum_xor(nums: Vec<i32>, maximum_bit: i32) -> Vec<i32> {
+    let max = 2_i32.pow(maximum_bit as u32) - 1;
+    let mut ret = vec![];
+    for i in 0..nums.len() {
+        let mut tmp = max;
+        for num in &nums[0..nums.len() - i] {
+            tmp ^= *num;
+        }
+        ret.push(tmp);
+    }
+    ret
+}
+
+fn main() {
+    let nums = vec![2,3,4,7];
+    let maximum_bit = 3;
+    println!("{:?}", get_maximum_xor(nums, maximum_bit));
+}
diff --git a/1887-reduction-operations-to-make-the-array-elements-equal.rs b/1887-reduction-operations-to-make-the-array-elements-equal.rs
new file mode 100644
index 0000000..72ff12f
--- /dev/null
+++ b/1887-reduction-operations-to-make-the-array-elements-equal.rs
@@ -0,0 +1,21 @@
+pub fn reduction_operations(nums: Vec<i32>) -> i32 {
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    for num in nums {
+        mmp.entry(num).and_modify(|e|*e += 1).or_insert(1);
+    }
+    let mut mmp_vec: Vec<_> = mmp.iter().collect();
+    mmp_vec.sort_by(|a, b|a.0.cmp(&b.0));
+    // println!("{:?}", mmp_vec);
+    let mut ret = 0;
+    for (i, r) in mmp_vec.iter().enumerate() {
+        ret += i * r.1
+    }
+    ret as i32
+}
+
+fn main() {
+    println!("{:?}", reduction_operations(vec![5,1,3]));
+    println!("{:?}", reduction_operations(vec![1,1,1]));
+    println!("{:?}", reduction_operations(vec![1,1,2,2,3]));
+}
diff --git a/1910-remove-all-occurrences-of-a-substring.rs b/1910-remove-all-occurrences-of-a-substring.rs
new file mode 100644
index 0000000..d6b39f7
--- /dev/null
+++ b/1910-remove-all-occurrences-of-a-substring.rs
@@ -0,0 +1,21 @@
+// Rust str API: split_once
+
+pub fn remove_occurrences(s: String, part: String) -> String {
+    let mut ret = s;
+    loop {
+        let parts = ret.split_once(&part);
+        if parts == None {
+            break
+        } else {
+            let uwparts = parts.unwrap();
+            ret = vec![uwparts.0, uwparts.1].join("");
+        }
+    }
+    ret
+}
+
+fn main() {
+    let s = "aabababa".to_string();
+    let part = "aba".to_string();
+    println!("{:?}", remove_occurrences(s, part));
+}
diff --git a/1980-find-unique-binary-string.rs b/1980-find-unique-binary-string.rs
new file mode 100644
index 0000000..a01b144
--- /dev/null
+++ b/1980-find-unique-binary-string.rs
@@ -0,0 +1,29 @@
+pub fn find_different_binary_string(nums: Vec<String>) -> String {
+    let n = nums[0].len();
+    let mut arr = (0..=2_i32.pow(n as u32)).map(|e|e as i32).collect::<Vec<i32>>();
+    for num in nums {
+        let intval = isize::from_str_radix(&num, 2).unwrap();
+        arr[intval as usize] = -1;
+    }
+    let mut ret = -1;
+    for i in arr {
+        if i != -1 {
+            ret = i;
+            break
+        }
+    }
+    let ret = format!("{:b}", ret);
+    let mut prefix = String::new();
+    if ret.len() < n {
+        for _ in 0 .. (n - ret.len()) {
+            prefix.push('0')
+        }
+    }
+    [prefix, ret].concat()
+}
+
+fn main() {
+    println!("{:?}", find_different_binary_string(vec!["01".to_string(),"10".to_string()]));
+    println!("{:?}", find_different_binary_string(vec!["00".to_string(),"01".to_string()]));
+    println!("{:?}", find_different_binary_string(vec!["111".to_string(),"011".to_string(),"001".to_string()]));
+}
diff --git a/2043-simple-bank-system.rs b/2043-simple-bank-system.rs
new file mode 100644
index 0000000..5fa2880
--- /dev/null
+++ b/2043-simple-bank-system.rs
@@ -0,0 +1,58 @@
+struct Bank {
+    balance: Vec<i64>
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+
+impl Bank {
+    fn new(balance: Vec<i64>) -> Self {
+        Bank {
+            balance: balance
+        }
+    }
+
+    fn transfer(&mut self, account1: i32, account2: i32, money: i64) -> bool {
+        if self.balance.get(account1 as usize - 1) == None {
+            return false;
+        }
+        if self.balance[account1 as usize - 1] < money {
+            return false;
+        }
+        if self.balance.get(account2 as usize - 1) == None {
+            return false;
+        }
+        self.balance[account1 as usize - 1] -= money;
+        self.balance[account2 as usize - 1] += money;
+        true
+    }
+
+    fn deposit(&mut self, account: i32, money: i64) -> bool {
+        if self.balance.get(account as usize - 1) == None {
+            return false;
+        }
+        self.balance[account as usize - 1] += money;
+        true
+    }
+
+    fn withdraw(&mut self, account: i32, money: i64) -> bool {
+        if self.balance.get(account as usize - 1) == None {
+            return false;
+        }
+        if self.balance[account as usize - 1] < money {
+            return false;
+        }
+        self.balance[account as usize - 1] -= money;
+        true
+    }
+}
+
+fn main() {
+    let mut bank = Bank::new(vec![10, 100, 20, 50, 30]);
+    bank.transfer(1, 2, 10);
+    bank.deposit(1, 30);
+    bank.withdraw(1, 10);
+    println!("{:?}", bank.balance.get(0));
+}
diff --git a/2073-time-needed-to-buy-tickets.rs b/2073-time-needed-to-buy-tickets.rs
new file mode 100644
index 0000000..5c944b7
--- /dev/null
+++ b/2073-time-needed-to-buy-tickets.rs
@@ -0,0 +1,21 @@
+pub fn time_required_to_buy(tickets: Vec<i32>, k: i32) -> i32 {
+    let mut tickets = tickets;
+    let mut ret = 0;
+    while tickets[k as usize] != 0 {
+        for i in 0..tickets.len() {
+            if tickets[i] != 0 {
+                tickets[i] -= 1;
+                ret += 1;
+            }
+            if tickets[k as usize] == 0 {
+                return ret
+            }
+        }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", time_required_to_buy(vec![2,3,2], 2));
+    println!("{:?}", time_required_to_buy(vec![84,49,5,24,70,77,87,8], 3));
+}
diff --git a/2109-adding-spaces-to-a-string.rs b/2109-adding-spaces-to-a-string.rs
new file mode 100644
index 0000000..ae60676
--- /dev/null
+++ b/2109-adding-spaces-to-a-string.rs
@@ -0,0 +1,16 @@
+pub fn add_spaces(s: String, spaces: Vec<i32>) -> String {
+    let mut s = s;
+    let mut z = 0;
+    for space in spaces {
+        let idx = space + z;
+        s.insert(idx as usize, ' ');
+        z += 1;
+    }
+    s
+}
+
+fn main() {
+    let s = "LeetcodeHelpsMeLearn".to_string();
+    let spaces = vec![8,13,15];
+    println!("{:?}", add_spaces(s, spaces));
+}
diff --git a/2144-minimum-cost-of-buying-candies-with-discount.rs b/2144-minimum-cost-of-buying-candies-with-discount.rs
new file mode 100644
index 0000000..d4a66cd
--- /dev/null
+++ b/2144-minimum-cost-of-buying-candies-with-discount.rs
@@ -0,0 +1,15 @@
+pub fn minimum_cost(cost: Vec<i32>) -> i32 {
+    let mut sorted = cost.clone();
+    sorted.sort_by(|a, b|b.cmp(&a));
+    let mut ret = 0;
+    for (i, e) in sorted.iter().enumerate() {
+        if i % 3 == 2 { continue }
+        ret += e;
+    }
+    ret
+}
+
+fn main() {
+    let cost = vec![6, 5, 7, 9, 2, 2];
+    println!("{:?}", minimum_cost(cost));
+}
diff --git a/2278-percentage-of-letter-in-string.rs b/2278-percentage-of-letter-in-string.rs
new file mode 100644
index 0000000..9888182
--- /dev/null
+++ b/2278-percentage-of-letter-in-string.rs
@@ -0,0 +1,13 @@
+pub fn percentage_letter(s: String, letter: char) -> i32 {
+    let mut counter = 0;
+    for c in s.chars().collect::<Vec<char>>() {
+        if c == letter {
+            counter += 1
+        }
+    }
+    (100.0 * counter as f64 / s.len() as f64) as i32
+}
+
+fn main() {
+    println!("{:?}", percentage_letter("foobar".to_string(), 'o'));
+}
diff --git a/2294-partition-array-such-that-maximum-difference-is-k.rs b/2294-partition-array-such-that-maximum-difference-is-k.rs
new file mode 100644
index 0000000..b34059a
--- /dev/null
+++ b/2294-partition-array-such-that-maximum-difference-is-k.rs
@@ -0,0 +1,21 @@
+pub fn partition_array(nums: Vec<i32>, k: i32) -> i32 {
+    let mut sorted_nums = nums.clone();
+    sorted_nums.sort();
+    let mut ret = 1;
+    let mut tmp = vec![sorted_nums[0]];
+    for num in &sorted_nums[1..] {
+        if num - tmp[0] > k {
+            tmp = vec![*num];
+            ret += 1;
+        } else {
+            tmp.push(*num);
+        }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", partition_array(vec![3, 6, 1, 2, 5], 2));
+    println!("{:?}", partition_array(vec![1, 2, 3], 1));
+    println!("{:?}", partition_array(vec![2, 2, 4, 5], 0));
+}
diff --git a/23350-minimum-amount-of-time-to-fill-cups.rs b/23350-minimum-amount-of-time-to-fill-cups.rs
new file mode 100644
index 0000000..6e174a6
--- /dev/null
+++ b/23350-minimum-amount-of-time-to-fill-cups.rs
@@ -0,0 +1,24 @@
+pub fn fill_cups(amount: Vec<i32>) -> i32 {
+    let mut sort_am = amount.clone();
+    sort_am.sort();
+    if sort_am[2] >= sort_am[0] + sort_am[1] {
+        // return amount[0] + amount[1] + amount[2] - (amount[0] + amount[1])
+        sort_am[2]
+    } else {
+        let mut ret = sort_am[2];
+        let left = sort_am[0] + sort_am[1] - sort_am[2];
+        if left % 2 == 0 {
+            ret += left / 2
+        } else {
+            ret += left / 2 + 1
+        }
+        ret
+    }
+}
+
+fn main() {
+    println!("{:?}", fill_cups(vec![1,4,2]));
+    println!("{:?}", fill_cups(vec![5,4,4]));
+    println!("{:?}", fill_cups(vec![3,4,5]));
+    println!("{:?}", fill_cups(vec![5,0,0]));
+}
diff --git a/2341-maximum-number-of-pairs-in-array.rs b/2341-maximum-number-of-pairs-in-array.rs
new file mode 100644
index 0000000..cf1ed0b
--- /dev/null
+++ b/2341-maximum-number-of-pairs-in-array.rs
@@ -0,0 +1,19 @@
+pub fn number_of_pairs(nums: Vec<i32>) -> Vec<i32> {
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    let nums_len = nums.len();
+    for n in nums {
+        mmp.entry(n).and_modify(|e|*e += 1).or_insert(1);
+    }
+    let mut a = 0;
+    for (_, v) in mmp {
+        a += v % 2;
+    }
+    vec!((nums_len as i32 - a) / 2, a)
+}
+
+fn main() {
+    println!("{:?}", number_of_pairs(vec![1,3,2,1,3,2,2]));
+    println!("{:?}", number_of_pairs(vec![1,1]));
+    println!("{:?}", number_of_pairs(vec![0]));
+}
diff --git a/2389-longest-subsequence-with-limited-sum.rs b/2389-longest-subsequence-with-limited-sum.rs
new file mode 100644
index 0000000..ba84043
--- /dev/null
+++ b/2389-longest-subsequence-with-limited-sum.rs
@@ -0,0 +1,21 @@
+pub fn answer_queries(nums: Vec<i32>, queries: Vec<i32>) -> Vec<i32> {
+    fn cal(q: i32, sorted_nums: &[i32]) -> i32 {
+        let mut sum = 0;
+        for (i, n) in sorted_nums.iter().enumerate() {
+            sum += n;
+            if sum > q {
+                return i as i32
+            }
+        }
+        sorted_nums.len() as i32
+    }
+    let mut sorted_nums = nums.clone();
+    sorted_nums.sort();
+    queries.iter().map(|e|cal(*e, &sorted_nums)).collect()
+}
+
+fn main() {
+    let nums = vec![4,5,2,1];
+    let queries = vec![3,10,21];
+    println!("{:?}", answer_queries(nums, queries));
+}
diff --git a/2390-removing-stars-from-a-string.rs b/2390-removing-stars-from-a-string.rs
new file mode 100644
index 0000000..e0e6891
--- /dev/null
+++ b/2390-removing-stars-from-a-string.rs
@@ -0,0 +1,11 @@
+pub fn remove_stars(s: String) -> String {
+    let mut ret = String::new();
+    for c in s.chars().collect::<Vec<char>>() {
+        if c == '*' { ret.pop(); } else { ret.push(c); }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", remove_stars("leet**cod*e".to_string()));
+}
diff --git a/2452-words-within-two-edits-of-dictionary.rs b/2452-words-within-two-edits-of-dictionary.rs
new file mode 100644
index 0000000..5c62264
--- /dev/null
+++ b/2452-words-within-two-edits-of-dictionary.rs
@@ -0,0 +1,28 @@
+pub fn two_edit_words(queries: Vec<String>, dictionary: Vec<String>) -> Vec<String> {
+    let dic_chars = dictionary.iter().map(|s|s.chars().collect::<Vec<char>>())
+        .collect::<Vec<Vec<char>>>();
+    let mut queries = queries;
+    queries.retain(|s|{
+        'outer: for d_ch in &dic_chars {
+            let mut count = 0;
+            for (i, c) in s.chars().collect::<Vec<char>>().iter().enumerate() {
+                if d_ch[i] != *c { count += 1 }
+                if count > 2 { continue 'outer }
+            }
+            return true
+        }
+        return false
+    });
+    queries
+}
+
+fn main() {
+    let queries = vec!["word".to_string(), "note".to_string(),
+        "ants".to_string(), "wood".to_string()];
+    let dictionary = vec!["wood".to_string(),
+        "joke".to_string(), "moat".to_string()];
+    println!("{:?}", two_edit_words(queries, dictionary));
+    let queries = vec!["yes".to_string()];
+    let dictionary = vec!["not".to_string()];
+    println!("{:?}", two_edit_words(queries, dictionary));
+}
diff --git a/2455-average-value-of-even-numbers-that-are-divisible-by-three.rs b/2455-average-value-of-even-numbers-that-are-divisible-by-three.rs
new file mode 100644
index 0000000..8c44767
--- /dev/null
+++ b/2455-average-value-of-even-numbers-that-are-divisible-by-three.rs
@@ -0,0 +1,10 @@
+pub fn average_value(nums: Vec<i32>) -> i32 {
+    let mut nums = nums;
+    nums.retain(|num| { num % 6 == 0 });
+    (nums.iter().sum::<i32>() as f64 / nums.len() as f64).floor() as i32
+}
+
+fn main() {
+    println!("{:?}", average_value(vec![1,3,6,10,12,15]));
+    println!("{:?}", average_value(vec![1,2,4,7,10]));
+}
diff --git a/2460-apply-operations-to-an-array.rs b/2460-apply-operations-to-an-array.rs
new file mode 100644
index 0000000..609901b
--- /dev/null
+++ b/2460-apply-operations-to-an-array.rs
@@ -0,0 +1,24 @@
+pub fn apply_operations(nums: Vec<i32>) -> Vec<i32> {
+    let mut none_zero = vec![];
+    let mut zero = vec![];
+    let mut nums_clone = nums.clone();
+    for i in 0 .. nums.len() {
+        if nums_clone[i] == 0 {
+            zero.push(0);
+            continue
+        }
+        if i + 1 < nums.len() && nums[i] == nums[i + 1] {
+            nums_clone[i] *= 2;
+            nums_clone[i + 1] = 0
+        }
+        none_zero.push(nums_clone[i]);
+    }
+    [none_zero, zero].concat()
+}
+
+fn main() {
+    println!("{:?}", apply_operations(vec![1, 2, 2, 1, 1, 0]));
+    println!("{:?}", apply_operations(vec![847,847,0,0,0,399,416,416,879,879,206,206,206,272]));
+    println!("{:?}", apply_operations(vec![0, 1]));
+
+}
diff --git a/2490-circular-sentence.rs b/2490-circular-sentence.rs
new file mode 100644
index 0000000..111d293
--- /dev/null
+++ b/2490-circular-sentence.rs
@@ -0,0 +1,26 @@
+pub fn is_circular_sentence(sentence: String) -> bool {
+    if sentence.chars().nth(0).unwrap() != 
+        sentence.chars().nth(sentence.len() - 1).unwrap() {
+        return false
+    }
+    let mut count = 0;
+    let mut prev_char: char = '?';
+    for word in sentence.split_ascii_whitespace() {
+        if count == 0 {
+            prev_char = word.chars().last().unwrap()
+        } else {
+            let curr_char = word.chars().nth(0).unwrap();
+            if curr_char != prev_char { return false }
+            prev_char = word.chars().last().unwrap();
+        }
+        count += 1
+    }
+    true
+}
+
+fn main() {
+    let sentence = "leetcode exercises sound delightful".to_string();
+    println!("{:?}", is_circular_sentence(sentence));
+    let sentence = "eetcode".to_string();
+    println!("{:?}", is_circular_sentence(sentence));
+}
diff --git a/2566-maximum-difference-by-remapping-a-digit.rs b/2566-maximum-difference-by-remapping-a-digit.rs
new file mode 100644
index 0000000..cec8baf
--- /dev/null
+++ b/2566-maximum-difference-by-remapping-a-digit.rs
@@ -0,0 +1,35 @@
+pub fn min_max_difference(num: i32) -> i32 {
+    let num_str = num.to_string().chars().collect::<Vec<char>>();
+    // println!("{:?}", num_str[0]);
+    let mut idx = 0;
+    for (i, c) in num_str.iter().enumerate() {
+        if *c != '9' {
+            idx = i;
+            break
+        }
+    }
+    let mut max_str = String::new();
+    let mut min_str = String::new();
+    for c in &num_str {
+        if *c == num_str[idx] {
+            max_str.push('9');
+        } else {
+            max_str.push(*c);
+        }
+        if *c == num_str[0] {
+            min_str.push('0');
+        } else {
+            min_str.push(*c);
+        }
+    }
+    
+    let max = max_str.parse::<i32>().unwrap();
+    let min = min_str.parse::<i32>().unwrap();
+    max - min
+}
+
+fn main() {
+    println!("{:?}", min_max_difference(11891)); // 99009
+    println!("{:?}", min_max_difference(90));    // 99
+    println!("{:?}", min_max_difference(2));     // 9
+}
diff --git a/283-move-zeroes.rs b/283-move-zeroes.rs
new file mode 100644
index 0000000..40b0e30
--- /dev/null
+++ b/283-move-zeroes.rs
@@ -0,0 +1,17 @@
+// 跟紧接着不为0的数字互换
+pub fn move_zeroes(nums: &mut Vec<i32>) {
+    for i in 0..nums.len() {
+        for j in i..nums.len() {
+            if nums[i] == 0 && nums[j] != 0 { nums.swap(i, j) }
+        }
+    }
+}
+
+fn main() {
+    let mut nums = vec![1, 0, 0, 4, 3, 12];
+    move_zeroes(&mut nums);
+    println!("{:?}", nums);
+    let mut nums = vec![1, 0, 0, 0, 1];
+    move_zeroes(&mut nums);
+    println!("{:?}", nums);
+}
diff --git a/347-top-k-frequent-elements.rs b/347-top-k-frequent-elements.rs
new file mode 100644
index 0000000..4e083a7
--- /dev/null
+++ b/347-top-k-frequent-elements.rs
@@ -0,0 +1,18 @@
+pub fn top_k_frequent(nums: Vec<i32>, k: i32) -> Vec<i32> {
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    for num in nums {
+        let count = mmp.entry(num).or_insert(0);
+        *count += 1;
+    }
+    let mut mv = mmp.iter().collect::<Vec<_>>();
+    mv.sort_by(|a, b|b.1.cmp(&a.1));
+    mv[0..k as usize].into_iter().map(|e|*e.0).collect()
+}
+
+fn main() {
+    let nums = vec![1, 1, 1, 2, 2, 3];
+    let k = 2;
+    println!("{:?}", top_k_frequent(nums, k));
+    println!("{:?}", top_k_frequent(vec![4,1,-1,2,-1,2,3], 2));
+}
diff --git a/350-intersection-of-two-arrays-ii.rs b/350-intersection-of-two-arrays-ii.rs
new file mode 100644
index 0000000..13ff104
--- /dev/null
+++ b/350-intersection-of-two-arrays-ii.rs
@@ -0,0 +1,38 @@
+pub fn intersect(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
+    use std::collections::HashMap;
+    let mut mmp1 = HashMap::new();
+    let mut mmp2 = HashMap::new();
+    let mut ret = vec![];
+    for num in nums1 {
+        mmp1.entry(num).and_modify(|m|*m += 1).or_insert(1);
+    }
+    for num in nums2 {
+        mmp2.entry(num).and_modify(|m|*m += 1).or_insert(1);
+    }
+    // println!("{:?} {:?}", mmp1, mmp2);
+    if mmp1.len() < mmp2.len() {
+        for (k1, v1) in mmp1 {
+            let v2 = mmp2.get(&k1);
+            if v2.is_some() {
+                for _ in 0..**[v2.unwrap(), &v1].iter().min().unwrap() {
+                    ret.push(k1);
+                }
+            }
+        }
+    } else {
+        for (k2, v2) in mmp2 {
+            let v1 = mmp1.get(&k2);
+            if v1.is_some() {
+                for _ in 0..**[v1.unwrap(), &v2].iter().min().unwrap() {
+                    ret.push(k2);
+                }
+            }
+        }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", intersect(vec![1,2,2,1], vec![2,2]));
+    println!("{:?}", intersect(vec![4,9,5], vec![9,4,9,8,4]));
+}
diff --git a/352-data-stream-as-disjoint-intervals.rs b/352-data-stream-as-disjoint-intervals.rs
new file mode 100644
index 0000000..48d6d9a
--- /dev/null
+++ b/352-data-stream-as-disjoint-intervals.rs
@@ -0,0 +1,32 @@
+use std::cmp;
+struct SummaryRanges {
+    set: std::collections::BTreeSet<(i32, i32)>,
+}
+
+impl SummaryRanges {
+    
+    fn new() -> Self {
+        SummaryRanges { 
+            set: std::collections::BTreeSet::new(),
+        }
+    }
+    
+    fn add_num(&mut self, val: i32) {
+        let mut new = (val, val);
+        let l = *self.set.range(..(val, val)).last().unwrap_or(&new);
+        let r= *self.set.range((val, val)..).next().unwrap_or(&new);
+        if l.1 >= val - 1 {
+            new = (l.0, cmp::max(val, l.1));
+            self.set.remove(&l);
+        }
+        if r.0 <= val + 1 && new.1 < r.1 {
+            new.1 = r.1;
+            self.set.remove(&r);
+        }
+        self.set.insert(new);
+    }
+    
+    fn get_intervals(&self) -> Vec<Vec<i32>> {
+        self.set.iter().map(|(l, r)| vec![*l, *r]).collect()
+    }
+}
diff --git a/384-shuffle-an-array.rs b/384-shuffle-an-array.rs
new file mode 100644
index 0000000..11f155d
--- /dev/null
+++ b/384-shuffle-an-array.rs
@@ -0,0 +1,33 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+struct Solution {
+    nums: Vec<i32>
+}
+impl Solution {
+    fn new(nums: Vec<i32>) -> Self {
+        Self { nums }
+    }
+    fn reset(&self) -> Vec<i32> {
+        self.nums.clone()
+    }
+    fn shuffle(&self) -> Vec<i32> {
+        let mut nums = self.nums.clone();
+        let mut n = nums.len() as u128;
+        while n > 1 {
+            let m = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos() % n;
+            nums.swap(m as usize, n as usize - 1);
+            n -= 1;
+        }
+        nums
+    }
+}
+
+fn main() {
+    let nums = vec![1, 2, 3];
+    let obj = Solution::new(nums);
+    let ret_1: Vec<i32> = obj.reset();
+    println!("{:?}", ret_1);
+    let ret_2: Vec<i32> = obj.shuffle();
+    println!("{:?}", ret_2);
+    let ret_3: Vec<i32> = obj.reset();
+    println!("{:?}", ret_3);
+}
diff --git a/398-random-pick-index.rs b/398-random-pick-index.rs
new file mode 100644
index 0000000..cc41cf9
--- /dev/null
+++ b/398-random-pick-index.rs
@@ -0,0 +1,37 @@
+use std::collections::HashMap;
+
+struct Solution {
+    mmp: HashMap<i32, Vec<usize>>
+}
+
+impl Solution {
+
+    fn new(nums: Vec<i32>) -> Self {
+        let mut mmp = HashMap::new();
+        for (i, num) in nums.iter().enumerate() {
+            mmp.entry(*num).or_insert(Vec::new()).push(i);
+        }
+        Solution {
+            mmp: mmp
+        }
+    }
+
+    fn pick(&mut self, target: i32) -> i32 {
+        self.mmp.get_mut(&target).unwrap().rotate_right(1);
+        self.mmp[&target][0] as i32
+    }
+}
+
+fn main() {
+    let mut obj = Solution::new(vec![1, 2, 3, 3, 3]);
+    println!("{:?}", obj.pick(3));
+    println!("{:?}", obj.pick(1));
+    println!("{:?}", obj.pick(3));
+    println!("{:?}", obj.pick(3));
+    println!("{:?}", obj.pick(3));
+    println!("{:?}", obj.pick(3));
+    println!("{:?}", obj.pick(3));
+    println!("{:?}", obj.pick(3));
+    println!("{:?}", obj.pick(3));
+    println!("{:?}", obj.pick(3));
+}
diff --git a/434-number-of-segments-in-a-string.rs b/434-number-of-segments-in-a-string.rs
new file mode 100644
index 0000000..48a873a
--- /dev/null
+++ b/434-number-of-segments-in-a-string.rs
@@ -0,0 +1,7 @@
+pub fn count_segments(s: String) -> i32 {
+    s.split_ascii_whitespace().count() as i32
+}
+
+fn main() {
+    println!("{:?}", count_segments("s Hello, my name is John".to_string()));
+}
diff --git a/46-permutations.rs b/46-permutations.rs
new file mode 100644
index 0000000..6d14992
--- /dev/null
+++ b/46-permutations.rs
@@ -0,0 +1,39 @@
+// backtrace 公式
+// result = []
+// def backtrack(路径, 选择列表):
+//     if 满足结束条件:
+//         result.add(路径)
+//         return
+
+//     for 选择 in 选择列表:
+//         做选择
+//         backtrack(路径, 选择列表)
+//         撤销选择
+
+struct Solution;
+
+impl Solution {
+    pub fn permute(mut path: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut ret = vec![];
+        Self::backtrack(&mut path, &mut ret, 0);
+        ret
+    }
+
+    fn backtrack(path: &mut Vec<i32>, ans: &mut Vec<Vec<i32>>, begin: usize) {
+        if begin == path.len() {
+            ans.push(path.to_vec());
+            return;
+        }
+
+        for i in begin..path.len() {
+            path.swap(i, begin);
+            Self::backtrack(path, ans, begin + 1);
+            path.swap(i, begin);
+        }
+    }
+}
+
+fn main() {
+    let nums = vec![1, 2, 3];
+    println!("{:?}", Solution::permute(nums));
+}
diff --git a/503-next-greater-element-ii.rs b/503-next-greater-element-ii.rs
new file mode 100644
index 0000000..9fa1427
--- /dev/null
+++ b/503-next-greater-element-ii.rs
@@ -0,0 +1,25 @@
+pub fn next_greater_elements(nums: Vec<i32>) -> Vec<i32> {
+    let mut ret = vec![];
+    let nums_len = nums.len();
+    'outer: for i in 0..nums_len {
+        for j in i+1..nums_len {
+            if nums[j] > nums[i] {
+                ret.push(nums[j]);
+                continue 'outer;
+            }
+        }
+        for k in 0..i {
+            if nums[k] > nums[i] {
+                ret.push(nums[k]);
+                continue 'outer;
+            }
+        }
+        ret.push(-1);
+    }
+    ret
+}
+
+fn main() {
+    let nums = vec![1, 2, 1];
+    println!("{:?}", next_greater_elements(nums));
+}
diff --git a/520-detect-capital.rs b/520-detect-capital.rs
new file mode 100644
index 0000000..e21e0ea
--- /dev/null
+++ b/520-detect-capital.rs
@@ -0,0 +1,30 @@
+pub fn detect_capital_use(word: String) -> bool {
+    let word_len = word.len();
+    let mut count = vec![0, 0];
+    let chars = word.chars().collect::<Vec<char>>();
+    let first_char = chars[0];
+    for c in chars {
+        if c.is_uppercase() {
+            count[0] += 1
+        } else {
+            count[1] += 1
+        }
+    }
+    if count[0] == 0 {
+        true
+    } else {
+        if count[1] == 0 {
+            true
+        } else {
+            count[1] == word_len - 1 && first_char.is_uppercase()
+        }
+    }
+}
+
+fn main() {
+    println!("{:?}", detect_capital_use("USA".to_string()));
+    println!("{:?}", detect_capital_use("leetcode".to_string()));
+    println!("{:?}", detect_capital_use("Google".to_string()));
+    println!("{:?}", detect_capital_use("FlaG".to_string()));
+    println!("{:?}", detect_capital_use("ffffffffffffffffffffF".to_string()));
+}
diff --git a/539-minimum-time-difference.rs b/539-minimum-time-difference.rs
new file mode 100644
index 0000000..7117601
--- /dev/null
+++ b/539-minimum-time-difference.rs
@@ -0,0 +1,19 @@
+pub fn find_min_difference(time_points: Vec<String>) -> i32 {
+    let mut mmp = vec![];
+    for p in time_points {
+        let arr = p.split(":").map(|e|e.parse::<i32>().unwrap()).collect::<Vec<i32>>();
+        mmp.push(arr[0]*60+arr[1]);
+        mmp.push((arr[0]+24)*60+arr[1]);
+    }
+    mmp.sort();
+    let mut ret = 24 * 60;
+    for i in 1..mmp.len() {
+        let tmp = mmp[i] - mmp[i-1];
+        if tmp < ret { ret = tmp }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", find_min_difference(vec!["00:00".to_string(),"23:59".to_string(),"00:00".to_string()]));
+}
diff --git a/647-palindromic-substrings.rs b/647-palindromic-substrings.rs
new file mode 100644
index 0000000..e0a8abf
--- /dev/null
+++ b/647-palindromic-substrings.rs
@@ -0,0 +1,22 @@
+pub fn count_substrings(s: String) -> i32 {
+    pub fn is_palindromic(cs: &[char]) -> bool {
+        // println!("{:?}", cs.clone().to_vec());
+        let tmp = cs.clone().to_vec();
+        let mut tmp_rev = cs.clone().to_vec();
+        tmp_rev.reverse();
+        tmp == tmp_rev
+    }
+    let cs = s.chars().collect::<Vec<char>>();
+    let mut ret = 0;
+    for i in 1 ..= s.len() {
+        for j in 0 ..= (s.len() - i) {
+            if is_palindromic(&cs[j..j+i]) { ret += 1 }
+        }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", count_substrings("abc".to_string()));
+    println!("{:?}", count_substrings("aaa".to_string()));
+}
diff --git a/648-replace-words.rs b/648-replace-words.rs
new file mode 100644
index 0000000..396a678
--- /dev/null
+++ b/648-replace-words.rs
@@ -0,0 +1,21 @@
+pub fn replace_words(dictionary: Vec<String>, sentence: String) -> String {
+    let mut dictionary = dictionary;
+    dictionary.sort_by(|a, b|a.len().cmp(&b.len()));
+    let mut ret_vec = vec![];
+    'outer: for word in sentence.split_ascii_whitespace() {
+        for prefix in &dictionary {
+            if word.starts_with(prefix) {
+                ret_vec.push(prefix.clone());
+                continue 'outer;
+            }
+        }
+        ret_vec.push(word.to_string())
+    }
+    ret_vec.join(" ")
+}
+
+fn main() {
+    let dictionary = vec!["catt".to_string(), "cat".to_string(), "bat".to_string(), "rat".to_string()];
+    let sentence = "the cattle was rattled by the battery".to_string();
+    println!("{:?}", replace_words(dictionary, sentence));
+}
diff --git a/661-image-smoother.rs b/661-image-smoother.rs
new file mode 100644
index 0000000..5666eba
--- /dev/null
+++ b/661-image-smoother.rs
@@ -0,0 +1,65 @@
+pub fn image_smoother(img: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
+    let mut ret = vec![];
+    for i in 0..img.len() {
+        let mut tmp = vec![];
+        let mut tmp_sum = 0;
+        let mut tmp_count = 0;
+        for j in 0..img[0].len() {
+            {
+                {
+                    tmp_sum += img[i][j];
+                    tmp_count += 1
+                }
+                if j > 0 {
+                    tmp_sum += img[i][j-1];
+                    tmp_count += 1
+                }
+                if j + 1 < img[0].len() {
+                    tmp_sum += img[i][j+1];
+                    tmp_count += 1
+                }
+            }
+            if i > 0 {
+                {
+                    tmp_sum += img[i-1][j];
+                    tmp_count += 1
+                }
+                if j > 0 {
+                    tmp_sum += img[i-1][j-1];
+                    tmp_count += 1
+                }
+                if j + 1 < img[0].len() {
+                    tmp_sum += img[i-1][j+1];
+                    tmp_count += 1
+                }
+            }
+            if i + 1 < img.len() {
+                {
+                    tmp_sum += img[i+1][j];
+                    tmp_count += 1
+                }
+                if j > 0 {
+                    tmp_sum += img[i+1][j-1];
+                    tmp_count += 1
+                }
+                if j + 1 < img[0].len() {
+                    tmp_sum += img[i+1][j+1];
+                    tmp_count += 1
+                }
+            }
+            tmp.push((tmp_sum as f64 / tmp_count as f64).floor() as i32);
+            tmp_sum = 0;
+            tmp_count = 0;
+        }
+        ret.push(tmp);
+    }
+    ret
+}
+
+fn main() {
+    let img = vec![vec![1,1,1], vec![1,0,1], vec![1,1,1]];
+    println!("{:?}", image_smoother(img));
+
+    let img = vec![vec![2,3,4], vec![5,6,7], vec![8,9,10], vec![11,12,13], vec![14,15,16]];
+    println!("{:?}", image_smoother(img));
+}
diff --git a/676-implement-magic-dictionary.rs b/676-implement-magic-dictionary.rs
new file mode 100644
index 0000000..76790b6
--- /dev/null
+++ b/676-implement-magic-dictionary.rs
@@ -0,0 +1,45 @@
+use std::collections::HashMap;
+
+struct MagicDictionary {
+    mmp: HashMap<usize, Vec<Vec<char>>>
+}
+
+impl MagicDictionary {
+    fn new() -> Self {
+        MagicDictionary {
+            mmp: HashMap::new()
+        }
+    }
+
+    fn build_dict(&mut self, dictionary: Vec<String>) {
+        for s in dictionary {
+            self.mmp.entry(s.len()).or_insert(Vec::new()).push(s.chars().collect::<Vec<char>>());
+        }
+    }
+
+    fn search(&self, search_word: String) -> bool {
+        let search_word_len = search_word.len();
+        let search_res = self.mmp.get(&search_word_len);
+        let search_chars = search_word.chars().collect::<Vec<char>>();
+        if search_res == None {
+            false
+        } else {
+            'outer: for chars in search_res.unwrap() {
+                let mut count = 0;
+                for i in 0..search_word_len {
+                    if chars[i] != search_chars[i] { count += 1 }
+                    if count > 1 { continue 'outer }
+                }
+                if count == 1 { return true }
+            }
+            false
+        }
+    }
+}
+
+fn main() {
+    let mut obj = MagicDictionary::new();
+    obj.build_dict(vec!["hello".to_string(),"hallo".to_string(), "judge".to_string()]);
+    let ret_2: bool = obj.search("judga".to_string());
+    println!("{:?}", ret_2);
+}
diff --git a/677-map-sum-pairs.rs b/677-map-sum-pairs.rs
new file mode 100644
index 0000000..33c369c
--- /dev/null
+++ b/677-map-sum-pairs.rs
@@ -0,0 +1,46 @@
+use std::collections::HashMap;
+
+struct MapSum {
+    mmp: HashMap<String, i32>,
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl MapSum {
+
+    fn new() -> Self {
+        MapSum {
+            mmp: HashMap::new()
+        }
+    }
+
+    fn insert(&mut self, key: String, val: i32) {
+        if let Some(x) = self.mmp.get_mut(&key) {
+            *x = val;
+        } else {
+            self.mmp.insert(key, val);
+        }
+    }
+
+    fn sum(&mut self, prefix: String) -> i32 {
+        let mut ret = 0;
+        for (k, v) in &self.mmp {
+            if k.starts_with(&prefix) {
+                ret += v;
+            }
+        }
+        ret
+    }
+}
+
+fn main() {
+    let mut obj = MapSum::new();
+    obj.insert("apple".to_string(), 2);
+    println!("{:?}", obj.sum("ap".to_string()));
+    obj.insert("app".to_string(), 3);
+    obj.insert("apple".to_string(), 3);
+    println!("{:?}", obj.sum("ap".to_string()));
+}
diff --git a/705-design-hashset.rs b/705-design-hashset.rs
index 26ceacc..cac0b3a 100644
--- a/705-design-hashset.rs
+++ b/705-design-hashset.rs
@@ -13,15 +13,15 @@ impl MyHashSet {
     fn new() -> Self {
         MyHashSet {set: HashSet::new()}
     }
-    
+
     fn add(&mut self, key: i32) {
         self.set.insert(key);
     }
-    
+
     fn remove(&mut self, key: i32) {
         self.set.remove(&key);
     }
-    
+
     fn contains(&self, key: i32) -> bool {
         self.set.contains(&key)
     }
diff --git a/706-design-hashmap.rs b/706-design-hashmap.rs
index b98f771..708d29c 100644
--- a/706-design-hashmap.rs
+++ b/706-design-hashmap.rs
@@ -15,12 +15,12 @@ impl MyHashMap {
     fn new() -> Self {
         MyHashMap{map: HashMap::new()}
     }
-    
+
     /** value will always be non-negative. */
     fn put(&mut self, key: i32, value: i32) {
         self.map.insert(key, value);
     }
-    
+
     /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
     fn get(&self, key: i32) -> i32 {
         if self.map.get(&key).is_some() {
@@ -29,7 +29,7 @@ impl MyHashMap {
             -1
         }
     }
-    
+
     /** Removes the mapping of the specified value key if this map contains a mapping for the key */
     fn remove(&mut self, key: i32) {
         self.map.remove(&key);
diff --git a/788-rotated-digits.rs b/788-rotated-digits.rs
new file mode 100644
index 0000000..3f8e44f
--- /dev/null
+++ b/788-rotated-digits.rs
@@ -0,0 +1,24 @@
+pub fn rotated_digits(n: i32) -> i32 {
+    pub fn is_good(e: i32) -> bool {
+        let digit_chars = e.to_string().chars().collect::<Vec<char>>();
+        let mut count = 0;
+        for digit_char in digit_chars {
+            if digit_char == '3' || digit_char == '4'
+            || digit_char == '7' {
+                return false
+            }
+            if digit_char == '2' || digit_char == '5'
+            || digit_char == '6' || digit_char == '9' {
+                count += 1
+            }
+        }
+        count > 0
+    }
+    let mut nums = (1..=n).collect::<Vec<i32>>();
+    nums.retain(|e|is_good(*e));
+    nums.len() as i32
+}
+
+fn main() {
+    println!("{:?}", rotated_digits(10));
+}
diff --git a/789-escape-the-ghosts.rs b/789-escape-the-ghosts.rs
new file mode 100644
index 0000000..614aa50
--- /dev/null
+++ b/789-escape-the-ghosts.rs
@@ -0,0 +1,16 @@
+// 这题考阅读理解和题意转化能力，其实问的就是有没鬼能比你更快到达终点(转)
+pub fn escape_ghosts(ghosts: Vec<Vec<i32>>, target: Vec<i32>) -> bool {
+    let dis = target[0].abs() + target[1].abs();
+    for g in ghosts {
+        if (g[0] - target[0]).abs() + (g[1] - target[1]).abs() <= dis {
+            return false
+        }
+    }
+    true
+}
+
+fn main() {
+    println!("{:?}", escape_ghosts(vec![vec![1,0], vec![0,3]], vec![0,1]));
+    println!("{:?}", escape_ghosts(vec![vec![2,0]], vec![1,0]));
+    println!("{:?}", escape_ghosts(vec![vec![2,0]], vec![1,0]));
+}
diff --git a/806-number-of-lines-to-write-string.rs b/806-number-of-lines-to-write-string.rs
new file mode 100644
index 0000000..98a8b32
--- /dev/null
+++ b/806-number-of-lines-to-write-string.rs
@@ -0,0 +1,28 @@
+pub fn number_of_lines(widths: Vec<i32>, s: String) -> Vec<i32> {
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    let cs = vec!['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'];
+    for (i, c) in cs.iter().enumerate() {
+        mmp.insert(c, widths[i]);
+    }
+    let mut current = 0;
+    let mut line = 1;
+    for c in s.chars().collect::<Vec<char>>() {
+        if current + mmp[&c] > 100 {
+            line += 1;
+            current = mmp[&c];
+        } else {
+            current += mmp[&c];
+        }
+    }
+    vec![line, current]
+}
+
+fn main() {
+    let widths = vec![10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10];
+    let s = "abcdefghijklmnopqrstuvwxyz".to_string();
+    println!("{:?}", number_of_lines(widths, s));
+    let widths = vec![4,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10];
+    let s = "bbbcccdddaaa".to_string();
+    println!("{:?}", number_of_lines(widths, s));
+}
diff --git a/841-keys-and-rooms.rs b/841-keys-and-rooms.rs
new file mode 100644
index 0000000..49c2ee2
--- /dev/null
+++ b/841-keys-and-rooms.rs
@@ -0,0 +1,23 @@
+pub fn can_visit_all_rooms(rooms: Vec<Vec<i32>>) -> bool {
+    use std::collections::HashSet;
+    let mut mmp: HashSet<i32> = HashSet::new();
+    pub fn dfs(mmp: &mut HashSet<i32>, rooms: &Vec<Vec<i32>>, key: i32) {
+        let keys = rooms.get(key as usize);
+        if keys == None { return }
+        for key in keys.unwrap() {
+            let tmp = mmp.get(key);
+            if tmp.is_some() { continue }
+            mmp.insert(*key);
+            dfs(mmp, rooms, *key);
+        }
+    }
+    dfs(&mut mmp, &rooms, 0);
+    let mut mmp = mmp.into_iter().collect::<Vec<i32>>();
+    mmp.sort();
+    (1..rooms.len() as i32).collect::<Vec<i32>>() == mmp
+}
+
+fn main() {
+    println!("{:?}", can_visit_all_rooms(vec![vec![1], vec![2], vec![3], vec![]]));
+    println!("{:?}", can_visit_all_rooms(vec![vec![1,3], vec![3,0,1], vec![2], vec![0]]));
+}
diff --git a/869-reordered-power-of-2.rs b/869-reordered-power-of-2.rs
new file mode 100644
index 0000000..fed9051
--- /dev/null
+++ b/869-reordered-power-of-2.rs
@@ -0,0 +1,31 @@
+// Enumerate numbers with same length
+
+pub fn reordered_power_of2(n: i32) -> bool {
+    let mut candidate_numbers = vec![];
+    let n_len = n.to_string().len();
+    let mut power = 0;
+    loop {
+        let tmp = 2_i32.pow(power);
+        if tmp.to_string().len() == n_len {
+            candidate_numbers.push(tmp);
+        }
+        if tmp.to_string().len() > n_len {
+            break;
+        }
+        power += 1
+    }
+    let mut sorted_nums = n.to_string().chars().collect::<Vec<char>>();
+    sorted_nums.sort();
+    for number in &candidate_numbers {
+        let mut sorted_tmp = number.to_string().chars().collect::<Vec<char>>();
+        sorted_tmp.sort();
+        if sorted_tmp == sorted_nums {
+            return true;
+        }
+    }
+    false
+}
+
+fn main() {
+    println!("{:?}", reordered_power_of2(10));
+}
diff --git a/888-fair-candy-swap.rs b/888-fair-candy-swap.rs
new file mode 100644
index 0000000..2ac7eca
--- /dev/null
+++ b/888-fair-candy-swap.rs
@@ -0,0 +1,21 @@
+pub fn fair_candy_swap(alice_sizes: Vec<i32>, bob_sizes: Vec<i32>) -> Vec<i32> {
+    let diff: i32 = alice_sizes.iter().sum::<i32>() - bob_sizes.iter().sum::<i32>();
+    let abs_diff = diff / 2;
+    let mut ret = vec![];
+    'o: for i in &alice_sizes {
+        for j in &bob_sizes {
+            if abs_diff == *i - *j {
+                ret = vec![*i, *j];
+                break 'o
+            }
+        }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", fair_candy_swap(vec![1, 1], vec![2, 2]));
+    println!("{:?}", fair_candy_swap(vec![1, 2], vec![2, 3]));
+    println!("{:?}", fair_candy_swap(vec![2], vec![1, 3]));
+    println!("{:?}", fair_candy_swap(vec![1, 2, 5], vec![2, 4]));
+}
diff --git a/892-surface-area-of-3d-shapes.rs b/892-surface-area-of-3d-shapes.rs
new file mode 100644
index 0000000..cabe294
--- /dev/null
+++ b/892-surface-area-of-3d-shapes.rs
@@ -0,0 +1,24 @@
+pub fn surface_area(grid: Vec<Vec<i32>>) -> i32 {
+    let mut ret = 0;
+    for j in 0..grid.len() {
+        for i in 0..grid.len() {
+            // 去掉0
+            if grid[i][j] == 0 { continue }
+            ret += grid[i][j] * 4 + 2;
+            // 减去上下左右的紧贴面积
+            if i > 0 { ret -= vec![grid[i-1][j], grid[i][j]].iter().min().unwrap() }
+            if i+1 < grid.len() { ret -= vec![grid[i+1][j], grid[i][j]].iter().min().unwrap() }
+            if j > 0 { ret -= vec![grid[i][j-1], grid[i][j]].iter().min().unwrap() }
+            if j+1 < grid.len() { ret -= vec![grid[i][j+1], grid[i][j]].iter().min().unwrap() }
+            // println!("{:?}", ret);
+        }
+    }
+    ret
+}
+
+fn main() {
+    // let grid = vec![vec![1,2],vec![3,4]];
+    // println!("{:?}", surface_area(grid));
+    let grid = vec![vec![1,1,1],vec![1,0,1],vec![1,1,1]];
+    println!("{:?}", surface_area(grid));
+}
diff --git a/946-validate-stack-sequences.rs b/946-validate-stack-sequences.rs
new file mode 100644
index 0000000..3a87fc5
--- /dev/null
+++ b/946-validate-stack-sequences.rs
@@ -0,0 +1,24 @@
+pub fn validate_stack_sequences(pushed: Vec<i32>, popped: Vec<i32>) -> bool {
+    let mut stack: Vec<i32> = vec![];
+    let mut pushed = pushed;
+    let mut popped = popped;
+    while pushed.len() > 0 {
+        let tmp = pushed.remove(0);
+        stack.push(tmp);
+        if tmp == popped[0] {
+            // 这里应该持续出栈
+            while stack.iter().last().is_some() && *stack.iter().last().unwrap() == popped[0] {
+                stack.pop();
+                popped.remove(0);
+            }
+        }
+    }
+    if stack.len() == 0 { return true }
+    stack.reverse();
+    stack == popped
+}
+
+fn main() {
+    println!("{:?}", validate_stack_sequences(vec![1,2,3,4,5], vec![4,5,3,2,1]));
+    println!("{:?}", validate_stack_sequences(vec![2,1,0], vec![1,2,0]));
+}
diff --git a/985-sum-of-even-numbers-after-queries.rs b/985-sum-of-even-numbers-after-queries.rs
new file mode 100644
index 0000000..18b7c60
--- /dev/null
+++ b/985-sum-of-even-numbers-after-queries.rs
@@ -0,0 +1,21 @@
+pub fn sum_even_after_queries(nums: Vec<i32>, queries: Vec<Vec<i32>>) -> Vec<i32> {
+    let mut ret = vec![];
+    let mut nums = nums.clone();
+    for i in 0 .. nums.len() {
+        let val = queries[i][0];
+        let index = queries[i][1];
+        nums[index as usize] += val;
+        let mut tmp = 0;
+        for j in 0 .. nums.len() {
+            if nums[j] % 2 == 0 { tmp += nums[j] }
+        }
+        ret.push(tmp)
+    }
+    ret
+}
+
+fn main() {
+    let nums = vec![1,2,3,4];
+    let queries = vec![vec![1,0], vec![-3,1], vec![-4,0], vec![2,3]];
+    println!("{:?}", sum_even_after_queries(nums, queries));
+}
diff --git a/commit.sh b/commit.sh
new file mode 100644
index 0000000..e77c3d9
--- /dev/null
+++ b/commit.sh
@@ -0,0 +1,4 @@
+FILE=`git status --porcelain | sed s/^...//`
+git add $FILE
+git commit -m "Upsert $FILE"
+https_proxy=localhost:1088 git push
diff --git a/lcp-61-6CE719.rs b/lcp-61-6CE719.rs
new file mode 100644
index 0000000..90ca500
--- /dev/null
+++ b/lcp-61-6CE719.rs
@@ -0,0 +1,47 @@
+pub fn temperature_trend(temperature_a: Vec<i32>, temperature_b: Vec<i32>) -> i32 {
+    let (mut trend_a, mut trend_b) = (vec![], vec![]);
+    for i in 1..temperature_a.len() {
+        if temperature_a[i] - temperature_a[i-1] > 0 {
+            trend_a.push(1);
+        }
+        if temperature_a[i] - temperature_a[i-1] == 0 {
+            trend_a.push(0);
+        }
+        if temperature_a[i] - temperature_a[i-1] < 0 {
+            trend_a.push(-1);
+        }
+        if temperature_b[i] - temperature_b[i-1] > 0 {
+            trend_b.push(1);
+        }
+        if temperature_b[i] - temperature_b[i-1] == 0 {
+            trend_b.push(0);
+        }
+        if temperature_b[i] - temperature_b[i-1] < 0 {
+            trend_b.push(-1);
+        }
+    }
+    let mut last_days = 0;
+    let mut ret = 0;
+    for i in 0..trend_a.len() {
+        if trend_a[i] == trend_b[i] {
+            last_days += 1;
+        } else {
+            if last_days > ret {
+                ret = last_days
+            }
+            last_days = 0;
+        }
+    }
+    if last_days > ret {
+        ret = last_days
+    }
+    println!("{:?} {:?} {:?}", trend_a, trend_b, last_days);
+    ret
+}
+
+
+fn main() {
+    let temperature_a = vec![5,10,16,-6,15,11,3];
+    let temperature_b = vec![16,22,23,23,25,3,-16];
+    println!("{:?}", temperature_trend(temperature_a, temperature_b));
+}
diff --git a/lcs-WqXACV.rs b/lcs-WqXACV.rs
new file mode 100644
index 0000000..c34a6a5
--- /dev/null
+++ b/lcs-WqXACV.rs
@@ -0,0 +1,22 @@
+pub fn half_questions(questions: Vec<i32>) -> i32 {
+    let n = questions.len() / 2;
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    for i in questions { *mmp.entry(i).or_insert(0) += 1 }
+    let mut mmp_vec: Vec<_> = mmp.iter().collect();
+    mmp_vec.sort_by(|b, a|a.1.cmp(&b.1));
+    let mut ret = 0;
+    let mut current = 0;
+    for e in mmp_vec {
+        ret += 1;
+        current += e.1;
+        if current >= n { break }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", half_questions(vec![13,8,3,7,5,6,11,12,3,6,6,11]));
+    println!("{:?}", half_questions(vec![2,1,6,2]));
+    println!("{:?}", half_questions(vec![1,5,1,3,4,5,2,5,3,3,8,6]));
+}