diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
new file mode 100644
index 0000000..5ff4db0
--- /dev/null
+++ b/.github/workflows/rust.yml
@@ -0,0 +1,24 @@
+name: Rust
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Build & Run
+      run:  |
+        for changed_file in ${{ steps.files.outputs.all }}; do
+          rustc changed_file -o bin
+          ./bin
+        done
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/1046-last-stone-weight.rs b/1046-last-stone-weight.rs
new file mode 100644
index 0000000..c81e069
--- /dev/null
+++ b/1046-last-stone-weight.rs
@@ -0,0 +1,21 @@
+pub fn last_stone_weight(stones: Vec<i32>) -> i32 {
+    let mut stones = stones.clone();
+    while stones.len() > 1 {
+        stones.sort_by(|a, b|b.cmp(&a));
+        if stones[0] == stones[1] {
+            stones.remove(0);
+        } else {
+            stones[1] = (stones[1]-stones[0]).abs();
+        }
+        stones.remove(0);
+    }
+    if stones.len() > 0 {
+        stones[0]
+    } else {
+        0
+    }
+}
+
+fn main() {
+    println!("{:?}", last_stone_weight(vec![2,2]));
+}
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/1189-maximum-number-of-balloons.rs b/1189-maximum-number-of-balloons.rs
new file mode 100644
index 0000000..9d61236
--- /dev/null
+++ b/1189-maximum-number-of-balloons.rs
@@ -0,0 +1,21 @@
+pub fn max_number_of_balloons(text: String) -> i32 {
+    let mut stats = vec![0; 5]; // b a l o n
+    for c in text.chars().collect::<Vec<char>>() {
+        match c {
+            'b' => stats[0] += 1,
+            'a' => stats[1] += 1,
+            'l' => stats[2] += 1,
+            'o' => stats[3] += 1,
+            'n' => stats[4] += 1,
+            _   => {},
+        }
+    }
+    stats[2] /= 2;
+    stats[3] /= 2;
+    *stats.iter().min().unwrap()
+}
+
+fn main() {
+    let text = "loonbalxballpoon".to_string();
+    println!("{:?}", max_number_of_balloons(text));
+}
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/1387-sort-integers-by-the-power-value.rs b/1387-sort-integers-by-the-power-value.rs
new file mode 100644
index 0000000..29c33ee
--- /dev/null
+++ b/1387-sort-integers-by-the-power-value.rs
@@ -0,0 +1,24 @@
+pub fn get_kth(lo: i32, hi: i32, k: i32) -> i32 {
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    for i in lo..=hi {
+        let mut tmp = i;
+        let mut count = 0;
+        while tmp != 1 {
+            if tmp % 2 == 0 {
+                tmp /= 2;
+            } else {
+                tmp = 3 * tmp + 1;
+            }
+            count += 1;
+        }
+        mmp.entry(count).or_insert(Vec::new()).push(i);
+    }
+    let mut mmp_vec: Vec<_> = mmp.iter().collect();
+    mmp_vec.sort_by(|a, b|a.0.cmp(b.0));
+    *mmp_vec.into_iter().map(|e|e.1).collect::<Vec<_>>().into_iter().flatten().collect::<Vec<_>>()[k as usize - 1]
+}
+
+fn main() {
+    println!("{:?}", get_kth(12, 15, 2));
+}
diff --git a/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k.rs b/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k.rs
new file mode 100644
index 0000000..0c2dde1
--- /dev/null
+++ b/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k.rs
@@ -0,0 +1,26 @@
+pub fn find_min_fibonacci_numbers(k: i32) -> i32 {
+    let mut fib_seq = vec![1];
+    let mut tmp = 1;
+    // 动态规划，列出1000000000以内fib数列
+    while tmp < 10_i32.pow(9) {
+        fib_seq.push(tmp);
+        let len = fib_seq.len();
+        tmp = fib_seq[len-1] + fib_seq[len-2];
+    }
+    let mut ret = 0;
+    let mut k = k;
+    // 贪心算法
+    while k != 0 {
+        for i in fib_seq.iter().rev() {
+            if k - i >= 0 {
+                k -= i;
+                ret += 1;
+            }
+        }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", find_min_fibonacci_numbers(7));
+}
diff --git a/1433-check-if-a-string-can-break-another-string.rs b/1433-check-if-a-string-can-break-another-string.rs
new file mode 100644
index 0000000..b038f07
--- /dev/null
+++ b/1433-check-if-a-string-can-break-another-string.rs
@@ -0,0 +1,34 @@
+pub fn check_if_can_break(s1: String, s2: String) -> bool {
+    let mut sorted_s1_chars = s1.chars().collect::<Vec<char>>();
+    let mut sorted_s2_chars = s2.chars().collect::<Vec<char>>();
+    sorted_s1_chars.sort();
+    sorted_s2_chars.sort();
+    let mut s1_gr_s2 = true;
+    for i in 0..sorted_s1_chars.len() {
+        if sorted_s1_chars[i] > sorted_s2_chars[i] {
+            break;
+        }
+        if sorted_s1_chars[i] < sorted_s2_chars[i] {
+            s1_gr_s2 = false;
+            break;
+        }
+    }
+    for i in 0..sorted_s1_chars.len() {
+        if sorted_s1_chars[i] > sorted_s2_chars[i] && !s1_gr_s2 {
+            return false;
+        }
+        if sorted_s1_chars[i] < sorted_s2_chars[i] && s1_gr_s2 {
+            return false;
+        }
+    }
+    true
+}
+
+fn main() {
+    let s1 = "bxfowqvnrhuzwqohquamvszkvunb".to_string();
+    let s2 = "xjegbjccjjxfnsiearbsgsofywtq".to_string();
+    println!("{:?}", check_if_can_break(s1, s2));
+}
+
+// "bxfowqvnrhuzwqohquamvszkvunb"
+// "xjegbjccjjxfnsiearbsgsofywtq"
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/1582-special-positions-in-a-binary-matrix.rs b/1582-special-positions-in-a-binary-matrix.rs
new file mode 100644
index 0000000..a30a45c
--- /dev/null
+++ b/1582-special-positions-in-a-binary-matrix.rs
@@ -0,0 +1,32 @@
+pub fn num_special(mat: Vec<Vec<i32>>) -> i32 {
+    let mut ret = 0;
+    let mut ps = vec![];
+    for i in 0..mat.len() {
+        for j in 0..mat[0].len() {
+            ps.push((i, j));
+        }
+    }
+    for p in ps {
+        if mat[p.0][p.1] == 1 {
+            let mut col_count = 0;
+            let mut row_count = 0;
+            for e in &mat[p.0] {
+                if *e == 1 { row_count += 1 }
+            }
+            for i in 0..mat.len() {
+                if mat[i][p.1] == 1 { col_count += 1 }
+            }
+            if col_count == 1 && row_count == 1 { ret += 1 }
+        }
+    }
+    ret
+}
+
+fn main() {
+    let mat = vec![
+                vec![0,0],
+                vec![0,0],
+                vec![1,0]
+              ];
+    println!("{:?}", num_special(mat));
+}
diff --git a/1598-crawler-log-folder.rs b/1598-crawler-log-folder.rs
new file mode 100644
index 0000000..a345f71
--- /dev/null
+++ b/1598-crawler-log-folder.rs
@@ -0,0 +1,18 @@
+pub fn min_operations(logs: Vec<String>) -> i32 {
+    let mut ret = 0;
+    for log in logs {
+        if log.contains("..") {
+            if ret > 0 { ret -= 1 }
+        } else if log.contains(".") {
+            continue
+        } else {
+            ret += 1
+        }
+    }
+    ret
+}
+
+fn main() {
+    let logs: Vec<String> = ["d1/","d2/","../","d21/","./"].iter().map(|e|e.to_string()).collect();
+    println!("{:?}", min_operations(logs));
+}
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/1710-maximum-units-on-a-truck.rs b/1710-maximum-units-on-a-truck.rs
new file mode 100644
index 0000000..26b5f6b
--- /dev/null
+++ b/1710-maximum-units-on-a-truck.rs
@@ -0,0 +1,15 @@
+// box_types.sort{|a, b|b[1]<=>a[1]}.map{|e|[e[1]]*e[0]}.flatten[...truck_size].sum
+
+pub fn maximum_units(box_types: Vec<Vec<i32>>, truck_size: i32) -> i32 {
+    let mut sorted_box_types = box_types.clone();
+    sorted_box_types.sort_by(|a, b| b[1].cmp(&a[1]));
+    let tmp = sorted_box_types.iter().map(|e|vec![e[1]; e[0] as usize]).collect::<Vec<Vec<i32>>>().into_iter().flatten().collect::<Vec<i32>>();
+    let idx = vec![tmp.len(), truck_size as usize].into_iter().min().unwrap();
+    tmp[..idx].iter().sum::<i32>()
+}
+
+fn main() {
+    let box_types = [[1,3],[5,5],[2,5],[4,2],[4,1],[3,1],[2,2],[1,3],[2,5],[3,2]].map(|e|e.to_vec()).to_vec();
+    let truck_size = 35;
+    println!("{:?}", maximum_units(box_types, truck_size));
+}
\ No newline at end of file
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/1743-restore-the-array-from-adjacent-pairs.rs b/1743-restore-the-array-from-adjacent-pairs.rs
new file mode 100644
index 0000000..9a34dc8
--- /dev/null
+++ b/1743-restore-the-array-from-adjacent-pairs.rs
@@ -0,0 +1,41 @@
+pub fn restore_array(adjacent_pairs: Vec<Vec<i32>>) -> Vec<i32> {
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    for p in adjacent_pairs {
+        mmp.entry(p[0]).or_insert(Vec::new()).push(p[1]);
+        mmp.entry(p[1]).or_insert(Vec::new()).push(p[0]);
+    }
+    let mut head = 0;
+    for (k, v) in &mmp {
+        if v.len() == 1 {
+            head = *k;
+            break;
+        }
+    }
+    // Firstly, find the head or tail
+    let mut ret = vec![head];
+    let mut count = 1;
+    let mut prev = head;
+    loop {
+        let current = ret.iter().last().unwrap().clone();
+        let item = &mmp[&current];
+        if item.len() == 1 {
+            ret.push(item[0]);
+        } else {
+            if item[0] == prev {
+                ret.push(item[1]);
+            } else {
+                ret.push(item[0]);
+            }
+        }
+        prev = current;
+        count += 1;
+        if count == mmp.len() { break }
+    }
+    ret
+}
+
+fn main() {
+    let adjacent_pairs = vec![vec![2,1], vec![3,4], vec![3,2]];
+    println!("{:?}", restore_array(adjacent_pairs));
+}
diff --git a/1758-minimum-changes-to-make-alternating-binary-string.rs b/1758-minimum-changes-to-make-alternating-binary-string.rs
new file mode 100644
index 0000000..c24eb6d
--- /dev/null
+++ b/1758-minimum-changes-to-make-alternating-binary-string.rs
@@ -0,0 +1,22 @@
+pub fn min_operations(s: String) -> i32 {
+    let s_len = s.len();
+    let mut final_0 = vec!['0'; s_len];
+    let mut final_1 = vec!['1'; s_len];
+    let idx: usize;
+    if s_len % 2 == 0 { idx = s_len / 2 } else { idx = s_len / 2 + 1 }
+    for i in 0..idx{
+        final_0[i * 2] = '1';
+        final_1[i * 2] = '0';
+    }
+    let (mut final_0_count, mut final_1_count) = (0, 0);
+    for (i, c) in s.chars().collect::<Vec<char>>().iter().enumerate() {
+        if final_0[i] != *c { final_0_count += 1 }
+        if final_1[i] != *c { final_1_count += 1 }
+    }
+    *vec![final_1_count, final_0_count].iter().min().unwrap()
+}
+
+fn main() {
+    let s = "1111".to_string();
+    println!("{:?}", min_operations(s));
+}
diff --git a/1780-check-if-number-is-a-sum-of-powers-of-three.rs b/1780-check-if-number-is-a-sum-of-powers-of-three.rs
new file mode 100644
index 0000000..231ac64
--- /dev/null
+++ b/1780-check-if-number-is-a-sum-of-powers-of-three.rs
@@ -0,0 +1,13 @@
+// n 转化为3进制，只有0、1
+pub fn check_powers_of_three(n: i32) -> bool {
+    let mut n = n;
+    while n > 0 {
+        if n % 3 == 2 { return false }
+        n /= 3;
+    }
+    true
+}
+
+fn main() {
+    println!("{:?}", check_powers_of_three(12));
+}
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/1817-finding-the-users-active-minutes.rs b/1817-finding-the-users-active-minutes.rs
new file mode 100644
index 0000000..cb77ac6
--- /dev/null
+++ b/1817-finding-the-users-active-minutes.rs
@@ -0,0 +1,19 @@
+pub fn finding_users_active_minutes(logs: Vec<Vec<i32>>, k: i32) -> Vec<i32> {
+    use std::collections::HashMap;
+    use std::collections::HashSet;
+    let mut mmp: HashMap<i32, HashSet<i32>> = HashMap::new();
+    for log in logs {
+        mmp.entry(log[0]).or_insert(HashSet::new()).insert(log[1]);
+    }
+    let mut ret = vec![0; k as usize];
+    for (_, v) in mmp {
+        ret[v.len()-1] += 1;
+    }
+    ret
+}
+
+fn main() {
+    let logs: Vec<Vec<i32>> = vec![[0,5],[1,2],[0,2],[0,5],[1,3]].iter().map(|e|e.to_vec()).collect();
+    let k = 5;
+    println!("{:?}", finding_users_active_minutes(logs, k));
+}
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/1833-maximum-ice-cream-bars.rs b/1833-maximum-ice-cream-bars.rs
new file mode 100644
index 0000000..590974d
--- /dev/null
+++ b/1833-maximum-ice-cream-bars.rs
@@ -0,0 +1,18 @@
+pub fn max_ice_cream(costs: Vec<i32>, coins: i32) -> i32 {
+    let mut sorted_costs = costs.clone();
+    sorted_costs.sort();
+    for i in 1..sorted_costs.len() {
+        sorted_costs[i] += sorted_costs[i-1];
+    }
+    for (i, c) in sorted_costs.iter().enumerate() {
+        if coins < *c { return i as i32 }
+    }
+    sorted_costs.len() as i32
+}
+
+fn main() {
+    let costs = vec![1,6,3,1,2,5];
+    let coins = 20;
+    println!("{:?}", max_ice_cream(costs, coins));
+    println!("{:?}", max_ice_cream(vec![1,3,2,4,1], 7));
+}
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/1897-redistribute-characters-to-make-all-strings-equal.rs b/1897-redistribute-characters-to-make-all-strings-equal.rs
new file mode 100644
index 0000000..6416ff1
--- /dev/null
+++ b/1897-redistribute-characters-to-make-all-strings-equal.rs
@@ -0,0 +1,19 @@
+pub fn make_equal(words: Vec<String>) -> bool {
+    let words_len = words.len();
+    if words_len == 1 { return true }
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    for word in words {
+        for c in word.chars().collect::<Vec<char>>() {
+            let count = mmp.entry(c).or_insert(0);
+            *count += 1;
+        }
+    }
+    mmp.retain(|_, v| *v % words_len != 0);
+    mmp.is_empty()
+}
+
+fn main() {
+    let words = ["abc","aabc","bc"].iter().map(|e|e.to_string()).collect::<Vec<String>>();
+    println!("{:?}", make_equal(words));
+}
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/1984-minimum-difference-between-highest-and-lowest-of-k-scores.rs b/1984-minimum-difference-between-highest-and-lowest-of-k-scores.rs
new file mode 100644
index 0000000..2ba4fd4
--- /dev/null
+++ b/1984-minimum-difference-between-highest-and-lowest-of-k-scores.rs
@@ -0,0 +1,22 @@
+pub fn minimum_difference(nums: Vec<i32>, k: i32) -> i32 {
+    let mut sorted_nums = nums.clone();
+    sorted_nums.sort();
+    let mut min = std::i32::MAX;
+    for i in 0..=sorted_nums.len() - k as usize {
+        let minus = sorted_nums[i + k as usize - 1] - sorted_nums[i];
+        if minus < min { min = minus }
+    }
+    min
+}
+
+fn main() {
+    let nums = vec![41900,69441,94407,37498,20299,10856,36221,2231,54526,79072,84309,76765,92282,13401,44698,17586,98455,47895,98889,65298,32271,23801,83153,12186,7453,79460,67209,54576,87785,47738,40750,31265,77990,93502,50364,75098,11712,80013,24193,35209,56300,85735,3590,24858,6780,50086,87549,7413,90444,12284,44970,39274,81201,43353,75808,14508,17389,10313,90055,43102,18659,20802,70315,48843,12273,78876,36638,17051,20478];
+    let k = 5;
+    println!("{}", minimum_difference(nums, k));
+    let nums = vec![90];
+    let k = 1;
+    println!("{}", minimum_difference(nums, k));
+    let nums = vec![9,4,1,7];
+    let k = 2;
+    println!("{}", minimum_difference(nums, k));
+}
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/2062-count-vowel-substrings-of-a-string.rs b/2062-count-vowel-substrings-of-a-string.rs
new file mode 100644
index 0000000..7a16528
--- /dev/null
+++ b/2062-count-vowel-substrings-of-a-string.rs
@@ -0,0 +1,28 @@
+pub fn count_vowel_substrings(word: String) -> i32 {
+    use std::collections::HashMap;
+    let mut ret = 0;
+    let vowel = vec!['a', 'e', 'i', 'o', 'u'];
+    for i in 0..word.len() {
+        'middle: for j in i+5..=word.len() {
+            let mut mmp = HashMap::new();
+            let cs = &word[i..j].to_string().clone();
+            for c in cs.chars().collect::<Vec<char>>() {
+                if vowel.contains(&c) {
+                    let count = mmp.entry(c).or_insert(0);
+                    *count += 1;
+                } else {
+                    continue 'middle;
+                }
+            }
+            if mmp.len() == 5 {
+                ret += 1;
+            }
+        }
+    }
+    ret
+}
+
+fn main() {
+    let word = "cuaieuouac".to_string();
+    println!("{:?}", count_vowel_substrings(word));
+}
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/2138-divide-a-string-into-groups-of-size-k.rs b/2138-divide-a-string-into-groups-of-size-k.rs
new file mode 100644
index 0000000..99bf9a3
--- /dev/null
+++ b/2138-divide-a-string-into-groups-of-size-k.rs
@@ -0,0 +1,21 @@
+pub fn divide_string(s: String, k: i32, fill: char) -> Vec<String> {
+    let mut ret = s.chars()
+        .collect::<Vec<char>>().chunks(k as usize)
+        .collect::<Vec<_>>().iter().map(|v|v.into_iter().collect::<String>())
+        .collect::<Vec<String>>();
+    let last_len = ret.last().unwrap().len();
+    let l = ret.len();
+    if last_len != k as usize {
+        for _ in 0..k as usize - last_len {
+            ret[l-1].push(fill);
+        }
+    }
+    ret
+}
+
+fn main() {
+    let s = "abcdefghij".to_string();
+    let k = 3;
+    let fill = 'x';
+    println!("{:?}", divide_string(s, k, fill));
+}
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/2148-count-elements-with-strictly-smaller-and-greater-elements.rs b/2148-count-elements-with-strictly-smaller-and-greater-elements.rs
new file mode 100644
index 0000000..4668130
--- /dev/null
+++ b/2148-count-elements-with-strictly-smaller-and-greater-elements.rs
@@ -0,0 +1,16 @@
+pub fn count_elements(nums: Vec<i32>) -> i32 {
+    let min = *nums.iter().min().unwrap();
+    let max = *nums.iter().max().unwrap();
+    let mut ret = 0;
+    for num in nums {
+        if num == min { continue }
+        if num == max { continue }
+        ret += 1;
+    }
+    ret
+}
+
+fn main() {
+    let nums = vec![-65,-65,50,-65,50,-55,-65,-65];
+    println!("{:?}", count_elements(nums));
+}
diff --git a/2150-find-all-lonely-numbers-in-the-array.rs b/2150-find-all-lonely-numbers-in-the-array.rs
new file mode 100644
index 0000000..6adcc44
--- /dev/null
+++ b/2150-find-all-lonely-numbers-in-the-array.rs
@@ -0,0 +1,21 @@
+pub fn find_lonely(nums: Vec<i32>) -> Vec<i32> {
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    for n in nums {
+        let count = mmp.entry(n).or_insert(0);
+        *count += 1;
+    }
+    let mut ret = vec!();
+    for (k, v) in &mmp {
+        if *v != 1 { continue }
+        if mmp.get(&(k-1)) != None { continue }
+        if mmp.get(&(k+1)) != None { continue }
+        ret.push(*k);
+    }
+    ret
+}
+
+fn main() {
+    let nums = vec![10,6,5,8];
+    println!("{:?}", find_lonely(nums));
+}
diff --git a/216-combination-sum-iii.rs b/216-combination-sum-iii.rs
new file mode 100644
index 0000000..5a74fd6
--- /dev/null
+++ b/216-combination-sum-iii.rs
@@ -0,0 +1,27 @@
+struct Solution;
+
+// 回溯 = 递归 + 循环
+impl Solution {
+    pub fn backtrace(n: i32, k: usize, start_index: i32, path: &mut Vec<i32>, ret: &mut Vec<Vec<i32>>, sum: i32) {
+        if path.len() == k && path.iter().sum::<i32>() == sum {
+            ret.push(path.to_vec());
+            return;
+        }
+        for i in start_index..=n {
+            path.push(i);
+            Self::backtrace(n, k, i+1, path, ret, sum);
+            path.pop();
+        }
+    }
+
+    pub fn combination_sum3(k: i32, n: i32) -> Vec<Vec<i32>> {
+        let mut path = vec![];
+        let mut ret = vec![];
+        Self::backtrace(9, k as usize, 1, &mut path, &mut ret, n);
+        ret
+    }
+}
+
+fn main() {
+    println!("{:?}", Solution::combination_sum3(3, 9));
+}
diff --git a/2177-find-three-consecutive-integers-that-sum-to-a-given-number.rs b/2177-find-three-consecutive-integers-that-sum-to-a-given-number.rs
new file mode 100644
index 0000000..5c773d6
--- /dev/null
+++ b/2177-find-three-consecutive-integers-that-sum-to-a-given-number.rs
@@ -0,0 +1,8 @@
+pub fn sum_of_three(num: i64) -> Vec<i64> {
+    if num % 3 == 0 {
+        let middle = num / 3;
+        vec![middle - 1, middle, middle + 1]
+    } else {
+        vec![]
+    }
+}
diff --git a/2231-largest-number-after-digit-swaps-by-parity.rs b/2231-largest-number-after-digit-swaps-by-parity.rs
new file mode 100644
index 0000000..e222c68
--- /dev/null
+++ b/2231-largest-number-after-digit-swaps-by-parity.rs
@@ -0,0 +1,40 @@
+pub fn largest_integer(num: i32) -> i32 {
+    let mut num_digits = vec!();
+    let mut num = num;
+    while num > 0 {
+        num_digits.insert(0, num % 10);
+        num /= 10;
+    }
+    let num_digits_len = num_digits.len();
+    let mut odd_idx = vec!();
+    let mut odd_num = vec!();
+    let mut even_idx = vec!();
+    let mut even_num = vec!();
+    for (i, d) in num_digits.iter().enumerate() {
+        if d % 2 == 0 {
+            even_idx.push(i);
+            even_num.push(d);
+        } else {
+            odd_idx.push(i);
+            odd_num.push(d);
+        }
+    }
+    odd_num.sort_by(|a, b|b.cmp(&a));
+    even_num.sort_by(|a, b|b.cmp(&a));
+    let mut ret_digits = vec!(0; num_digits_len);
+    for (i, d) in odd_idx.iter().enumerate() {
+        ret_digits[*d] = *odd_num[i];
+    }
+    for (i, d) in even_idx.iter().enumerate() {
+        ret_digits[*d] = *even_num[i];
+    }
+    let mut ret = 0;
+    for (i, d) in ret_digits.iter().rev().enumerate() {
+        ret += d * 10_i32.pow(i as u32);
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", largest_integer(65875));
+}
diff --git a/2243-calculate-digit-sum-of-a-string.rs b/2243-calculate-digit-sum-of-a-string.rs
new file mode 100644
index 0000000..65cbd77
--- /dev/null
+++ b/2243-calculate-digit-sum-of-a-string.rs
@@ -0,0 +1,20 @@
+pub fn digit_sum(s: String, k: i32) -> String {
+    let mut ret = s.clone();
+    while ret.len() > k as usize {
+        let mut tmp = String::new();
+        for ch in ret.chars().collect::<Vec<char>>().chunks(k as usize) {
+            let mut sum = 0;
+            for c in ch {
+                sum += c.to_string().parse::<i32>().unwrap();
+            }
+            tmp.push_str(&sum.to_string());
+        }
+        ret = tmp;
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", digit_sum("11111222223".to_string(), 3));
+    println!("{:?}", digit_sum("00000000".to_string(), 3));
+}
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/2293-min-max-game.rs b/2293-min-max-game.rs
new file mode 100644
index 0000000..62e3484
--- /dev/null
+++ b/2293-min-max-game.rs
@@ -0,0 +1,21 @@
+pub fn min_max_game(nums: Vec<i32>) -> i32 {
+    let mut nums = nums.clone();
+    while nums.len() > 1 {
+        let nums_chunks = nums.chunks(2);
+        let mut tmp = vec!();
+        for (i, chunk) in nums_chunks.enumerate() {
+            if i % 2 == 0 {
+                tmp.push(*chunk.iter().min().unwrap());
+            } else {
+                tmp.push(*chunk.iter().max().unwrap());
+            }
+        }
+        nums = tmp;
+    }
+    nums[0]
+}
+
+fn main() {
+    let nums = vec![1,3,5,2,4,8,2,2];
+    println!("{:?}", min_max_game(nums));
+}
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/2303-calculate-amount-paid-in-taxes.rs b/2303-calculate-amount-paid-in-taxes.rs
new file mode 100644
index 0000000..7ba0763
--- /dev/null
+++ b/2303-calculate-amount-paid-in-taxes.rs
@@ -0,0 +1,23 @@
+pub fn calculate_tax(brackets: Vec<Vec<i32>>, income: i32) -> f64 {
+    let mut ret = 0.0_f64;
+    let mut prev = 0.0_f64;
+    let mut left_income: f64 = income.into();
+    for b in brackets {
+        if left_income <= 0.0 { break }
+        if left_income > b[0] as f64 - prev {
+            ret += ( b[0] as f64 - prev ) * b[1] as f64/ 100.0_f64;
+            left_income -= b[0] as f64 - prev;
+            prev = b[0] as f64;
+        } else {
+            ret += left_income * b[1] as f64 / 100.0_f64;
+            break;
+        }
+    }
+    ret
+}
+
+fn main() {
+    let brackets = vec![vec![3,50], vec![7,10], vec![12,25]];
+    let income = 10;
+    println!("{:?}", calculate_tax(brackets, income));
+}
diff --git a/2309-greatest-english-letter-in-upper-and-lower-case.rs b/2309-greatest-english-letter-in-upper-and-lower-case.rs
new file mode 100644
index 0000000..c595219
--- /dev/null
+++ b/2309-greatest-english-letter-in-upper-and-lower-case.rs
@@ -0,0 +1,20 @@
+pub fn greatest_letter(s: String) -> String {
+    use std::collections::HashMap;
+    let mut s_chars = s.chars().collect::<Vec<char>>();
+    s_chars.sort_unstable();
+    s_chars.dedup();
+    let mut mmp = HashMap::new();
+    let mut ret = '0';
+    for c in s_chars {
+        let cu = c.to_ascii_uppercase();
+        let count = mmp.entry(cu).or_insert(0);
+        *count += 1;
+        if *count > 1 && cu > ret { ret = cu }
+    }
+    if ret == '0' { return String::new() }
+    ret.to_string()
+}
+
+fn main() {
+    println!("{:?}", greatest_letter("AbCdEfGhIjK".to_string()));
+}
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/2336-smallest-number-in-infinite-set.rs b/2336-smallest-number-in-infinite-set.rs
new file mode 100644
index 0000000..06355d5
--- /dev/null
+++ b/2336-smallest-number-in-infinite-set.rs
@@ -0,0 +1,43 @@
+struct SmallestInfiniteSet {
+    set: Vec<i32>,
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl SmallestInfiniteSet {
+
+    fn new() -> Self {
+        SmallestInfiniteSet {
+            set: (1..=1000).collect()
+        }
+    }
+
+    fn pop_smallest(&mut self) -> i32 {
+        let mut ret = -1;
+        for (i, num) in self.set.iter().enumerate() {
+            if *num != 0 {
+                ret = *num;
+                self.set[i] = 0;
+                break;
+            }
+        }
+        ret
+    }
+
+    fn add_back(&mut self, num: i32) {
+        self.set[num as usize - 1] = num;
+    }
+}
+
+fn main() {
+    let mut obj = SmallestInfiniteSet::new();
+    obj.add_back(2);
+    println!("{:?}", obj.pop_smallest());
+    obj.add_back(2);
+    println!("{:?}", obj.pop_smallest());
+    obj.add_back(1);
+    println!("{:?}", obj.pop_smallest());
+}
\ No newline at end of file
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/413-arithmetic-slices.rs b/413-arithmetic-slices.rs
new file mode 100644
index 0000000..ea595c1
--- /dev/null
+++ b/413-arithmetic-slices.rs
@@ -0,0 +1,21 @@
+pub fn number_of_arithmetic_slices(nums: Vec<i32>) -> i32 {
+    if nums.len() < 3 { return 0; }
+    pub fn is_arithmetic(nums: &[i32]) -> bool {
+        let minus = nums[1] - nums[0];
+        for i in 2..nums.len() {
+            if nums[i] - nums[i-1] != minus { return false; }
+        }
+        true
+    }
+    let mut ret = 0;
+    for length in 3..=nums.len() {
+        for i in 0..=nums.len() - length {
+            if is_arithmetic(&nums[i..i+length]) { ret += 1; }
+        }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", number_of_arithmetic_slices(vec![1, 2, 3, 4]));
+}
diff --git a/423-reconstruct-original-digits-from-english.rs b/423-reconstruct-original-digits-from-english.rs
new file mode 100644
index 0000000..7b187d1
--- /dev/null
+++ b/423-reconstruct-original-digits-from-english.rs
@@ -0,0 +1,54 @@
+// 脑筋急转弯
+// 数学归纳法
+pub fn original_digits(s: String) -> String {
+    let string = s;
+    let mut z = 0;
+    let mut w = 0;
+    let mut g = 0;
+    let mut x = 0;
+    let mut t = 0;
+    let mut r = 0;
+    let mut s = 0;
+    let mut o = 0;
+    let mut v = 0;
+    let mut i = 0;
+    for c in string.chars().collect::<Vec<char>>() {
+        match c {
+            'z' => z += 1,
+            'w' => w += 1,
+            'g' => g += 1,
+            'x' => x += 1,
+            't' => t += 1,
+            'r' => r += 1,
+            's' => s += 1,
+            'o' => o += 1,
+            'v' => v += 1,
+            'i' => i += 1,
+            _ => {},
+        }
+    }
+    let mut n = vec!(0; 10);
+    n[0] = z;
+    n[2] = w;
+    n[8] = g;
+    n[6] = x;
+    n[3] = t - n[2] - n[8];
+    n[4] = r - n[3] - n[0];
+    n[7] = s - n[6];
+    n[1] = o - n[4] - n[2] - n[0];
+    n[5] = v - n[7];
+    n[9] = i - n[8] - n[6] - n[5];
+    let mut ret = String::new();
+    for (i, e) in n.iter().enumerate() {
+        if *e == 0 { continue }
+        for _ in 0..*e {
+            ret.push_str(&i.to_string());
+        }
+    }
+    ret
+}
+
+fn main() {
+    let s = "owoztneoer".to_string();
+    println!("{:?}", original_digits(s));
+}
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/566-reshape-the-matrix.rs b/566-reshape-the-matrix.rs
new file mode 100644
index 0000000..9bd7007
--- /dev/null
+++ b/566-reshape-the-matrix.rs
@@ -0,0 +1,20 @@
+pub fn matrix_reshape(mat: Vec<Vec<i32>>, r: i32, c: i32) -> Vec<Vec<i32>> {
+    let mut flattened = mat.clone().into_iter().flatten().collect::<Vec<i32>>();
+    if flattened.len() != (r  * c) as usize { return mat }
+    let mut ret = vec![];
+    for _ in 0..r {
+        let mut tmp = vec![];
+        for _ in 0..c {
+            tmp.push(flattened.remove(0));
+        }
+        ret.push(tmp);
+    }
+    ret
+}
+
+fn main() {
+    let mat = vec![vec![1,2], vec![3,4]];
+    let r = 1;
+    let c = 4;
+    println!("{:?}", matrix_reshape(mat, r, c));
+}
diff --git a/6124-first-letter-to-appear-twice.rs b/6124-first-letter-to-appear-twice.rs
new file mode 100644
index 0000000..cdd97b8
--- /dev/null
+++ b/6124-first-letter-to-appear-twice.rs
@@ -0,0 +1,18 @@
+pub fn repeated_character(s: String) -> char {
+    use std::collections::HashMap;
+    let mut mp = HashMap::new();
+    let mut ret = '!';
+    for c in s.chars().collect::<Vec<char>>() {
+        let count = mp.entry(c).or_insert(0);
+        *count += 1;
+        if *count == 2 {
+            ret = c;
+            break;
+        }
+    }
+    ret
+}
+
+fn main() {
+    println!("{:?}", repeated_character("abccbaacz".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/739-daily-temperatures.rs b/739-daily-temperatures.rs
new file mode 100644
index 0000000..2854105
--- /dev/null
+++ b/739-daily-temperatures.rs
@@ -0,0 +1,18 @@
+pub fn daily_temperatures(temperatures: Vec<i32>) -> Vec<i32> {
+    let mut ret = vec!();
+    'outer: for (i, t) in temperatures.iter().enumerate() {
+        for (j, e) in temperatures[i+1..].iter().enumerate() {
+            if *e > *t {
+                ret.push(j as i32 + 1);
+                continue 'outer;
+            }
+        }
+        ret.push(0);
+    }
+    ret
+}
+
+fn main() {
+    let temperatures = vec![73,74,75,71,69,72,76,73];
+    println!("{:?}", daily_temperatures(temperatures));
+}
diff --git a/75-sort-colors.rs b/75-sort-colors.rs
new file mode 100644
index 0000000..cda11ec
--- /dev/null
+++ b/75-sort-colors.rs
@@ -0,0 +1,18 @@
+pub fn sort_colors(nums: &mut Vec<i32>) {
+    let lst_idx = nums.len() - 1;
+    for i in 0..lst_idx {
+        for j in 0..lst_idx-i {
+            if nums[j] > nums[j+1] {
+                let tmp = nums[j];
+                nums[j] = nums[j+1];
+                nums[j+1] = tmp;
+            }
+        }
+    }
+}
+
+fn main() {
+    let mut nums = vec![2,0,2,1,1,0];
+    sort_colors(&mut nums);
+    println!("{:?}", nums);
+}
diff --git a/766-toeplitz-matrix.rs b/766-toeplitz-matrix.rs
new file mode 100644
index 0000000..da79964
--- /dev/null
+++ b/766-toeplitz-matrix.rs
@@ -0,0 +1,36 @@
+pub fn is_toeplitz_matrix(matrix: Vec<Vec<i32>>) -> bool {
+    let (m, n) = (matrix[0].len(), matrix.len());
+    // 00 11 22
+    // 01 12 23
+    // 02 13
+    // 03
+    for y in 0..m {
+        let mut i = 0;
+        let mut j = y;
+        let prev = matrix[i][j];
+        while j < m && i < n {
+            if matrix[i][j] != prev { return false; }
+            i += 1;
+            j += 1;
+        }
+    }
+    // 00 11 22
+    // 10 21
+    // 20
+    for x in 0..n {
+        let mut i = x;
+        let mut j = 0;
+        let prev = matrix[i][j];
+        while j < m && i < n {
+            if matrix[i][j] != prev { return false; }
+            i += 1;
+            j += 1;
+        }
+    }
+    true
+}
+
+fn main() {
+    let matrix = vec![vec![1,2,3,4], vec![5,1,2,3], vec![9,5,1,2]];
+    println!("{:?}", is_toeplitz_matrix(matrix));
+}
diff --git a/77-combinations.rs b/77-combinations.rs
new file mode 100644
index 0000000..6c6a85d
--- /dev/null
+++ b/77-combinations.rs
@@ -0,0 +1,27 @@
+struct Solution;
+
+// 回溯 = 递归 + 循环
+impl Solution {
+    pub fn backtrace(n: i32, k: usize, start_index: i32, path: &mut Vec<i32>, ret: &mut Vec<Vec<i32>>) {
+        if path.len() == k {
+            ret.push(path.to_vec());
+            return;
+        }
+        for i in start_index..=n {
+            path.push(i);
+            Self::backtrace(n, k, i+1, path, ret);
+            path.pop();
+        }
+    }
+
+    pub fn combine(n: i32, k: i32) -> Vec<Vec<i32>> {
+        let mut path = vec![];
+        let mut ret = vec![];
+        Self::backtrace(n, k as usize, 1, &mut path, &mut ret);
+        ret
+    }
+}
+
+fn main() {
+    println!("{:?}", Solution::combine(4, 2));
+}
diff --git a/784-letter-case-permutation.rs b/784-letter-case-permutation.rs
new file mode 100644
index 0000000..06099d2
--- /dev/null
+++ b/784-letter-case-permutation.rs
@@ -0,0 +1,31 @@
+// 动态规划 回溯
+pub fn letter_case_permutation(s: String) -> Vec<String> {
+    let mut dp: Vec<String> = vec![String::new()];
+    let mut current_count = 1;
+    for c in s.chars().collect::<Vec<char>>() {
+        if c.is_numeric() {
+            for i in dp.len()-current_count..dp.len() {
+                let mut tmp = dp[i].clone();
+                tmp.push(c);
+                dp.push(tmp);
+            }
+        } else {
+            for i in dp.len()-current_count..dp.len() {
+                let mut tmp_lower = dp[i].clone();
+                let mut tmp_upper = dp[i].clone();
+                tmp_lower.push(c.to_ascii_lowercase());
+                tmp_upper.push(c.to_ascii_uppercase());
+                dp.push(tmp_lower);
+                dp.push(tmp_upper);
+            }
+        }
+        current_count *= 2;
+    }
+    dp.retain(|e|e.len() == s.len());
+    dp
+}
+
+fn main() {
+    let s = "a1b2".to_string();
+    println!("{:?}", letter_case_permutation(s));
+}
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/791-custom-sort-string.rs b/791-custom-sort-string.rs
new file mode 100644
index 0000000..c39827d
--- /dev/null
+++ b/791-custom-sort-string.rs
@@ -0,0 +1,32 @@
+pub fn custom_sort_string(order: String, s: String) -> String {
+    use std::collections::HashMap;
+    let mut mmp = HashMap::new();
+    let order_chars = order.chars().collect::<Vec<char>>();
+    for c in &order_chars {
+        mmp.entry(*c).or_insert(Vec::new());
+    }
+    for c in s.chars().collect::<Vec<char>>() {
+        mmp.entry(c).or_insert(Vec::new()).push(c.to_string());
+    }
+    let mut ret = String::new();
+    for c in order_chars {
+        let tmp = mmp.get(&c);
+        if tmp != None {
+            ret.push_str(&tmp.unwrap().join(""));
+            mmp.remove(&c);
+        }
+    }
+    for (_, v) in mmp {
+        ret.push_str(&v.join(""));
+    }
+    ret
+}
+
+fn main() {
+    let order = "cba".to_string();
+    let s = "abcd".to_string();
+    println!("{:?}", custom_sort_string(order, s));
+    let order = "cbafg".to_string();
+    let s = "abcd".to_string();
+    println!("{:?}", custom_sort_string(order, s));
+}
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/961-n-repeated-element-in-size-2n-array.rs b/961-n-repeated-element-in-size-2n-array.rs
new file mode 100644
index 0000000..2b74041
--- /dev/null
+++ b/961-n-repeated-element-in-size-2n-array.rs
@@ -0,0 +1,29 @@
+// solution 1
+// pub fn repeated_n_times(nums: Vec<i32>) -> i32 {
+//     use std::collections::HashMap;
+//     let mut mmp = HashMap::new();
+//     let half_len = nums.len() / 2;
+//     let mut ret = 0;
+//     for num in nums {
+//         let count = mmp.entry(num).or_insert(0);
+//         *count += 1;
+//         if *count == half_len {
+//             ret = num;
+//             break;
+//         }
+//     }
+//     ret
+// }
+
+// solution 2
+pub fn repeated_n_times(nums: Vec<i32>) -> i32 {
+    let mut sorted_nums = nums.clone();
+    sorted_nums.sort();
+    let half_len = nums.len() / 2;
+    if sorted_nums[half_len] == sorted_nums[half_len+1] { sorted_nums[half_len+1] } else { sorted_nums[half_len-1] }
+}
+
+fn main() {
+    let nums = vec![3,3,5,9];
+    println!("{:?}", repeated_n_times(nums));
+}
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]));
+}