Merge branch 'main' of github.com:1132719438/rust-course

book/contents/SUMMARY.md

@@ -18,7 +18,7 @@
     - [变量绑定与解构](basic/variable.md)
     - [基本类型](basic/base-type/index.md)
         - [数值类型](basic/base-type/numbers.md)
-        - [字符、布尔、元类型](basic/base-type/char-bool.md)
+        - [字符、布尔、单元类型](basic/base-type/char-bool.md)
         - [语句与表达式](basic/base-type/statement-expression.md)
         - [函数](basic/base-type/function.md)
     - [所有权和借用](basic/ownership/index.md)
@@ -108,19 +108,9 @@
     - [使用初印象](tokio/getting-startted.md)
     - [创建异步任务](tokio/spawning.md)
     <!-- - [异步消息流](tokio/stream.md))    -->
-   
-- [Rust最佳实践 doing](practice/intro.md)
-    - [日常开发三方库精选](practice/third-party-libs.md)
-    - [一些写代码的技巧 todo](practice/coding-tips.md)
-    - [最佳实践 todo](practice/best-pratice.md)
-    - [值得学习的源代码 todo](practice/good-sourcecode.md)
-    - [代码规范 doing](practice/style-guide/intro.md)
-        - [命名规范](practice/style-guide/naming.md)
-        - [代码风格(todo)](practice/style-guide/code.md)
-        - [代码标记](practice/style-guide/mark.md)
-        - [Clippy](practice/style-guide/clippy.md)
+
         
-- [对抗编译检查(持续更新)](fight-with-compiler/intro.md)
+- [对抗编译检查 doing](fight-with-compiler/intro.md)
     - [幽灵数据(todo)](fight-with-compiler/phantom-data.md)
     - [生命周期](fight-with-compiler/lifetime/intro.md)
         - [生命周期过大-01](fight-with-compiler/lifetime/too-long1.md)
@@ -133,7 +123,7 @@
     - [类型未限制(todo)](fight-with-compiler/unconstrained.md)
 
 
-- [Rust陷阱系列(持续更新)](pitfalls/index.md)
+- [Rust陷阱系列](pitfalls/index.md)
     - [for循环中使用外部数组](pitfalls/use-vec-in-for.md)
     - [线程类型导致的栈溢出](pitfalls/stack-overflow.md)
     - [算术溢出导致的panic](pitfalls/arithmetic-overflow.md)
@@ -145,8 +135,22 @@
     - [无处不在的迭代器](pitfalls/iterator-everywhere.md)
     - [线程间传递消息导致主线程无法结束](pitfalls/main-with-channel-blocked.md)
 
-- [如何实现一个链表]()
+   
+- [Rust最佳实践 doing](practice/intro.md)
+    - [日常开发三方库精选](practice/third-party-libs.md)
+    - [一些写代码的技巧 todo](practice/coding-tips.md)
+    - [最佳实践 todo](practice/best-pratice.md)
+    - [值得学习的源代码 todo](practice/good-sourcecode.md)
+    - [代码规范 doing](practice/style-guide/intro.md)
+        - [命名规范](practice/style-guide/naming.md)
+        - [代码风格(todo)](practice/style-guide/code.md)
+        - [代码标记 todo](practice/style-guide/mark.md)
+        - [Clippy todo](practice/style-guide/clippy.md)
+  
+- [如何实现一个链表 todo]()
     
+- [Javascript 和 WASM todo]()
+  
 - [进阶类型转换](converse/intro.md)
     - [枚举和整数](converse/enum-int.md)
     

book/contents/advance/crate-module/intro.md

@@ -8,8 +8,8 @@
 
 同时，将大的代码文件拆分成包和模块，还允许我们实现代码抽象和复用：将你的代码封装好后提供给用户，那么用户只需要调用公共接口即可，无需知道内部该如何实现。
 
-因此，跟其它语言一样，Rust也提供了相应概念用于代码的组织管理:
-- Packages: 一个`Cargo`提供的feature，可以用来构建、测试和分享包
+因此，跟其它语言一样，Rust 也提供了相应概念用于代码的组织管理：
+- Packages: 一个 `Cargo` 提供的feature，可以用来构建、测试和分享包
 - 包Crate: 一个由多个模块组成的树形结构，可以作为三方库进行分发，也可以生成可执行文件进行运行
 - 模块：可以一个文件多个模块，也可以一个文件一个模块，模块可以被认为是真实项目中的代码组织单元
 

book/contents/advance/custom-type.md

@@ -178,7 +178,7 @@ error[E0308]: `match` arms have incompatible types // match的分支类型不同
 4 | |        0..3 => i,
   | |                - this is found to be of type `{integer}` // 该分支返回整数类型
 5 | |        _ => println!("不合规定的值:{}",i) 
-  | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected integer, found `()` // 该分支返回()元类型
+  | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected integer, found `()` // 该分支返回()单元类型
 6 | |     };
   | |_____- `match` arms have incompatible types
 ```

book/contents/advance/functional-programing/closure.md

@@ -1,6 +1,6 @@
 # 闭包closure
 
-关于闭包这个词语由来已久，自上世纪60年代就由`Scheme`语言引进，之后，被广泛用于函数式编程语言中，进入21世纪后，各种现代化的编程语言也都不约而同的把闭包作为核心特性纳入到语言设计中来。那么到底何为闭包？
+闭包这个词语由来已久，自上世纪60年代就由 `Scheme` 语言引进之后，被广泛用于函数式编程语言中，进入21世纪后，各种现代化的编程语言也都不约而同地把闭包作为核心特性纳入到语言设计中来。那么到底何为闭包？
 
 闭包是**一种匿名函数，它可以赋值给变量也可以作为参数传递给其它函数，不同于函数的是，它允许捕获调用者作用域中的值**，例如：
 ```rust
@@ -12,14 +12,14 @@ fn main() {
 }
 ```
 
-上面的代码展示了非常简单的闭包`sum`，它拥有一个入参`y`，同时捕获了作用域中的`x`的值，因此调用`sum(2)`意味着将2(参数`y`)跟1（`x`）进行相加,最终返回它们的和:`3`。
+上面的代码展示了非常简单的闭包 `sum`，它拥有一个入参 `y`，同时捕获了作用域中的 `x` 的值，因此调用 `sum(2)` 意味着将 2(参数 `y`) 跟 1（`x`）进行相加,最终返回它们的和：`3`。
 
-可以看到`sum`非常符合闭包的定义：可以赋值给变量，允许捕获调用者作用域中的值。
+可以看到 `sum` 非常符合闭包的定义：可以赋值给变量，允许捕获调用者作用域中的值。
 
 ## 使用闭包来简化代码
 
 #### 传统函数实现
-想象一下，我们要进行健身，用代码怎么实现(写代码什么鬼，健身难道不应该去健身房嘛？答曰：健身太累了，还是虚拟健身好，点到为止)？这里是我的想法：
+想象一下，我们要进行健身，用代码怎么实现（写代码什么鬼，健身难道不应该去健身房嘛？答曰：健身太累了，还是虚拟健身好，点到为止）？这里是我的想法：
 ```rust
 use std::thread;
 use std::time::Duration;
@@ -34,11 +34,11 @@ fn muuuuu(intensity: u32) -> u32 {
 fn workout(intensity: u32, random_number: u32) {
     if intensity < 25 {
         println!(
-            "今天活力满满, 先做 {} 个俯卧撑!",
+            "今天活力满满，先做 {} 个俯卧撑!",
             muuuuu(intensity)
-        );
+        ); 
         println!(
-            "旁边有妹子在看，俯卧撑太low, 再来 {} 组卧推!",
+            "旁边有妹子在看，俯卧撑太low，再来 {} 组卧推!",
             muuuuu(intensity)
         );
     } else {
@@ -46,7 +46,7 @@ fn workout(intensity: u32, random_number: u32) {
             println!("昨天练过度了，今天还是休息下吧！");
         } else {
             println!(
-                "昨天练过度了，今天干干有氧, 跑步 {} 分钟!",
+                "昨天练过度了，今天干干有氧，跑步 {} 分钟!",
                 muuuuu(intensity)
             );
         }
@@ -64,10 +64,10 @@ fn main() {
 }
 ```
 
-可以看到，在健身时我们根据想要的强度来调整具体的动作，然后调用`muuuuu`函数来开始健身。这个程序本身很简单，没啥好说的，但是假如未来不用`muuuu`函数了，是不是得把所有`muuuu`都替换成，比如说`woooo`? 如果`muuuu`出现了几十次，那意味着我们要修改几十处地方。
+可以看到，在健身时我们根据想要的强度来调整具体的动作，然后调用 `muuuuu` 函数来开始健身。这个程序本身很简单，没啥好说的，但是假如未来不用 `muuuu` 函数了，是不是得把所有 `muuuu` 都替换成，比如说 `woooo` ？如果 `muuuu` 出现了几十次，那意味着我们要修改几十处地方。
 
 #### 函数变量实现
-一个可行的办法是，把函数赋值给一个变量，然后通过变量调用:
+一个可行的办法是，把函数赋值给一个变量，然后通过变量调用：
 ```rust
 fn workout(intensity: u32, random_number: u32) {
     let action = muuuuu;
@@ -94,15 +94,15 @@ fn workout(intensity: u32, random_number: u32) {
 ```
 
 
-经过上面修改后，所有的调用都通过`action`来完成，若未来声(动)音(作)变了，只要修改为`let action = woooo`即可。
+经过上面修改后，所有的调用都通过 `action` 来完成，若未来声(动)音(作)变了，只要修改为 `let action = woooo` 即可。
 
-但是问题又来了,若`intensity`也变了怎么办？例如变成`action(intensity + 1)`，那你又得哐哐哐修改几十处调用。
+但是问题又来了，若 `intensity` 也变了怎么办？例如变成 `action(intensity + 1)`，那你又得哐哐哐修改几十处调用。
 
 该怎么办？没太好的办法了，只能祭出大杀器：闭包。
 
 #### 闭包实现
 
-上面提到`intensity`要是变化怎么办，简单，使用闭包来捕获它，这是我们的拿手好戏:
+上面提到 `intensity` 要是变化怎么办，简单，使用闭包来捕获它，这是我们的拿手好戏：
 ```rust
 fn workout(intensity: u32, random_number: u32) {
     let action = || {
@@ -113,11 +113,11 @@ fn workout(intensity: u32, random_number: u32) {
 
     if intensity < 25 {
         println!(
-            "今天活力满满, 先做 {} 个俯卧撑!",
+            "今天活力满满，先做 {} 个俯卧撑!",
             action()
         );
         println!(
-            "旁边有妹子在看，俯卧撑太low, 再来 {} 组卧推!",
+            "旁边有妹子在看，俯卧撑太low，再来 {} 组卧推!",
             action()
         );
     } else {
@@ -125,7 +125,7 @@ fn workout(intensity: u32, random_number: u32) {
             println!("昨天练过度了，今天还是休息下吧！");
         } else {
             println!(
-                "昨天练过度了，今天干干有氧, 跑步 {} 分钟!",
+                "昨天练过度了，今天干干有氧，跑步 {} 分钟!",
                 action()
             );
         }
@@ -143,9 +143,9 @@ fn main() {
 }
 ```
 
-在上面代码中，无论你要修改什么，只要修改闭包`action`的实现即可，其它地方只负责调用，完美解决了我们的问题！
+在上面代码中，无论你要修改什么，只要修改闭包 `action` 的实现即可，其它地方只负责调用，完美解决了我们的问题！
 
-Rust闭包在形式上借鉴了`Smalltalk`和`Ruby`语言，与函数最大的不同就是它的参数是通过`|parm1|`的形式进行声明，如果是多个参数就`|param1, param2,...|`, 下面给出闭包的形式定义：
+Rust 闭包在形式上借鉴了 `Smalltalk` 和 `Ruby` 语言，与函数最大的不同就是它的参数是通过 `|parm1|` 的形式进行声明，如果是多个参数就 `|param1, param2,...|`， 下面给出闭包的形式定义：
 ```rust
 |param1, param2,...| {
     语句1;
@@ -159,31 +159,31 @@ Rust闭包在形式上借鉴了`Smalltalk`和`Ruby`语言，与函数最大的
 |param1| 返回表达式
 ```
 
-上例中还有两点值得注意:
-- **闭包中最后一行表达式返回的值，就是闭包执行后的返回值**，因此`action()`调用返回了`intensity`的值`10`
-- `let action = ||...`只是把闭包赋值给变量`action`，并不是把闭包执行后的结果赋值给`action`，因此这里`action`就相当于闭包函数，可以跟函数一样进行调用：`action()`
+上例中还有两点值得注意：
+- **闭包中最后一行表达式返回的值，就是闭包执行后的返回值**，因此 `action()` 调用返回了 `intensity` 的值 `10`
+- `let action = ||...` 只是把闭包赋值给变量 `action`，并不是把闭包执行后的结果赋值给 `action`，因此这里 `action` 就相当于闭包函数，可以跟函数一样进行调用：`action()`
 
 ## 闭包的类型推导
-Rust是静态语言，因此所有的变量都具有类型，但是得益于编译器的强大类型推导能力，在很多时候我们并不需要显式的去声明类型，但是显然函数并不在此列，必须手动为函数的所有参数和返回值指定类型，原因在于函数往往会作为API提供给你的用户，因此你的用户必须在使用时知道传入参数的类型和返回值类型。
+Rust 是静态语言，因此所有的变量都具有类型，但是得益于编译器的强大类型推导能力，在很多时候我们并不需要显式地去声明类型，但是显然函数并不在此列，必须手动为函数的所有参数和返回值指定类型，原因在于函数往往会作为 API 提供给你的用户，因此你的用户必须在使用时知道传入参数的类型和返回值类型。
 
 与函数相反，闭包并不会作为API对外提供，因此它可以享受编译器的类型推导能力，无需标注参数和返回值的类型。
 
-为了增加代码可读性，有时候我们会显式的给类型进行标注，出于同样的目的，也可以给闭包标注类型：
+为了增加代码可读性，有时候我们会显式地给类型进行标注，出于同样的目的，也可以给闭包标注类型：
 ```rust
 let sum = |x: i32, y: i32| -> i32 {
     x + y
 }
 ```
 
-与之相比，不标注类型的闭包声明会更简洁些: `let sum = |x, y| x + y`, 需要注意的是，针对`sum`闭包，如果你不在后续代码中使用它，编译器会提示你为`x,y`添加类型标注，因为它缺乏必要的上下文：
+与之相比，不标注类型的闭包声明会更简洁些：`let sum = |x, y| x + y`，需要注意的是，针对 `sum` 闭包，如果你只进行了声明，但是没有使用，编译器会提示你为 `x,y` 添加类型标注，因为它缺乏必要的上下文：
 ```rust
 let sum  = |x, y| x + y;
 let v = sum(1,2);
 ```
 
-这里我们使用了`sum`，同时把`1`传给了`x`，`2`传给了`y`，因此编译器才可以推导出`x,y`的类型为`i32`。
+这里我们使用了 `sum`，同时把 `1` 传给了 `x`，`2` 传给了 `y`，因此编译器才可以推导出 `x,y` 的类型为 `i32`。
 
-下面展示了同一个功能的函数和闭包实现形式:
+下面展示了同一个功能的函数和闭包实现形式：
 ```rust
 fn  add_one_v1   (x: u32) -> u32 { x + 1 }
 let add_one_v2 = |x: u32| -> u32 { x + 1 };
@@ -193,7 +193,7 @@ let add_one_v4 = |x|               x + 1  ;
 
 可以看出第一行的函数和后面的闭包其实在形式上是非常接近的，同时三种不同的闭包也展示了三种不同的使用方式：省略参数、返回值和花括号对。
 
-虽然类型推导很好用，但是它不是泛型，**当编译器推导出一种类型后，它就会一直使用该类型**:
+虽然类型推导很好用，但是它不是泛型，**当编译器推导出一种类型后，它就会一直使用该类型**：
 ```rust
 let example_closure = |x| x;
 
@@ -201,7 +201,7 @@ let s = example_closure(String::from("hello"));
 let n = example_closure(5);
 ```
 
-首先，在`s`中，编译器为`x`推导出类型`String`，但是紧接着`n`试图用`5`这个整型去调用闭包，跟编译器之前推导的`String`类型不符，因此报错：
+首先，在 `s` 中，编译器为 `x` 推导出类型 `String`，但是紧接着 `n` 试图用 `5` 这个整型去调用闭包，跟编译器之前推导的 `String` 类型不符，因此报错：
 ```console
 error[E0308]: mismatched types
  --> src/main.rs:5:29
@@ -229,19 +229,19 @@ where
 }
 ```
 
-等等，我都跟着这本教程学完Rust基础了，为何还有我不认识的东东？`Fn(u32) -> u32`是什么鬼？别急，先回答你第一个问题：骚年，too young too naive，你以为Rust的语法特性就基础入门那一些嘛？太年轻了！如果是长征，你才刚到赤水河.
+等等，我都跟着这本教程学完 Rust 基础了，为何还有我不认识的东东？`Fn(u32) -> u32` 是什么鬼？别急，先回答你第一个问题：骚年，too young too naive，你以为 Rust 的语法特性就基础入门那一些吗？太年轻了！如果是长征，你才刚到赤水河。
 
-其实，可以看的出这一长串是`T`的特征约束，再结合之前的已知信息：`query`是一个闭包，大概可以推测出，`Fn(u32) -> u32`是一个特征，用来表示`T`是一个闭包类型？Bingo，恭喜你，答对了！
+其实，可以看得出这一长串是 `T` 的特征约束，再结合之前的已知信息：`query` 是一个闭包，大概可以推测出，`Fn(u32) -> u32` 是一个特征，用来表示 `T` 是一个闭包类型？Bingo，恭喜你，答对了！
 
-那为什么不用具体的类型来标注`query`呢？原因很简单，每一个闭包实例都有独属于自己的类型，甚至于两个签名一模一样的闭包，它们的类型都是不同的，因此你无法用一个统一的类型来标注`query`闭包。
+那为什么不用具体的类型来标注 `query` 呢？原因很简单，每一个闭包实例都有独属于自己的类型，即使于两个签名一模一样的闭包，它们的类型也是不同的，因此你无法用一个统一的类型来标注 `query` 闭包。
 
-而标准库提供的`Fn`系列特征，再结合特征约束，就很好的解决了这个问题. `T: Fn(u32) -> u32`意味着`query`的类型是`T`，该类型必须实现了相应的闭包特征`Fn(u32) -> u32`。从特征的角度来看它长得非常反直觉，但是如果从闭包的角度来看又极其符合直觉，不得不佩服Rust团队的鬼才设计。。。
+而标准库提供的 `Fn` 系列特征，再结合特征约束，就能很好的解决了这个问题. `T: Fn(u32) -> u32` 意味着 `query` 的类型是 `T`，该类型必须实现了相应的闭包特征 `Fn(u32) -> u32`。从特征的角度来看它长得非常反直觉，但是如果从闭包的角度来看又极其符合直觉，不得不佩服 Rust 团队的鬼才设计。。。
 
-特征`Fn(u32) -> u32`从表面来看，就对闭包形式进行了显而易见的限制：**该闭包拥有一个`u32`类型的参数，同时返回一个`u32`类型的值**.
+特征 `Fn(u32) -> u32` 从表面来看，就对闭包形式进行了显而易见的限制：**该闭包拥有一个`u32`类型的参数，同时返回一个`u32`类型的值**。
 
-> 需要注意的是，其实Fn特征不仅仅适用于闭包，还适用于函数，因此上面的`query`字段除了使用闭包作为值外，还能使用一个具名的函数来作为它的值
+> 需要注意的是，其实 Fn 特征不仅仅适用于闭包，还适用于函数，因此上面的 `query` 字段除了使用闭包作为值外，还能使用一个具名的函数来作为它的值
 
-接着，为缓存实现方法:
+接着，为缓存实现方法：
 ```rust
 impl<T> Cacher<T>
 where
@@ -254,7 +254,7 @@ where
         }
     }
 
-    // 先查询缓存值`self.value`，若不存在，则调用`query`加载
+    // 先查询缓存值 `self.value`，若不存在，则调用 `query` 加载
     fn value(&mut self, arg: u32) -> u32 {
         match self.value {
             Some(v) => v,
@@ -268,11 +268,11 @@ where
 }
 ```
 
-上面的缓存有一个很大的问题：只支持`u32`类型的值，若我们想要缓存`String`类型，显然就行不通了，因此需要将`u32`替换成泛型`E`，该练习就留给读者自己完成，具体代码可以参考[这里](https://github.com/sunface/rust-course/blob/main/book/solutions/closure.md)
+上面的缓存有一个很大的问题：只支持 `u32` 类型的值，若我们想要缓存 `String` 类型，显然就行不通了，因此需要将 `u32` 替换成泛型 `E`，该练习就留给读者自己完成，具体代码可以参考[这里](https://github.com/sunface/rust-course/blob/main/book/solutions/closure.md)
 
 
 ## 捕获作用域中的值
-在之前代码中，我们一直在用闭包的匿名函数特性(赋值给变量)，然而闭包还拥有一项函数所不具备的特性: 捕获作用域中的值。
+在之前代码中，我们一直在用闭包的匿名函数特性(赋值给变量)，然而闭包还拥有一项函数所不具备的特性：捕获作用域中的值。
 ```rust
 fn main() {
     let x = 4;
@@ -285,9 +285,9 @@ fn main() {
 }
 ```
 
-上面代码中，`x`并不是闭包`equal_to_x`的参数，但是它依然可以去使用`x`，因为`equal_to_x`在`x`的作用域范围内。
+上面代码中，`x` 并不是闭包 `equal_to_x` 的参数，但是它依然可以去使用 `x`，因为 `equal_to_x` 在 `x` 的作用域范围内。
 
-对于函数来说，就算你把函数定义在`main`函数体中，它也不能访问`x`:
+对于函数来说，就算你把函数定义在 `main` 函数体中，它也不能访问 `x`：
 ```rust
 fn main() {
     let x = 4;
@@ -313,14 +313,14 @@ error[E0434]: can't capture dynamic environment in a fn item // 在函数中无
   = help: use the `|| { ... }` closure form instead // 使用闭包替代
 ```
 
-如上所示，编译器准确的告诉了我们错误，同时甚至给出了提示：使用闭包来替代函数，这种聪明令我有些无所适从，总感觉会显得我很笨。
+如上所示，编译器准确地告诉了我们错误，甚至同时给出了提示：使用闭包来替代函数，这种聪明令我有些无所适从，总感觉会显得我很笨。
 
 #### 闭包对内存的影响
 当闭包从环境中捕获一个值时，会分配内存去存储这些值。对于有些场景来说，这种额外的内存分配会成为一种负担。与之相比，函数就不会去捕获这些环境值，因此定义和使用函数不会拥有这种内存负担。
 
 #### 三种Fn特征
-闭包捕获变量有三种途径，恰好对应函数参数的三种传入方式：转移所有权、可变借用、不可变借用，因此相应的Fn特征也有三种:
-1. `FnOnce`, 该类型的闭包会拿走被捕获变量的所有权。`Once`顾名思义，说明该闭包只能运行一次：
+闭包捕获变量有三种途径，恰好对应函数参数的三种传入方式：转移所有权、可变借用、不可变借用，因此相应的 `Fn` 特征也有三种：
+1. `FnOnce`，该类型的闭包会拿走被捕获变量的所有权。`Once` 顾名思义，说明该闭包只能运行一次：
 
 ```rust
 fn fn_once<F>(func: F)
@@ -354,7 +354,7 @@ error[E0382]: use of moved value: `func`
   |
 ```
 
-这里面有一个很重要的提示，因为`F`没有实现`Copy`特征，所以会报错，那么我们添加一个约束，试试实现了`Copy`的闭包：
+这里面有一个很重要的提示，因为 `F` 没有实现 `Copy` 特征，所以会报错，那么我们添加一个约束，试试实现了 `Copy` 的闭包：
 
 ```rust
 fn fn_once<F>(func: F)
@@ -371,16 +371,16 @@ fn main() {
 }
 ```
 
-上面代码中，`func`的类型`F`实现了`Copy`特征，调用时使用的将是它的拷贝，所以并没有发生所有权的转移。
+上面代码中，`func` 的类型 `F` 实现了 `Copy` 特征，调用时使用的将是它的拷贝，所以并没有发生所有权的转移。
 
 ```console
 true 
 false
 ```
 
-如果你想强制闭包取得捕获变量的所有权，可以在参数列表前添加`move`关键字，这种用法通常用于闭包的生命周期大于捕获变量的生命周期时，例如将闭包返回或移入其他线程。
+如果你想强制闭包取得捕获变量的所有权，可以在参数列表前添加 `move` 关键字，这种用法通常用于闭包的生命周期大于捕获变量的生命周期时，例如将闭包返回或移入其他线程。
 
-2. `FnMut`, 它以可变借用的方式捕获了环境中的值，因此可以修改该值：
+2. `FnMut`，它以可变借用的方式捕获了环境中的值，因此可以修改该值：
 ```rust
 fn main() {
     let mut s = String::new();
@@ -392,7 +392,7 @@ fn main() {
 }
 ```
 
-在闭包中，我们调用`s.push_str`去改变外部`s`的字符串值，因此这里捕获了它的可变借用，运行下试试：
+在闭包中，我们调用 `s.push_str` 去改变外部 `s` 的字符串值，因此这里捕获了它的可变借用，运行下试试：
 ```console
 error[E0596]: cannot borrow `update_string` as mutable, as it is not declared as mutable
  --> src/main.rs:5:5  
@@ -405,7 +405,7 @@ error[E0596]: cannot borrow `update_string` as mutable, as it is not declared as
   |     ^^^^^^^^^^^^^ cannot borrow as mutable
 ```
 
-虽然报错了，但是编译器给出了非常清晰的提示，想要在闭包内部捕获可变借用，需要把该闭包声明为可变类型，也就是`update_string`要修改为`mut update_string`:
+虽然报错了，但是编译器给出了非常清晰的提示，想要在闭包内部捕获可变借用，需要把该闭包声明为可变类型，也就是 `update_string` 要修改为 `mut update_string`：
 ```rust
 fn main() {
     let mut s = String::new();
@@ -417,7 +417,7 @@ fn main() {
 }
 ```
 
-这种写法有点反直觉，相比起来前面的`move`更符合使用和阅读习惯。但是如果你忽略`update_string`的类型，仅仅把它当成一个普通变量，那么这种声明就比较合理了。
+这种写法有点反直觉，相比起来前面的 `move` 更符合使用和阅读习惯。但是如果你忽略 `update_string` 的类型，仅仅把它当成一个普通变量，那么这种声明就比较合理了。
 
 再来看一个复杂点的：
 ```rust
@@ -436,10 +436,28 @@ fn exec<'a, F: FnMut(&'a str)>(mut f: F)  {
 }
 ```
 
-这段代码非常清晰的说明了`update_string`实现了`FnMut`特征
+这段代码非常清晰的说明了 `update_string` 实现了 `FnMut` 特征
+
+3. `Fn` 特征，它以不可变借用的方式捕获环境中的值
+让我们把上面的代码中 `exec` 的 `F` 泛型参数类型修改为 `Fn(&'a str)`：
+```rust
+fn main() {
+    let mut s = String::new();
+
+    let update_string =  |str| s.push_str(str);
+   
+    exec(update_string);
+    
+    println!("{:?}",s);
+}
+
+fn exec<'a, F: Fn(&'a str)>(mut f: F)  {
+    f("hello")
+}
+```
+
+然后运行看看结果：
 
-3. `Fn`特征，它以不可变借用的方式捕获环境中的值
-让我们把上面的代码中`exec`的`F`泛型参数类型修改为`Fn(&'a str)`，然后运行看看结果:
 ```console
 error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnMut`
  --> src/main.rs:4:26  // 期望闭包实现的是`Fn`特征，但是它只实现了`FnMut`特征
@@ -454,7 +472,7 @@ error[E0525]: expected a closure that implements the `Fn` trait, but this closur
   |     ---- the requirement to implement `Fn` derives from here
 ```
 
-从报错中很清晰的看出，我们的闭包实现的是`FnMut`特征，但是在`exec`中却给它标注了`Fn`特征，因此产生了不匹配，再来看看正确的不可变借用方式：
+从报错中很清晰的看出，我们的闭包实现的是 `FnMut` 特征，需要的是可变借用，但是在 `exec` 中却给它标注了 `Fn` 特征，因此产生了不匹配，再来看看正确的不可变借用方式： 
 ```rust
 fn main() {
     let s = "hello, ".to_string();
@@ -471,13 +489,13 @@ fn exec<'a, F: Fn(String) -> ()>(f: F)  {
 }
 ```
 
-在这里，因为无需改变`s`，因此闭包中只对`s`进行了不可变借用，那么在`exec`中，将其标记为`Fn`特征就完全正确。
+在这里，因为无需改变 `s`，因此闭包中只对 `s` 进行了不可变借用，那么在 `exec` 中，将其标记为 `Fn` 特征就完全正确。
 
 
 ##### move和Fn
-在上面，我们讲到了`move`关键字对于`FnOnce`特征的重要性，但是实际上使用了`move`的闭包依然可能实现了`Fn`或`FnMut`特征。
+在上面，我们讲到了 `move` 关键字对于 `FnOnce` 特征的重要性，但是实际上使用了 `move` 的闭包依然可能实现了 `Fn` 或 `FnMut` 特征。
 
-因为，**一个闭包实现了哪种Fn特征取决于该闭包如何使用被捕获的变量，而不是取决于闭包如何捕获它们**。`move`本身强调的就是后者：闭包如何捕获变量:
+因为，**一个闭包实现了哪种 Fn 特征取决于该闭包如何使用被捕获的变量，而不是取决于闭包如何捕获它们**。`move` 本身强调的就是后者，闭包如何捕获变量：
 ```rust
 fn main() {
     let s = String::new();
@@ -487,14 +505,14 @@ fn main() {
     exec(update_string);
 }
 
-fn exec<F: Fn()>(f: F)  {
+fn exec<F: FnOnce()>(f: F)  {
     f()
 }
 ```
 
-我们在上面的闭包中使用了`move`关键字，因此我们的闭包捕获了它，但是由于闭包对`s`的使用仅仅是不可变借用，因为该闭包实际上**还**实现了`Fn`特征，如`exec`函数所示。
+我们在上面的闭包中使用了 `move` 关键字，所以我们的闭包捕获了它，但是由于闭包对 `s` 的使用仅仅是不可变借用，因此该闭包实际上**还**实现了 `Fn` 特征。
 
-细心的读者肯定发现我在上段中使用了一个`还`字，这是什么意思呢？因为该闭包不仅仅实现了`Fn`特征，还实现了`FnOnce`特征，因此将代码修改成下面这样，依然可以编译：
+细心的读者肯定发现我在上段中使用了一个 `还` 字，这是什么意思呢？因为该闭包不仅仅实现了 `FnOnce` 特征，还实现了 `Fn` 特征，将代码修改成下面这样，依然可以编译：
 ```rust
 fn main() {
     let s = String::new();
@@ -504,18 +522,18 @@ fn main() {
     exec(update_string);
 }
 
-fn exec<F: FnOnce()>(f: F)  {
+fn exec<F: Fn()>(f: F)  {
     f()
 }
 ```
 
-##### 三种Fn的关系
-实际上，一个闭包并不仅仅实现某一种Fn特征，规则如下：
-- 所有的闭包都实现了`FnOnce`特征，因此任何一个闭包都至少可以被调用一次
-- 没有移出所捕获变量的所有权的闭包实现了`FnMut`特征
-- 不需要对捕获变量进行改变的闭包实现了`Fn`特征
+##### 三种 Fn 的关系
+实际上，一个闭包并不仅仅实现某一种 `Fn` 特征，规则如下：
+- 所有的闭包都自动实现了 `FnOnce` 特征，因此任何一个闭包都至少可以被调用一次
+- 没有移出所捕获变量的所有权的闭包自动实现了 `FnMut` 特征
+- 不需要对捕获变量进行改变的闭包自动实现了 `Fn` 特征
 
-用一段代码来简单诠释上述规则:
+用一段代码来简单诠释上述规则：
 ```rust
 fn main() {
     let s = String::new();
@@ -540,7 +558,7 @@ fn exec2<F: Fn()>(f: F)  {
 }
 ```
 
-虽然，闭包只是对`s`进行了不可变借用，实际上，它可以适用于任何一种`Fn`特征：三个`exec`函数说明了一切。强烈建议读者亲自动手试试各种情况下使用的`Fn`特征，更有助于加深这方面的理解。
+虽然，闭包只是对 `s` 进行了不可变借用，实际上，它可以适用于任何一种 `Fn` 特征：三个 `exec` 函数说明了一切。强烈建议读者亲自动手试试各种情况下使用的 `Fn` 特征，更有助于加深这方面的理解。
 
 关于第二条规则，有如下示例：
 
@@ -566,7 +584,7 @@ fn exec<'a, F: FnMut(&'a str) -> String>(mut f: F) {
   |                         this closure implements `FnOnce`, not `FnMut`
 ```
 
-此例中，闭包从捕获环境中移出了变量`s`的所有权，因此这个闭包仅实现了`FnOnce`，未实现`FnMut`和`Fn`。再次印证之前讲的**一个闭包实现了哪种Fn特征取决于该闭包如何使用被捕获的变量，而不是取决于闭包如何捕获它们**，跟是否使用`move`没有必然联系。
+此例中，闭包从捕获环境中移出了变量 `s` 的所有权，因此这个闭包仅自动实现了 `FnOnce`，未实现 `FnMut` 和 `Fn`。再次印证之前讲的**一个闭包实现了哪种 Fn 特征取决于该闭包如何使用被捕获的变量，而不是取决于闭包如何捕获它们**，跟是否使用 `move` 没有必然联系。
 
 如果还是有疑惑？没关系，我们来看看这三个特征的简化版源码：
 ```rust
@@ -585,10 +603,10 @@ pub trait FnOnce<Args> {
 }
 ```
 
-看到没？从特征约束能看出来`Fn`的前提是实现`FnMut`，`FnMut`的前提是实现`FnOne`，因此要实现`Fn`就要同时实现`FnMut`和`FnOnce`，这段源码从侧面印证了之前规则的正确性。
+看到没？从特征约束能看出来 `Fn` 的前提是实现 `FnMut`，`FnMut` 的前提是实现 `FnOne`，因此要实现 `Fn` 就要同时实现 `FnMut` 和 `FnOnce`，这段源码从侧面印证了之前规则的正确性。
 
-从源码中还能看出一点：`Fn`获取`&self`，`FnMut`获取`&mut self`，而`FnOnce`获取`self`.
-在实际项目中，**建议先使用`Fn`特征**，然后编译器会告诉你正误以及该如何选择。
+从源码中还能看出一点：`Fn` 获取 `&self`，`FnMut` 获取 `&mut self`，而 `FnOnce` 获取 `self`。
+在实际项目中，**建议先使用 `Fn` 特征**，然后编译器会告诉你正误以及该如何选择。
 
 ## 闭包作为函数返回值
 看到这里，相信大家对于如何使用闭包作为函数参数，已经很熟悉了，但是如果要使用闭包作为函数返回值，该如何做？
@@ -607,24 +625,24 @@ let answer = f(1);
 assert_eq!(6, answer);
 ```
 
-上面这段代码看起来还是蛮正常的，用`Fn(i32) -> i32`特征来代表`|x| x + num`，非常合理嘛，肯定可以编译通过, 可惜理想总是难以照进现实，编译器给我们报了一大堆错误，先挑几个重点来看看：
+上面这段代码看起来还是蛮正常的，用 `Fn(i32) -> i32` 特征来代表 `|x| x + num`，非常合理嘛，肯定可以编译通过, 可惜理想总是难以照进现实，编译器给我们报了一大堆错误，先挑几个重点来看看：
 ```console
 fn factory<T>() -> Fn(i32) -> i32 {
   |                    ^^^^^^^^^^^^^^ doesn't have a size known at compile-time // 该类型在编译器没有固定的大小
 ```
 
-Rust要求函数的参数和返回类型，必须有固定的内存大小，例如`i32`就是4个字节，引用类型是8个字节，总之，绝大部分类型都有固定的大小，但是不包括特征，因为特征类似接口，对于编译器来说，无法知道它后面藏的真实类型是什么，因为也无法得知具体的大小。
+Rust 要求函数的参数和返回类型，必须有固定的内存大小，例如 `i32` 就是4个字节，引用类型是8个字节，总之，绝大部分类型都有固定的大小，但是不包括特征，因为特征类似接口，对于编译器来说，无法知道它后面藏的真实类型是什么，因为也无法得知具体的大小。
 
-但是我们又无法知道闭包的具体类型，该怎么办呢？再看看报错提示:
+同样，我们也无法知道闭包的具体类型，该怎么办呢？再看看报错提示：
 ```console
 help: use `impl Fn(i32) -> i32` as the return type, as all return paths are of type `[closure@src/main.rs:11:5: 11:21]`, which implements `Fn(i32) -> i32`
   |
 8 | fn factory<T>() -> impl Fn(i32) -> i32 {
 ```
 
-嗯，编译器提示我们加一个`impl`关键字，哦，这样一说，读者可能就想起来了，`impl Trait`可以用来返回一个实现了指定特征的类型，那么这里`impl Fn(i32) -> i32`的返回值形式，说明我们要返回一个闭包类型，它实现了`Fn(i32) -> i32`特征。
+嗯，编译器提示我们加一个 `impl` 关键字，哦，这样一说，读者可能就想起来了，`impl Trait` 可以用来返回一个实现了指定特征的类型，那么这里 `impl Fn(i32) -> i32` 的返回值形式，说明我们要返回一个闭包类型，它实现了 `Fn(i32) -> i32` 特征。
 
-完美解决，但是，在[特征](../../basic/trait/trait.md)那一章，我们提到过，`impl Trait`的返回方式有一个非常大的局限，就是你只能返回同样的类型，例如:
+完美解决，但是，在[特征](../../basic/trait/trait.md)那一章，我们提到过，`impl Trait` 的返回方式有一个非常大的局限，就是你只能返回同样的类型，例如：
 ```rust
 fn factory(x:i32) -> impl Fn(i32) -> i32 {
 
@@ -637,7 +655,7 @@ fn factory(x:i32) -> impl Fn(i32) -> i32 {
     }
 }
 ```
-运行后，编译器报错:
+运行后，编译器报错：
 ```console
 error[E0308]: `if` and `else` have incompatible types
   --> src/main.rs:15:9
@@ -653,14 +671,14 @@ error[E0308]: `if` and `else` have incompatible types
    |
 ```
 
-嗯，提示很清晰：`if`和`else`分支中返回了不同的闭包类型，这就很奇怪了，明明这两个闭包长的一样的，好在细心的读者应该回想起来，本章节前面咱们有提到：就算签名一样的闭包，类型也是不同的，因此在这种情况下，就无法再使用`impl Trait`的方式去返回闭包。
+嗯，提示很清晰：`if` 和 `else` 分支中返回了不同的闭包类型，这就很奇怪了，明明这两个闭包长的一样的，好在细心的读者应该回想起来，本章节前面咱们有提到：就算签名一样的闭包，类型也是不同的，因此在这种情况下，就无法再使用 `impl Trait` 的方式去返回闭包。
 
-怎么办？再看看编译器提示，里面有这样一行小字:
+怎么办？再看看编译器提示，里面有这样一行小字：
 ```console
 = help: consider boxing your closure and/or using it as a trait object
 ```
 
-哦，相信你已经恍然大悟，可以用特征对象！只需要用`Box`的方式即可实现：
+哦，相信你已经恍然大悟，可以用特征对象！只需要用 `Box` 的方式即可实现：
 ```rust
 fn factory(x:i32) -> Box<dyn Fn(i32) -> i32> {
     let num = 5;
@@ -676,4 +694,4 @@ fn factory(x:i32) -> Box<dyn Fn(i32) -> i32> {
 至此，闭包作为函数返回值就已完美解决，若以后你再遇到报错时，一定要仔细阅读编译器的提示，很多时候，转角都能遇到爱。
 
 ## 闭包的生命周期
-这块儿内容在进阶生命周期章节中有讲，这里就不再赘述，读者可移步[此处](https://course.rs/advance/lifetime/advance.html#闭包函数的消除规则)进行回顾。
+这块儿内容在进阶生命周期章节中有讲，这里就不再赘述，读者可移步[此处](https://course.rs/advance/lifetime/advance.html#闭包函数的消除规则)进行回顾。

book/contents/advance/functional-programing/iterator.md

@@ -1,12 +1,12 @@
-# 迭代器Iterator
-如果你询问一个Rust资深开发：写Rust项目最需要掌握什么？相信迭代器往往就是答案之一。无论你是编程新手亦或是高手，实际上大概率都用过迭代器，虽然自己可能并没有意识到这一点:)
+# 迭代器 Iterator
+如果你询问一个 Rust 资深开发：写 Rust 项目最需要掌握什么？相信迭代器往往就是答案之一。无论你是编程新手亦或是高手，实际上大概率都用过迭代器，虽然自己可能并没有意识到这一点:)
 
-迭代器允许我们迭代一个连续的集合，例如数组、动态数组Vec、`HashMap`等，在此过程中，只需关心集合中的元素如何处理，而无需去关心如何开始、如何结束、按照什么样的索引去访问等问题。
+迭代器允许我们迭代一个连续的集合，例如数组、动态数组 `Vec`、`HashMap` 等，在此过程中，只需关心集合中的元素如何处理，而无需关心如何开始、如何结束、按照什么样的索引去访问等问题。
 
-## For循环与迭代器
-从用途来看，迭代器跟`for`循环颇为相似，都是去遍历一个集合，但是实际上它们存在不小的差别，其中最主要的差别就是：**是否通过索引来访问集合**。
+## For 循环与迭代器
+从用途来看，迭代器跟 `for` 循环颇为相似，都是去遍历一个集合，但是实际上它们存在不小的差别，其中最主要的差别就是：**是否通过索引来访问集合**。
 
-例如以下的JS代码就是一个循环:
+例如以下的JS代码就是一个循环：
 ```javascript
 let arr = [1, 2, 3];
 for (let i = 0; i < arr.length; i++) {
@@ -14,7 +14,7 @@ for (let i = 0; i < arr.length; i++) {
 }
 ```
 
-在上面代码中，我们设置索引的开始点和结束点，然后再通过索引去访问元素`arr[i]`，这就是典型的循环，来对比下Rust中的`for`:
+在上面代码中，我们设置索引的开始点和结束点，然后再通过索引去访问元素 `arr[i]`，这就是典型的循环，来对比下 Rust 中的 `for`：
 ```rust
 let arr = [1, 2, 3];
 for v in arr {
@@ -22,11 +22,11 @@ for v in arr {
 }
 ```
 
-首先，不得不说这两语法还挺像！与JS循环不同，`Rust`中没有使用索引，它把`arr`数组当成一个迭代器，直接去遍历其中的元素，从哪里开始，从哪里结束，都无需操心。因此严格来说，Rust中的`for`循环是编译器提供的语法糖，最终还是对迭代器中的元素进行遍历。
+首先，不得不说这两语法还挺像！与 JS 循环不同，`Rust`中没有使用索引，它把 `arr` 数组当成一个迭代器，直接去遍历其中的元素，从哪里开始，从哪里结束，都无需操心。因此严格来说，Rust 中的 `for` 循环是编译器提供的语法糖，最终还是对迭代器中的元素进行遍历。
 
-那又有同学要发问了，在Rust中数组是迭代器吗？因为在之前的代码中直接对数组`arr`进行了迭代，答案是`No`。那既然数组不是迭代器，为啥咱可以对它的元素进行迭代呢？
+那又有同学要发问了，在 Rust 中数组是迭代器吗？因为在之前的代码中直接对数组 `arr` 进行了迭代，答案是 `No`。那既然数组不是迭代器，为啥咱可以对它的元素进行迭代呢？
 
-简而言之就是数组实现了`IntoIterator`特征，Rust通过`for`语法糖，自动把实现了该特征的数组类型转换为迭代器(你也可以为自己的集合类型实现此特征)，最终让我们可以直接对一个数组进行迭代，类似的还有：
+简而言之就是数组实现了 `IntoIterator` 特征，Rust 通过 `for` 语法糖，自动把实现了该特征的数组类型转换为迭代器(你也可以为自己的集合类型实现此特征)，最终让我们可以直接对一个数组进行迭代，类似的还有：
 ```rust
 for i in 1..10 {
     println!("{}", i);
@@ -34,7 +34,7 @@ for i in 1..10 {
 ```
 直接对数值序列进行迭代，也是很常见的使用方式。
 
-`IntoIterator`特征拥有一个`into_iter`方法，因此我们还可以显式的把数组转换成迭代器：
+`IntoIterator` 特征拥有一个 `into_iter` 方法，因此我们还可以显式的把数组转换成迭代器：
 ```rust
 let arr = [1, 2, 3];
 for v in arr.into_iter() {
@@ -42,7 +42,7 @@ for v in arr.into_iter() {
 }
 ```
 
-迭代器是函数语言的核心特性，它赋予了Rust远超于循环的强大表达能力，我们也将在本章中一一为大家进行展现。
+迭代器是函数语言的核心特性，它赋予了 Rust 远超于循环的强大表达能力，我们将在本章中一一为大家进行展现。
 
 ## 惰性初始化
 在Rust中，迭代器是惰性的，意味着如果你不使用它，那么它将不会发生任何事：
@@ -56,14 +56,14 @@ for val in v1_iter {
 }
 ```
 
-在`for`循环之前，我们只是简单的创建了一个迭代器`v1_iter`，此时不会发生任何迭代行为，只有在`for`循环开始后，迭代器才会开始迭代其中的元素，最后打印出来。
+在 `for` 循环之前，我们只是简单的创建了一个迭代器 `v1_iter`，此时不会发生任何迭代行为，只有在 `for` 循环开始后，迭代器才会开始迭代其中的元素，最后打印出来。
 
-这种惰性初始化的方式确保了创建迭代器不会有任何额外的性能损耗，其中的元素也不会被消耗，只有到使用该迭代器的时候，一切才开始。
+这种惰性初始化的方式确保了创建迭代器不会有任何额外的性能损耗，其中的元素也不会被消耗，只有使用到该迭代器的时候，一切才开始。
 
-## next方法
-对于`for`如何遍历迭代器，还有一个问题，它如何取出迭代器中的元素？
+## next 方法
+对于 `for` 如何遍历迭代器，还有一个问题，它如何取出迭代器中的元素？
 
-先来看一个特征:
+先来看一个特征：
 ```rust
 pub trait Iterator {
     type Item;
@@ -74,11 +74,11 @@ pub trait Iterator {
 }
 ```
 
-呦，该特征竟然和迭代器iterator同名，难不成。。。没错，它们就是有一腿。**迭代器之所以成为迭代器，就是因为实现了`Iterator`特征**，要实现该特征，最主要的就是实现其中的`next`方法，该方法控制如何从集合中取值，最终返回值的类型是[关联类型](https://course.rs/basic/trait/advance-trait#关联类型)`Item`.
+呦，该特征竟然和迭代器 `iterator` 同名，难不成。。。没错，它们就是有一腿。**迭代器之所以成为迭代器，就是因为实现了 `Iterator` 特征**，要实现该特征，最主要的就是实现其中的 `next` 方法，该方法控制如何从集合中取值，最终返回值的类型是[关联类型](https://course.rs/basic/trait/advance-trait#关联类型) `Item`。
 
-因此，之前问题的答案已经很明显：`for`循环通过不停调用迭代器上的`next`方法，来获取迭代器中的元素。
+因此，之前问题的答案已经很明显：`for` 循环通过不停调用迭代器上的 `next` 方法，来获取迭代器中的元素。
 
-既然`for`可以调用`next`方法，是不是意味着我们也可以？来试试:
+既然 `for` 可以调用 `next` 方法，是不是意味着我们也可以？来试试：
 ```rust
 fn main() {
     let arr = [1, 2, 3];
@@ -91,16 +91,16 @@ fn main() {
 }
 ```
 
-果不其然，将`arr`转换成迭代器后，通过调用其上的`next`方法，我们获取了`arr`中的元素, 有两点需要注意:
+果不其然，将 `arr` 转换成迭代器后，通过调用其上的 `next` 方法，我们获取了 `arr` 中的元素，有两点需要注意：
 
-- `next`方法返回的是`Option`类型，当有值时返回`Some(i32)`,无值时返回`None`
-- 遍历是按照迭代器中元素的排列顺序依次进行的，因此我们严格按照数组中元素的顺序取出了`Some(1)`,`Some(2)`,`Some(3)`
-- 手动迭代必须将迭代器声明为`mut`可变，因为调用`next`会改变迭代器其中的状态数据(当前遍历的位置等)，而`for`循环去迭代则无需标注`mut`，因为它会帮我们自动完成
+- `next` 方法返回的是 `Option` 类型，当有值时返回 `Some(i32)`，无值时返回 `None`
+- 遍历是按照迭代器中元素的排列顺序依次进行的，因此我们严格按照数组中元素的顺序取出了 `Some(1)`，`Some(2)`，`Some(3)`
+- 手动迭代必须将迭代器声明为 `mut` 可变，因为调用 `next` 会改变迭代器其中的状态数据(当前遍历的位置等)，而 `for` 循环去迭代则无需标注 `mut`，因为它会帮我们自动完成
 
-总之，`next`方法对**迭代器的遍历是消耗性的**，每次消耗它一个元素，最终迭代器中将没有任何元素, 只能返回`None`.
+总之，`next` 方法对**迭代器的遍历是消耗性的**，每次消耗它一个元素，最终迭代器中将没有任何元素，只能返回 `None`。
 
 #### 例子：模拟实现for循环
-因为for循环是迭代器的语法糖，因此我们完全可以通过迭代器来模拟实现它：
+因为 `for` 循环是迭代器的语法糖，因此我们完全可以通过迭代器来模拟实现它：
 ```rust
 let values = vec![1, 2, 3];
 
@@ -117,15 +117,21 @@ let values = vec![1, 2, 3];
 }
 ```
 
-`IntoIterator::into_iter`是使用[完全限定](https://course.rs/basic/trait/advance-trait.html#完全限定语法)的方式去调用`into_iter`方法，这种调用方式跟`values.into_iter()`是等价的。
+`IntoIterator::into_iter` 是使用[完全限定](https://course.rs/basic/trait/advance-trait.html#完全限定语法)的方式去调用 `into_iter` 方法，这种调用方式跟 `values.into_iter()` 是等价的。
 
-同时我们使用了`loop`循环配合`next`方法来遍历迭代器中的元素，当迭代器返回`None`时，跳出循环。
+同时我们使用了 `loop` 循环配合 `next` 方法来遍历迭代器中的元素，当迭代器返回 `None` 时，跳出循环。
 
-## IntoIterator特征
-其实有一个细节，由于`Vec`动态数组实现了`IntoIterator`特征，因此可以通过`into_iter`将其转换为迭代器，那如果本身就是一个迭代器，该怎么办？实际上，迭代器自身也实现了`IntoIterator`，标准库早就帮我们考虑好了:
+## IntoIterator 特征
+其实有一个细节，由于 `Vec` 动态数组实现了 `IntoIterator` 特征，因此可以通过 `into_iter` 将其转换为迭代器，那如果本身就是一个迭代器，该怎么办？实际上，迭代器自身也实现了 `IntoIterator`，标准库早就帮我们考虑好了：
 ```rust
 impl<I: Iterator> IntoIterator for I {
-    // ...
+    type Item = I::Item;
+    type IntoIter = I;
+
+    #[inline]
+    fn into_iter(self) -> I {
+        self
+    }
 }
 ```
 
@@ -141,15 +147,15 @@ fn main() {
 ```
 
 #### into_iter, iter, iter_mut
-在之前的代码中，我们统一使用了`into_iter`的方式将数组转化为迭代器，除此之外，还有`iter`和`iter_mut`，聪明的读者应该大概能猜到这三者的区别：
+在之前的代码中，我们统一使用了 `into_iter` 的方式将数组转化为迭代器，除此之外，还有 `iter` 和 `iter_mut`，聪明的读者应该大概能猜到这三者的区别：
 
-- `into_iter`会夺走所有权
-- `iter`是借用
-- `iter_mut`是可变借用
+- `into_iter` 会夺走所有权
+- `iter` 是借用
+- `iter_mut` 是可变借用
 
-其实如果以后见多识广了，你会发现这种问题一眼就能看穿，`into_`之类的，都是拿走所有权，`_mut`之类的都是可变借用，剩下的就是不可变借用。
+其实如果以后见多识广了，你会发现这种问题一眼就能看穿，`into_` 之类的，都是拿走所有权，`_mut` 之类的都是可变借用，剩下的就是不可变借用。
 
-使用一段代码来解释下:
+使用一段代码来解释下：
 ```rust
 fn main() {
     let values = vec![1, 2, 3];
@@ -158,17 +164,17 @@ fn main() {
         println!("{}", v)
     }
 
-    // 下面的代码将报错，因为values的所有权在上面`for`循环中已经被转移走
+    // 下面的代码将报错，因为 values 的所有权在上面 `for` 循环中已经被转移走
     // println!("{:?}",values);
 
     let values = vec![1, 2, 3];
     let _values_iter = values.iter();
 
-    // 不会报错，因为values_iter是借用了values中的元素
+    // 不会报错，因为 values_iter 只是借用了 values 中的元素
     println!("{:?}", values);
 
     let mut values = vec![1, 2, 3];
-    // 对values中的元素进行可变借用
+    // 对 values 中的元素进行可变借用
     let mut values_iter_mut = values.iter_mut();
 
     // 取出第一个元素，并修改为0
@@ -180,23 +186,23 @@ fn main() {
     println!("{:?}", values);
 }
 ```
-具体解释在代码注释中，就不再赘述,不过有两点需要注意的是：
+具体解释在代码注释中，就不再赘述，不过有两点需要注意的是：
 
-- `.iter()`方法实现的迭代器，调用`next`方法返回的类型是`Some(&T)`
-- `.iter_mut()`方法实现的迭代器，调用`next`方法返回的类型是`Some(&mut T)`, 因此在`if let Some(v) = values_iter_mut.next()`中，`v`的类型是`&mut i32`，最终我们可以通过`*v = 0`的方式修改其值
+- `.iter()` 方法实现的迭代器，调用 `next` 方法返回的类型是 `Some(&T)`
+- `.iter_mut()` 方法实现的迭代器，调用 `next` 方法返回的类型是 `Some(&mut T)`，因此在 `if let Some(v) = values_iter_mut.next()` 中，`v` 的类型是 `&mut i32`，最终我们可以通过 `*v = 0` 的方式修改其值
 
-#### Iterator和IntoIterator的区别
-这两个其实还蛮容易搞混的，但我们只需要记住，`Iterator`就是迭代器特征，只有实现了它才能称为迭代器，才能调用`next`。
+#### Iterator 和 IntoIterator 的区别
+这两个其实还蛮容易搞混的，但我们只需要记住，`Iterator` 就是迭代器特征，只有实现了它才能称为迭代器，才能调用 `next`。
 
-而`IntoIterator`强调的是某一个类型如果实现了该特征，它可以通过`into_iter`，`iter`等方法变成一个迭代器.
+而 `IntoIterator` 强调的是某一个类型如果实现了该特征，它可以通过 `into_iter`，`iter` 等方法变成一个迭代器。
 
 ## 消费者与适配器
-消费者是迭代器上的方法，它会消费掉迭代器中的元素，然后返回其它类型的值，这些消费者都有一个共同的特点：在它们的定义中，都依赖`next`方法来消费元素，因此这也是为什么迭代器要实现`Iterator`特征，而该特征必须要实现`next`方法的原因。
+消费者是迭代器上的方法，它会消费掉迭代器中的元素，然后返回其它类型的值，这些消费者都有一个共同的特点：在它们的定义中，都依赖 `next` 方法来消费元素，因此这也是为什么迭代器要实现 `Iterator` 特征，而该特征必须要实现 `next` 方法的原因。
 
 #### 消费者适配器
-只要迭代器上的某个方法`A`在其内部调用了`next`方法，那么`A`就被称为**消费性适配器**: 因为`next`方法会消耗掉迭代器上的元素，可以推出方法`A`的调用也会消耗掉迭代器上的元素。
+只要迭代器上的某个方法 `A` 在其内部调用了 `next` 方法，那么 `A` 就被称为**消费性适配器**：因为 `next` 方法会消耗掉迭代器上的元素，所以方法 `A` 的调用也会消耗掉迭代器上的元素。
 
-其中一个例子是`sum`方法，它会拿走迭代器的所有权，然后通过不断调用`next`方法对里面的元素进行求和:
+其中一个例子是 `sum` 方法，它会拿走迭代器的所有权，然后通过不断调用 `next` 方法对里面的元素进行求和：
 ```rust
 fn main() {
     let v1 = vec![1, 2, 3];
@@ -207,15 +213,15 @@ fn main() {
 
     assert_eq!(total, 6);
     
-    // v1_iter是借用了v1，因此v1可以照常使用
+    // v1_iter 是借用了 v1，因此 v1 可以照常使用
     println!("{:?}",v1);
 
-    // 以下代码会报错，因为`sum`拿到了迭代器`v1_iter`的所有权
+    // 以下代码会报错，因为 `sum` 拿到了迭代器 `v1_iter` 的所有权
     // println!("{:?}",v1_iter);
 }
 ```
 
-如代码注释中所说明的：在使用`sum`方法后，我们将无法再使用`v1_iter`，因为`sum`拿走了该迭代器的所有权:
+如代码注释中所说明的：在使用 `sum` 方法后，我们将无法再使用 `v1_iter`，因为 `sum` 拿走了该迭代器的所有权：
 ```rust
 fn sum<S>(self) -> S
     where
@@ -227,10 +233,10 @@ fn sum<S>(self) -> S
 
 ```
 
-从`sum`源码中也可以清晰看出，`self`类型的方法参数拿走了所有权。
+从 `sum` 源码中也可以清晰看出，`self` 类型的方法参数拿走了所有权。
 
 #### 迭代器适配器
-既然消费者适配器是消费掉迭代器，然后返回一个值。那么迭代器适配器，顾名思义，会返回一个新的迭代器，这是实现链式方法调用的关键:`v.iter().map().filter()...`。
+既然消费者适配器是消费掉迭代器，然后返回一个值。那么迭代器适配器，顾名思义，会返回一个新的迭代器，这是实现链式方法调用的关键：`v.iter().map().filter()...`。
 
 与消费者适配器不同，迭代器适配器是惰性的，意味着你**需要一个消费者适配器来收尾，最终将迭代器转换成一个具体的值**：
 ```rust
@@ -251,7 +257,7 @@ warning: unused `Map` that must be used
   = note: iterators are lazy and do nothing unless consumed // 迭代器map是惰性的，这里不产生任何效果
 ```
 
-如上述中文注释所说，这里的`map`方法是一个迭代者适配器，它是惰性的，不产生任何行为，因此我们还需要一个消费者适配器进行收尾:
+如上述中文注释所说，这里的 `map` 方法是一个迭代者适配器，它是惰性的，不产生任何行为，因此我们还需要一个消费者适配器进行收尾：
 ```rust
 let v1: Vec<i32> = vec![1, 2, 3];
 
@@ -261,13 +267,13 @@ assert_eq!(v2, vec![2, 3, 4]);
 ```
 
 #### collect
-上面代码中，使用了`collect`方法，该方法就是一个消费者适配器，使用它可以将一个迭代器中的元素收集到指定类型中，这里我们为`v2`标注了`Vec<_>`类型，就是为了告诉`collect`：请把迭代器中的元素消费掉，然后把值收集成`Vec<_>`类型，至于为何使用`_`，因为编译器会帮我们自动推导。
+上面代码中，使用了 `collect` 方法，该方法就是一个消费者适配器，使用它可以将一个迭代器中的元素收集到指定类型中，这里我们为 `v2` 标注了 `Vec<_>` 类型，就是为了告诉 `collect`：请把迭代器中的元素消费掉，然后把值收集成 `Vec<_>` 类型，至于为何使用 `_`，因为编译器会帮我们自动推导。
 
-为何`collect`在消费时要指定类型？是因为该方法其实很强大，可以收集成多种不同的集合类型，`Vec<T>`仅仅是其中之一，因此我们必须显式的告诉编译器我们想要收集成的集合类型。
+为何 `collect` 在消费时要指定类型？是因为该方法其实很强大，可以收集成多种不同的集合类型，`Vec<T>` 仅仅是其中之一，因此我们必须显式的告诉编译器我们想要收集成的集合类型。
 
-还有一点值得注意,`map`会对迭代器中的每一个值进行一系列操作，然后把该值转换成另外一个新值， 该操作是通过闭包`|x| x + 1`来完成: 最终迭代器中的每个值都增加了`1`，从`[1, 2, 3]`变为`[2, 3, 4]`.
+还有一点值得注意，`map` 会对迭代器中的每一个值进行一系列操作，然后把该值转换成另外一个新值，该操作是通过闭包 `|x| x + 1` 来完成：最终迭代器中的每个值都增加了 `1`，从 `[1, 2, 3]` 变为 `[2, 3, 4]`。
 
-再来看看如何使用`collect`收集成`HashMap`集合：
+再来看看如何使用 `collect` 收集成 `HashMap` 集合：
 ```rust
 use std::collections::HashMap;
 fn main() {
@@ -279,12 +285,12 @@ fn main() {
 }
 ```
 
-`zip`是一个迭代器适配器，它的作用就是将两个迭代器的内容压缩到一起，形成`Iterator<Item=(ValueFromA, ValueFromB)>` 这样的新的迭代器,在此处就是形如`[(name1, age1), (name2, age2)]`的迭代器。
+`zip` 是一个迭代器适配器，它的作用就是将两个迭代器的内容压缩到一起，形成 `Iterator<Item=(ValueFromA, ValueFromB)>` 这样的新的迭代器，在此处就是形如 `[(name1, age1), (name2, age2)]` 的迭代器。
 
-然后再通过`collect`将新迭代器中`(K, V)`形式的值收集成`HashMap<K, V>`，同样的，这里必须显式声明类型，然后`HashMap`内部的`KV`类型可以交给编译器去推导，最终编译器会推导出`HashMap<&str, i32>`，完全正确！
+然后再通过 `collect` 将新迭代器中`(K, V)` 形式的值收集成 `HashMap<K, V>`，同样的，这里必须显式声明类型，然后 `HashMap` 内部的 `KV` 类型可以交给编译器去推导，最终编译器会推导出 `HashMap<&str, i32>`，完全正确！
 
 #### 闭包作为适配器参数
-之前的`map`方法中，我们使用闭包来作为迭代器适配器的参数，它最大的好处不仅在于就地实现迭代器中元素的处理，还在于可以捕获环境值:
+之前的 `map` 方法中，我们使用闭包来作为迭代器适配器的参数，它最大的好处不仅在于可以就地实现迭代器中元素的处理，还在于可以捕获环境值：
 ```rust
 struct Shoe {
     size: u32,
@@ -296,10 +302,10 @@ fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
 }
 ```
 
-`filter`是迭代器适配器，用于对迭代器中的每个值进行过滤。 它使用闭包作为参数，该闭包的参数`s`是来自迭代器中的值，然后使用`s`跟外部环境中的`shoe_size`进行比较，若相等，则在迭代器中保留`s`值，若不相等，则从迭代器中剔除`s`值，最终通过`collect`收集为`Vec<Shoe>`类型.
+`filter` 是迭代器适配器，用于对迭代器中的每个值进行过滤。 它使用闭包作为参数，该闭包的参数 `s` 是来自迭代器中的值，然后使用 `s` 跟外部环境中的 `shoe_size` 进行比较，若相等，则在迭代器中保留 `s` 值，若不相等，则从迭代器中剔除 `s` 值，最终通过 `collect` 收集为 `Vec<Shoe>` 类型。
 
-## 实现Iterator特征
-之前的内容我们一直基于数组来创建迭代器，实际上，不仅仅是数组，基于其它集合类型一样可以创建迭代器，例如`HashMap`。 你也可以创建自己的迭代器 - 只要为自定义类型实现`Iterator`特征即可。
+## 实现 Iterator 特征
+之前的内容我们一直基于数组来创建迭代器，实际上，不仅仅是数组，基于其它集合类型一样可以创建迭代器，例如 `HashMap`。 你也可以创建自己的迭代器 - 只要为自定义类型实现 `Iterator` 特征即可。
 
 首先，创建一个计数器：
 ```rust
@@ -314,7 +320,7 @@ impl Counter {
 }
 ```
 
-我们为计数器`Counter`实现了一个关联函数`new`，用于创建新的计数器实例。下面们继续为计数器实现`Iterator`特征：
+我们为计数器 `Counter` 实现了一个关联函数 `new`，用于创建新的计数器实例。下面们继续为计数器实现 `Iterator` 特征：
 ```rust
 impl Iterator for Counter {
     type Item = u32;
@@ -330,11 +336,11 @@ impl Iterator for Counter {
 }
 ```
 
-首先，将该特征的关联类型设置为`u32`，由于我们的计数器保存的`count`字段就是`u32`类型， 因此在`next`方法中，最后返回的是实际上是`Option<u32>`类型.
+首先，将该特征的关联类型设置为 `u32`，由于我们的计数器保存的 `count` 字段就是 `u32` 类型， 因此在 `next` 方法中，最后返回的是实际上是 `Option<u32>` 类型。
 
-每次调用`next`方法，都会让计数器的值加一，然后返回最新的计数值，一旦计数大于5，就返回`None`。
+每次调用 `next` 方法，都会让计数器的值加一，然后返回最新的计数值，一旦计数大于5，就返回 `None`。
 
-最后，使用我们新建的`Counter`进行迭代：
+最后，使用我们新建的 `Counter` 进行迭代：
 ```rust
  let mut counter = Counter::new();
 
@@ -346,8 +352,8 @@ assert_eq!(counter.next(), Some(5));
 assert_eq!(counter.next(), None);
 ```
 
-#### 实现Iterator特征的其它方法
-可以看出，实现自己的迭代器非常简单，但是`Iterator`特征中，不仅仅是只有`next`一个方法，那为什么我们只需要实现它呢？因为其它方法都具有[默认实现](https://course.rs/basic/trait/trait.html#默认实现)，无需像`next`这样手动去实现，而且这些默认实现的方法其实都是基于`next`方法实现的。
+#### 实现 Iterator 特征的其它方法
+可以看出，实现自己的迭代器非常简单，但是 `Iterator` 特征中，不仅仅是只有 `next` 一个方法，那为什么我们只需要实现它呢？因为其它方法都具有[默认实现](https://course.rs/basic/trait/trait.html#默认实现)，所以无需像 `next` 这样手动去实现，而且这些默认实现的方法其实都是基于 `next` 方法实现的。
 
 下面的代码演示了部分方法的使用：
 ```rust
@@ -359,16 +365,16 @@ let sum: u32 = Counter::new()
 assert_eq!(18, sum);
 ```
 
-其中`zip`, `map`, `filter`是迭代器适配器：
+其中 `zip`，`map`，`filter` 是迭代器适配器：
 
-- `zip`把两个迭代器合并成一个迭代器，新迭代器中，每个元素都是一个元组，由之前两个迭代器的元素组成。例如将**形如**`[1, 2, 3]`和`[4, 5, 6]`的迭代器合并后，新的迭代器形如`[(1, 4),(2, 5),(3, 6)]`
-- `map`是将迭代器中的值经过映射后，转换成新的值
-- `filter`对迭代器中的元素进行过滤，若闭包返回`true`则保留元素，反之剔除
+- `zip` 把两个迭代器合并成一个迭代器，新迭代器中，每个元素都是一个元组，由之前两个迭代器的元素组成。例如将**形如** `[1, 2, 3]` 和 `[4, 5, 6]` 的迭代器合并后，新的迭代器形如 `[(1, 4),(2, 5),(3, 6)]`
+- `map` 是将迭代器中的值经过映射后，转换成新的值
+- `filter` 对迭代器中的元素进行过滤，若闭包返回 `true` 则保留元素，反之剔除
 
-而`sum`是消费者适配器，对迭代器中的所有元素求和，最终返回一个`u32`值`18`。
+而 `sum` 是消费者适配器，对迭代器中的所有元素求和，最终返回一个 `u32` 值 `18`。
 
 ##### enumerate
-在之前的流程控制章节，针对`for`循环，我们提供了一种方法可以获取迭代时的索引:
+在之前的流程控制章节，针对 `for` 循环，我们提供了一种方法可以获取迭代时的索引：
 ```rust
 let v = vec![1u64, 2, 3, 4, 5, 6];
 for (i,v) in v.iter().enumerate() {
@@ -376,10 +382,10 @@ for (i,v) in v.iter().enumerate() {
 }
 ```
 
-相信当时，很多读者还是很迷茫的，不知道为什么要这么复杂才能获取到索引，学习本章节后，相信你有了全新的理解，首先`v.iter()`创建迭代器，其次
-调用`Iterator`特征上的方法`enumerate`，该方法产生一个新的迭代器，其中每个元素均是元组`(索引，值)`。
+相信当时，很多读者还是很迷茫的，不知道为什么要这么复杂才能获取到索引，学习本章节后，相信你有了全新的理解，首先 `v.iter()` 创建迭代器，其次
+调用 `Iterator` 特征上的方法 `enumerate`，该方法产生一个新的迭代器，其中每个元素均是元组 `(索引，值)`。
 
-因为`enumerate`是迭代器适配器，因此我们可以对它返回的迭代器调用其它`Iterator`特征方法：
+因为 `enumerate` 是迭代器适配器，因此我们可以对它返回的迭代器调用其它 `Iterator` 特征方法：
 ```rust
 let v = vec![1u64, 2, 3, 4, 5, 6];
 let val = v.iter()
@@ -396,7 +402,7 @@ println!("{}", val);
 
 ## 迭代器的性能
 
-前面提到，要完成集合遍历，既可以使用for循环也可以使用迭代器，那么二者之间该怎么选择呢，性能有多大差距呢？
+前面提到，要完成集合遍历，既可以使用 `for` 循环也可以使用迭代器，那么二者之间该怎么选择呢，性能有多大差距呢？
 
 理论分析不会有结果，直接测试最为靠谱：
 
@@ -449,7 +455,7 @@ mod bench {
 }
 ```
 
-上面的代码对比了for循环和迭代器iterator完成同样的求和任务的性能对比，可以看到迭代器还要更快一点。
+上面的代码对比了 `for` 循环和迭代器 `iterator` 完成同样的求和任务的性能对比，可以看到迭代器还要更快一点。
 
 ```console
 test bench::bench_for  ... bench:     998,331 ns/iter (+/- 36,250)
@@ -467,7 +473,7 @@ And further: What you do use, you couldn’t hand code any better.
 （翻译一下：用就完事了）
 ```
 
-总之，迭代器是 Rust 受函数式语言启发而提供的高级语言特性，可以写出更加简洁、逻辑清晰的代码。编译器还可以通过循环展开（Unrolling）、向量化、消除边界检查等优化手段，使得迭代器和for循环都有极为高效的执行效率。
+总之，迭代器是 Rust 受函数式语言启发而提供的高级语言特性，可以写出更加简洁、逻辑清晰的代码。编译器还可以通过循环展开（Unrolling）、向量化、消除边界检查等优化手段，使得迭代器和 `for` 循环都有极为高效的执行效率。
 
 所以请放心大胆的使用迭代器，在获得更高的表达力的同时，也不会导致运行时的损失，何乐而不为呢！
 

book/contents/advance/lifetime/advance.md

@@ -158,7 +158,7 @@ struct DoubleRef<'a,'b:'a, T> {
 }
 ```
 
-例如上述代码定义一个结构体，它拥有两个引用字段，类型都是泛型 `T`，每个引用都拥有自己的生命周期，由于我们使用了生命周期约束 `'b: 'a`，因此 `'b` 必须活得比 `'a` 久，也就是结构体中的 `r` 字段引用的值必须要比 `s` 字段引用的值活得要久。
+例如上述代码定义一个结构体，它拥有两个引用字段，类型都是泛型 `T`，每个引用都拥有自己的生命周期，由于我们使用了生命周期约束 `'b: 'a`，因此 `'b` 必须活得比 `'a` 久，也就是结构体中的 `s` 字段引用的值必须要比 `r` 字段引用的值活得要久。
 
 #### T: 'a
 表示类型 `T` 必须比 `'a` 活得要久：

book/contents/appendix/difficulties.md

@@ -5,7 +5,7 @@
 | 难点及链接          | 简介                                                                            |
 |-----             | ------                                                                             |
 | [?](../basic/result-error/result.md#传播界的大明星:)   |       用于简化错误传播                          |
-| [()](../basic/base-type/function.md#无返回值) |  元类型          |
+| [()](../basic/base-type/function.md#无返回值) |  单元类型          |
 | `!` : [1](../basic/base-type/function.md#永不返回的函数), [2](../advance/custom-type.md#!从不返回类型) | 永不返回 |
 | [@](../basic/match-pattern/all-patterns.md#绑定) | 为一个字段绑定另外一个变量 |
 | ['a: 'b](../advance/lifetime/advance.md#生命周期约束) | 生命周期约束   |

book/contents/async/future-excuting.md

@@ -263,7 +263,7 @@ Rust的 `Future` 是惰性的：只有屁股上拍一拍，它才会努力动一
 futures = "0.3"
 ```
 
-在之前的内容中，我们在 `src/lib.rs` 中创建了定时器 `Future` ，现在在 `src/main.js` 中来创建程序的主体内容，开始之前，先引入所需的包：
+在之前的内容中，我们在 `src/lib.rs` 中创建了定时器 `Future` ，现在在 `src/main.rs` 中来创建程序的主体内容，开始之前，先引入所需的包：
 ```rust
 use {
     futures::{
@@ -301,7 +301,7 @@ struct Task {
     /// 进行中的Future，在未来的某个时间点会被完成
     /// 
     /// 按理来说`Mutext`在这里是多余的，因为我们只有一个线程来执行任务。但是由于
-    /// Rust并不聪明，它无法知道`Future`只会在一个线程内被修改，并不会被夸线程修改。因此
+    /// Rust并不聪明，它无法知道`Future`只会在一个线程内被修改，并不会被跨线程修改。因此
     /// 我们需要使用`Mutex`来满足这个笨笨的编译器对线程安全的执着。
     ///
     /// 如果是生产级的执行器实现，不会使用`Mutex`，因为会带来性能上的开销，取而代之的是使用`UnsafeCell`
@@ -474,4 +474,4 @@ let event = io_blocker.block();
 println!("Socket {:?} is now {:?}", event.id, event.signals);
 ```
 
-这样，我们只需要一个执行器线程，它会接收IO事件并将其分发到对应的 `Waker` 中，接着后者会唤醒相关的任务，最终通过执行器 `poll` 后，任务可以顺利的继续执行, 这种IO读取流程可以不停的循环，直到 `socket` 关闭。
+这样，我们只需要一个执行器线程，它会接收IO事件并将其分发到对应的 `Waker` 中，接着后者会唤醒相关的任务，最终通过执行器 `poll` 后，任务可以顺利的继续执行, 这种IO读取流程可以不停的循环，直到 `socket` 关闭。

book/contents/basic/base-type/char-bool.md

@@ -1,4 +1,4 @@
-# 字符、布尔、元类型
+# 字符、布尔、单元类型
 
 这三个类型所处的地位比较尴尬，你说它们重要吧，有时候也是不可或缺，说它们不重要吧，确实出现的身影不是很多，而且这三个类型都有一个共同点：简单，因此我们统一放在一起讲。
 
@@ -55,14 +55,14 @@ fn main() {
 
 使用布尔类型的场景主要在于流程控制，例如上述代码的中的 `if` 就是其中之一。
 
-## 元类型
+## 单元类型
 
-元类型就是 `()` ，对，你没看错，就是 `()` ，唯一的值也是 `()` ，一些读者读到这里可能就不愿意了，你也太敷衍了吧，管这叫类型？
+单元类型就是 `()` ，对，你没看错，就是 `()` ，唯一的值也是 `()` ，一些读者读到这里可能就不愿意了，你也太敷衍了吧，管这叫类型？
 
 只能说，再不起眼的东西，都有其用途，在目前为止的学习过程中，大家已经看到过很多次 `fn main()` 函数的使用吧？那么这个函数返回什么呢？
 
-没错， `main` 函数就返回这个元类型 `()`，你不能说 `main` 函数无返回值，因为没有返回值的函数在 Rust 中是有单独的定义的：`发散函数`，顾名思义，无法收敛的函数。
+没错， `main` 函数就返回这个单元类型 `()`，你不能说 `main` 函数无返回值，因为没有返回值的函数在 Rust 中是有单独的定义的：`发散函数`，顾名思义，无法收敛的函数。
 
-例如常见的 `println!()` 的返回值也是元类型 `()`。
+例如常见的 `println!()` 的返回值也是单元类型 `()`。
 
 再比如，你可以用 `()` 作为 `map` 的值，表示我们不关注具体的值，只关注 `key`。 这种用法和 Go 语言的 ***struct{}*** 类似，可以作为一个值用来占位，但是完全**不占用**任何内存。

book/contents/basic/base-type/function.md

@@ -115,7 +115,7 @@ fn main() {
 
 对于 Rust 新手来说，有些返回类型很难理解，而且如果你想通过百度或者谷歌去搜索，都不好查询，因为这些符号太常见了，根本难以精确搜索到。
 
-例如元类型 `()`，是一个零长度的元组。它没啥作用，但是可以用来表达一个函数没有返回值：
+例如单元类型 `()`，是一个零长度的元组。它没啥作用，但是可以用来表达一个函数没有返回值：
 - 函数没有返回值，那么返回一个 `()`
 - 通过 `;` 结尾的表达式返回一个 `()`
 

book/contents/basic/base-type/index.md

@@ -7,7 +7,7 @@ Rust 每个值都有其确切的数据类型，总的来说可以分为两类：
 - 字符串：字符串字面量和字符串切片 `&str`
 - 布尔类型： `true`和`false`
 - 字符类型: 表示单个Unicode字符，存储为4个字节
-- 元类型: 即 `()` ，其唯一的值也是 `()`
+- 单元类型: 即 `()` ，其唯一的值也是 `()`
 
 
 ## 类型推导与标注

book/contents/basic/compound-type/intro.md

@@ -33,7 +33,7 @@ fn main() {
 
  `read`函数也非常有趣，它返回一个`!`，这个表明该函数是一个发散函数，不会返回任何值，包括`()`。`unimplemented!()`告诉编译器该函数尚未实现，`unimplemented!()`标记通常意味着我们期望快速完成主要代码，回头再通过搜索这些标记来完成次要代码，类似的标记还有`todo!()`，当代码执行到这种未实现的地方时，程序会直接报错: 你可以反注释`read(&mut f1, &mut vec![]);`这行，然后再观察下结果。
 
- 同时，从代码设计角度来看，关于文件操作的类型和函数应该组织在一起，散落得到处都是，是难以管理和使用的。而且通过`open(&mut f1)`进行调用，也远没有使用`f1.open()`来调用好，这就体现出了只使用基本类型得局限性：**无法从更高的抽象层次去简化代码**。
+ 同时，从代码设计角度来看，关于文件操作的类型和函数应该组织在一起，散落得到处都是，是难以管理和使用的。而且通过`open(&mut f1)`进行调用，也远没有使用`f1.open()`来调用好，这就体现出了只使用基本类型的局限性：**无法从更高的抽象层次去简化代码**。
 
 
 接下来，我们将引入一个高级数据结构 - 结构体`struct`，来看看复合类型是怎样更好的解决这类问题。 开始之前，先来看看Rust的重点也是难点：字符串`String`和`&str`。

book/contents/basic/compound-type/struct.md

@@ -182,7 +182,7 @@ println!("{:?}", user1);
 元组结构体在你希望有一个整体名称，但是又不关心里面字段的名称时将非常有用。例如上面的`Point`元组结构体，众所周知3D点是`(x,y,z)`形式的坐标点，因此我们无需再为内部的字段逐一命名为：`x`,`y`,`z`。
 
 ## 元结构体(Unit-like Struct)
-还记得之前讲过的基本没啥用的[元类型](../base-type/char-bool.md#元类型)吧? 元结构体就跟它很像，没有任何字段和属性，但是好在，它还挺有用。
+还记得之前讲过的基本没啥用的[单元类型](../base-type/char-bool.md#单)吧? 元结构体就跟它很像，没有任何字段和属性，但是好在，它还挺有用。
 
 如果你定义一个类型，但是不关心该类型的内容, 只关心它的行为时，就可以使用`元结构体`:
 ```rust

book/contents/basic/ownership/borrowing.md

@@ -1,14 +1,14 @@
 # 引用与借用
 
-上节中提到，如果仅仅支持通过转移所有权的方式获取一个值，那会让程序变得复杂。 Rust能否像其它编程语言一样，使用某个变量的指针或者引用呢？答案是可以。
+上节中提到，如果仅仅支持通过转移所有权的方式获取一个值，那会让程序变得复杂。 Rust 能否像其它编程语言一样，使用某个变量的指针或者引用呢？答案是可以。
 
-Rust通过`借用(Borrowing)`这个概念来达成上述的目的: **获取变量的引用，称之为借用(borrowing)**。正如现实生活中，如果一个人拥有某样东西，你可以从他那里借来，当使用完毕后，也必须要物归原主.
+Rust 通过 `借用(Borrowing)` 这个概念来达成上述的目的: **获取变量的引用，称之为借用(borrowing)**。正如现实生活中，如果一个人拥有某样东西，你可以从他那里借来，当使用完毕后，也必须要物归原主。
 
 
 
 ### 引用与解引用
 
-常规引用是一个指针类型，指向了对象存储的内存地址。在下面代码中，我们创建一个`i32`值的引用`y`，然后使用解引用运算符来解出`y`所使用的值:
+常规引用是一个指针类型，指向了对象存储的内存地址。在下面代码中，我们创建一个 `i32` 值的引用 `y`，然后使用解引用运算符来解出 `y` 所使用的值:
 ```rust
 fn main() {
     let x = 5;
@@ -19,7 +19,7 @@ fn main() {
 }
 ```
 
-变量 `x` 存放了一个 `i32` 值 `5`。`y`是 `x` 的一个引用。可以断言 `x` 等于 `5`。然而，如果希望对 `y` 的值做出断言，必须使用 `*y` 来解出引用所指向的值（也就是 **解引用**）。一旦解引用了 `y`，就可以访问 `y` 所指向的整型值并可以与 `5` 做比较。
+变量 `x` 存放了一个 `i32` 值 `5`。`y` 是 `x` 的一个引用。可以断言 `x` 等于 `5`。然而，如果希望对 `y` 的值做出断言，必须使用 `*y` 来解出引用所指向的值（也就是 **解引用**）。一旦解引用了 `y`，就可以访问 `y` 所指向的整型值并可以与 `5` 做比较。
 
 相反如果尝试编写 `assert_eq!(5, y);`，则会得到如下编译错误：
 
@@ -38,7 +38,7 @@ error[E0277]: can't compare `{integer}` with `&{integer}`
 
 ### 不可变引用
 
-下面的代码，我们用s1的引用作为参数传递给`calculate_length`函数，而不是把s1的所有权转移给该函数：
+下面的代码，我们用 `s1` 的引用作为参数传递给 `calculate_length` 函数，而不是把 `s1` 的所有权转移给该函数：
 ```rust
 fn main() {
     let s1 = String::from("hello");
@@ -55,14 +55,14 @@ fn calculate_length(s: &String) -> usize {
 
 能注意到两点：
 1. 无需像上章一样：先通过函数参数传入所有权，然后再通过函数返回来传出所有权，代码更加简洁
-2. `calculate_length`的参数`s`类型从`String`变为`&String`
+2. `calculate_length` 的参数 `s` 类型从 `String` 变为 `&String`
 
-这里，`&`符号即是引用，它们允许你使用值，但是不获取所有权，如图所示：
+这里，`&` 符号即是引用，它们允许你使用值，但是不获取所有权，如图所示：
 <img alt="&String s pointing at String s1" src="/img/borrowing-01.svg" class="center" />
 
-通过`&s1`语法，我们创建了一个**指向s1的引用**，但是并不拥有它。因为并不拥有这个值，当引用离开作用域后，其指向的值也不会被丢弃。
+通过 `&s1` 语法，我们创建了一个 **指向s1的引用**，但是并不拥有它。因为并不拥有这个值，当引用离开作用域后，其指向的值也不会被丢弃。
 
-同理，函数`calculate_length`使用`&`来表明参数`s`的类型是一个引用：
+同理，函数 `calculate_length` 使用 `&` 来表明参数 `s` 的类型是一个引用：
 ```rust
 fn calculate_length(s: &String) -> usize { // s 是对 String 的引用
     s.len()
@@ -113,11 +113,11 @@ fn change(some_string: &mut String) {
 }
 ```
 
-首先，声明`s`是可变类型，其次创建一个可变的引用`&mut s`和接受可变引用的函数`some_string: &mut String`。
+首先，声明 `s` 是可变类型，其次创建一个可变的引用 `&mut s` 和接受可变引用的函数 `some_string: &mut String`。
 
 ##### 可变引用同时只能存在一个
 
-不过可变引用并不是随心所欲、想用就用的，它有一个很大的限制：同一作用域，特定数据只能有一个可变引用:
+不过可变引用并不是随心所欲、想用就用的，它有一个很大的限制： **同一作用域，特定数据只能有一个可变引用**：
 ```rust
 let mut s = String::from("hello");
 
@@ -129,7 +129,7 @@ println!("{}, {}", r1, r2);
 
 以上代码会报错：
 ```console
-error[E0499]: cannot borrow `s` as mutable more than once at a time 同一时间无法对`s`进行两次可变借用
+error[E0499]: cannot borrow `s` as mutable more than once at a time 同一时间无法对 `s` 进行两次可变借用
  --> src/main.rs:5:14
   |
 4 |     let r1 = &mut s;
@@ -141,16 +141,16 @@ error[E0499]: cannot borrow `s` as mutable more than once at a time 同一时间
   |                        -- first borrow later used here 第一个借用在这里使用
   ```
 
-这段代码出错的原因在于，第一个可变借用`r1`必须要持续到最后一次使用的位置`println!`，在`r1`创建和最后一次使用之间，我们又尝试创建第二个可变引用`r2`。
+这段代码出错的原因在于，第一个可变借用 `r1` 必须要持续到最后一次使用的位置 `println!`，在 `r1` 创建和最后一次使用之间，我们又尝试创建第二个可变引用 `r2`。
 
-对于新手来说，这个特性绝对是一大拦路虎，也是新人们谈之色变的编译器`borrow checker`特性之一，不过各行各业都一样，限制往往是出于安全的考虑，Rust也一样。
+对于新手来说，这个特性绝对是一大拦路虎，也是新人们谈之色变的编译器 `borrow checker` 特性之一，不过各行各业都一样，限制往往是出于安全的考虑，Rust 也一样。
 
-这种限制的好处就是使Rust在编译期就避免数据竞争，数据竞争可由以下行为造成：
+这种限制的好处就是使 Rust 在编译期就避免数据竞争，数据竞争可由以下行为造成：
 - 两个或更多的指针同时访问同一数据
 - 至少有一个指针被用来写入数据
 - 没有同步数据访问的机制
 
-数据竞争会导致未定义行为，这种行为很可能超出我们的预期，难以在运行时追踪，并且难以诊断和修复。而Rust避免了这种情况的发生，因为它甚至不会编译存在数据竞争的代码！
+数据竞争会导致未定义行为，这种行为很可能超出我们的预期，难以在运行时追踪，并且难以诊断和修复。而 Rust 避免了这种情况的发生，因为它甚至不会编译存在数据竞争的代码！
 
 很多时候，大括号可以帮我们解决一些编译不通过的问题，通过手动限制变量的作用域：
 ```rust
@@ -179,7 +179,8 @@ println!("{}, {}, and {}", r1, r2, r3);
 
 错误如下：
 ```console
-error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable 无法借用可变`s`因为它已经被借用了不可变
+error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
+        // 无法借用可变 `s` 因为它已经被借用了不可变
  --> src/main.rs:6:14
   |
 4 |     let r1 = &s; // 没问题
@@ -194,9 +195,9 @@ error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immuta
 
 其实这个也很好理解，正在借用不可变引用的用户，肯定不希望他借用的东西，被另外一个人莫名其妙改变了。多个不可变借用被允许是因为没有人会去试图修改数据，每个人都只读这一份数据而不做修改，因此不用担心数据被污染。
 
-> 注意，引用的作用域s从创建开始，一直持续到它最后一次使用的地方，这个跟变量的作用域有所不同，变量的作用域从创建持续到某一个花括号`}`
+> 注意，引用的作用域 `s` 从创建开始，一直持续到它最后一次使用的地方，这个跟变量的作用域有所不同，变量的作用域从创建持续到某一个花括号 `}`
 
-Rust的编译器一直在优化，早期的时候，引用的作用域跟变量作用域是一致的，这对日常使用带来了很大的困扰，你必须非常小心的去安排可变、不可变变量的借用，免得无法通过编译，例如以下代码：
+Rust 的编译器一直在优化，早期的时候，引用的作用域跟变量作用域是一致的，这对日常使用带来了很大的困扰，你必须非常小心的去安排可变、不可变变量的借用，免得无法通过编译，例如以下代码：
 ```rust
 fn main() {
    let mut s = String::from("hello");
@@ -212,22 +213,22 @@ fn main() {
   // 新编译器中，r3作用域在这里结束
 ```
 
-在老版本的编译器中（Rust 1.31前），将会报错，因为`r1`和`r2`的作用域在花括号`}`处结束，那么`r3`的借用就会触发**无法同时借用可变和不可变**的规则。
+在老版本的编译器中（Rust 1.31前），将会报错，因为 `r1` 和 `r2` 的作用域在花括号 `}` 处结束，那么 `r3` 的借用就会触发 **无法同时借用可变和不可变**的规则。
 
-但是在新的编译器中，该代码将顺利通过，因为**引用作用域的结束位置从花括号变成最后一次使用的位置**,因此`r1`借用和`r2`借用在`println!`后，就结束了，此时`r3`可以顺利借用到可变引用。
+但是在新的编译器中，该代码将顺利通过，因为 **引用作用域的结束位置从花括号变成最后一次使用的位置**，因此 `r1` 借用和 `r2` 借用在 `println!` 后，就结束了，此时 `r3` 可以顺利借用到可变引用。
 
 #### NLL
 
-对于这种编译器优化行为，Rust专门起了一个名字 - Non-Lexical Lifetimes(NLL)，专门用于找到某个引用在作用域(`}`)结束前就不再被使用的代码位置。
+对于这种编译器优化行为，Rust 专门起了一个名字 —— **Non-Lexical Lifetimes(NLL)**，专门用于找到某个引用在作用域(`}`)结束前就不再被使用的代码位置。
 
-虽然这种借用错误有的时候会让我们很郁闷，但是你只要想想这是Rust提前帮你发现了潜在的bug，其实就开心了，虽然减慢了开发速度，但是从长期来看，大幅减少了后续开发和运维成本.
+虽然这种借用错误有的时候会让我们很郁闷，但是你只要想想这是 Rust 提前帮你发现了潜在的 BUG，其实就开心了，虽然减慢了开发速度，但是从长期来看，大幅减少了后续开发和运维成本。
 
 
 ### 悬垂引用（Dangling References）
 
 悬垂引用也叫做悬垂指针，指的是指针指向某个值后，这个值被释放掉了，而指针仍然存在，其指向的内存可能不存在任何值或已被其它变量重新使用。在 Rust 中编译器可以确保引用永远也不会变成悬垂状态：当你拥有一些数据的引用，编译器可以确保数据不会在其引用之前被释放，要想释放数据，必须先停止其引用的使用。
 
-让我们尝试创建一个悬垂引用，Rust会抛出一个编译时错误：
+让我们尝试创建一个悬垂引用，Rust 会抛出一个编译时错误：
 
 ```rust
 fn main() {
@@ -258,7 +259,7 @@ help: consider using the `'static` lifetime
 
 ```
 
-错误信息引用了一个我们还未介绍的功能：生命周期（lifetimes）。[该章](../../advance/lifetime.md)会详细介绍生命周期。不过，即使你不理解生命周期，也可以通过错误信息知道这段代码错误的关键信息：
+错误信息引用了一个我们还未介绍的功能：[生命周期（lifetimes）](../../advance/lifetime/basic.md)。不过，即使你不理解生命周期，也可以通过错误信息知道这段代码错误的关键信息：
 
 ```text
 this function's return type contains a borrowed value, but there is no value for it to be borrowed from.
@@ -290,7 +291,7 @@ fn no_dangle() -> String {
 }
 ```
 
-这样就没有任何错误了，最终`String`的**所有权被转移给外面的调用者**。
+这样就没有任何错误了，最终 `String` 的 **所有权被转移给外面的调用者**。
 
 
 ## 借用规则总结

book/contents/basic/ownership/index.md

@@ -1,7 +1,7 @@
 # 所有权和借用
 
-Rust之所以能成为万众瞩目的语言，就是因为其内存安全性。在以往，内存安全几乎都是通过GC的方式实现，但是GC会引来性能、内存占用以及Stop the world等问题，在高性能场景和系统编程上是不可接受的，因此Rust采用了与(错)众(误)不(之)同(源)的方式：**所有权系统**。
+Rust 之所以能成为万众瞩目的语言，就是因为其内存安全性。在以往，内存安全几乎都是通过 GC 的方式实现，但是 GC 会引来性能、内存占用以及 Stop the world 等问题，在高性能场景和系统编程上是不可接受的，因此 Rust 采用了与(错)众(误)不(之)同(源)的方式：**所有权系统**。
 
-理解所有权和借用，对于Rust学习是至关重要的，因此我们把本章提到了非常靠前的位置，So，骚年们，准备好迎接狂风暴雨了嘛？
+理解**所有权**和**借用**，对于 Rust 学习是至关重要的，因此我们把本章提到了非常靠前的位置，So，骚年们，准备好迎接狂风暴雨了嘛？
 
-从现在开始，鉴于大家已经掌握了非常基本的语法，有些时候，在示例代码中，将省略`fn main() {}`的模版代码，只要将相应的示例放在`fn main() {}`中，即可运行。
+从现在开始，鉴于大家已经掌握了非常基本的语法，有些时候，在示例代码中，将省略 `fn main() {}` 的模版代码，只要将相应的示例放在 `fn main() {}` 中，即可运行。

book/contents/basic/ownership/ownership.md

@@ -5,9 +5,9 @@
 - **手动管理内存的分配和释放**, 在程序中，通过函数调用的方式来申请和释放内存，典型代表：C++
 - **通过所有权来管理内存**，编译器在编译时会根据一系列规则进行检查
 
-其中Rust选择了第三种，最妙的是，这种检查只发生在编译期，因此对于程序运行期，不会有任何性能上的损失。
+其中 Rust 选择了第三种，最妙的是，这种检查只发生在编译期，因此对于程序运行期，不会有任何性能上的损失。
 
-由于所有权是一个新概念，因此读者需要花费一些时间来掌握它，一旦掌握，海阔天空任你飞跃，在本章，我们将通过`字符串`来引导讲解所有权的相关知识。
+由于所有权是一个新概念，因此读者需要花费一些时间来掌握它，一旦掌握，海阔天空任你飞跃，在本章，我们将通过 `字符串` 来引导讲解所有权的相关知识。
 
 ## 一段不安全的代码
 
@@ -21,17 +21,17 @@ int* foo() {
 }                   // 变量a和c的作用域结束
 ```
 
-这段代码虽然可以编译通过，但是其实非常糟糕，变量`a`和`c`都是局部变量，函数结束后将局部变量`a`的地址返回，但局部变量`a`存在栈中，在离开作用域后，`a`所申请的栈上内存都会被系统回收，从而造成了`悬空指针(Dangling Pointer)`的问题。这是一个非常典型的内存安全问题,虽然编译可以通过，但是运行的时候会出现错误, 很多编程语言都存在。
+这段代码虽然可以编译通过，但是其实非常糟糕，变量 `a` 和 `c` 都是局部变量，函数结束后将局部变量 `a` 的地址返回，但局部变量 `a` 存在栈中，在离开作用域后，`a` 所申请的栈上内存都会被系统回收，从而造成了 `悬空指针(Dangling Pointer)` 的问题。这是一个非常典型的内存安全问题，虽然编译可以通过，但是运行的时候会出现错误, 很多编程语言都存在。
 
-再来看变量`c`，`c`的值是常量字符串，存储于常量区，可能这个函数我们只调用了一次，也可能我们不再会使用这个字符串，但`xyz`只有当整个程序结束后系统才能回收这片内存。
+再来看变量 `c`，`c` 的值是常量字符串，存储于常量区，可能这个函数我们只调用了一次，也可能我们不再会使用这个字符串，但 `"xyz"` 只有当整个程序结束后系统才能回收这片内存。
 
-所以内存安全问题，一直都是程序员非常头疼的问题，好在, 在Rust中这些问题即将成为历史，因为Rust在编译的时候就可以帮助我们发现内存不安全的问题，那Rust如何做到这一点呢？
+所以内存安全问题，一直都是程序员非常头疼的问题，好在, 在 Rust 中这些问题即将成为历史，因为 Rust 在编译的时候就可以帮助我们发现内存不安全的问题，那 Rust 如何做到这一点呢？
 
 在正式进入主题前，先来一个预热知识。
 
 ## 栈（Stack）与堆（Heap）
 
-栈和堆是编程语言最核心的数据结构，但是在很多语言中，你并不需要深入了解栈与堆。 但对于Rust这样的系统编程语言，值是位于栈上还是堆上非常重要, 因为这会影响程序的行为和性能。
+栈和堆是编程语言最核心的数据结构，但是在很多语言中，你并不需要深入了解栈与堆。 但对于 Rust 这样的系统编程语言，值是位于栈上还是堆上非常重要, 因为这会影响程序的行为和性能。
 
 栈和堆的核心目标就是为程序在运行时提供可供使用的内存空间。
 
@@ -48,9 +48,9 @@ int* foo() {
 
 与栈不同，对于大小未知或者可能变化的数据，我们需要将它存储在堆上。
 
-当向堆上放入数据时，需要请求一定大小的内存空间。操作系统在堆的某处找到一块足够大的空位，把它标记为已使用，并返回一个表示该位置地址的 **指针**, 该过程被称为 **在堆上分配内存**，有时简称为 “分配”（allocating）。 
+当向堆上放入数据时，需要请求一定大小的内存空间。操作系统在堆的某处找到一块足够大的空位，把它标记为已使用，并返回一个表示该位置地址的 **指针**, 该过程被称为 **在堆上分配内存**，有时简称为 “分配”（allocating）。
 
-接着，该指针会被推入`栈`中，因为指针的大小是已知且固定的，在后续使用过程中，你将通过栈中的指针，来获取数据在堆上的实际内存位置，进而访问该数据。
+接着，该指针会被推入 **栈** 中，因为指针的大小是已知且固定的，在后续使用过程中，你将通过栈中的 **指针**，来获取数据在堆上的实际内存位置，进而访问该数据。
 
 由上可知，堆是一种缺乏组织的数据结构。想象一下去餐馆就座吃饭: 进入餐馆，告知服务员有几个人，然后服务员找到一个够大的空桌子(堆上分配的内存空间)并领你们过去。如果有人来迟了，他们也可以通过桌号(栈上的指针)来找到你们坐在哪。
 
@@ -58,24 +58,24 @@ int* foo() {
 
 写入方面：入栈比在堆上分配内存要快，因为入栈时操作系统无需分配新的空间，只需要将新数据放入栈顶即可。相比之下，在堆上分配内存则需要更多的工作，这是因为操作系统必须首先找到一块足够存放数据的内存空间，接着做一些记录为下一次分配做准备。
 
-读取方面：得益于CPU高速缓存，使得处理器可以减少对内存的访问，高速缓存和内存的访问速度差异在10倍以上！栈数据往往可以直接存储在CPU高速缓存中，而堆数据只能存储在内存中。访问堆上的数据比访问栈上的数据慢，因为必须先访问栈再通过栈上的指针来访问内存。
+读取方面：得益于 CPU 高速缓存，使得处理器可以减少对内存的访问，高速缓存和内存的访问速度差异在 10 倍以上！栈数据往往可以直接存储在 CPU 高速缓存中，而堆数据只能存储在内存中。访问堆上的数据比访问栈上的数据慢，因为必须先访问栈再通过栈上的指针来访问内存。
 
 因此，处理器处理和分配在栈上数据会比在堆上的数据更加高效。
 
 #### 所有权与堆栈
 
-当你的代码调用一个函数时，传递给函数的参数(包括可能指向堆上数据的指针和函数的局部变量)依次被压入栈中，当函数调用结束时，这些值将被从栈中按照相反的顺序依次移除。
+当你的代码调用一个函数时，传递给函数的参数（包括可能指向堆上数据的指针和函数的局部变量）依次被压入栈中，当函数调用结束时，这些值将被从栈中按照相反的顺序依次移除。
 
-因为堆上的数据缺乏组织，因此跟踪这些数据何时分配和释放是非常重要的，否则堆上的数据将产生内存泄漏 - 这些数据将永远无法被回收。这就是Rust所有权系统为我们提供的强大保障。 
+因为堆上的数据缺乏组织，因此跟踪这些数据何时分配和释放是非常重要的，否则堆上的数据将产生内存泄漏 —— 这些数据将永远无法被回收。这就是 Rust 所有权系统为我们提供的强大保障。
 
-对于其他很多编程语言，你确实无需理解堆栈的原理，**但是在Rust中，明白堆栈的原理，对于我们理解所有权的工作原理会有很大的帮助**.
+对于其他很多编程语言，你确实无需理解堆栈的原理，但是 **在 Rust 中，明白堆栈的原理，对于我们理解所有权的工作原理会有很大的帮助**。
 
 
 
 ## 所有权原则
 
 理解了堆栈，接下来看一下*关于所有权的规则*，首先请谨记以下规则：
-> 1. Rust中每一个值都`有且只有`一个所有者(变量)
+> 1. Rust 中每一个值都 `有且只有` 一个所有者(变量)
 > 2. 当所有者(变量)离开作用域范围时，这个值将被丢弃(free)
 
 
@@ -87,7 +87,7 @@ int* foo() {
 let s = "hello"
 ```
 
-变量`s`绑定到了一个字符串字面值，该字符串字面值是硬编码到程序代码中的。`s`变量从声明的点开始直到当前作用域的结束都是有效的：
+变量 `s` 绑定到了一个字符串字面值，该字符串字面值是硬编码到程序代码中的。`s` 变量从声明的点开始直到当前作用域的结束都是有效的：
 ```rust
 {                      // s 在这里无效，它尚未声明
     let s = "hello";   // 从此处起，s 是有效的
@@ -96,25 +96,25 @@ let s = "hello"
 }                      // 此作用域已结束，s不再有效
 ```
 
-简而言之，`s`从创建伊始就开始有效，然后有效期持续到它离开作用域为止，可以看出，就作用域来说，Rust语言跟其他编程语言没有区别。
+简而言之，`s` 从创建伊始就开始有效，然后有效期持续到它离开作用域为止，可以看出，就作用域来说，Rust 语言跟其他编程语言没有区别。
 
 #### 简单介绍String类型
 
-之前提到过，本章会用String作为例子，因此这里会进行一下简单的介绍，具体的String学习请参见[String类型](../compound-type/string-slice.md)。
+之前提到过，本章会用 `String` 作为例子，因此这里会进行一下简单的介绍，具体的 `String` 学习请参见 [String类型](../compound-type/string-slice.md)。
 
-我们已经见过字符串字面值`let s ="hello"`，s是被硬编码进程序里的字符串值（类型为&str）。字符串字面值是很方便的，但是它并不适用于所有场景。原因有二：
+我们已经见过字符串字面值 `let s ="hello"`，`s` 是被硬编码进程序里的字符串值（类型为 `&str` ）。字符串字面值是很方便的，但是它并不适用于所有场景。原因有二：
 - **字符串字面值是不可变的**，因为被硬编码到程序代码中
 - 并非所有字符串的值都能在编写代码时得知
 
 
-例如，字符串是需要程序运行时，通过用户动态输入然后存储在内存中的，这种情况，字符串字面值就完全无用武之地。 为此，Rust为我们提供动态字符串类型: `String`, 该类型被分配到堆上，因此可以动态伸缩，也就能存储在编译时大小未知的文本。
+例如，字符串是需要程序运行时，通过用户动态输入然后存储在内存中的，这种情况，字符串字面值就完全无用武之地。 为此，Rust 为我们提供动态字符串类型: `String`, 该类型被分配到堆上，因此可以动态伸缩，也就能存储在编译时大小未知的文本。
 
-可以使用下面的方法基于字符串字面量来创建`String`类型:
+可以使用下面的方法基于字符串字面量来创建 `String` 类型：
 ```rust
 let s = String::from("hello");
 ```
 
-`::`是一种调用操作符，这里表示调用`String`中的`from`方法，因为`String`存储在堆上是动态的，你可以这样修改它：
+`::` 是一种调用操作符，这里表示调用 `String` 中的 `from` 方法，因为 `String` 存储在堆上是动态的，你可以这样修改它：
 ```rust
 let mut s = String::from("hello");
 
@@ -123,7 +123,7 @@ s.push_str(", world!"); // push_str() 在字符串后追加字面值
 println!("{}", s); // 将打印 `hello, world!`
 ```
 
-言归正传，了解`String`内容后，一起来看看关于所有权的交互。
+言归正传，了解 `String` 内容后，一起来看看关于所有权的交互。
 
 ## 变量绑定背后的数据交互
 
@@ -135,31 +135,31 @@ let x = 5;
 let y = x;
 ```
 
-代码背后的逻辑很简单, 将 `5 `绑定到变量`x`；接着拷贝`x`的值赋给`y`,最终`x`和`y`都等于`5`,因为整数是Rust基本数据类型，是固定大小的简单值，因此这两个值都是通过自动拷贝的方式来赋值的，都被存在栈中，完全无需在堆上分配内存。
+代码背后的逻辑很简单, 将 `5` 绑定到变量 `x`；接着拷贝 `x` 的值赋给 `y`，最终 `x` 和 `y` 都等于 `5`，因为整数是 Rust 基本数据类型，是固定大小的简单值，因此这两个值都是通过自动拷贝的方式来赋值的，都被存在栈中，完全无需在堆上分配内存。
 
-可能有同学会有疑问：这种拷贝不消耗性能吗？实际上，这种栈上的数据足够简单，而且拷贝非常非常快，只需要复制一个整数大小(i32，4个字节)的内存即可，因此在这种情况下，拷贝的速度远比在堆上创建内存来得快的多。实际上，上一章我们讲到的Rust基本类型都是通过自动拷贝的方式来赋值的，就像上面代码一样。
+可能有同学会有疑问：这种拷贝不消耗性能吗？实际上，这种栈上的数据足够简单，而且拷贝非常非常快，只需要复制一个整数大小（`i32`，4 个字节）的内存即可，因此在这种情况下，拷贝的速度远比在堆上创建内存来得快的多。实际上，上一章我们讲到的 Rust 基本类型都是通过自动拷贝的方式来赋值的，就像上面代码一样。
 
 然后再来看一段代码：
 ```rust
 let s1 = String::from("hello");
 let s2 = s1;
 ```
-此时，可能某个大聪明(善意昵称)已经想到了：嗯，把`s1`的内容拷贝一份赋值给`s2`，实际上，并不是这样。之前也提到了，对于基本类型(存储在栈上)，Rust会自动拷贝，但是`String`不是基本类型，而是存储在堆上的，因此不能自动拷贝。
+此时，可能某个大聪明(善意昵称)已经想到了：嗯，把 `s1` 的内容拷贝一份赋值给 `s2`，实际上，并不是这样。之前也提到了，对于基本类型(存储在栈上)，Rust 会自动拷贝，但是 `String` 不是基本类型，而且是存储在堆上的，因此不能自动拷贝。
 
-实际上，`String`类型是一个复杂类型，由存储在栈中的堆指针、字符串长度、字符串容量共同组成，其中堆指针是最重要的，它指向了真实存储字符串内容的堆内存，至于长度和容量，如果你有Go语言的经验，这里就很好理解：容量是堆内存分配空间的大小，长度是目前已经使用的大小.
+实际上， `String` 类型是一个复杂类型，由 **存储在栈中的堆指针**、 **字符串长度**、 **字符串容量**共同组成，其中 **堆指针**是最重要的，它指向了真实存储字符串内容的堆内存，至于长度和容量，如果你有 Go 语言的经验，这里就很好理解：容量是堆内存分配空间的大小，长度是目前已经使用的大小。
 
-总之`String`类型指向了一个堆上的空间，这里存储着它的真实数据, 下面对上面代码中的`let s2 = s1`分成两种情况讨论：
-1. 拷贝`String`和存储在堆上的字节数组
-如果该语句是拷贝所有数据(深拷贝)，那么无论是`String`本身还是底层的堆上数据，都会被全部拷贝，这对于性能而言会造成非常大的影响
+总之 `String` 类型指向了一个堆上的空间，这里存储着它的真实数据, 下面对上面代码中的 `let s2 = s1` 分成两种情况讨论：
+1. 拷贝 `String` 和存储在堆上的字节数组
+如果该语句是拷贝所有数据(深拷贝)，那么无论是 `String` 本身还是底层的堆上数据，都会被全部拷贝，这对于性能而言会造成非常大的影响
 
-2. 只拷贝`String`本身
-这样的拷贝非常快，因为在64位机器上就拷贝了`8字节的指针`、`8字节的长度`、`8字节的容量`，总计24字节，但是带来了新的问题，还记得我们之前提到的所有权规则吧？其中有一条就是，一个值只允许有一个所有者，而现在这个值(堆上的真实字符串数据)有了两个所有者：`s1`和`s2`。
+2. 只拷贝 `String` 本身
+这样的拷贝非常快，因为在 64 位机器上就拷贝了 `8字节的指针`、`8字节的长度`、`8字节的容量`，总计 24 字节，但是带来了新的问题，还记得我们之前提到的所有权规则吧？其中有一条就是： **一个值只允许有一个所有者**，而现在这个值(堆上的真实字符串数据)有了两个所有者：`s1` 和 `s2`。
 
 好吧，就假定一个值可以拥有两个所有者，会发生什么呢？
 
-当变量离开作用域后，Rust会自动调用 `drop` 函数并清理变量的堆内存。不过由于两个`String`变量指向了同一位置。这就有了一个问题：当 `s1` 和 `s2` 离开作用域，它们都会尝试释放相同的内存。这是一个叫做 二次释放（double free）的错误，也是之前提到过的内存安全性 bug 之一。两次释放（相同）内存会导致内存污染，它可能会导致潜在的安全漏洞。
+当变量离开作用域后，Rust 会自动调用 `drop` 函数并清理变量的堆内存。不过由于两个 `String` 变量指向了同一位置。这就有了一个问题：当 `s1` 和 `s2` 离开作用域，它们都会尝试释放相同的内存。这是一个叫做 **二次释放（double free）**的错误，也是之前提到过的内存安全性 BUG 之一。两次释放（相同）内存会导致内存污染，它可能会导致潜在的安全漏洞。
 
-因此，Rust这样解决问题：**当`s1`赋予`s2`后，Rust认为`s1`不再有效，因此也无需在`s1`离开作用域后`drop`任何东西，这就是把所有权从`s1`转移给了`s2`，`s1`在被赋予`s2`后就马上失效了**.
+因此，Rust 这样解决问题： **当 `s1` 赋予 `s2` 后，Rust 认为 `s1` 不再有效，因此也无需在 `s1` 离开作用域后 `drop` 任何东西，这就是把所有权从 `s1` 转移给了 `s2`，`s1` 在被赋予 `s2` 后就马上失效了**。
 
 再来看看，在所有权转移后再来使用旧的所有者，会发生什么：
 ```rust
@@ -169,7 +169,7 @@ let s2 = s1;
 println!("{}, world!", s1);
 ```
 
-由于Rust禁止你使用无效的引用，你会看到以下的错误
+由于 Rust 禁止你使用无效的引用，你会看到以下的错误：
 ```console
 error[E0382]: use of moved value: `s1`
  --> src/main.rs:5:28
@@ -185,21 +185,21 @@ error[E0382]: use of moved value: `s1`
 ```
 
 现在再回头看看之前的规则，相信大家已经有了更深刻的理解：
-> 1. Rust中每一个值都`有且只有`一个所有者(变量)
-> 2. 当所有者(变量)离开作用域范围时，这个值将被丢弃
+> 1. Rust 中每一个值都 `有且只有` 一个所有者(变量)
+> 2. 当所有者(变量)离开作用域范围时，这个值将被丢弃(free)
 
-如果你在其他语言中听说过术语 浅拷贝（shallow copy）和 深拷贝（deep copy），那么拷贝指针、长度和容量而不拷贝数据听起来就像浅拷贝，但是又因为 Rust 同时使第一个变量`s1`无效了，因此这个操作被称为 移动（move），而不是浅拷贝。上面的例子可以解读为 `s1` 被 移动 到了 `s2` 中。那么具体发生了什么，用一张图简单说明：
+如果你在其他语言中听说过术语 **浅拷贝（shallow copy）**和 **深拷贝（deep copy）**，那么拷贝指针、长度和容量而不拷贝数据听起来就像浅拷贝，但是又因为 Rust 同时使第一个变量 `s1` 无效了，因此这个操作被称为 **移动（move）**，而不是浅拷贝。上面的例子可以解读为 `s1` 被 **移动**到了 `s2` 中。那么具体发生了什么，用一张图简单说明：
 
 <img alt="s1 moved to s2" src="/img/ownership01.svg" class="center" style="width: 50%;" />
 
-这样就解决了我们之前的问题，`s1`不再指向任何数据，只有`s2`是有效的，当`s2`离开作用域，它就会释放内存。 相信此刻，你应该明白了，为什么Rust称呼`let a = b`为**变量绑定**了吧？
+这样就解决了我们之前的问题，`s1` 不再指向任何数据，只有 `s2` 是有效的，当 `s2` 离开作用域，它就会释放内存。 相信此刻，你应该明白了，为什么 Rust 称呼 `let a = b` 为 **变量绑定**了吧？
 
 
 #### 克隆(深拷贝)
 
-首先，**Rust 永远也不会自动创建数据的 “深拷贝”**。因此，任何**自动**的复制都不是深拷贝，可以被认为对运行时性能影响较小。
+首先，**Rust 永远也不会自动创建数据的 “深拷贝”**。因此，任何 **自动**的复制都不是深拷贝，可以被认为对运行时性能影响较小。
 
-如果我们**确实**需要深度复制`String`中堆上的数据，而不仅仅是栈上的数据，可以使用一个叫做`clone`的方法。
+如果我们 **确实**需要深度复制 `String` 中堆上的数据，而不仅仅是栈上的数据，可以使用一个叫做 `clone` 的方法。
 
 ```rust
 let s1 = String::from("hello");
@@ -208,9 +208,9 @@ let s2 = s1.clone();
 println!("s1 = {}, s2 = {}", s1, s2);
 ```
 
-这段代码能够正常运行，因此说明`s2`确实完整的复制了`s1`的数据。
+这段代码能够正常运行，因此说明 `s2` 确实完整的复制了 `s1` 的数据。
 
-如果代码性能无关紧要，例如初始化程序时，或者在某段时间只会执行一次时，你可以使用`clone`来简化编程。但是对于执行较为频繁的代码(热点路径)，使用`clone`会极大的降低程序性能，需要小心使用！
+如果代码性能无关紧要，例如初始化程序时，或者在某段时间只会执行一次时，你可以使用 `clone` 来简化编程。但是对于执行较为频繁的代码(热点路径)，使用 `clone` 会极大的降低程序性能，需要小心使用！
 
 #### 拷贝(浅拷贝)
 
@@ -224,13 +224,13 @@ let y = x;
 println!("x = {}, y = {}", x, y);
 ```
 
-但这段代码似乎与我们刚刚学到的内容相矛盾：没有调用 `clone`，不过依然实现了类似深拷贝的效果 - 没有报所有权的错误。
+但这段代码似乎与我们刚刚学到的内容相矛盾：没有调用 `clone`，不过依然实现了类似深拷贝的效果 —— 没有报所有权的错误。
 
-原因是像整型这样的基本类型在编译时是已知大小的，会被存储在栈上，所以拷贝其实际的值是快速的。这意味着没有理由在创建变量 `y` 后使 `x` 无效（`x`、 `y`都仍然有效）。换句话说，这里没有深浅拷贝的区别，因此这里调用 `clone` 并不会与通常的浅拷贝有什么不同，我们可以不用管它（可以理解成在栈上做了深拷贝）。
+原因是像整型这样的基本类型在编译时是已知大小的，会被存储在栈上，所以拷贝其实际的值是快速的。这意味着没有理由在创建变量 `y` 后使 `x` 无效（`x`、`y` 都仍然有效）。换句话说，这里没有深浅拷贝的区别，因此这里调用 `clone` 并不会与通常的浅拷贝有什么不同，我们可以不用管它（可以理解成在栈上做了深拷贝）。
 
-Rust 有一个叫做 `Copy`的特征，可以用在类似整型这样在栈中存储的类型。如果一个类型拥有 `Copy`特征，一个旧的变量在被赋值给其他变量后仍然可用。
+Rust 有一个叫做 `Copy` 的特征，可以用在类似整型这样在栈中存储的类型。如果一个类型拥有 `Copy` 特征，一个旧的变量在被赋值给其他变量后仍然可用。
 
-那么什么类型是可`Copy` 的呢？可以查看给定类型的文档来确认，不过作为一个通用的规则:**任何基本类型的组合可以是 `Copy` 的，不需要分配内存或某种形式资源的类型是 `Copy` 的**。如下是一些 `Copy` 的类型：
+那么什么类型是可 `Copy` 的呢？可以查看给定类型的文档来确认，不过作为一个通用的规则： **任何基本类型的组合可以是 `Copy` 的，不需要分配内存或某种形式资源的类型是 `Copy` 的**。如下是一些 `Copy` 的类型：
 
 * 所有整数类型，比如 `u32`。
 * 布尔类型，`bool`，它的值是 `true` 和 `false`。
@@ -239,7 +239,7 @@ Rust 有一个叫做 `Copy`的特征，可以用在类似整型这样在栈中
 * 元组，当且仅当其包含的类型也都是 `Copy` 的时候。比如，`(i32, i32)` 是 `Copy` 的，但 `(i32, String)` 就不是。
 
 ## 函数传值与返回
-将值传递给函数，一样会发生`移动`或者`复制`，就跟`let`语句一样，下面的代码展示了所有权、作用域的规则：
+将值传递给函数，一样会发生 `移动` 或者 `复制`，就跟 `let` 语句一样，下面的代码展示了所有权、作用域的规则：
 ```rust
 fn main() {
     let s = String::from("hello");  // s 进入作用域
@@ -264,7 +264,7 @@ fn makes_copy(some_integer: i32) { // some_integer 进入作用域
 } // 这里，some_integer 移出作用域。不会有特殊操作
 ```
 
-你可以尝试在`takes_ownership`之后，再使用`s`，看看如何报错？例如添加一行`println!("在move进函数后继续使用s: {}",s);`。
+你可以尝试在 `takes_ownership` 之后，再使用 `s`，看看如何报错？例如添加一行 `println!("在move进函数后继续使用s: {}",s);`。
 
 
 同样的，函数返回值也有所有权，例如:
@@ -297,5 +297,5 @@ fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用
 ```
 
 
-所有权很强大，避免了内存的不安全性，但是也带来了一个新麻烦: **总是把一个值传来传去来使用它**。 传入一个函数，很可能还要从该函数传出去，结果就是语言表达变得非常啰嗦，幸运的是，Rust提供了新功能解决这个问题。
+所有权很强大，避免了内存的不安全性，但是也带来了一个新麻烦: **总是把一个值传来传去来使用它**。 传入一个函数，很可能还要从该函数传出去，结果就是语言表达变得非常啰嗦，幸运的是，Rust 提供了新功能解决这个问题。
 

book/contents/basic/trait/advance-trait.md

@@ -25,18 +25,20 @@ impl Iterator for Counter {
 
     fn next(&mut self) -> Option<Self::Item> {
         // --snip--
+    }
+}
 ```
 
 在上述代码中，我们为 `Counter` 类型实现了 `Iterator` 特征，那么 `Self` 就是当前的 `Iterator` 特征对象， `Item` 就是 `u32` 类型。
 
-聪明的读者之所以聪明，是因为你们喜欢联想和举一反三，同时你们也喜欢提问：为何不用泛型，例如如下代码
+聪明的读者之所以聪明，是因为你们喜欢联想和举一反三，同时你们也喜欢提问：为何不用泛型，例如如下代码：
 ```rust
 pub trait Iterator<Item> {
     fn next(&mut self) -> Option<Item>;
 }
 ```
 
-答案其实很简单，为了代码的可读性，当你使用了泛型后，你需要在所有地方都这样写 `Iterator<Item>`，而使用了关联类型，你只需要这样写 `Iterator`，当类型定义复杂时，这种写法可以极大的增加可读性：
+答案其实很简单，为了代码的可读性，当你使用了泛型后，你需要在所有地方都写 `Iterator<Item>`，而使用了关联类型，你只需要写 `Iterator`，当类型定义复杂时，这种写法可以极大的增加可读性：
 ```rust
 pub trait CacheableItem: Clone + Default + fmt::Debug + Decodable + Encodable {
   type Address: AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash;
@@ -57,7 +59,7 @@ fn difference<A,B,C>(container: &C) -> i32
     C : Container<A,B> {...}
 ```
 
-可以看到，由于使用了泛型，导致函数头部也必须增加泛型的声明，而使用关联类型，将得到可读性好的多的代码：
+可以看到，由于使用了泛型，导致函数头部也必须增加泛型的声明，而使用关联类型，将得到可读性好得多的代码：
 ```rust
 trait Container{
     type A;

book/contents/basic/variable.md

@@ -12,9 +12,9 @@
 
 ## 变量命名
 
-在命名方面，和其它语言没有区别，不过当给变量命名时，需要遵循[Rust命名规范](../practice/style-guide/naming.md)。
+在命名方面，和其它语言没有区别，不过当给变量命名时，需要遵循 [Rust 命名规范](../practice/style-guide/naming.md)。
 
-> Rust 语言有一些**关键字**（*keywords*），和其他语言一样，这些关键字都是被保留给 Rust 语言使用的，因此，它们不能被用作变量或函数的名称。在[附录 A](../appendix/keywords) 中可找到关键字列表。
+> Rust 语言有一些**关键字**（*keywords*），和其他语言一样，这些关键字都是被保留给 Rust 语言使用的，因此，它们不能被用作变量或函数的名称。在 [附录 A](../appendix/keywords) 中可找到关键字列表。
 
 ## 变量绑定
 

book/contents/fight-with-compiler/lifetime/too-long2.md

@@ -120,7 +120,11 @@ impl<'a> Writer<'a> {
     ...
 }
 ```
-好像有点问题，`indent`返回的`Writer`的生命周期和外面的`Writer`的生命周期一模一样，这很不合理，一眼就能看出前者远小于后者,那我们尝试着修改下`indent`:
+好像有点问题，`indent`返回的`Writer`的生命周期和外面调用者的`Writer`的生命周期一模一样，这很不合理，一眼就能看出前者远小于后者。
+
+这里稍微展开以下，为何`indent`方法返回值的生命周期不能与参数中的`self`相同。**首先，我们假设它们可以相同，也就是上面的代码可以编译通过**，由于此时在返回值中借用了`self`的可变引用，意味着**如果你在返回值被使用后，还继续使用`self` 会导致重复借用的错误，因为返回值的生命周期将持续到 `self` 结束**。 
+
+既然不能相同，那我们尝试着修改下`indent`:
 ```rust
  fn indent<'b>(&'b mut self) -> Writer<'b> {
     Writer {

book/contents/first-try/cargo.md

@@ -1,6 +1,6 @@
 ## 认识Cargo
 
-但凡经历过 C/C++、Go 语言 1.10 版本之前的用户都知道，一个好的包管理工具有多么的重要！！我那个时候是如此的渴望类似 `nodejs` 的 `npm `包管理工具，但是却求而不得，包管理工具最重要的意义就是**任何用户拿到你的代码，都能运行起来**"，而不会因为各种包版本依赖焦头烂额，Go 语言在 1.10 版本之前，所有的包都是在 `github.com` 下存放，导致了所有的项目都公用一套依赖代码，在本地项目复杂后，这简直是一种灾难。
+但凡经历过 C/C++、Go 语言 1.10 版本之前的用户都知道，一个好的包管理工具有多么的重要！！我那个时候是如此的渴望类似 `nodejs` 的 `npm `包管理工具，但是却求而不得，包管理工具最重要的意义就是**任何用户拿到你的代码，都能运行起来**，而不会因为各种包版本依赖焦头烂额，Go 语言在 1.10 版本之前，所有的包都是在 `github.com` 下存放，导致了所有的项目都公用一套依赖代码，在本地项目复杂后，这简直是一种灾难。
 
 说多了都是泪，笔者目前还有一个早期 Go 的项目(15年写的)，用到了 `iris` (一个坑爹HTTP服务)，结果现在运行不起来了，因为找不到 `iris` 当时的那个版本！！
 

book/writing-material/posts/plugins.md

@@ -0,0 +1,2 @@
+
+https://www.reddit.com/r/rust/comments/sboyb2/designing_a_rust_rust_plugin_system/

codes/.gitignore

@@ -1,2 +0,0 @@
-book
-.DS_Store

codes/CNAME

@@ -1 +0,0 @@
-codes.rs

codes/README.md

@@ -1,21 +0,0 @@
-## Rust代码鉴赏(Rust Codes)
-
-- 官方网址：[https://codes.rs](https://codes.rs)
-- 修订时间： **尚未发行**
-- Rust版本：Rust edition 2021
-- QQ交流群： 1009730433
-
-学习Rust光看一讲语法的书是不够的，因为Rust语言着实复杂和高级，所以本书是<<Rust语言圣经>>的补充阅读书本，目标是：
-1. 为用户呈现高质量的代码片段，这种代码你往往会在某个时刻需要用到，却不知道如何更好的实现，甚至无法让它通过编译检查
-2. 精算的数据结构和算法设计
-3. 标准库代码分析
-
-所以，这本书可以成为你的口袋书和工具书，随时可以打开手机鉴赏几段令人赏心悦目的代码。
-
-**如果你想系统学习Rust，请先阅读我们的开山巨作**：[Rust语言圣经](https://course.rs)，绝对是一极其优秀的Rust全面教学书籍。
-
-## 开源版权说明
-
-Rust代码鉴赏是完全开源的电子书籍，但是也应该受到版权的保护。
-
-因此我们选择了[No License](https://www.google.com.hk/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwigkv-KtMT0AhXFdXAKHdI4BCcQFnoECAQQAw&url=https%3A%2F%2Fchoosealicense.com%2Fno-permission%2F&usg=AOvVaw3M2Q4IbdhnpJ2K71TF7SPB)作为我们的版权，这意味着读者可以随意的fork、阅读，但是不能私下修改后再分发，如果想要修改，请提RP或者加入[Rust编程学院](https://college.rs)，成为正式成员。

codes/assets/baidu_verify_code-6xpiXNfMYY.html

@@ -1 +0,0 @@
-717a8be683db73a812bab355e948d1f7

codes/book.toml

@@ -1,14 +0,0 @@
-[book]
-authors = ["sunface"]
-language = "zh-CN"
-multilingual = false
-src = "src"
-title = "Rust代码鉴赏(Rust Codes)"
-
-[output.html]
-git-repository-url = "https://github.com/sunface/rust-course/tree/main/codes"
-edit-url-template = "https://github.com/sunface/rust-course/tree/main/codes/{path}"
-
-[output.html.fold]
-enable = true
-level = 1

codes/deploy

@@ -1,20 +0,0 @@
-## this script is releasing the book to github pages
-
-## build book
-mdbook build
-## copy CNAME info to book dir
-cp CNAME ./book/
-cp ./assets/*.html ./book/
-
-## init git repo
-cd book
-git init
-git config user.name "sunface"
-git config user.email "cto@188.com"
-git add .
-git commit -m 'release book'
-git branch -M gh-pages
-git remote add origin https://github.com/sunface/rust-codes
-
-## push to github pages
-git push -u -f origin gh-pages

codes/src/SUMMARY.md

@@ -1,147 +0,0 @@
-# Summary
-
-[Rust代码鉴赏](./about-book.md)
-
-- [算法之美](algorithms/index.md)
-    - [排序](algorithms/sorting/index.md)
-        - [冒泡排序](algorithms/sorting/bubble-sort.md)
-        - [桶排序](algorithms/sorting/bucket-sort.md)
-        - [鸡尾酒排序](algorithms/sorting/cocktail-shaker-sort.md)
-        - [梳排序](algorithms/sorting/comb-sort.md)
-        - [计数排序](algorithms/sorting/counting-sort.md)
-        - [地精排序](algorithms/sorting/gnome-sort.md)
-        - [堆排序](algorithms/sorting/heap-sort.md)
-        - [插入排序](algorithms/sorting/insertion-sort.md)
-        - [归并排序](algorithms/sorting/merge-sort.md)
-        - [奇偶排序](algorithms/sorting/odd-even.md)
-        - [快速排序](algorithms/sorting/quick-sort.md)
-        - [基数排序](algorithms/sorting/radix-sort.md)
-        - [选择排序](algorithms/sorting/selection-sort.md)
-        - [希尔排序](algorithms/sorting/shell-sort.md)
-        - [臭皮匠排序](algorithms/sorting/stooge-sort.md)
-
-    - [字符串](algorithms/string/index.md)
-        - [逆序倒转](algorithms/string/reverse.md)
-        - [数据转换算法](algorithms/string/burrows-wheeler-transform.md)
-        - [KMP算法](algorithms/string/knuth-morris-pratt.md)
-        - [马拉车算法](algorithms/string/manacher.md)
-        - [Rabin Karp算法](algorithms/string/rabin-karp.md)
-
-    - [查找算法](algorithms/searching/index.md)
-        - [二分查找](algorithms/searching/binary-search.md)
-        - [递归二分查找](algorithms/searching/binary-search-recursive.md)
-        - [查找第K小的元素](algorithms/searching/kth-smallest.md)
-        - [线性搜索](algorithms/searching/linear-search.md)
-
-    - [图论](algorithms/graph/index.md)
-        - [最短路径-Bellman Ford](algorithms/graph/bellman-ford.md)
-        - [最短路径-Dijkstra](algorithms/graph/dijkstra.md)
-        - [深度优先搜索](algorithms/graph/depth-first-search.md)
-        - [广度优先搜索](algorithms/graph/breadth-first-search.md)
-        - [深度优先Tic Tac Toe](algorithms/graph/depth-first-tic-tac-toe.md)
-        - [最小生成树](algorithms/graph/minimum-spanning-tree.md)
-        - [Prim算法(最小生成树)](algorithms/graph/prim.md)
-
-    - [动态规划](algorithms/dynamic-programming/index.md)
-        - [斐波那契(fibonacci)](algorithms/dynamic-programming/fibonacci.md)
-        - [找钱(Coin change)](algorithms/dynamic-programming/coin-change.md)
-        - [最小编辑距离(Edit distance)](algorithms/dynamic-programming/edit-distance.md)
-        - [扔鸡蛋(Egg dropping)](algorithms/dynamic-programming/egg-dropping.md)
-        - [判断子序列](algorithms/dynamic-programming/is-subsequence.md)
-        - [背包问题](algorithms/dynamic-programming/knapsack.md)
-        - [最长公共子序列](algorithms/dynamic-programming/longese-common-sequence.md)
-        - [最长连续递增序列](algorithms/dynamic-programming/longest_continuous_increasing_subsequence.md)
-        - [最长上升子序列](algorithms/dynamic-programming/longest-increasing-subsequence.md)
-        - [最大正方形](algorithms/dynamic-programming/maximal-square.md)
-        - [最大子数组](algorithms/dynamic-programming/maximal-subarray.md)
-        - [棒的切割](algorithms/dynamic-programming/rod-cutting.md)
-
-    - [数学]()
-        - [扩展欧几里得算法](algorithms/math/extended-euclidean.md)
-        - [最大公约数](algorithms/math/greatest-common-divisor.md)
-        - [帕斯卡三角](algorithms/math/pascal-triange.md)
-        - [寻找完美数](algorithms/math/perfect-numbers.md)
-        - [质数检测](algorithms/math/prime-check.md)
-        - [质数筛法](algorithms/math/prime-numbers.md)
-        - [试除法](algorithms/math/trial-division.md)
-
-    - [几何]()
-        - [最近点算法](algorithms/geometry/closet-points.md)
-
-    - [常用算法]()
-        - [凸包算法](algorithms/general/convex-hull.md)
-        - [汉诺塔算法](algorithms/general/hanoi.md)
-        - [K-Means算法](algorithms/general/kmeans.md)
-        - [N皇后算法](algorithms/general/nqueens.md)
-        - [两数之和](algorithms/general/two-sum.md)
-
-    - [加密算法](algorithms/cipher/index.md)
-        - [凯撒算法(caesar)](algorithms/cipher/caesar.md)
-        - [摩斯码](algorithms/cipher/morse-code.md)
-        - [Polibius密码](algorithms/cipher/polibius.md)
-        - [rot13加密算法](algorithms/cipher/rot13.md)
-        - [rot13第二种实现](algorithms/cipher/another-rot13.md)
-        - [sha256加密](algorithms/cipher/sha256.md)
-        - [vigenere加密](algorithms/cipher/vigenere.md)
-        - [xor](algorithms/cipher/xor.md)
-
-- [数据结构](data-structures/index.md)
-    - [B树](data-structures/b-tree.md)
-    - [二叉树](data-structures/binary-search-tree.md)
-    - [avl树](data-structures/avl-tree.md)
-    - [链表](data-structures/linked-list.md)
-    - [堆(Heap)](data-structures/heap.md)
-    - [栈](data-structures/stack.md)
-    - [队列](data-structures/queue.md)
-    - [trie(字典树)](data-structures/trie.md)
-    - [图(graph)](data-structures/graph.md)
-
-- [对抗编译检查](fight-compiler/index.md)
-    - [迭代器Iterator](fight-compiler/iterator.md)
-
-- [深入特征](deep-trait/index.md)
-    - [Deref](deep-trait/deref.md)
-
-- [Rust陷阱系列](pitfalls/index.md)
-    - [for循环中使用外部数组](pitfalls/use-vec-in-for.md)
-    - [线程类型导致的栈溢出](pitfalls/stack-overflow.md)
-    - [算术溢出导致的panic](pitfalls/arithmetic-overflow.md)
-    - [闭包中奇怪的生命周期](pitfalls/closure-with-lifetime.md)
-    - [可变变量不可变？](pitfalls/the-disabled-mutability.md)
-    - [可变借用失败引发的深入思考](pitfalls/multiple-mutable-references.md)
-
-- [迭代器Iterator](iterator/index.md)
-    - [同时从首尾遍历](iterator/from-start-and-end.md)
-
-- [Unsafe Rust](unsafe/index.md)
-    - [通过元素获取数组索引](unsafe/get-arryr-index-by-elem.md)
-    - [实现多维数组](unsafe/multi-dimension-array.md)
-    - [实现自引用](unsafe/self-ref.md)
-    
-- [运算符重载](operator-override/index.md)
-    - [数组索引](operator-override/index.md)
-
-- [模式匹配](pattern-match/index.md)
-    - [使用match和if let返回值](pattern-match/return-with-match.md)
-    
-- [奇怪代码背后的原理](principles-behind-weird-code/index.md)
-    - [右值取地址](principles-behind-weird-code/ref-to-rvalue.md)
-    - [autoref/autoderef](principles-behind-weird-code/autoref.md)
-
-- [有趣但是用处不大的代码](fun-but-useless/index.md)
-    - [?嵌套](fun-but-useless/question-mark-nested.md)
-
-- [堆和栈](stack-heap/index.md)
-    - [避免递归函数栈溢出](stack-heap/recursive-stack-overlfow.md)
-    
-- [将复杂的实现简化](make-things-easier/index.md)
-    - [代码1](make-things-easier/1.md)
-
-- [复杂难懂的代码](obscure/index.md)
-    - [代码1](obscure/1.md)
-
-## 场景模版
-- [场景模版 todo](templates/intro.md)
-    - [文件操作](templates/files/intro.md)
-        - [目录(todo)](templates/files/dir.md)
-    - [Http请求(todo)](templates/http/intro.md)

codes/src/about-book.md

@@ -1,12 +0,0 @@
-## Rust代码鉴赏(Rust Codes)
-
-- 书本官网：[https://codes.rs](https://codes.rs)
-
-学习Rust光看一讲语法的书是不够的，因为Rust语言着实复杂和高级，所以本书是<<Rust语言圣经>>的补充阅读书本，目标是：
-1. 为用户呈现高质量的代码片段，这种代码你往往会在某个时刻需要用到，却不知道如何更好的实现，甚至无法让它通过编译检查
-2. 精算的数据结构和算法设计
-3. 标准库代码分析
-
-所以，这本书可以成为你的口袋书和工具书，随时可以打开手机鉴赏几段令人赏心悦目的代码。
-
-**如果你想系统学习Rust，请先阅读我们的开山巨作**：[Rust语言圣经](https://course.rs)，绝对是一极其优秀的Rust全面教学书籍。

codes/src/algorithms/cipher/another-rot13.md

@@ -1,39 +0,0 @@
-# rot13第二种实现
-
-```rust
-pub fn another_rot13(text: &str) -> String {
-    let input = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-    let output = "NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm";
-    text.chars()
-        .map(|c| match input.find(c) {
-            Some(i) => output.chars().nth(i).unwrap(),
-            None => c,
-        })
-        .collect()
-}
-
-#[cfg(test)]
-mod tests {
-    // Note this useful idiom: importing names from outer (for mod tests) scope.
-    use super::*;
-
-    #[test]
-    fn test_simple() {
-        assert_eq!(another_rot13("ABCzyx"), "NOPmlk");
-    }
-
-    #[test]
-    fn test_every_alphabet_with_space() {
-        assert_eq!(
-            another_rot13("The quick brown fox jumps over the lazy dog"),
-            "Gur dhvpx oebja sbk whzcf bire gur ynml qbt"
-        );
-    }
-
-    #[test]
-    fn test_non_alphabet() {
-        assert_eq!(another_rot13("🎃 Jack-o'-lantern"), "🎃 Wnpx-b'-ynagrea");
-    }
-}
-```
-

codes/src/algorithms/cipher/caesar.md

@@ -1,38 +0,0 @@
-# 凯撒算法(caesar)
-
-```rust
-pub fn another_rot13(text: &str) -> String {
-    let input = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-    let output = "NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm";
-    text.chars()
-        .map(|c| match input.find(c) {
-            Some(i) => output.chars().nth(i).unwrap(),
-            None => c,
-        })
-        .collect()
-}
-
-#[cfg(test)]
-mod tests {
-    // Note this useful idiom: importing names from outer (for mod tests) scope.
-    use super::*;
-
-    #[test]
-    fn test_simple() {
-        assert_eq!(another_rot13("ABCzyx"), "NOPmlk");
-    }
-
-    #[test]
-    fn test_every_alphabet_with_space() {
-        assert_eq!(
-            another_rot13("The quick brown fox jumps over the lazy dog"),
-            "Gur dhvpx oebja sbk whzcf bire gur ynml qbt"
-        );
-    }
-
-    #[test]
-    fn test_non_alphabet() {
-        assert_eq!(another_rot13("🎃 Jack-o'-lantern"), "🎃 Wnpx-b'-ynagrea");
-    }
-}
-```

codes/src/algorithms/cipher/index.md

@@ -1,9 +0,0 @@
-# 加密算法
-
-数据加密的基本过程就是对原来为明文的文件或数据按某种算法进行处理，使其成为不可读的一段代码为“密文”，使其只能在输入相应的密钥之后才能显示出原容，通过这样的途径来达到保护数据不被非法人窃取、阅读的目的。 该过程的逆过程为解密，即将该编码信息转化为其原来数据的过程。
-
-随着信息化和数字化社会的发展，人们对信息安全和保密的重要性认识不断提高，于是在1997年，美国国家标准局公布实施了“美国数据加密标准（DES）”，民间力量开始全面介入密码学的研究和应用中，采用的加密算法有`DES、RSA、SHA`等。随着对加密强度需求的不断提高，近期又出现了`AES、ECC`等。
-使用密码学可以达到以下目的：
-- 保密性：防止用户的标识或数据被读取。
-- 数据完整性：防止数据被更改。
-- 身份验证：确保数据发自特定的一方。

codes/src/algorithms/cipher/morse-code.md

@@ -1,202 +0,0 @@
-# 摩斯码
-
-```rust
-use std::collections::HashMap;
-use std::io;
-
-const UNKNOWN_CHARACTER: &str = "........";
-const _UNKNOWN_MORSE_CHARACTER: &str = "_";
-
-pub fn encode(message: &str) -> String {
-    let dictionary = _morse_dictionary();
-    message
-        .chars()
-        .into_iter()
-        .map(|char| char.to_uppercase().to_string())
-        .map(|letter| dictionary.get(letter.as_str()))
-        .map(|option| option.unwrap_or(&UNKNOWN_CHARACTER).to_string())
-        .collect::<Vec<String>>()
-        .join(" ")
-}
-
-// Declaritive macro for creating readable map declarations, for more info see https://doc.rust-lang.org/book/ch19-06-macros.html
-macro_rules! map {
-    ($($key:expr => $value:expr),* $(,)?) => {
-        std::iter::Iterator::collect(std::array::IntoIter::new([$(($key, $value),)*]))
-    };
-}
-
-fn _morse_dictionary() -> HashMap<&'static str, &'static str> {
-    map! {
-        "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" => "--..",
-
-        "1" => ".----",   "2" => "..---",   "3" => "...--",
-        "4" => "....-",   "5" => ".....",   "6" => "-....",
-        "7" => "--...",   "8" => "---..",   "9" => "----.",
-        "0" => "-----",
-
-        "&" => ".-...",   "@" => ".--.-.",  ":" => "---...",
-        "," => "--..--",  "." => ".-.-.-",  "'" => ".----.",
-        "\"" => ".-..-.", "?" => "..--..",  "/" => "-..-.",
-        "=" => "-...-",   "+" => ".-.-.",   "-" => "-....-",
-        "(" => "-.--.",   ")" => "-.--.-",  " " => "/",
-        "!" => "-.-.--",
-    }
-}
-
-fn _morse_to_alphanumeric_dictionary() -> HashMap<&'static str, &'static str> {
-    map! {
-        ".-"   =>  "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",
-
-        ".----" => "1",    "..---" => "2",   "...--" => "3",
-        "....-" => "4",    "....." => "5",   "-...." => "6",
-        "--..." => "7",    "---.." => "8",   "----." => "9",
-        "-----" => "0",
-
-        ".-..." => "&",    ".--.-." => "@",  "---..." => ":",
-        "--..--" => ",",   ".-.-.-" => ".",  ".----." => "'",
-        ".-..-." => "\"",  "..--.." => "?",  "-..-." => "/",
-        "-...-" => "=",   ".-.-." => "+",   "-....-" => "-",
-        "-.--." => "(",   "-.--.-" => ")",  "/" => " ",
-        "-.-.--" => "!",  " " => " ",       "" => ""
-    }
-}
-
-fn _check_part(string: &str) -> bool {
-    for c in string.chars() {
-        match c {
-            '.' | '-' | ' ' => (),
-            _ => return false,
-        }
-    }
-    true
-}
-
-fn _check_all_parts(string: &str) -> bool {
-    string.split('/').all(_check_part)
-}
-
-fn _decode_token(string: &str) -> String {
-    _morse_to_alphanumeric_dictionary()
-        .get(string)
-        .unwrap_or(&_UNKNOWN_MORSE_CHARACTER)
-        .to_string()
-}
-
-fn _decode_part(string: &str) -> String {
-    string
-        .split(' ')
-        .map(_decode_token)
-        .collect::<Vec<String>>()
-        .join("")
-}
-
-/// Convert morse code to ascii.
-///
-/// Given a morse code, return the corresponding message.
-/// If the code is invalid, the undecipherable part of the code is replaced by `_`.
-pub fn decode(string: &str) -> Result<String, io::Error> {
-    if !_check_all_parts(string) {
-        return Err(io::Error::new(
-            io::ErrorKind::InvalidData,
-            "Invalid morse code",
-        ));
-    }
-
-    let mut partitions: Vec<String> = vec![];
-
-    for part in string.split('/') {
-        partitions.push(_decode_part(part));
-    }
-
-    Ok(partitions.join(" "))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn encrypt_only_letters() {
-        let message = "Hello Morse";
-        let cipher = encode(message);
-        assert_eq!(
-            cipher,
-            ".... . .-.. .-.. --- / -- --- .-. ... .".to_string()
-        )
-    }
-
-    #[test]
-    fn encrypt_letters_and_special_characters() {
-        let message = "What's a great day!";
-        let cipher = encode(message);
-        assert_eq!(
-            cipher,
-            ".-- .... .- - .----. ... / .- / --. .-. . .- - / -.. .- -.-- -.-.--".to_string()
-        )
-    }
-
-    #[test]
-    fn encrypt_message_with_unsupported_character() {
-        let message = "Error?? {}";
-        let cipher = encode(message);
-        assert_eq!(
-            cipher,
-            ". .-. .-. --- .-. ..--.. ..--.. / ........ ........".to_string()
-        )
-    }
-
-    #[test]
-    fn decrypt_valid_morsecode_with_spaces() {
-        let expected = "Hello Morse! How's it goin, \"eh\"?"
-            .to_string()
-            .to_uppercase();
-        let encypted = encode(&expected);
-        let result = decode(&encypted).unwrap();
-
-        assert_eq!(expected, result);
-    }
-
-    #[test]
-    fn decrypt_valid_character_set_invalid_morsecode() {
-        let expected = format!(
-            "{}{}{}{} {}",
-            _UNKNOWN_MORSE_CHARACTER,
-            _UNKNOWN_MORSE_CHARACTER,
-            _UNKNOWN_MORSE_CHARACTER,
-            _UNKNOWN_MORSE_CHARACTER,
-            _UNKNOWN_MORSE_CHARACTER,
-        );
-
-        let encypted = ".-.-.--.-.-. --------. ..---.-.-. .-.-.--.-.-. / .-.-.--.-.-.".to_string();
-        let result = decode(&encypted).unwrap();
-
-        assert_eq!(expected, result);
-    }
-
-    #[test]
-    fn decrypt_invalid_morsecode_with_spaces() {
-        let encypted = "1... . .-.. .-.. --- / -- --- .-. ... .";
-        let result = decode(encypted).map_err(|e| e.kind());
-        let expected = Err(io::ErrorKind::InvalidData);
-
-        assert_eq!(expected, result);
-    }
-}
-```

codes/src/algorithms/cipher/polibius.md

@@ -1,153 +0,0 @@
-# Polibius密码
-
-```rust
-/// Encode an ASCII string into its location in a Polybius square.
-/// Only alphabetical characters are encoded.
-pub fn encode_ascii(string: &str) -> String {
-    string
-        .chars()
-        .map(|c| match c {
-            'a' | 'A' => "11",
-            'b' | 'B' => "12",
-            'c' | 'C' => "13",
-            'd' | 'D' => "14",
-            'e' | 'E' => "15",
-            'f' | 'F' => "21",
-            'g' | 'G' => "22",
-            'h' | 'H' => "23",
-            'i' | 'I' | 'j' | 'J' => "24",
-            'k' | 'K' => "25",
-            'l' | 'L' => "31",
-            'm' | 'M' => "32",
-            'n' | 'N' => "33",
-            'o' | 'O' => "34",
-            'p' | 'P' => "35",
-            'q' | 'Q' => "41",
-            'r' | 'R' => "42",
-            's' | 'S' => "43",
-            't' | 'T' => "44",
-            'u' | 'U' => "45",
-            'v' | 'V' => "51",
-            'w' | 'W' => "52",
-            'x' | 'X' => "53",
-            'y' | 'Y' => "54",
-            'z' | 'Z' => "55",
-            _ => "",
-        })
-        .collect()
-}
-
-/// Decode a string of ints into their corresponding
-/// letters in a Polybius square.
-///
-/// Any invalid characters, or whitespace will be ignored.
-pub fn decode_ascii(string: &str) -> String {
-    string
-        .chars()
-        .filter(|c| !c.is_whitespace())
-        .collect::<String>()
-        .as_bytes()
-        .chunks(2)
-        .map(|s| match std::str::from_utf8(s) {
-            Ok(v) => v.parse::<i32>().unwrap_or(0),
-            Err(_) => 0,
-        })
-        .map(|i| match i {
-            11 => 'A',
-            12 => 'B',
-            13 => 'C',
-            14 => 'D',
-            15 => 'E',
-            21 => 'F',
-            22 => 'G',
-            23 => 'H',
-            24 => 'I',
-            25 => 'K',
-            31 => 'L',
-            32 => 'M',
-            33 => 'N',
-            34 => 'O',
-            35 => 'P',
-            41 => 'Q',
-            42 => 'R',
-            43 => 'S',
-            44 => 'T',
-            45 => 'U',
-            51 => 'V',
-            52 => 'W',
-            53 => 'X',
-            54 => 'Y',
-            55 => 'Z',
-            _ => ' ',
-        })
-        .collect::<String>()
-        .replace(" ", "")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{decode_ascii, encode_ascii};
-
-    #[test]
-    fn encode_empty() {
-        assert_eq!(encode_ascii(""), "");
-    }
-
-    #[test]
-    fn encode_valid_string() {
-        assert_eq!(encode_ascii("This is a test"), "4423244324431144154344");
-    }
-
-    #[test]
-    fn encode_emoji() {
-        assert_eq!(encode_ascii("🙂"), "");
-    }
-
-    #[test]
-    fn decode_empty() {
-        assert_eq!(decode_ascii(""), "");
-    }
-
-    #[test]
-    fn decode_valid_string() {
-        assert_eq!(
-            decode_ascii("44 23 24 43 24 43 11 44 15 43 44 "),
-            "THISISATEST"
-        );
-    }
-
-    #[test]
-    fn decode_emoji() {
-        assert_eq!(decode_ascii("🙂"), "");
-    }
-
-    #[test]
-    fn decode_string_with_whitespace() {
-        assert_eq!(
-            decode_ascii("44\n23\t\r24\r\n43   2443\n 11 \t 44\r \r15 \n43 44"),
-            "THISISATEST"
-        );
-    }
-
-    #[test]
-    fn decode_unknown_string() {
-        assert_eq!(decode_ascii("94 63 64 83 64 48 77 00 05 47 48 "), "");
-    }
-
-    #[test]
-    fn decode_odd_length() {
-        assert_eq!(decode_ascii("11 22 33 4"), "AGN");
-    }
-
-    #[test]
-    fn encode_and_decode() {
-        let string = "Do you ever wonder why we're here?";
-        let encode = encode_ascii(string);
-        assert_eq!(
-            "1434543445155115425234331415425223545215421523154215",
-            encode,
-        );
-        assert_eq!("DOYOUEVERWONDERWHYWEREHERE", decode_ascii(&encode));
-    }
-}
-```

codes/src/algorithms/cipher/rot13.md

@@ -1,40 +0,0 @@
-# rot13加密算法
-
-```rust
-pub fn rot13(text: &str) -> String {
-    let to_enc = text.to_uppercase();
-    to_enc
-        .chars()
-        .map(|c| match c {
-            'A'..='M' => ((c as u8) + 13) as char,
-            'N'..='Z' => ((c as u8) - 13) as char,
-            _ => c,
-        })
-        .collect()
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_single_letter() {
-        assert_eq!("N", rot13("A"));
-    }
-
-    #[test]
-    fn test_bunch_of_letters() {
-        assert_eq!("NOP", rot13("ABC"));
-    }
-
-    #[test]
-    fn test_non_ascii() {
-        assert_eq!("😀NO", rot13("😀AB"));
-    }
-
-    #[test]
-    fn test_twice() {
-        assert_eq!("ABCD", rot13(&rot13("ABCD")));
-    }
-}
-```

codes/src/algorithms/cipher/sha256.md

@@ -1,187 +0,0 @@
-# sha256加密
-
-```rust
-//! SHA-2 (256 Bit)
-
-struct BufState {
-    data: Vec<u8>,
-    len: usize,
-    total_len: usize,
-    single: bool,
-    total: bool,
-}
-
-pub fn sha256(data: &[u8]) -> [u8; 32] {
-    let mut hash: [u8; 32] = [0; 32];
-
-    let mut h: [u32; 8] = [
-        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab,
-        0x5be0cd19,
-    ];
-
-    let k: [u32; 64] = [
-        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4,
-        0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe,
-        0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f,
-        0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
-        0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
-        0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
-        0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116,
-        0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7,
-        0xc67178f2,
-    ];
-
-    let mut chunk: [u8; 64] = [0; 64];
-
-    let mut state: BufState = BufState {
-        data: (*data).to_owned(),
-        len: data.len(),
-        total_len: data.len(),
-        single: false,
-        total: false,
-    };
-
-    while calc_chunk(&mut chunk, &mut state) {
-        let mut ah: [u32; 8] = h;
-        let mut w: [u32; 16] = [0; 16];
-        for i in 0..4 {
-            for j in 0..16 {
-                if i == 0 {
-                    w[j] = ((chunk[j * 4] as u32) << 24)
-                        | ((chunk[j * 4 + 1] as u32) << 16)
-                        | ((chunk[j * 4 + 2] as u32) << 8)
-                        | (chunk[j * 4 + 3] as u32);
-                } else {
-                    let s0 = (w[(j + 1) & 0xf].rotate_right(7) ^ w[(j + 1) & 0xf].rotate_right(18))
-                        ^ (w[(j + 1) & 0xf] >> 3);
-                    let s1 = w[(j + 14) & 0xf].rotate_right(17)
-                        ^ w[(j + 14) & 0xf].rotate_right(19)
-                        ^ (w[(j + 14) & 0xf] >> 10);
-                    w[j] = w[j]
-                        .wrapping_add(s0)
-                        .wrapping_add(w[(j + 9) & 0xf])
-                        .wrapping_add(s1);
-                }
-
-                let s1: u32 =
-                    ah[4].rotate_right(6) ^ ah[4].rotate_right(11) ^ ah[4].rotate_right(25);
-                let ch: u32 = (ah[4] & ah[5]) ^ (!ah[4] & ah[6]);
-                let temp1: u32 = ah[7]
-                    .wrapping_add(s1)
-                    .wrapping_add(ch)
-                    .wrapping_add(k[i << 4 | j])
-                    .wrapping_add(w[j]);
-                let s0: u32 =
-                    ah[0].rotate_right(2) ^ ah[0].rotate_right(13) ^ ah[0].rotate_right(22);
-                let maj: u32 = (ah[0] & ah[1]) ^ (ah[0] & ah[2]) ^ (ah[1] & ah[2]);
-                let temp2: u32 = s0.wrapping_add(maj);
-
-                ah[7] = ah[6];
-                ah[6] = ah[5];
-                ah[5] = ah[4];
-                ah[4] = ah[3].wrapping_add(temp1);
-                ah[3] = ah[2];
-                ah[2] = ah[1];
-                ah[1] = ah[0];
-                ah[0] = temp1.wrapping_add(temp2);
-            }
-        }
-
-        for i in 0..8 {
-            h[i] = h[i].wrapping_add(ah[i]);
-        }
-        chunk = [0; 64];
-    }
-
-    for i in 0..8 {
-        hash[i * 4] = (h[i] >> 24) as u8;
-        hash[i * 4 + 1] = (h[i] >> 16) as u8;
-        hash[i * 4 + 2] = (h[i] >> 8) as u8;
-        hash[i * 4 + 3] = h[i] as u8;
-    }
-
-    hash
-}
-
-fn calc_chunk(chunk: &mut [u8; 64], state: &mut BufState) -> bool {
-    if state.total {
-        return false;
-    }
-
-    if state.len >= 64 {
-        for x in chunk {
-            *x = state.data[0];
-            state.data.remove(0);
-        }
-        state.len -= 64;
-        return true;
-    }
-
-    let remaining: usize = state.data.len();
-    let space: usize = 64 - remaining;
-    for x in chunk.iter_mut().take(state.data.len()) {
-        *x = state.data[0];
-        state.data.remove(0);
-    }
-
-    if !state.single {
-        chunk[remaining] = 0x80;
-        state.single = true;
-    }
-
-    if space >= 8 {
-        let mut len = state.total_len;
-        chunk[63] = (len << 3) as u8;
-        len >>= 5;
-        for i in 1..8 {
-            chunk[(63 - i)] = len as u8;
-            len >>= 8;
-        }
-        state.total = true;
-    }
-
-    true
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn empty() {
-        assert_eq!(
-            sha256(&Vec::new()),
-            [
-                0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f,
-                0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b,
-                0x78, 0x52, 0xb8, 0x55
-            ]
-        );
-    }
-
-    #[test]
-    fn ascii() {
-        assert_eq!(
-            sha256(&b"The quick brown fox jumps over the lazy dog".to_vec()),
-            [
-                0xD7, 0xA8, 0xFB, 0xB3, 0x07, 0xD7, 0x80, 0x94, 0x69, 0xCA, 0x9A, 0xBC, 0xB0, 0x08,
-                0x2E, 0x4F, 0x8D, 0x56, 0x51, 0xE4, 0x6D, 0x3C, 0xDB, 0x76, 0x2D, 0x02, 0xD0, 0xBF,
-                0x37, 0xC9, 0xE5, 0x92
-            ]
-        )
-    }
-
-    #[test]
-    fn ascii_avalanche() {
-        assert_eq!(
-            sha256(&b"The quick brown fox jumps over the lazy dog.".to_vec()),
-            [
-                0xEF, 0x53, 0x7F, 0x25, 0xC8, 0x95, 0xBF, 0xA7, 0x82, 0x52, 0x65, 0x29, 0xA9, 0xB6,
-                0x3D, 0x97, 0xAA, 0x63, 0x15, 0x64, 0xD5, 0xD7, 0x89, 0xC2, 0xB7, 0x65, 0x44, 0x8C,
-                0x86, 0x35, 0xFB, 0x6C
-            ]
-        )
-    }
-}
-```

codes/src/algorithms/cipher/vigenere.md

@@ -1,90 +0,0 @@
-# vigenere加密
-
-```rust
-//! Vigenère Cipher
-//!
-//! # Algorithm
-//!
-//! Rotate each ascii character by the offset of the corresponding key character.
-//! When we reach the last key character, we start over from the first one.
-//! This implementation does not rotate unicode characters.
-
-/// Vigenère cipher to rotate plain_text text by key and return an owned String.
-pub fn vigenere(plain_text: &str, key: &str) -> String {
-    // Remove all unicode and non-ascii characters from key
-    let key: String = key.chars().filter(|&c| c.is_ascii_alphabetic()).collect();
-    key.to_ascii_lowercase();
-
-    let key_len = key.len();
-    if key_len == 0 {
-        return String::from(plain_text);
-    }
-
-    let mut index = 0;
-
-    plain_text
-        .chars()
-        .map(|c| {
-            if c.is_ascii_alphabetic() {
-                let first = if c.is_ascii_lowercase() { b'a' } else { b'A' };
-                let shift = key.as_bytes()[index % key_len] - b'a';
-                index += 1;
-                // modulo the distance to keep character range
-                (first + (c as u8 + shift - first) % 26) as char
-            } else {
-                c
-            }
-        })
-        .collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn empty() {
-        assert_eq!(vigenere("", "test"), "");
-    }
-
-    #[test]
-    fn vigenere_base() {
-        assert_eq!(
-            vigenere("LoremIpsumDolorSitAmet", "base"),
-            "MojinIhwvmVsmojWjtSqft"
-        );
-    }
-
-    #[test]
-    fn vigenere_with_spaces() {
-        assert_eq!(
-            vigenere(
-                "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
-                "spaces"
-            ),
-            "Ddrgq ahhuo hgddr uml sbev, ggfheexwljr chahxsemfy tlkx."
-        );
-    }
-
-    #[test]
-    fn vigenere_unicode_and_numbers() {
-        assert_eq!(
-            vigenere("1 Lorem ⏳ ipsum dolor sit amet Ѡ", "unicode"),
-            "1 Fbzga ⏳ ltmhu fcosl fqv opin Ѡ"
-        );
-    }
-
-    #[test]
-    fn vigenere_unicode_key() {
-        assert_eq!(
-            vigenere("Lorem ipsum dolor sit amet", "😉 key!"),
-            "Vspoq gzwsw hmvsp cmr kqcd"
-        );
-    }
-
-    #[test]
-    fn vigenere_empty_key() {
-        assert_eq!(vigenere("Lorem ipsum", ""), "Lorem ipsum");
-    }
-}
-```

codes/src/algorithms/cipher/xor.md

@@ -1,26 +0,0 @@
-# xor
-
-```rust
-pub fn xor(text: &str, key: u8) -> String {
-    text.chars().map(|c| ((c as u8) ^ key) as char).collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_simple() {
-        let test_string = "test string";
-        let ciphered_text = xor(test_string, 32);
-        assert_eq!(test_string, xor(&ciphered_text, 32));
-    }
-
-    #[test]
-    fn test_every_alphabet_with_space() {
-        let test_string = "The quick brown fox jumps over the lazy dog";
-        let ciphered_text = xor(test_string, 64);
-        assert_eq!(test_string, xor(&ciphered_text, 64));
-    }
-}
-```

codes/src/algorithms/dynamic-programming/coin-change.md

@@ -1,71 +0,0 @@
-# 找钱(Coin change)
-
-```rust
-/// Coin change via Dynamic Programming
-
-/// coin_change(coins, amount) returns the fewest number of coins that need to make up that amount.
-/// If that amount of money cannot be made up by any combination of the coins, return `None`.
-///
-/// Arguments:
-///     * `coins` - coins of different denominations
-///     * `amount` - a total amount of money be made up.
-/// Complexity
-///     - time complexity: O(amount * coins.length),
-///     - space complexity: O(amount),
-pub fn coin_change(coins: &[usize], amount: usize) -> Option<usize> {
-    let mut dp = vec![std::usize::MAX; amount + 1];
-    dp[0] = 0;
-
-    // Assume dp[i] is the fewest number of coins making up amount i,
-    // then for every coin in coins, dp[i] = min(dp[i - coin] + 1).
-    for i in 0..=amount {
-        for j in 0..coins.len() {
-            if i >= coins[j] && dp[i - coins[j]] != std::usize::MAX {
-                dp[i] = dp[i].min(dp[i - coins[j]] + 1);
-            }
-        }
-    }
-
-    match dp[amount] {
-        std::usize::MAX => None,
-        _ => Some(dp[amount]),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        // 11 = 5 * 2 + 1 * 1
-        let coins = vec![1, 2, 5];
-        assert_eq!(Some(3), coin_change(&coins, 11));
-
-        // 119 = 11 * 10 + 7 * 1 + 2 * 1
-        let coins = vec![2, 3, 5, 7, 11];
-        assert_eq!(Some(12), coin_change(&coins, 119));
-    }
-
-    #[test]
-    fn coins_empty() {
-        let coins = vec![];
-        assert_eq!(None, coin_change(&coins, 1));
-    }
-
-    #[test]
-    fn amount_zero() {
-        let coins = vec![1, 2, 3];
-        assert_eq!(Some(0), coin_change(&coins, 0));
-    }
-
-    #[test]
-    fn fail_change() {
-        // 3 can't be change by 2.
-        let coins = vec![2];
-        assert_eq!(None, coin_change(&coins, 3));
-        let coins = vec![10, 20, 50, 100];
-        assert_eq!(None, coin_change(&coins, 5));
-    }
-}
-```

codes/src/algorithms/dynamic-programming/edit-distance.md

@@ -1,71 +0,0 @@
-# 最小编辑距离(Edit distance)
-
-```rust
-/// Coin change via Dynamic Programming
-
-/// coin_change(coins, amount) returns the fewest number of coins that need to make up that amount.
-/// If that amount of money cannot be made up by any combination of the coins, return `None`.
-///
-/// Arguments:
-///     * `coins` - coins of different denominations
-///     * `amount` - a total amount of money be made up.
-/// Complexity
-///     - time complexity: O(amount * coins.length),
-///     - space complexity: O(amount),
-pub fn coin_change(coins: &[usize], amount: usize) -> Option<usize> {
-    let mut dp = vec![std::usize::MAX; amount + 1];
-    dp[0] = 0;
-
-    // Assume dp[i] is the fewest number of coins making up amount i,
-    // then for every coin in coins, dp[i] = min(dp[i - coin] + 1).
-    for i in 0..=amount {
-        for j in 0..coins.len() {
-            if i >= coins[j] && dp[i - coins[j]] != std::usize::MAX {
-                dp[i] = dp[i].min(dp[i - coins[j]] + 1);
-            }
-        }
-    }
-
-    match dp[amount] {
-        std::usize::MAX => None,
-        _ => Some(dp[amount]),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        // 11 = 5 * 2 + 1 * 1
-        let coins = vec![1, 2, 5];
-        assert_eq!(Some(3), coin_change(&coins, 11));
-
-        // 119 = 11 * 10 + 7 * 1 + 2 * 1
-        let coins = vec![2, 3, 5, 7, 11];
-        assert_eq!(Some(12), coin_change(&coins, 119));
-    }
-
-    #[test]
-    fn coins_empty() {
-        let coins = vec![];
-        assert_eq!(None, coin_change(&coins, 1));
-    }
-
-    #[test]
-    fn amount_zero() {
-        let coins = vec![1, 2, 3];
-        assert_eq!(Some(0), coin_change(&coins, 0));
-    }
-
-    #[test]
-    fn fail_change() {
-        // 3 can't be change by 2.
-        let coins = vec![2];
-        assert_eq!(None, coin_change(&coins, 3));
-        let coins = vec![10, 20, 50, 100];
-        assert_eq!(None, coin_change(&coins, 5));
-    }
-}
-```

codes/src/algorithms/dynamic-programming/egg-dropping.md

@@ -1,95 +0,0 @@
-# 扔鸡蛋(Egg dropping)
-
-```rust
-/// # Egg Dropping Puzzle
-
-/// `egg_drop(eggs, floors)` returns the least number of egg droppings
-///     required to determine the highest floor from which an egg will not
-///     break upon dropping
-///
-/// Assumptions: n > 0
-pub fn egg_drop(eggs: u32, floors: u32) -> u32 {
-    assert!(eggs > 0);
-
-    // Explicity handle edge cases (optional)
-    if eggs == 1 || floors == 0 || floors == 1 {
-        return floors;
-    }
-
-    let eggs_index = eggs as usize;
-    let floors_index = floors as usize;
-
-    // Store solutions to subproblems in 2D Vec,
-    // where egg_drops[i][j] represents the solution to the egg dropping
-    // problem with i eggs and j floors
-    let mut egg_drops: Vec<Vec<u32>> = vec![vec![0; floors_index + 1]; eggs_index + 1];
-
-    // Assign solutions for egg_drop(n, 0) = 0, egg_drop(n, 1) = 1
-    for egg_drop in egg_drops.iter_mut().skip(1) {
-        egg_drop[0] = 0;
-        egg_drop[1] = 1;
-    }
-
-    // Assign solutions to egg_drop(1, k) = k
-    for j in 1..=floors_index {
-        egg_drops[1][j] = j as u32;
-    }
-
-    // Complete solutions vector using optimal substructure property
-    for i in 2..=eggs_index {
-        for j in 2..=floors_index {
-            egg_drops[i][j] = std::u32::MAX;
-
-            for k in 1..=j {
-                let res = 1 + std::cmp::max(egg_drops[i - 1][k - 1], egg_drops[i][j - k]);
-
-                if res < egg_drops[i][j] {
-                    egg_drops[i][j] = res;
-                }
-            }
-        }
-    }
-
-    egg_drops[eggs_index][floors_index]
-}
-
-#[cfg(test)]
-mod tests {
-    use super::egg_drop;
-
-    #[test]
-    fn zero_floors() {
-        assert_eq!(egg_drop(5, 0), 0);
-    }
-
-    #[test]
-    fn one_egg() {
-        assert_eq!(egg_drop(1, 8), 8);
-    }
-
-    #[test]
-    fn eggs2_floors2() {
-        assert_eq!(egg_drop(2, 2), 2);
-    }
-
-    #[test]
-    fn eggs3_floors5() {
-        assert_eq!(egg_drop(3, 5), 3);
-    }
-
-    #[test]
-    fn eggs2_floors10() {
-        assert_eq!(egg_drop(2, 10), 4);
-    }
-
-    #[test]
-    fn eggs2_floors36() {
-        assert_eq!(egg_drop(2, 36), 8);
-    }
-
-    #[test]
-    fn large_floors() {
-        assert_eq!(egg_drop(2, 100), 14);
-    }
-}
-```

codes/src/algorithms/dynamic-programming/fibonacci.md

@@ -1,209 +0,0 @@
-# 斐波那契(fibonacci)
-
-```rust
-/// Fibonacci via Dynamic Programming
-
-/// fibonacci(n) returns the nth fibonacci number
-/// This function uses the definition of Fibonacci where:
-/// F(0) = F(1) = 1 and F(n+1) = F(n) + F(n-1) for n>0
-///
-/// Warning: This will overflow the 128-bit unsigned integer at n=186
-pub fn fibonacci(n: u32) -> u128 {
-    // Use a and b to store the previous two values in the sequence
-    let mut a = 0;
-    let mut b = 1;
-    for _i in 0..n {
-        // As we iterate through, move b's value into a and the new computed
-        // value into b.
-        let c = a + b;
-        a = b;
-        b = c;
-    }
-    b
-}
-
-/// fibonacci(n) returns the nth fibonacci number
-/// This function uses the definition of Fibonacci where:
-/// F(0) = F(1) = 1 and F(n+1) = F(n) + F(n-1) for n>0
-///
-/// Warning: This will overflow the 128-bit unsigned integer at n=186
-pub fn recursive_fibonacci(n: u32) -> u128 {
-    // Call the actual tail recursive implementation, with the extra
-    // arguments set up.
-    _recursive_fibonacci(n, 0, 1)
-}
-
-fn _recursive_fibonacci(n: u32, previous: u128, current: u128) -> u128 {
-    if n == 0 {
-        current
-    } else {
-        _recursive_fibonacci(n - 1, current, current + previous)
-    }
-}
-
-/// classical_fibonacci(n) returns the nth fibonacci number
-/// This function uses the definition of Fibonacci where:
-/// F(0) = 0, F(1) = 1 and F(n+1) = F(n) + F(n-1) for n>0
-///
-/// Warning: This will overflow the 128-bit unsigned integer at n=186
-pub fn classical_fibonacci(n: u32) -> u128 {
-    match n {
-        0 => 0,
-        1 => 1,
-        _ => {
-            let k = n / 2;
-            let f1 = classical_fibonacci(k);
-            let f2 = classical_fibonacci(k - 1);
-
-            match n % 4 {
-                0 | 2 => f1 * (f1 + 2 * f2),
-                1 => (2 * f1 + f2) * (2 * f1 - f2) + 2,
-                _ => (2 * f1 + f2) * (2 * f1 - f2) - 2,
-            }
-        }
-    }
-}
-
-/// logarithmic_fibonacci(n) returns the nth fibonacci number
-/// This function uses the definition of Fibonacci where:
-/// F(0) = 0, F(1) = 1 and F(n+1) = F(n) + F(n-1) for n>0
-///
-/// Warning: This will overflow the 128-bit unsigned integer at n=186
-pub fn logarithmic_fibonacci(n: u32) -> u128 {
-    // if it is the max value before overflow, use n-1 then get the second
-    // value in the tuple
-    if n == 186 {
-        let (_, second) = _logarithmic_fibonacci(185);
-        second
-    } else {
-        let (first, _) = _logarithmic_fibonacci(n);
-        first
-    }
-}
-
-fn _logarithmic_fibonacci(n: u32) -> (u128, u128) {
-    match n {
-        0 => (0, 1),
-        _ => {
-            let (current, next) = _logarithmic_fibonacci(n / 2);
-            let c = current * (next * 2 - current);
-            let d = current * current + next * next;
-
-            match n % 2 {
-                0 => (c, d),
-                _ => (d, c + d),
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::classical_fibonacci;
-    use super::fibonacci;
-    use super::logarithmic_fibonacci;
-    use super::recursive_fibonacci;
-
-    #[test]
-    fn test_fibonacci() {
-        assert_eq!(fibonacci(0), 1);
-        assert_eq!(fibonacci(1), 1);
-        assert_eq!(fibonacci(2), 2);
-        assert_eq!(fibonacci(3), 3);
-        assert_eq!(fibonacci(4), 5);
-        assert_eq!(fibonacci(5), 8);
-        assert_eq!(fibonacci(10), 89);
-        assert_eq!(fibonacci(20), 10946);
-        assert_eq!(fibonacci(100), 573147844013817084101);
-        assert_eq!(fibonacci(184), 205697230343233228174223751303346572685);
-    }
-
-    #[test]
-    fn test_recursive_fibonacci() {
-        assert_eq!(recursive_fibonacci(0), 1);
-        assert_eq!(recursive_fibonacci(1), 1);
-        assert_eq!(recursive_fibonacci(2), 2);
-        assert_eq!(recursive_fibonacci(3), 3);
-        assert_eq!(recursive_fibonacci(4), 5);
-        assert_eq!(recursive_fibonacci(5), 8);
-        assert_eq!(recursive_fibonacci(10), 89);
-        assert_eq!(recursive_fibonacci(20), 10946);
-        assert_eq!(recursive_fibonacci(100), 573147844013817084101);
-        assert_eq!(
-            recursive_fibonacci(184),
-            205697230343233228174223751303346572685
-        );
-    }
-
-    #[test]
-    fn test_classical_fibonacci() {
-        assert_eq!(classical_fibonacci(0), 0);
-        assert_eq!(classical_fibonacci(1), 1);
-        assert_eq!(classical_fibonacci(2), 1);
-        assert_eq!(classical_fibonacci(3), 2);
-        assert_eq!(classical_fibonacci(4), 3);
-        assert_eq!(classical_fibonacci(5), 5);
-        assert_eq!(classical_fibonacci(10), 55);
-        assert_eq!(classical_fibonacci(20), 6765);
-        assert_eq!(classical_fibonacci(21), 10946);
-        assert_eq!(classical_fibonacci(100), 354224848179261915075);
-        assert_eq!(
-            classical_fibonacci(184),
-            127127879743834334146972278486287885163
-        );
-    }
-
-    #[test]
-    fn test_logarithmic_fibonacci() {
-        assert_eq!(logarithmic_fibonacci(0), 0);
-        assert_eq!(logarithmic_fibonacci(1), 1);
-        assert_eq!(logarithmic_fibonacci(2), 1);
-        assert_eq!(logarithmic_fibonacci(3), 2);
-        assert_eq!(logarithmic_fibonacci(4), 3);
-        assert_eq!(logarithmic_fibonacci(5), 5);
-        assert_eq!(logarithmic_fibonacci(10), 55);
-        assert_eq!(logarithmic_fibonacci(20), 6765);
-        assert_eq!(logarithmic_fibonacci(21), 10946);
-        assert_eq!(logarithmic_fibonacci(100), 354224848179261915075);
-        assert_eq!(
-            logarithmic_fibonacci(184),
-            127127879743834334146972278486287885163
-        );
-    }
-
-    #[test]
-    /// Check that the itterative and recursive fibonacci
-    /// produce the same value. Both are combinatorial ( F(0) = F(1) = 1 )
-    fn test_iterative_and_recursive_equivalence() {
-        assert_eq!(fibonacci(0), recursive_fibonacci(0));
-        assert_eq!(fibonacci(1), recursive_fibonacci(1));
-        assert_eq!(fibonacci(2), recursive_fibonacci(2));
-        assert_eq!(fibonacci(3), recursive_fibonacci(3));
-        assert_eq!(fibonacci(4), recursive_fibonacci(4));
-        assert_eq!(fibonacci(5), recursive_fibonacci(5));
-        assert_eq!(fibonacci(10), recursive_fibonacci(10));
-        assert_eq!(fibonacci(20), recursive_fibonacci(20));
-        assert_eq!(fibonacci(100), recursive_fibonacci(100));
-        assert_eq!(fibonacci(184), recursive_fibonacci(184));
-    }
-
-    #[test]
-    /// Check that classical and combinatorial fibonacci produce the
-    /// same value when 'n' differs by 1.
-    /// classical fibonacci: ( F(0) = 0, F(1) = 1 )
-    /// combinatorial fibonacci: ( F(0) = F(1) = 1 )
-    fn test_classical_and_combinatorial_are_off_by_one() {
-        assert_eq!(classical_fibonacci(1), fibonacci(0));
-        assert_eq!(classical_fibonacci(2), fibonacci(1));
-        assert_eq!(classical_fibonacci(3), fibonacci(2));
-        assert_eq!(classical_fibonacci(4), fibonacci(3));
-        assert_eq!(classical_fibonacci(5), fibonacci(4));
-        assert_eq!(classical_fibonacci(6), fibonacci(5));
-        assert_eq!(classical_fibonacci(11), fibonacci(10));
-        assert_eq!(classical_fibonacci(20), fibonacci(19));
-        assert_eq!(classical_fibonacci(21), fibonacci(20));
-        assert_eq!(classical_fibonacci(101), fibonacci(100));
-        assert_eq!(classical_fibonacci(185), fibonacci(184));
-    }
-}
-```

codes/src/algorithms/dynamic-programming/index.md

@@ -1,4 +0,0 @@
-# 动态规划
-
-动态规划算法是通过拆分问题，定义问题状态和状态之间的关系，使得问题能够以递推（或者说分治）的方式去解决。
-动态规划算法的基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。依次解决各子问题，最后一个子问题就是初始问题的解。

codes/src/algorithms/dynamic-programming/is-subsequence.md

@@ -1,209 +0,0 @@
-# 判断子序列
-
-```rust
-/// Fibonacci via Dynamic Programming
-
-/// fibonacci(n) returns the nth fibonacci number
-/// This function uses the definition of Fibonacci where:
-/// F(0) = F(1) = 1 and F(n+1) = F(n) + F(n-1) for n>0
-///
-/// Warning: This will overflow the 128-bit unsigned integer at n=186
-pub fn fibonacci(n: u32) -> u128 {
-    // Use a and b to store the previous two values in the sequence
-    let mut a = 0;
-    let mut b = 1;
-    for _i in 0..n {
-        // As we iterate through, move b's value into a and the new computed
-        // value into b.
-        let c = a + b;
-        a = b;
-        b = c;
-    }
-    b
-}
-
-/// fibonacci(n) returns the nth fibonacci number
-/// This function uses the definition of Fibonacci where:
-/// F(0) = F(1) = 1 and F(n+1) = F(n) + F(n-1) for n>0
-///
-/// Warning: This will overflow the 128-bit unsigned integer at n=186
-pub fn recursive_fibonacci(n: u32) -> u128 {
-    // Call the actual tail recursive implementation, with the extra
-    // arguments set up.
-    _recursive_fibonacci(n, 0, 1)
-}
-
-fn _recursive_fibonacci(n: u32, previous: u128, current: u128) -> u128 {
-    if n == 0 {
-        current
-    } else {
-        _recursive_fibonacci(n - 1, current, current + previous)
-    }
-}
-
-/// classical_fibonacci(n) returns the nth fibonacci number
-/// This function uses the definition of Fibonacci where:
-/// F(0) = 0, F(1) = 1 and F(n+1) = F(n) + F(n-1) for n>0
-///
-/// Warning: This will overflow the 128-bit unsigned integer at n=186
-pub fn classical_fibonacci(n: u32) -> u128 {
-    match n {
-        0 => 0,
-        1 => 1,
-        _ => {
-            let k = n / 2;
-            let f1 = classical_fibonacci(k);
-            let f2 = classical_fibonacci(k - 1);
-
-            match n % 4 {
-                0 | 2 => f1 * (f1 + 2 * f2),
-                1 => (2 * f1 + f2) * (2 * f1 - f2) + 2,
-                _ => (2 * f1 + f2) * (2 * f1 - f2) - 2,
-            }
-        }
-    }
-}
-
-/// logarithmic_fibonacci(n) returns the nth fibonacci number
-/// This function uses the definition of Fibonacci where:
-/// F(0) = 0, F(1) = 1 and F(n+1) = F(n) + F(n-1) for n>0
-///
-/// Warning: This will overflow the 128-bit unsigned integer at n=186
-pub fn logarithmic_fibonacci(n: u32) -> u128 {
-    // if it is the max value before overflow, use n-1 then get the second
-    // value in the tuple
-    if n == 186 {
-        let (_, second) = _logarithmic_fibonacci(185);
-        second
-    } else {
-        let (first, _) = _logarithmic_fibonacci(n);
-        first
-    }
-}
-
-fn _logarithmic_fibonacci(n: u32) -> (u128, u128) {
-    match n {
-        0 => (0, 1),
-        _ => {
-            let (current, next) = _logarithmic_fibonacci(n / 2);
-            let c = current * (next * 2 - current);
-            let d = current * current + next * next;
-
-            match n % 2 {
-                0 => (c, d),
-                _ => (d, c + d),
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::classical_fibonacci;
-    use super::fibonacci;
-    use super::logarithmic_fibonacci;
-    use super::recursive_fibonacci;
-
-    #[test]
-    fn test_fibonacci() {
-        assert_eq!(fibonacci(0), 1);
-        assert_eq!(fibonacci(1), 1);
-        assert_eq!(fibonacci(2), 2);
-        assert_eq!(fibonacci(3), 3);
-        assert_eq!(fibonacci(4), 5);
-        assert_eq!(fibonacci(5), 8);
-        assert_eq!(fibonacci(10), 89);
-        assert_eq!(fibonacci(20), 10946);
-        assert_eq!(fibonacci(100), 573147844013817084101);
-        assert_eq!(fibonacci(184), 205697230343233228174223751303346572685);
-    }
-
-    #[test]
-    fn test_recursive_fibonacci() {
-        assert_eq!(recursive_fibonacci(0), 1);
-        assert_eq!(recursive_fibonacci(1), 1);
-        assert_eq!(recursive_fibonacci(2), 2);
-        assert_eq!(recursive_fibonacci(3), 3);
-        assert_eq!(recursive_fibonacci(4), 5);
-        assert_eq!(recursive_fibonacci(5), 8);
-        assert_eq!(recursive_fibonacci(10), 89);
-        assert_eq!(recursive_fibonacci(20), 10946);
-        assert_eq!(recursive_fibonacci(100), 573147844013817084101);
-        assert_eq!(
-            recursive_fibonacci(184),
-            205697230343233228174223751303346572685
-        );
-    }
-
-    #[test]
-    fn test_classical_fibonacci() {
-        assert_eq!(classical_fibonacci(0), 0);
-        assert_eq!(classical_fibonacci(1), 1);
-        assert_eq!(classical_fibonacci(2), 1);
-        assert_eq!(classical_fibonacci(3), 2);
-        assert_eq!(classical_fibonacci(4), 3);
-        assert_eq!(classical_fibonacci(5), 5);
-        assert_eq!(classical_fibonacci(10), 55);
-        assert_eq!(classical_fibonacci(20), 6765);
-        assert_eq!(classical_fibonacci(21), 10946);
-        assert_eq!(classical_fibonacci(100), 354224848179261915075);
-        assert_eq!(
-            classical_fibonacci(184),
-            127127879743834334146972278486287885163
-        );
-    }
-
-    #[test]
-    fn test_logarithmic_fibonacci() {
-        assert_eq!(logarithmic_fibonacci(0), 0);
-        assert_eq!(logarithmic_fibonacci(1), 1);
-        assert_eq!(logarithmic_fibonacci(2), 1);
-        assert_eq!(logarithmic_fibonacci(3), 2);
-        assert_eq!(logarithmic_fibonacci(4), 3);
-        assert_eq!(logarithmic_fibonacci(5), 5);
-        assert_eq!(logarithmic_fibonacci(10), 55);
-        assert_eq!(logarithmic_fibonacci(20), 6765);
-        assert_eq!(logarithmic_fibonacci(21), 10946);
-        assert_eq!(logarithmic_fibonacci(100), 354224848179261915075);
-        assert_eq!(
-            logarithmic_fibonacci(184),
-            127127879743834334146972278486287885163
-        );
-    }
-
-    #[test]
-    /// Check that the itterative and recursive fibonacci
-    /// produce the same value. Both are combinatorial ( F(0) = F(1) = 1 )
-    fn test_iterative_and_recursive_equivalence() {
-        assert_eq!(fibonacci(0), recursive_fibonacci(0));
-        assert_eq!(fibonacci(1), recursive_fibonacci(1));
-        assert_eq!(fibonacci(2), recursive_fibonacci(2));
-        assert_eq!(fibonacci(3), recursive_fibonacci(3));
-        assert_eq!(fibonacci(4), recursive_fibonacci(4));
-        assert_eq!(fibonacci(5), recursive_fibonacci(5));
-        assert_eq!(fibonacci(10), recursive_fibonacci(10));
-        assert_eq!(fibonacci(20), recursive_fibonacci(20));
-        assert_eq!(fibonacci(100), recursive_fibonacci(100));
-        assert_eq!(fibonacci(184), recursive_fibonacci(184));
-    }
-
-    #[test]
-    /// Check that classical and combinatorial fibonacci produce the
-    /// same value when 'n' differs by 1.
-    /// classical fibonacci: ( F(0) = 0, F(1) = 1 )
-    /// combinatorial fibonacci: ( F(0) = F(1) = 1 )
-    fn test_classical_and_combinatorial_are_off_by_one() {
-        assert_eq!(classical_fibonacci(1), fibonacci(0));
-        assert_eq!(classical_fibonacci(2), fibonacci(1));
-        assert_eq!(classical_fibonacci(3), fibonacci(2));
-        assert_eq!(classical_fibonacci(4), fibonacci(3));
-        assert_eq!(classical_fibonacci(5), fibonacci(4));
-        assert_eq!(classical_fibonacci(6), fibonacci(5));
-        assert_eq!(classical_fibonacci(11), fibonacci(10));
-        assert_eq!(classical_fibonacci(20), fibonacci(19));
-        assert_eq!(classical_fibonacci(21), fibonacci(20));
-        assert_eq!(classical_fibonacci(101), fibonacci(100));
-        assert_eq!(classical_fibonacci(185), fibonacci(184));
-    }
-}
-```

codes/src/algorithms/dynamic-programming/knapsack.md

@@ -1,152 +0,0 @@
-# 背包问题
-
-```rust
-//! Solves the knapsack problem
-use std::cmp::max;
-
-/// knapsack_table(w, weights, values) returns the knapsack table (`n`, `m`) with maximum values, where `n` is number of items
-///
-/// Arguments:
-///     * `w` - knapsack capacity
-///     * `weights` - set of weights for each item
-///     * `values` - set of values for each item
-fn knapsack_table(w: &usize, weights: &[usize], values: &[usize]) -> Vec<Vec<usize>> {
-    // Initialize `n` - number of items
-    let n: usize = weights.len();
-    // Initialize `m`
-    // m[i, w] - the maximum value that can be attained with weight less that or equal to `w` using items up to `i`
-    let mut m: Vec<Vec<usize>> = vec![vec![0; w + 1]; n + 1];
-
-    for i in 0..=n {
-        for j in 0..=*w {
-            // m[i, j] compiled according to the following rule:
-            if i == 0 || j == 0 {
-                m[i][j] = 0;
-            } else if weights[i - 1] <= j {
-                // If `i` is in the knapsack
-                // Then m[i, j] is equal to the maximum value of the knapsack,
-                // where the weight `j` is reduced by the weight of the `i-th` item and the set of admissible items plus the value `k`
-                m[i][j] = max(values[i - 1] + m[i - 1][j - weights[i - 1]], m[i - 1][j]);
-            } else {
-                // If the item `i` did not get into the knapsack
-                // Then m[i, j] is equal to the maximum cost of a knapsack with the same capacity and a set of admissible items
-                m[i][j] = m[i - 1][j]
-            }
-        }
-    }
-    m
-}
-
-/// knapsack_items(weights, m, i, j) returns the indices of the items of the optimal knapsack (from 1 to `n`)
-///
-/// Arguments:
-///     * `weights` - set of weights for each item
-///     * `m` - knapsack table with maximum values
-///     * `i` - include items 1 through `i` in knapsack (for the initial value, use `n`)
-///     * `j` - maximum weight of the knapsack
-fn knapsack_items(weights: &[usize], m: &[Vec<usize>], i: usize, j: usize) -> Vec<usize> {
-    if i == 0 {
-        return vec![];
-    }
-    if m[i][j] > m[i - 1][j] {
-        let mut knap: Vec<usize> = knapsack_items(weights, m, i - 1, j - weights[i - 1]);
-        knap.push(i);
-        knap
-    } else {
-        knapsack_items(weights, m, i - 1, j)
-    }
-}
-
-/// knapsack(w, weights, values) returns the tuple where first value is `optimal profit`,
-/// second value is `knapsack optimal weight` and the last value is `indices of items`, that we got (from 1 to `n`)
-///
-/// Arguments:
-///     * `w` - knapsack capacity
-///     * `weights` - set of weights for each item
-///     * `values` - set of values for each item
-///
-/// Complexity
-///     - time complexity: O(nw),
-///     - space complexity: O(nw),
-///
-/// where `n` and `w` are `number of items` and `knapsack capacity`
-pub fn knapsack(w: usize, weights: Vec<usize>, values: Vec<usize>) -> (usize, usize, Vec<usize>) {
-    // Checks if the number of items in the list of weights is the same as the number of items in the list of values
-    assert_eq!(weights.len(), values.len(), "Number of items in the list of weights doesn't match the number of items in the list of values!");
-    // Initialize `n` - number of items
-    let n: usize = weights.len();
-    // Find the knapsack table
-    let m: Vec<Vec<usize>> = knapsack_table(&w, &weights, &values);
-    // Find the indices of the items
-    let items: Vec<usize> = knapsack_items(&weights, &m, n, w);
-    // Find the total weight of optimal knapsack
-    let mut total_weight: usize = 0;
-    for i in items.iter() {
-        total_weight += weights[i - 1];
-    }
-    // Return result
-    (m[n][w], total_weight, items)
-}
-
-#[cfg(test)]
-mod tests {
-    // Took test datasets from https://people.sc.fsu.edu/~jburkardt/datasets/bin_packing/bin_packing.html
-    use super::*;
-
-    #[test]
-    fn test_p02() {
-        assert_eq!(
-            (51, 26, vec![2, 3, 4]),
-            knapsack(26, vec![12, 7, 11, 8, 9], vec![24, 13, 23, 15, 16])
-        );
-    }
-
-    #[test]
-    fn test_p04() {
-        assert_eq!(
-            (150, 190, vec![1, 2, 5]),
-            knapsack(
-                190,
-                vec![56, 59, 80, 64, 75, 17],
-                vec![50, 50, 64, 46, 50, 5]
-            )
-        );
-    }
-
-    #[test]
-    fn test_p01() {
-        assert_eq!(
-            (309, 165, vec![1, 2, 3, 4, 6]),
-            knapsack(
-                165,
-                vec![23, 31, 29, 44, 53, 38, 63, 85, 89, 82],
-                vec![92, 57, 49, 68, 60, 43, 67, 84, 87, 72]
-            )
-        );
-    }
-
-    #[test]
-    fn test_p06() {
-        assert_eq!(
-            (1735, 169, vec![2, 4, 7]),
-            knapsack(
-                170,
-                vec![41, 50, 49, 59, 55, 57, 60],
-                vec![442, 525, 511, 593, 546, 564, 617]
-            )
-        );
-    }
-
-    #[test]
-    fn test_p07() {
-        assert_eq!(
-            (1458, 749, vec![1, 3, 5, 7, 8, 9, 14, 15]),
-            knapsack(
-                750,
-                vec![70, 73, 77, 80, 82, 87, 90, 94, 98, 106, 110, 113, 115, 118, 120],
-                vec![135, 139, 149, 150, 156, 163, 173, 184, 192, 201, 210, 214, 221, 229, 240]
-            )
-        );
-    }
-}
-```

codes/src/algorithms/dynamic-programming/longese-common-sequence.md

@@ -1,77 +0,0 @@
-# 最长公共子序列
-
-```rust
-/// Longest common subsequence via Dynamic Programming
-
-/// longest_common_subsequence(a, b) returns the longest common subsequence
-/// between the strings a and b.
-pub fn longest_common_subsequence(a: &str, b: &str) -> String {
-    let a: Vec<_> = a.chars().collect();
-    let b: Vec<_> = b.chars().collect();
-    let (na, nb) = (a.len(), b.len());
-
-    // solutions[i][j] is the length of the longest common subsequence
-    // between a[0..i-1] and b[0..j-1]
-    let mut solutions = vec![vec![0; nb + 1]; na + 1];
-
-    for (i, ci) in a.iter().enumerate() {
-        for (j, cj) in b.iter().enumerate() {
-            // if ci == cj, there is a new common character;
-            // otherwise, take the best of the two solutions
-            // at (i-1,j) and (i,j-1)
-            solutions[i + 1][j + 1] = if ci == cj {
-                solutions[i][j] + 1
-            } else {
-                solutions[i][j + 1].max(solutions[i + 1][j])
-            }
-        }
-    }
-
-    // reconstitute the solution string from the lengths
-    let mut result: Vec<char> = Vec::new();
-    let (mut i, mut j) = (na, nb);
-    while i > 0 && j > 0 {
-        if a[i - 1] == b[j - 1] {
-            result.push(a[i - 1]);
-            i -= 1;
-            j -= 1;
-        } else if solutions[i - 1][j] > solutions[i][j - 1] {
-            i -= 1;
-        } else {
-            j -= 1;
-        }
-    }
-
-    result.reverse();
-    result.iter().collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::longest_common_subsequence;
-
-    #[test]
-    fn test_longest_common_subsequence() {
-        // empty case
-        assert_eq!(&longest_common_subsequence("", ""), "");
-        assert_eq!(&longest_common_subsequence("", "abcd"), "");
-        assert_eq!(&longest_common_subsequence("abcd", ""), "");
-
-        // simple cases
-        assert_eq!(&longest_common_subsequence("abcd", "c"), "c");
-        assert_eq!(&longest_common_subsequence("abcd", "d"), "d");
-        assert_eq!(&longest_common_subsequence("abcd", "e"), "");
-        assert_eq!(&longest_common_subsequence("abcdefghi", "acegi"), "acegi");
-
-        // less simple cases
-        assert_eq!(&longest_common_subsequence("abcdgh", "aedfhr"), "adh");
-        assert_eq!(&longest_common_subsequence("aggtab", "gxtxayb"), "gtab");
-
-        // unicode
-        assert_eq!(
-            &longest_common_subsequence("你好，世界", "再见世界"),
-            "世界"
-        );
-    }
-}
-```

codes/src/algorithms/dynamic-programming/longest-increasing-subsequence.md

@@ -1,432 +0,0 @@
-# 最长上升子序列
-
-```rust
-/// Finds the longest increasing subsequence and returns it.
-///
-/// If multiple subsequences with the longest possible subsequence length can be found, the
-/// subsequence which appeared first will be returned (see `test_example_1`).
-///
-/// Inspired by [this LeetCode problem](https://leetcode.com/problems/longest-increasing-subsequence/).
-pub fn longest_increasing_subsequence<T: Ord + Clone>(input_array: Vec<T>) -> Vec<T> {
-    let n = input_array.len();
-    if n <= 1 {
-        return input_array;
-    }
-
-    // Find longest increasing subsequence
-    let mut dp = vec![(1, None); n];
-    let mut pair = 0;
-
-    for i in 0..n {
-        for j in 0..i {
-            if input_array[j] < input_array[i] && dp[j].0 + 1 > dp[i].0 {
-                dp[i] = (dp[j].0 + 1, Some(j));
-
-                if dp[i].0 > dp[pair].0 {
-                    pair = i;
-                }
-            }
-        }
-    }
-
-    // Construct subsequence
-    let mut out: Vec<T> = Vec::with_capacity(dp[pair].0);
-
-    out.push(input_array[pair].clone());
-    while let Some(next) = dp[pair].1 {
-        pair = next;
-        out.push(input_array[pair].clone());
-    }
-
-    out.into_iter().rev().collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::longest_increasing_subsequence;
-
-    #[test]
-    /// Need to specify generic type T in order to function
-    fn test_empty_vec() {
-        assert_eq!(longest_increasing_subsequence::<i32>(vec![]), vec![]);
-    }
-
-    #[test]
-    fn test_example_1() {
-        assert_eq!(
-            longest_increasing_subsequence(vec![10, 9, 2, 5, 3, 7, 101, 18]),
-            vec![2, 5, 7, 101]
-        );
-    }
-
-    #[test]
-    fn test_example_2() {
-        assert_eq!(
-            longest_increasing_subsequence(vec![0, 1, 0, 3, 2, 3]),
-            vec![0, 1, 2, 3]
-        );
-    }
-
-    #[test]
-    fn test_example_3() {
-        assert_eq!(
-            longest_increasing_subsequence(vec![7, 7, 7, 7, 7, 7, 7]),
-            vec![7]
-        );
-    }
-
-    #[test]
-    #[ignore]
-    fn test_tle() {
-        assert_eq!(
-            longest_increasing_subsequence(vec![
-                1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
-                24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
-                45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
-                66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
-                87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
-                106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
-                122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
-                138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
-                154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
-                170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
-                186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201,
-                202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
-                218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
-                234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
-                250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
-                266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281,
-                282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297,
-                298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313,
-                314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329,
-                330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345,
-                346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361,
-                362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377,
-                378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393,
-                394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409,
-                410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425,
-                426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441,
-                442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457,
-                458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473,
-                474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489,
-                490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505,
-                506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521,
-                522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537,
-                538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553,
-                554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569,
-                570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585,
-                586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601,
-                602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617,
-                618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633,
-                634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649,
-                650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665,
-                666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681,
-                682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697,
-                698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713,
-                714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729,
-                730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745,
-                746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761,
-                762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777,
-                778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793,
-                794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809,
-                810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825,
-                826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841,
-                842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857,
-                858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873,
-                874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889,
-                890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905,
-                906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921,
-                922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937,
-                938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953,
-                954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969,
-                970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985,
-                986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001,
-                1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015,
-                1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029,
-                1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043,
-                1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057,
-                1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071,
-                1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085,
-                1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099,
-                1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113,
-                1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127,
-                1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141,
-                1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155,
-                1156, 1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169,
-                1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183,
-                1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197,
-                1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211,
-                1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225,
-                1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239,
-                1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253,
-                1254, 1255, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267,
-                1268, 1269, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281,
-                1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 1295,
-                1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309,
-                1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323,
-                1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337,
-                1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351,
-                1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365,
-                1366, 1367, 1368, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379,
-                1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393,
-                1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407,
-                1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1421,
-                1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435,
-                1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449,
-                1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463,
-                1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477,
-                1478, 1479, 1480, 1481, 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491,
-                1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505,
-                1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519,
-                1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533,
-                1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547,
-                1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561,
-                1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575,
-                1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589,
-                1590, 1591, 1592, 1593, 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603,
-                1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617,
-                1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631,
-                1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645,
-                1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 1658, 1659,
-                1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673,
-                1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687,
-                1688, 1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701,
-                1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715,
-                1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729,
-                1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743,
-                1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757,
-                1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, 1770, 1771,
-                1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785,
-                1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799,
-                1800, 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813,
-                1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827,
-                1828, 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841,
-                1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, 1850, 1851, 1852, 1853, 1854, 1855,
-                1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869,
-                1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883,
-                1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897,
-                1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911,
-                1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925,
-                1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939,
-                1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953,
-                1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967,
-                1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981,
-                1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-                1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-                2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023,
-                2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037,
-                2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051,
-                2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065,
-                2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079,
-                2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093,
-                2094, 2095, 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 2104, 2105, 2106, 2107,
-                2108, 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121,
-                2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135,
-                2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149,
-                2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163,
-                2164, 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177,
-                2178, 2179, 2180, 2181, 2182, 2183, 2184, 2185, 2186, 2187, 2188, 2189, 2190, 2191,
-                2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, 2200, 2201, 2202, 2203, 2204, 2205,
-                2206, 2207, 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219,
-                2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, 2232, 2233,
-                2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 2242, 2243, 2244, 2245, 2246, 2247,
-                2248, 2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2259, 2260, 2261,
-                2262, 2263, 2264, 2265, 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275,
-                2276, 2277, 2278, 2279, 2280, 2281, 2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289,
-                2290, 2291, 2292, 2293, 2294, 2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, 2303,
-                2304, 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, 2315, 2316, 2317,
-                2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329, 2330, 2331,
-                2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345,
-                2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, 2358, 2359,
-                2360, 2361, 2362, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373,
-                2374, 2375, 2376, 2377, 2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387,
-                2388, 2389, 2390, 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401,
-                2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 2411, 2412, 2413, 2414, 2415,
-                2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, 2425, 2426, 2427, 2428, 2429,
-                2430, 2431, 2432, 2433, 2434, 2435, 2436, 2437, 2438, 2439, 2440, 2441, 2442, 2443,
-                2444, 2445, 2446, 2447, 2448, 2449, 2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457,
-                2458, 2459, 2460, 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 2471,
-                2472, 2473, 2474, 2475, 2476, 2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, 2485,
-                2486, 2487, 2488, 2489, 2490, 2491, 2492, 2493, 2494, 2495, 2496, 2497, 2498, 2499,
-                2500
-            ]),
-            vec![
-                1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
-                24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
-                45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
-                66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
-                87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
-                106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
-                122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
-                138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
-                154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
-                170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
-                186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201,
-                202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
-                218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
-                234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
-                250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
-                266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281,
-                282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297,
-                298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313,
-                314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329,
-                330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345,
-                346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361,
-                362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377,
-                378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393,
-                394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409,
-                410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425,
-                426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441,
-                442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457,
-                458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473,
-                474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489,
-                490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505,
-                506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521,
-                522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537,
-                538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553,
-                554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569,
-                570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585,
-                586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601,
-                602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617,
-                618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633,
-                634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649,
-                650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665,
-                666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681,
-                682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697,
-                698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713,
-                714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729,
-                730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745,
-                746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761,
-                762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777,
-                778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793,
-                794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809,
-                810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825,
-                826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841,
-                842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857,
-                858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873,
-                874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889,
-                890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905,
-                906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921,
-                922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937,
-                938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953,
-                954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969,
-                970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985,
-                986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001,
-                1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015,
-                1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029,
-                1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043,
-                1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057,
-                1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071,
-                1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085,
-                1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099,
-                1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113,
-                1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127,
-                1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141,
-                1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155,
-                1156, 1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169,
-                1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183,
-                1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197,
-                1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211,
-                1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225,
-                1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239,
-                1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253,
-                1254, 1255, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267,
-                1268, 1269, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281,
-                1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 1295,
-                1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309,
-                1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323,
-                1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337,
-                1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351,
-                1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365,
-                1366, 1367, 1368, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379,
-                1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393,
-                1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407,
-                1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1421,
-                1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435,
-                1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449,
-                1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463,
-                1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477,
-                1478, 1479, 1480, 1481, 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491,
-                1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505,
-                1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519,
-                1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533,
-                1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547,
-                1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561,
-                1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575,
-                1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589,
-                1590, 1591, 1592, 1593, 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603,
-                1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617,
-                1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631,
-                1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645,
-                1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 1658, 1659,
-                1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673,
-                1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687,
-                1688, 1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701,
-                1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715,
-                1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729,
-                1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743,
-                1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757,
-                1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, 1770, 1771,
-                1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785,
-                1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799,
-                1800, 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813,
-                1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827,
-                1828, 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841,
-                1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, 1850, 1851, 1852, 1853, 1854, 1855,
-                1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869,
-                1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883,
-                1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897,
-                1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911,
-                1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925,
-                1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939,
-                1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953,
-                1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967,
-                1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981,
-                1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-                1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-                2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023,
-                2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037,
-                2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051,
-                2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065,
-                2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079,
-                2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093,
-                2094, 2095, 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 2104, 2105, 2106, 2107,
-                2108, 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121,
-                2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135,
-                2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149,
-                2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163,
-                2164, 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177,
-                2178, 2179, 2180, 2181, 2182, 2183, 2184, 2185, 2186, 2187, 2188, 2189, 2190, 2191,
-                2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, 2200, 2201, 2202, 2203, 2204, 2205,
-                2206, 2207, 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219,
-                2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, 2232, 2233,
-                2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 2242, 2243, 2244, 2245, 2246, 2247,
-                2248, 2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2259, 2260, 2261,
-                2262, 2263, 2264, 2265, 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275,
-                2276, 2277, 2278, 2279, 2280, 2281, 2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289,
-                2290, 2291, 2292, 2293, 2294, 2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, 2303,
-                2304, 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, 2315, 2316, 2317,
-                2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329, 2330, 2331,
-                2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345,
-                2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, 2358, 2359,
-                2360, 2361, 2362, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373,
-                2374, 2375, 2376, 2377, 2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387,
-                2388, 2389, 2390, 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401,
-                2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 2411, 2412, 2413, 2414, 2415,
-                2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, 2425, 2426, 2427, 2428, 2429,
-                2430, 2431, 2432, 2433, 2434, 2435, 2436, 2437, 2438, 2439, 2440, 2441, 2442, 2443,
-                2444, 2445, 2446, 2447, 2448, 2449, 2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457,
-                2458, 2459, 2460, 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 2471,
-                2472, 2473, 2474, 2475, 2476, 2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, 2485,
-                2486, 2487, 2488, 2489, 2490, 2491, 2492, 2493, 2494, 2495, 2496, 2497, 2498, 2499,
-                2500
-            ]
-        );
-    }
-
-    #[test]
-    fn test_negative_elements() {
-        assert_eq!(longest_increasing_subsequence(vec![-2, -1]), vec![-2, -1]);
-    }
-}
-```

codes/src/algorithms/dynamic-programming/longest_continuous_increasing_subsequence.md

@@ -1,78 +0,0 @@
-# 最长连续递增序列
-
-```rust
-pub fn longest_continuous_increasing_subsequence<T: Ord>(input_array: &[T]) -> &[T] {
-    let length: usize = input_array.len();
-
-    //Handle the base cases
-    if length <= 1 {
-        return input_array;
-    }
-
-    //Create the array to store the longest subsequence at each location
-    let mut tracking_vec = vec![1; length];
-
-    //Iterate through the input and store longest subsequences at each location in the vector
-    for i in (0..length - 1).rev() {
-        if input_array[i] < input_array[i + 1] {
-            tracking_vec[i] = tracking_vec[i + 1] + 1;
-        }
-    }
-
-    //Find the longest subsequence
-    let mut max_index: usize = 0;
-    let mut max_value: i32 = 0;
-    for (index, value) in tracking_vec.iter().enumerate() {
-        if value > &max_value {
-            max_value = *value;
-            max_index = index;
-        }
-    }
-
-    &input_array[max_index..max_index + max_value as usize]
-}
-
-#[cfg(test)]
-mod tests {
-    use super::longest_continuous_increasing_subsequence;
-
-    #[test]
-    fn test_longest_increasing_subsequence() {
-        //Base Cases
-        let base_case_array: [i32; 0] = [];
-        assert_eq!(
-            &longest_continuous_increasing_subsequence(&base_case_array),
-            &[]
-        );
-        assert_eq!(&longest_continuous_increasing_subsequence(&[1]), &[1]);
-
-        //Normal i32 Cases
-        assert_eq!(
-            &longest_continuous_increasing_subsequence(&[1, 2, 3, 4]),
-            &[1, 2, 3, 4]
-        );
-        assert_eq!(
-            &longest_continuous_increasing_subsequence(&[1, 2, 2, 3, 4, 2]),
-            &[2, 3, 4]
-        );
-        assert_eq!(
-            &longest_continuous_increasing_subsequence(&[5, 4, 3, 2, 1]),
-            &[5]
-        );
-        assert_eq!(
-            &longest_continuous_increasing_subsequence(&[5, 4, 3, 4, 2, 1]),
-            &[3, 4]
-        );
-
-        //Non-Numeric case
-        assert_eq!(
-            &longest_continuous_increasing_subsequence(&['a', 'b', 'c']),
-            &['a', 'b', 'c']
-        );
-        assert_eq!(
-            &longest_continuous_increasing_subsequence(&['d', 'c', 'd']),
-            &['c', 'd']
-        );
-    }
-}
-```

codes/src/algorithms/dynamic-programming/maximal-square.md

@@ -1,68 +0,0 @@
-# 最大正方形
-
-```rust
-use std::cmp::max;
-use std::cmp::min;
-
-/// Maximal Square
-/// Given an m x n binary matrix filled with 0's and 1's, find the largest square containing only 1's and return its area.
-/// https://leetcode.com/problems/maximal-square/
-///
-/// Arguments:
-///     * `matrix` - an array of integer array
-/// Complexity
-///     - time complexity: O(n^2),
-///     - space complexity: O(n),
-pub fn maximal_square(matrix: &mut Vec<Vec<i32>>) -> i32 {
-    if matrix.is_empty() {
-        return 0;
-    }
-
-    let rows = matrix.len();
-    let cols = matrix[0].len();
-    let mut result: i32 = 0;
-
-    for row in 0..rows {
-        for col in 0..cols {
-            if matrix[row][col] == 1 {
-                if row == 0 || col == 0 {
-                    result = max(result, 1);
-                } else {
-                    let temp = min(matrix[row - 1][col - 1], matrix[row - 1][col]);
-
-                    let count: i32 = min(temp, matrix[row][col - 1]) + 1;
-                    result = max(result, count);
-
-                    matrix[row][col] = count;
-                }
-            }
-        }
-    }
-
-    result * result
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test() {
-        assert_eq!(maximal_square(&mut vec![]), 0);
-
-        let mut matrix = vec![vec![0, 1], vec![1, 0]];
-        assert_eq!(maximal_square(&mut matrix), 1);
-
-        let mut matrix = vec![
-            vec![1, 0, 1, 0, 0],
-            vec![1, 0, 1, 1, 1],
-            vec![1, 1, 1, 1, 1],
-            vec![1, 0, 0, 1, 0],
-        ];
-        assert_eq!(maximal_square(&mut matrix), 4);
-
-        let mut matrix = vec![vec![0]];
-        assert_eq!(maximal_square(&mut matrix), 0);
-    }
-}
-```

codes/src/algorithms/dynamic-programming/maximal-subarray.md

@@ -1,66 +0,0 @@
-# 最大子数组
-
-```rust
-/// ## maximum subarray via Dynamic Programming
-
-/// maximum_subarray(array) find the subarray (containing at least one number) which has the largest sum
-/// and return its sum.
-///
-/// A subarray is a contiguous part of an array.
-///
-/// Arguments:
-///     * `array` - an integer array
-/// Complexity
-///     - time complexity: O(array.length),
-///     - space complexity: O(array.length),
-pub fn maximum_subarray(array: &[i32]) -> i32 {
-    let mut dp = vec![0; array.len()];
-    dp[0] = array[0];
-    let mut result = dp[0];
-
-    for i in 1..array.len() {
-        if dp[i - 1] > 0 {
-            dp[i] = dp[i - 1] + array[i];
-        } else {
-            dp[i] = array[i];
-        }
-        result = result.max(dp[i]);
-    }
-
-    result
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn non_negative() {
-        //the maximum value: 1 + 0 + 5 + 8 = 14
-        let array = vec![1, 0, 5, 8];
-        assert_eq!(maximum_subarray(&array), 14);
-    }
-
-    #[test]
-    fn negative() {
-        //the maximum value: -1
-        let array = vec![-3, -1, -8, -2];
-        assert_eq!(maximum_subarray(&array), -1);
-    }
-
-    #[test]
-    fn normal() {
-        //the maximum value: 3 + (-2) + 5 = 6
-        let array = vec![-4, 3, -2, 5, -8];
-        assert_eq!(maximum_subarray(&array), 6);
-    }
-
-    #[test]
-    fn single_element() {
-        let array = vec![6];
-        assert_eq!(maximum_subarray(&array), 6);
-        let array = vec![-6];
-        assert_eq!(maximum_subarray(&array), -6);
-    }
-}
-```

codes/src/algorithms/dynamic-programming/rod-cutting.md

@@ -1,59 +0,0 @@
-# 棒的切割
-
-```rust
-//! Solves the rod-cutting problem
-use std::cmp::max;
-
-/// `rod_cut(p)` returns the maximum possible profit if a rod of length `n` = `p.len()`
-/// is cut into up to `n` pieces, where the profit gained from each piece of length
-/// `l` is determined by `p[l - 1]` and the total profit is the sum of the profit
-/// gained from each piece.
-///
-/// # Arguments
-///    - `p` - profit for rods of length 1 to n inclusive
-///
-/// # Complexity
-///    - time complexity: O(n^2),
-///    - space complexity: O(n^2),
-///
-/// where n is the length of `p`.
-pub fn rod_cut(p: &[usize]) -> usize {
-    let n = p.len();
-    // f is the dynamic programming table
-    let mut f = vec![0; n];
-
-    for i in 0..n {
-        let mut max_price = p[i];
-        for j in 1..=i {
-            max_price = max(max_price, p[j - 1] + f[i - j]);
-        }
-        f[i] = max_price;
-    }
-
-    // accomodate for input with length zero
-    if n != 0 {
-        f[n - 1]
-    } else {
-        0
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::rod_cut;
-
-    #[test]
-    fn test_rod_cut() {
-        assert_eq!(0, rod_cut(&[]));
-        assert_eq!(15, rod_cut(&[5, 8, 2]));
-        assert_eq!(10, rod_cut(&[1, 5, 8, 9]));
-        assert_eq!(25, rod_cut(&[5, 8, 2, 1, 7]));
-        assert_eq!(87, rod_cut(&[0, 0, 0, 0, 0, 87]));
-        assert_eq!(49, rod_cut(&[7, 6, 5, 4, 3, 2, 1]));
-        assert_eq!(22, rod_cut(&[1, 5, 8, 9, 10, 17, 17, 20]));
-        assert_eq!(60, rod_cut(&[6, 4, 8, 2, 5, 8, 2, 3, 7, 11]));
-        assert_eq!(30, rod_cut(&[1, 5, 8, 9, 10, 17, 17, 20, 24, 30]));
-        assert_eq!(12, rod_cut(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]));
-    }
-}
-```

codes/src/algorithms/general/convex-hull.md

@@ -1,177 +0,0 @@
-# 凸包算法
-
-```rust
-use std::cmp::Ordering::Equal;
-
-fn sort_by_min_angle(pts: &[(f64, f64)], min: &(f64, f64)) -> Vec<(f64, f64)> {
-    let mut points: Vec<(f64, f64, (f64, f64))> = pts
-        .iter()
-        .map(|x| {
-            (
-                ((x.1 - min.1) as f64).atan2((x.0 - min.0) as f64),
-                // angle
-                ((x.1 - min.1) as f64).hypot((x.0 - min.0) as f64),
-                // distance (we want the closest to be first)
-                *x,
-            )
-        })
-        .collect();
-    points.sort_by(|a, b| a.partial_cmp(b).unwrap_or(Equal));
-    points.into_iter().map(|x| x.2).collect()
-}
-
-// calculates the z coordinate of the vector product of vectors ab and ac
-fn calc_z_coord_vector_product(a: &(f64, f64), b: &(f64, f64), c: &(f64, f64)) -> f64 {
-    (b.0 - a.0) * (c.1 - a.1) - (c.0 - a.0) * (b.1 - a.1)
-}
-
-/*
-    If three points are aligned and are part of the convex hull then the three are kept.
-    If one doesn't want to keep those points, it is easy to iterate the answer and remove them.
-    The first point is the one with the lowest y-coordinate and the lowest x-coordinate.
-    Points are then given counter-clockwise, and the closest one is given first if needed.
-*/
-pub fn convex_hull_graham(pts: &[(f64, f64)]) -> Vec<(f64, f64)> {
-    if pts.is_empty() {
-        return vec![];
-    }
-
-    let mut stack: Vec<(f64, f64)> = vec![];
-    let min = pts
-        .iter()
-        .min_by(|a, b| {
-            let ord = a.1.partial_cmp(&b.1).unwrap_or(Equal);
-            match ord {
-                Equal => a.0.partial_cmp(&b.0).unwrap_or(Equal),
-                o => o,
-            }
-        })
-        .unwrap();
-    let points = sort_by_min_angle(pts, min);
-
-    if points.len() <= 3 {
-        return points;
-    }
-
-    for point in points {
-        while stack.len() > 1
-            && calc_z_coord_vector_product(&stack[stack.len() - 2], &stack[stack.len() - 1], &point)
-                < 0.
-        {
-            stack.pop();
-        }
-        stack.push(point);
-    }
-
-    stack
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn empty() {
-        assert_eq!(convex_hull_graham(&vec![]), vec![]);
-    }
-
-    #[test]
-    fn not_enough_points() {
-        let list = vec![(0f64, 0f64)];
-        assert_eq!(convex_hull_graham(&list), list);
-    }
-
-    #[test]
-    fn not_enough_points1() {
-        let list = vec![(2f64, 2f64), (1f64, 1f64), (0f64, 0f64)];
-        let ans = vec![(0f64, 0f64), (1f64, 1f64), (2f64, 2f64)];
-        assert_eq!(convex_hull_graham(&list), ans);
-    }
-
-    #[test]
-    fn not_enough_points2() {
-        let list = vec![(2f64, 2f64), (1f64, 2f64), (0f64, 0f64)];
-        let ans = vec![(0f64, 0f64), (2f64, 2f64), (1f64, 2f64)];
-        assert_eq!(convex_hull_graham(&list), ans);
-    }
-
-    #[test]
-    // from https://codegolf.stackexchange.com/questions/11035/find-the-convex-hull-of-a-set-of-2d-points
-    fn lots_of_points() {
-        let list = vec![
-            (4.4, 14.),
-            (6.7, 15.25),
-            (6.9, 12.8),
-            (2.1, 11.1),
-            (9.5, 14.9),
-            (13.2, 11.9),
-            (10.3, 12.3),
-            (6.8, 9.5),
-            (3.3, 7.7),
-            (0.6, 5.1),
-            (5.3, 2.4),
-            (8.45, 4.7),
-            (11.5, 9.6),
-            (13.8, 7.3),
-            (12.9, 3.1),
-            (11., 1.1),
-        ];
-        let ans = vec![
-            (11., 1.1),
-            (12.9, 3.1),
-            (13.8, 7.3),
-            (13.2, 11.9),
-            (9.5, 14.9),
-            (6.7, 15.25),
-            (4.4, 14.),
-            (2.1, 11.1),
-            (0.6, 5.1),
-            (5.3, 2.4),
-        ];
-
-        assert_eq!(convex_hull_graham(&list), ans);
-    }
-
-    #[test]
-    // from https://codegolf.stackexchange.com/questions/11035/find-the-convex-hull-of-a-set-of-2d-points
-    fn lots_of_points2() {
-        let list = vec![
-            (1., 0.),
-            (1., 1.),
-            (1., -1.),
-            (0.68957, 0.283647),
-            (0.909487, 0.644276),
-            (0.0361877, 0.803816),
-            (0.583004, 0.91555),
-            (-0.748169, 0.210483),
-            (-0.553528, -0.967036),
-            (0.316709, -0.153861),
-            (-0.79267, 0.585945),
-            (-0.700164, -0.750994),
-            (0.452273, -0.604434),
-            (-0.79134, -0.249902),
-            (-0.594918, -0.397574),
-            (-0.547371, -0.434041),
-            (0.958132, -0.499614),
-            (0.039941, 0.0990732),
-            (-0.891471, -0.464943),
-            (0.513187, -0.457062),
-            (-0.930053, 0.60341),
-            (0.656995, 0.854205),
-        ];
-        let ans = vec![
-            (1., -1.),
-            (1., 0.),
-            (1., 1.),
-            (0.583004, 0.91555),
-            (0.0361877, 0.803816),
-            (-0.930053, 0.60341),
-            (-0.891471, -0.464943),
-            (-0.700164, -0.750994),
-            (-0.553528, -0.967036),
-        ];
-
-        assert_eq!(convex_hull_graham(&list), ans);
-    }
-}
-```

codes/src/algorithms/general/hanoi.md

@@ -1,25 +0,0 @@
-# 汉诺塔算法
-
-```rust
-pub fn hanoi(n: i32, from: i32, to: i32, via: i32, moves: &mut Vec<(i32, i32)>) {
-    if n > 0 {
-        hanoi(n - 1, from, via, to, moves);
-        moves.push((from, to));
-        hanoi(n - 1, via, to, from, moves);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn hanoi_simple() {
-        let correct_solution: Vec<(i32, i32)> =
-            vec![(1, 3), (1, 2), (3, 2), (1, 3), (2, 1), (2, 3), (1, 3)];
-        let mut our_solution: Vec<(i32, i32)> = Vec::new();
-        hanoi(3, 1, 3, 2, &mut our_solution);
-        assert_eq!(correct_solution, our_solution);
-    }
-}
-```

codes/src/algorithms/general/index.md

@@ -1 +0,0 @@
-# 常用算法

codes/src/algorithms/general/kmeans.md

@@ -1,180 +0,0 @@
-# K-Means算法
-
-```rust
-// Macro to implement kmeans for both f64 and f32 without writing everything
-// twice or importing the `num` crate
-macro_rules! impl_kmeans {
-    ($kind: ty, $modname: ident) => {
-        // Since we can't overload methods in rust, we have to use namespacing
-        pub mod $modname {
-            use std::$modname::INFINITY;
-
-            /// computes sum of squared deviation between two identically sized vectors
-            /// `x`, and `y`.
-            fn distance(x: &[$kind], y: &[$kind]) -> $kind {
-                x.iter()
-                    .zip(y.iter())
-                    .fold(0.0, |dist, (&xi, &yi)| dist + (xi - yi).powi(2))
-            }
-
-            /// Returns a vector containing the indices z<sub>i</sub> in {0, ..., K-1} of
-            /// the centroid nearest to each datum.
-            fn nearest_centroids(xs: &[Vec<$kind>], centroids: &[Vec<$kind>]) -> Vec<usize> {
-                xs.iter()
-                    .map(|xi| {
-                        // Find the argmin by folding using a tuple containing the argmin
-                        // and the minimum distance.
-                        let (argmin, _) = centroids.iter().enumerate().fold(
-                            (0_usize, INFINITY),
-                            |(min_ix, min_dist), (ix, ci)| {
-                                let dist = distance(xi, ci);
-                                if dist < min_dist {
-                                    (ix, dist)
-                                } else {
-                                    (min_ix, min_dist)
-                                }
-                            },
-                        );
-                        argmin
-                    })
-                    .collect()
-            }
-
-            /// Recompute the centroids given the current clustering
-            fn recompute_centroids(
-                xs: &[Vec<$kind>],
-                clustering: &[usize],
-                k: usize,
-            ) -> Vec<Vec<$kind>> {
-                let ndims = xs[0].len();
-
-                // NOTE: Kind of inefficient because we sweep all the data from each of the
-                // k centroids.
-                (0..k)
-                    .map(|cluster_ix| {
-                        let mut centroid: Vec<$kind> = vec![0.0; ndims];
-                        let mut n_cluster: $kind = 0.0;
-                        xs.iter().zip(clustering.iter()).for_each(|(xi, &zi)| {
-                            if zi == cluster_ix {
-                                n_cluster += 1.0;
-                                xi.iter().enumerate().for_each(|(j, &x_ij)| {
-                                    centroid[j] += x_ij;
-                                });
-                            }
-                        });
-                        centroid.iter().map(|&c_j| c_j / n_cluster).collect()
-                    })
-                    .collect()
-            }
-
-            /// Assign the N D-dimensional data, `xs`, to `k` clusters using K-Means clustering
-            pub fn kmeans(xs: Vec<Vec<$kind>>, k: usize) -> Vec<usize> {
-                assert!(xs.len() >= k);
-
-                // Rather than pulling in a dependency to radomly select the staring
-                // points for the centroids, we're going to deterministally choose them by
-                // slecting evenly spaced points in `xs`
-                let n_per_cluster: usize = xs.len() / k;
-                let centroids: Vec<Vec<$kind>> =
-                    (0..k).map(|j| xs[j * n_per_cluster].clone()).collect();
-
-                let mut clustering = nearest_centroids(&xs, &centroids);
-
-                loop {
-                    let centroids = recompute_centroids(&xs, &clustering, k);
-                    let new_clustering = nearest_centroids(&xs, &centroids);
-
-                    // loop until the clustering doesn't change after the new centroids are computed
-                    if new_clustering
-                        .iter()
-                        .zip(clustering.iter())
-                        .all(|(&za, &zb)| za == zb)
-                    {
-                        // We need to use `return` to break out of the `loop`
-                        return clustering;
-                    } else {
-                        clustering = new_clustering;
-                    }
-                }
-            }
-        }
-    };
-}
-
-// generate code for kmeans for f32 and f64 data
-impl_kmeans!(f64, f64);
-impl_kmeans!(f32, f32);
-
-#[cfg(test)]
-mod test {
-    use self::super::f64::kmeans;
-
-    #[test]
-    fn easy_univariate_clustering() {
-        let xs: Vec<Vec<f64>> = vec![
-            vec![-1.1],
-            vec![-1.2],
-            vec![-1.3],
-            vec![-1.4],
-            vec![1.1],
-            vec![1.2],
-            vec![1.3],
-            vec![1.4],
-        ];
-        let clustering = kmeans(xs, 2);
-        assert_eq!(clustering, vec![0, 0, 0, 0, 1, 1, 1, 1]);
-    }
-
-    #[test]
-    fn easy_univariate_clustering_odd_number_of_data() {
-        let xs: Vec<Vec<f64>> = vec![
-            vec![-1.1],
-            vec![-1.2],
-            vec![-1.3],
-            vec![-1.4],
-            vec![1.1],
-            vec![1.2],
-            vec![1.3],
-            vec![1.4],
-            vec![1.5],
-        ];
-        let clustering = kmeans(xs, 2);
-        assert_eq!(clustering, vec![0, 0, 0, 0, 1, 1, 1, 1, 1]);
-    }
-
-    #[test]
-    fn easy_bivariate_clustering() {
-        let xs: Vec<Vec<f64>> = vec![
-            vec![-1.1, 0.2],
-            vec![-1.2, 0.3],
-            vec![-1.3, 0.1],
-            vec![-1.4, 0.4],
-            vec![1.1, -1.1],
-            vec![1.2, -1.0],
-            vec![1.3, -1.2],
-            vec![1.4, -1.3],
-        ];
-        let clustering = kmeans(xs, 2);
-        assert_eq!(clustering, vec![0, 0, 0, 0, 1, 1, 1, 1]);
-    }
-
-    #[test]
-    fn high_dims() {
-        let xs: Vec<Vec<f64>> = vec![
-            vec![-2.7825343, -1.7604825, -5.5550113, -2.9752946, -2.7874138],
-            vec![-2.9847919, -3.8209332, -2.1531757, -2.2710119, -2.3582877],
-            vec![-3.0109320, -2.2366132, -2.8048492, -1.2632331, -4.5755581],
-            vec![-2.8432186, -1.0383805, -2.2022826, -2.7435962, -2.0013399],
-            vec![-2.6638082, -3.5520086, -1.3684702, -2.1562444, -1.3186447],
-            vec![1.7409171, 1.9687576, 4.7162628, 4.5743537, 3.7905611],
-            vec![3.2932369, 2.8508700, 2.5580937, 2.0437325, 4.2192562],
-            vec![2.5843321, 2.8329818, 2.1329531, 3.2562319, 2.4878733],
-            vec![2.1859638, 3.2880048, 3.7018615, 2.3641232, 1.6281994],
-            vec![2.6201773, 0.9006588, 2.6774097, 1.8188620, 1.6076493],
-        ];
-
-        let clustering = kmeans(xs, 2);
-        assert_eq!(clustering, vec![0, 0, 0, 0, 0, 1, 1, 1, 1, 1]);
-    }
-}
-```

codes/src/algorithms/general/nqueens.md

@@ -1,152 +0,0 @@
-# N皇后算法
-
-```rust
-#[allow(unused_imports)]
-use std::env::args;
-
-#[allow(dead_code)]
-fn main() {
-    let mut board_width = 0;
-
-    for arg in args() {
-        board_width = match arg.parse() {
-            Ok(x) => x,
-            _ => 0,
-        };
-
-        if board_width != 0 {
-            break;
-        }
-    }
-
-    if board_width < 4 {
-        println!(
-            "Running algorithm with 8 as a default. Specify an alternative Chess board size for \
-             N-Queens as a command line argument.\n"
-        );
-        board_width = 8;
-    }
-
-    let board = match nqueens(board_width) {
-        Ok(success) => success,
-        Err(err) => panic!("{}", err),
-    };
-
-    println!("N-Queens {} by {} board result:", board_width, board_width);
-    print_board(&board);
-}
-
-/*
-The n-Queens search is a backtracking algorithm. Each row of the Chess board where a Queen is
-placed is dependent on all earlier rows. As only one Queen can fit per row, a one-dimensional
-integer array is used to represent the Queen's offset on each row.
-*/
-pub fn nqueens(board_width: i64) -> Result<Vec<i64>, &'static str> {
-    let mut board_rows = vec![0; board_width as usize];
-    let mut conflict;
-    let mut current_row = 0;
-
-    //Process by row up to the current active row
-    loop {
-        conflict = false;
-
-        //Column review of previous rows
-        for review_index in 0..current_row {
-            //Calculate the diagonals of earlier rows where a Queen would be a conflict
-            let left = board_rows[review_index] - (current_row as i64 - review_index as i64);
-            let right = board_rows[review_index] + (current_row as i64 - review_index as i64);
-
-            if board_rows[current_row] == board_rows[review_index]
-                || (left >= 0 && left == board_rows[current_row])
-                || (right < board_width as i64 && right == board_rows[current_row])
-            {
-                conflict = true;
-                break;
-            }
-        }
-
-        match conflict {
-            true => {
-                board_rows[current_row] += 1;
-
-                if current_row == 0 && board_rows[current_row] == board_width {
-                    return Err("No solution exists for specificed board size.");
-                }
-
-                while board_rows[current_row] == board_width {
-                    board_rows[current_row] = 0;
-
-                    if current_row == 0 {
-                        return Err("No solution exists for specificed board size.");
-                    }
-
-                    current_row -= 1;
-                    board_rows[current_row] += 1;
-                }
-            }
-            _ => {
-                current_row += 1;
-
-                if current_row as i64 == board_width {
-                    break;
-                }
-            }
-        }
-    }
-
-    Ok(board_rows)
-}
-
-fn print_board(board: &[i64]) {
-    for row in 0..board.len() {
-        print!("{}\t", board[row as usize]);
-
-        for column in 0..board.len() as i64 {
-            if board[row as usize] == column {
-                print!("Q");
-            } else {
-                print!(".");
-            }
-        }
-        println!();
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    fn check_board(board: &Vec<i64>) -> bool {
-        for current_row in 0..board.len() {
-            //Column review
-            for review_index in 0..current_row {
-                //Look for any conflict.
-                let left = board[review_index] - (current_row as i64 - review_index as i64);
-                let right = board[review_index] + (current_row as i64 - review_index as i64);
-
-                if board[current_row] == board[review_index]
-                    || (left >= 0 && left == board[current_row])
-                    || (right < board.len() as i64 && right == board[current_row])
-                {
-                    return false;
-                }
-            }
-        }
-        true
-    }
-
-    #[test]
-    fn test_board_size_4() {
-        let board = nqueens(4).expect("Error propagated.");
-        assert_eq!(board, vec![1, 3, 0, 2]);
-        assert!(check_board(&board));
-    }
-
-    #[test]
-    fn test_board_size_7() {
-        let board = nqueens(7).expect("Error propagated.");
-        assert_eq!(board, vec![0, 2, 4, 6, 1, 3, 5]);
-        assert!(check_board(&board));
-    }
-}
-```

codes/src/algorithms/general/two-sum.md

@@ -1,43 +0,0 @@
-# 两数之和
-
-```rust
-use std::collections::HashMap;
-use std::convert::TryInto;
-
-// Given an array of integers nums and an integer target,
-// return indices of the two numbers such that they add up to target.
-
-pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
-    let mut hash_map: HashMap<i32, i32> = HashMap::new();
-
-    for (i, item) in nums.iter().enumerate() {
-        match hash_map.get(&(target - item)) {
-            Some(value) => {
-                return vec![i.try_into().unwrap(), *value];
-            }
-            None => {
-                hash_map.insert(*item, i.try_into().unwrap());
-            }
-        }
-    }
-
-    vec![]
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test() {
-        let nums = vec![2, 7, 11, 15];
-        assert_eq!(two_sum(nums, 9), vec![1, 0]);
-
-        let nums = vec![3, 2, 4];
-        assert_eq!(two_sum(nums, 6), vec![2, 1]);
-
-        let nums = vec![3, 3];
-        assert_eq!(two_sum(nums, 6), vec![1, 0]);
-    }
-}
-```

codes/src/algorithms/geometry/closet-points.md

@@ -1,225 +0,0 @@
-# 最近点算法
-
-```rust
-type Point = (f64, f64);
-use std::cmp::Ordering;
-
-fn point_cmp((a1, a2): &Point, (b1, b2): &Point) -> Ordering {
-    let acmp = f64_cmp(a1, b1);
-    match acmp {
-        Ordering::Equal => f64_cmp(a2, b2),
-        _ => acmp,
-    }
-}
-
-fn f64_cmp(a: &f64, b: &f64) -> Ordering {
-    a.partial_cmp(b).unwrap()
-}
-
-/// returns the two closest points
-/// or None if there are zero or one point
-pub fn closest_points(points: &[Point]) -> Option<(Point, Point)> {
-    let mut points: Vec<Point> = points.to_vec();
-    points.sort_by(point_cmp);
-
-    closest_points_aux(&points, 0, points.len())
-}
-
-fn dist((x1, y1): &Point, (x2, y2): &Point) -> f64 {
-    let dx = *x1 - *x2;
-    let dy = *y1 - *y2;
-
-    (dx * dx + dy * dy).sqrt()
-}
-
-fn closest_points_aux(
-    points: &[Point],
-    mut start: usize,
-    mut end: usize,
-) -> Option<(Point, Point)> {
-    let n = end - start;
-
-    if n <= 1 {
-        return None;
-    }
-
-    if n <= 3 {
-        // bruteforce
-        let mut min = dist(&points[0], &points[1]);
-        let mut pair = (points[0], points[1]);
-
-        for i in 0..n {
-            for j in (i + 1)..n {
-                let new = dist(&points[i], &points[j]);
-                if new < min {
-                    min = new;
-                    pair = (points[i], points[j]);
-                }
-            }
-        }
-        return Some(pair);
-    }
-
-    let mid = (start + end) / 2;
-    let left = closest_points_aux(points, start, mid);
-    let right = closest_points_aux(points, mid, end);
-
-    let (mut min_dist, mut pair) = match (left, right) {
-        (Some((l1, l2)), Some((r1, r2))) => {
-            let dl = dist(&l1, &l2);
-            let dr = dist(&r1, &r2);
-            if dl < dr {
-                (dl, (l1, l2))
-            } else {
-                (dr, (r1, r2))
-            }
-        }
-        (Some((a, b)), None) => (dist(&a, &b), (a, b)),
-        (None, Some((a, b))) => (dist(&a, &b), (a, b)),
-        (None, None) => unreachable!(),
-    };
-
-    let mid_x = points[mid].0;
-    while points[start].0 < mid_x - min_dist {
-        start += 1;
-    }
-    while points[end - 1].0 > mid_x + min_dist {
-        end -= 1;
-    }
-
-    let mut mids: Vec<&Point> = points[start..end].iter().collect();
-    mids.sort_by(|a, b| f64_cmp(&a.1, &b.1));
-
-    for (i, e) in mids.iter().enumerate() {
-        for k in 1..8 {
-            if i + k >= mids.len() {
-                break;
-            }
-
-            let new = dist(e, mids[i + k]);
-            if new < min_dist {
-                min_dist = new;
-                pair = (**e, *mids[i + k]);
-            }
-        }
-    }
-
-    Some(pair)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::closest_points;
-    use super::Point;
-
-    fn eq(p1: Option<(Point, Point)>, p2: Option<(Point, Point)>) -> bool {
-        match (p1, p2) {
-            (None, None) => true,
-            (Some((p1, p2)), Some((p3, p4))) => (p1 == p3 && p2 == p4) || (p1 == p4 && p2 == p3),
-            _ => false,
-        }
-    }
-
-    macro_rules! assert_display {
-        ($left: expr, $right: expr) => {
-            assert!(
-                eq($left, $right),
-                "assertion failed: `(left == right)`\nleft: `{:?}`,\nright: `{:?}`",
-                $left,
-                $right
-            )
-        };
-    }
-
-    #[test]
-    fn zero_points() {
-        let vals: [Point; 0] = [];
-        assert_display!(closest_points(&vals), None::<(Point, Point)>);
-    }
-
-    #[test]
-    fn one_points() {
-        let vals = [(0., 0.)];
-        assert_display!(closest_points(&vals), None::<(Point, Point)>);
-    }
-
-    #[test]
-    fn two_points() {
-        let vals = [(0., 0.), (1., 1.)];
-        assert_display!(closest_points(&vals), Some(((0., 0.), (1., 1.))));
-    }
-
-    #[test]
-    fn three_points() {
-        let vals = [(0., 0.), (1., 1.), (3., 3.)];
-        assert_display!(closest_points(&vals), Some(((0., 0.), (1., 1.))));
-    }
-
-    #[test]
-    fn list_1() {
-        let vals = [
-            (0., 0.),
-            (2., 1.),
-            (5., 2.),
-            (2., 3.),
-            (4., 0.),
-            (0., 4.),
-            (5., 6.),
-            (4., 4.),
-            (7., 3.),
-            (-1., 2.),
-            (2., 6.),
-        ];
-        assert_display!(closest_points(&vals), Some(((2., 1.), (2., 3.))));
-    }
-
-    #[test]
-    fn list_2() {
-        let vals = [
-            (1., 3.),
-            (4., 6.),
-            (8., 8.),
-            (7., 5.),
-            (5., 3.),
-            (10., 3.),
-            (7., 1.),
-            (8., 3.),
-            (4., 9.),
-            (4., 12.),
-            (4., 15.),
-            (7., 14.),
-            (8., 12.),
-            (6., 10.),
-            (4., 14.),
-            (2., 7.),
-            (3., 8.),
-            (5., 8.),
-            (6., 7.),
-            (8., 10.),
-            (6., 12.),
-        ];
-        assert_display!(closest_points(&vals), Some(((4., 14.), (4., 15.))));
-    }
-
-    #[test]
-    fn vertical_points() {
-        let vals = [
-            (0., 0.),
-            (0., 50.),
-            (0., -25.),
-            (0., 40.),
-            (0., 42.),
-            (0., 100.),
-            (0., 17.),
-            (0., 29.),
-            (0., -50.),
-            (0., 37.),
-            (0., 34.),
-            (0., 8.),
-            (0., 3.),
-            (0., 46.),
-        ];
-        assert_display!(closest_points(&vals), Some(((0., 40.), (0., 42.))));
-    }
-}
-```

codes/src/algorithms/geometry/index.md

@@ -1 +0,0 @@
-# 几何

codes/src/algorithms/graph/bellman-ford.md

@@ -1,272 +0,0 @@
-# 最短路径-Bellman Ford
-
-```rust
-use std::collections::BTreeMap;
-use std::ops::Add;
-
-use std::ops::Neg;
-
-type Graph<V, E> = BTreeMap<V, BTreeMap<V, E>>;
-
-// performs the Bellman-Ford algorithm on the given graph from the given start
-// the graph is an undirected graph
-//
-// if there is a negative weighted loop it returns None
-// else it returns a map that for each reachable vertex associates the distance and the predecessor
-// since the start has no predecessor but is reachable, map[start] will be None
-pub fn bellman_ford<
-    V: Ord + Copy,
-    E: Ord + Copy + Add<Output = E> + Neg<Output = E> + std::ops::Sub<Output = E>,
->(
-    graph: &Graph<V, E>,
-    start: &V,
-) -> Option<BTreeMap<V, Option<(V, E)>>> {
-    let mut ans: BTreeMap<V, Option<(V, E)>> = BTreeMap::new();
-
-    ans.insert(*start, None);
-
-    for _ in 1..(graph.len()) {
-        for (u, edges) in graph {
-            let dist_u = match ans.get(u) {
-                Some(Some((_, d))) => Some(*d),
-                Some(None) => None,
-                None => continue,
-            };
-
-            for (v, d) in edges {
-                match ans.get(v) {
-                    Some(Some((_, dist)))
-                        // if this is a longer path, do nothing
-                        if match dist_u {
-                            Some(dist_u) => dist_u + *d >= *dist,
-                            None => d >= dist,
-                        } => {}
-                    Some(None) => {
-                        match dist_u {
-                            // if dist_u + d < 0 there is a negative loop going by start
-                            // else it's just a longer path
-                            Some(dist_u) if dist_u >= -*d => {}
-                            // negative self edge or negative loop
-                            _ => {
-                                if *d > *d + *d {
-                                    return None;
-                                }
-                            }
-                        };
-                    }
-                    // it's a shorter path: either dist_v was infinite or it was longer than dist_u + d
-                    _ => {
-                        ans.insert(
-                            *v,
-                            Some((
-                                *u,
-                                match dist_u {
-                                    Some(dist) => dist + *d,
-                                    None => *d,
-                                },
-                            )),
-                        );
-                    }
-                }
-            }
-        }
-    }
-
-    for (u, edges) in graph {
-        for (v, d) in edges {
-            match (ans.get(u), ans.get(v)) {
-                (Some(None), Some(None)) if *d > *d + *d => return None,
-                (Some(None), Some(Some((_, dv)))) if d < dv => return None,
-                (Some(Some((_, du))), Some(None)) if *du < -*d => return None,
-                (Some(Some((_, du))), Some(Some((_, dv)))) if *du + *d < *dv => return None,
-                (_, _) => {}
-            }
-        }
-    }
-
-    Some(ans)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{bellman_ford, Graph};
-    use std::collections::BTreeMap;
-
-    fn add_edge<V: Ord + Copy, E: Ord>(graph: &mut Graph<V, E>, v1: V, v2: V, c: E) {
-        graph.entry(v1).or_insert_with(BTreeMap::new).insert(v2, c);
-        graph.entry(v2).or_insert_with(BTreeMap::new);
-    }
-
-    #[test]
-    fn single_vertex() {
-        let mut graph: Graph<isize, isize> = BTreeMap::new();
-        graph.insert(0, BTreeMap::new());
-
-        let mut dists = BTreeMap::new();
-        dists.insert(0, None);
-
-        assert_eq!(bellman_ford(&graph, &0), Some(dists));
-    }
-
-    #[test]
-    fn single_edge() {
-        let mut graph = BTreeMap::new();
-        add_edge(&mut graph, 0, 1, 2);
-
-        let mut dists_0 = BTreeMap::new();
-        dists_0.insert(0, None);
-        dists_0.insert(1, Some((0, 2)));
-
-        assert_eq!(bellman_ford(&graph, &0), Some(dists_0));
-
-        let mut dists_1 = BTreeMap::new();
-        dists_1.insert(1, None);
-
-        assert_eq!(bellman_ford(&graph, &1), Some(dists_1));
-    }
-
-    #[test]
-    fn tree_1() {
-        let mut graph = BTreeMap::new();
-        let mut dists = BTreeMap::new();
-        dists.insert(1, None);
-        for i in 1..100 {
-            add_edge(&mut graph, i, i * 2, i * 2);
-            add_edge(&mut graph, i, i * 2 + 1, i * 2 + 1);
-
-            match dists[&i] {
-                Some((_, d)) => {
-                    dists.insert(i * 2, Some((i, d + i * 2)));
-                    dists.insert(i * 2 + 1, Some((i, d + i * 2 + 1)));
-                }
-                None => {
-                    dists.insert(i * 2, Some((i, i * 2)));
-                    dists.insert(i * 2 + 1, Some((i, i * 2 + 1)));
-                }
-            }
-        }
-
-        assert_eq!(bellman_ford(&graph, &1), Some(dists));
-    }
-
-    #[test]
-    fn graph_1() {
-        let mut graph = BTreeMap::new();
-        add_edge(&mut graph, 'a', 'c', 12);
-        add_edge(&mut graph, 'a', 'd', 60);
-        add_edge(&mut graph, 'b', 'a', 10);
-        add_edge(&mut graph, 'c', 'b', 20);
-        add_edge(&mut graph, 'c', 'd', 32);
-        add_edge(&mut graph, 'e', 'a', 7);
-
-        let mut dists_a = BTreeMap::new();
-        dists_a.insert('a', None);
-        dists_a.insert('c', Some(('a', 12)));
-        dists_a.insert('d', Some(('c', 44)));
-        dists_a.insert('b', Some(('c', 32)));
-        assert_eq!(bellman_ford(&graph, &'a'), Some(dists_a));
-
-        let mut dists_b = BTreeMap::new();
-        dists_b.insert('b', None);
-        dists_b.insert('a', Some(('b', 10)));
-        dists_b.insert('c', Some(('a', 22)));
-        dists_b.insert('d', Some(('c', 54)));
-        assert_eq!(bellman_ford(&graph, &'b'), Some(dists_b));
-
-        let mut dists_c = BTreeMap::new();
-        dists_c.insert('c', None);
-        dists_c.insert('b', Some(('c', 20)));
-        dists_c.insert('d', Some(('c', 32)));
-        dists_c.insert('a', Some(('b', 30)));
-        assert_eq!(bellman_ford(&graph, &'c'), Some(dists_c));
-
-        let mut dists_d = BTreeMap::new();
-        dists_d.insert('d', None);
-        assert_eq!(bellman_ford(&graph, &'d'), Some(dists_d));
-
-        let mut dists_e = BTreeMap::new();
-        dists_e.insert('e', None);
-        dists_e.insert('a', Some(('e', 7)));
-        dists_e.insert('c', Some(('a', 19)));
-        dists_e.insert('d', Some(('c', 51)));
-        dists_e.insert('b', Some(('c', 39)));
-        assert_eq!(bellman_ford(&graph, &'e'), Some(dists_e));
-    }
-
-    #[test]
-    fn graph_2() {
-        let mut graph = BTreeMap::new();
-        add_edge(&mut graph, 0, 1, 6);
-        add_edge(&mut graph, 0, 3, 7);
-        add_edge(&mut graph, 1, 2, 5);
-        add_edge(&mut graph, 1, 3, 8);
-        add_edge(&mut graph, 1, 4, -4);
-        add_edge(&mut graph, 2, 1, -2);
-        add_edge(&mut graph, 3, 2, -3);
-        add_edge(&mut graph, 3, 4, 9);
-        add_edge(&mut graph, 4, 0, 3);
-        add_edge(&mut graph, 4, 2, 7);
-
-        let mut dists_0 = BTreeMap::new();
-        dists_0.insert(0, None);
-        dists_0.insert(1, Some((2, 2)));
-        dists_0.insert(2, Some((3, 4)));
-        dists_0.insert(3, Some((0, 7)));
-        dists_0.insert(4, Some((1, -2)));
-        assert_eq!(bellman_ford(&graph, &0), Some(dists_0));
-
-        let mut dists_1 = BTreeMap::new();
-        dists_1.insert(0, Some((4, -1)));
-        dists_1.insert(1, None);
-        dists_1.insert(2, Some((4, 3)));
-        dists_1.insert(3, Some((0, 6)));
-        dists_1.insert(4, Some((1, -4)));
-        assert_eq!(bellman_ford(&graph, &1), Some(dists_1));
-
-        let mut dists_2 = BTreeMap::new();
-        dists_2.insert(0, Some((4, -3)));
-        dists_2.insert(1, Some((2, -2)));
-        dists_2.insert(2, None);
-        dists_2.insert(3, Some((0, 4)));
-        dists_2.insert(4, Some((1, -6)));
-        assert_eq!(bellman_ford(&graph, &2), Some(dists_2));
-
-        let mut dists_3 = BTreeMap::new();
-        dists_3.insert(0, Some((4, -6)));
-        dists_3.insert(1, Some((2, -5)));
-        dists_3.insert(2, Some((3, -3)));
-        dists_3.insert(3, None);
-        dists_3.insert(4, Some((1, -9)));
-        assert_eq!(bellman_ford(&graph, &3), Some(dists_3));
-
-        let mut dists_4 = BTreeMap::new();
-        dists_4.insert(0, Some((4, 3)));
-        dists_4.insert(1, Some((2, 5)));
-        dists_4.insert(2, Some((4, 7)));
-        dists_4.insert(3, Some((0, 10)));
-        dists_4.insert(4, None);
-        assert_eq!(bellman_ford(&graph, &4), Some(dists_4));
-    }
-
-    #[test]
-    fn graph_with_negative_loop() {
-        let mut graph = BTreeMap::new();
-        add_edge(&mut graph, 0, 1, 6);
-        add_edge(&mut graph, 0, 3, 7);
-        add_edge(&mut graph, 1, 2, 5);
-        add_edge(&mut graph, 1, 3, 8);
-        add_edge(&mut graph, 1, 4, -4);
-        add_edge(&mut graph, 2, 1, -4);
-        add_edge(&mut graph, 3, 2, -3);
-        add_edge(&mut graph, 3, 4, 9);
-        add_edge(&mut graph, 4, 0, 3);
-        add_edge(&mut graph, 4, 2, 7);
-
-        assert_eq!(bellman_ford(&graph, &0), None);
-        assert_eq!(bellman_ford(&graph, &1), None);
-        assert_eq!(bellman_ford(&graph, &2), None);
-        assert_eq!(bellman_ford(&graph, &3), None);
-        assert_eq!(bellman_ford(&graph, &4), None);
-    }
-}
-```

codes/src/algorithms/graph/breadth-first-search.md

@@ -1,207 +0,0 @@
-# 广度优先搜索
-
-```rust
-use std::collections::HashSet;
-use std::collections::VecDeque;
-
-/// Perform a breadth-first search on Graph `graph`.
-///
-/// # Parameters
-///
-/// - `graph`: The graph to search.
-/// - `root`: The starting node of the graph from which to begin searching.
-/// - `target`: The target node for the search.
-///
-/// # Returns
-///
-/// If the target is found, an Optional vector is returned with the history
-/// of nodes visited as its contents.
-///
-/// If the target is not found or there is no path from the root,
-/// `None` is returned.
-///
-pub fn breadth_first_search(graph: &Graph, root: Node, target: Node) -> Option<Vec<u32>> {
-    let mut visited: HashSet<Node> = HashSet::new();
-    let mut history: Vec<u32> = Vec::new();
-    let mut queue = VecDeque::new();
-
-    visited.insert(root);
-    queue.push_back(root);
-    while let Some(currentnode) = queue.pop_front() {
-        history.push(currentnode.value());
-
-        // If we reach the goal, return our travel history.
-        if currentnode == target {
-            return Some(history);
-        }
-
-        // Check the neighboring nodes for any that we've not visited yet.
-        for neighbor in currentnode.neighbors(graph) {
-            if !visited.contains(&neighbor) {
-                visited.insert(neighbor);
-                queue.push_back(neighbor);
-            }
-        }
-    }
-
-    // All nodes were visited, yet the target was not found.
-    None
-}
-
-// Data Structures
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub struct Node(u32);
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub struct Edge(u32, u32);
-
-#[derive(Clone)]
-pub struct Graph {
-    nodes: Vec<Node>,
-    edges: Vec<Edge>,
-}
-
-impl Graph {
-    pub fn new(nodes: Vec<Node>, edges: Vec<Edge>) -> Self {
-        Graph { nodes, edges }
-    }
-}
-
-impl From<u32> for Node {
-    fn from(item: u32) -> Self {
-        Node(item)
-    }
-}
-
-impl Node {
-    pub fn value(&self) -> u32 {
-        self.0
-    }
-
-    pub fn neighbors(&self, graph: &Graph) -> Vec<Node> {
-        graph
-            .edges
-            .iter()
-            .filter(|e| e.0 == self.0)
-            .map(|e| e.1.into())
-            .collect()
-    }
-}
-
-impl From<(u32, u32)> for Edge {
-    fn from(item: (u32, u32)) -> Self {
-        Edge(item.0, item.1)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /* Example graph #1:
-     *
-     *            (1)   <--- Root
-     *           /   \
-     *         (2)   (3)
-     *        / |     | \
-     *     (4) (5)   (6) (7)
-     *          |
-     *         (8)
-     */
-    fn graph1() -> Graph {
-        let nodes = vec![1, 2, 3, 4, 5, 6, 7];
-        let edges = vec![(1, 2), (1, 3), (2, 4), (2, 5), (3, 6), (3, 7), (5, 8)];
-
-        Graph::new(
-            nodes.into_iter().map(|v| v.into()).collect(),
-            edges.into_iter().map(|e| e.into()).collect(),
-        )
-    }
-
-    #[test]
-    fn breadth_first_search_graph1_when_node_not_found_returns_none() {
-        let graph = graph1();
-        let root = 1;
-        let target = 10;
-
-        assert_eq!(
-            breadth_first_search(&graph, root.into(), target.into()),
-            None
-        );
-    }
-
-    #[test]
-    fn breadth_first_search_graph1_when_target_8_should_evaluate_all_nodes_first() {
-        let graph = graph1();
-        let root = 1;
-        let target = 8;
-
-        let expected_path = vec![1, 2, 3, 4, 5, 6, 7, 8];
-
-        assert_eq!(
-            breadth_first_search(&graph, root.into(), target.into()),
-            Some(expected_path)
-        );
-    }
-
-    /* Example graph #2:
-     *
-     *     (1) --- (2)     (3) --- (4)
-     *            / |     /       /
-     *          /   |   /       /
-     *        /     | /       /
-     *     (5)     (6) --- (7)     (8)
-     */
-    fn graph2() -> Graph {
-        let nodes = vec![1, 2, 3, 4, 5, 6, 7, 8];
-        let undirected_edges = vec![
-            (1, 2),
-            (2, 1),
-            (2, 5),
-            (5, 2),
-            (2, 6),
-            (6, 2),
-            (3, 4),
-            (4, 3),
-            (3, 6),
-            (6, 3),
-            (4, 7),
-            (7, 4),
-            (6, 7),
-            (7, 6),
-        ];
-
-        Graph::new(
-            nodes.into_iter().map(|v| v.into()).collect(),
-            undirected_edges.into_iter().map(|e| e.into()).collect(),
-        )
-    }
-
-    #[test]
-    fn breadth_first_search_graph2_when_no_path_to_node_returns_none() {
-        let graph = graph2();
-        let root = 8;
-        let target = 4;
-
-        assert_eq!(
-            breadth_first_search(&graph, root.into(), target.into()),
-            None
-        );
-    }
-
-    #[test]
-    fn breadth_first_search_graph2_should_find_path_from_4_to_1() {
-        let graph = graph2();
-        let root = 4;
-        let target = 1;
-
-        let expected_path = vec![4, 3, 7, 6, 2, 1];
-
-        assert_eq!(
-            breadth_first_search(&graph, root.into(), target.into()),
-            Some(expected_path)
-        );
-    }
-}
-```

codes/src/algorithms/graph/depth-first-search.md

@@ -1,195 +0,0 @@
-# 深度优先搜索
-
-```rust
-use std::collections::HashSet;
-use std::collections::VecDeque;
-
-// Perform a Depth First Search Algorithm to find a element in a graph
-//
-// Return a Optional with a vector with history of vertex visiteds
-// or a None if the element not exists on the graph
-pub fn depth_first_search(graph: &Graph, root: Vertex, objective: Vertex) -> Option<Vec<u32>> {
-    let mut visited: HashSet<Vertex> = HashSet::new();
-    let mut history: Vec<u32> = Vec::new();
-    let mut queue = VecDeque::new();
-    queue.push_back(root);
-
-    // While there is an element in the queue
-    // get the first element of the vertex queue
-    while let Some(current_vertex) = queue.pop_front() {
-        // Added current vertex in the history of visiteds vertex
-        history.push(current_vertex.value());
-
-        // Verify if this vertex is the objective
-        if current_vertex == objective {
-            // Return the Optional with the history of visiteds vertex
-            return Some(history);
-        }
-
-        // For each over the neighbors of current vertex
-        for neighbor in current_vertex.neighbors(graph).into_iter().rev() {
-            // Insert in the HashSet of visiteds if this value not exist yet
-            if visited.insert(neighbor) {
-                // Add the neighbor on front of queue
-                queue.push_front(neighbor);
-            }
-        }
-    }
-
-    // If all vertex is visited and the objective is not found
-    // return a Optional with None value
-    None
-}
-
-// Data Structures
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub struct Vertex(u32);
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub struct Edge(u32, u32);
-#[derive(Clone)]
-pub struct Graph {
-    vertices: Vec<Vertex>,
-    edges: Vec<Edge>,
-}
-
-impl Graph {
-    pub fn new(vertices: Vec<Vertex>, edges: Vec<Edge>) -> Self {
-        Graph { vertices, edges }
-    }
-}
-
-impl From<u32> for Vertex {
-    fn from(item: u32) -> Self {
-        Vertex(item)
-    }
-}
-
-impl Vertex {
-    pub fn value(&self) -> u32 {
-        self.0
-    }
-
-    pub fn neighbors(&self, graph: &Graph) -> VecDeque<Vertex> {
-        graph
-            .edges
-            .iter()
-            .filter(|e| e.0 == self.0)
-            .map(|e| e.1.into())
-            .collect()
-    }
-}
-
-impl From<(u32, u32)> for Edge {
-    fn from(item: (u32, u32)) -> Self {
-        Edge(item.0, item.1)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn find_1_fail() {
-        let vertices = vec![1, 2, 3, 4, 5, 6, 7];
-        let edges = vec![(1, 2), (1, 3), (2, 4), (2, 5), (3, 6), (3, 7)];
-
-        let root = 1;
-        let objective = 99;
-
-        let graph = Graph::new(
-            vertices.into_iter().map(|v| v.into()).collect(),
-            edges.into_iter().map(|e| e.into()).collect(),
-        );
-
-        assert_eq!(
-            depth_first_search(&graph, root.into(), objective.into()),
-            None
-        );
-    }
-
-    #[test]
-    fn find_1_sucess() {
-        let vertices = vec![1, 2, 3, 4, 5, 6, 7];
-        let edges = vec![(1, 2), (1, 3), (2, 4), (2, 5), (3, 6), (3, 7)];
-
-        let root = 1;
-        let objective = 7;
-
-        let correct_path = vec![1, 2, 4, 5, 3, 6, 7];
-
-        let graph = Graph::new(
-            vertices.into_iter().map(|v| v.into()).collect(),
-            edges.into_iter().map(|e| e.into()).collect(),
-        );
-
-        assert_eq!(
-            depth_first_search(&graph, root.into(), objective.into()),
-            Some(correct_path)
-        );
-    }
-
-    #[test]
-    fn find_2_sucess() {
-        let vertices = vec![0, 1, 2, 3, 4, 5, 6, 7];
-        let edges = vec![
-            (0, 1),
-            (1, 3),
-            (3, 2),
-            (2, 1),
-            (3, 4),
-            (4, 5),
-            (5, 7),
-            (7, 6),
-            (6, 4),
-        ];
-
-        let root = 0;
-        let objective = 6;
-
-        let correct_path = vec![0, 1, 3, 2, 4, 5, 7, 6];
-
-        let graph = Graph::new(
-            vertices.into_iter().map(|v| v.into()).collect(),
-            edges.into_iter().map(|e| e.into()).collect(),
-        );
-
-        assert_eq!(
-            depth_first_search(&graph, root.into(), objective.into()),
-            Some(correct_path)
-        );
-    }
-
-    #[test]
-    fn find_3_sucess() {
-        let vertices = vec![0, 1, 2, 3, 4, 5, 6, 7];
-        let edges = vec![
-            (0, 1),
-            (1, 3),
-            (3, 2),
-            (2, 1),
-            (3, 4),
-            (4, 5),
-            (5, 7),
-            (7, 6),
-            (6, 4),
-        ];
-
-        let root = 0;
-        let objective = 4;
-
-        let correct_path = vec![0, 1, 3, 2, 4];
-
-        let graph = Graph::new(
-            vertices.into_iter().map(|v| v.into()).collect(),
-            edges.into_iter().map(|e| e.into()).collect(),
-        );
-
-        assert_eq!(
-            depth_first_search(&graph, root.into(), objective.into()),
-            Some(correct_path)
-        );
-    }
-}
-```

codes/src/algorithms/graph/depth-first-tic-tac-toe.md

@@ -1,392 +0,0 @@
-# 深度优先Tic Tac Toe
-
-```rust
-#[allow(unused_imports)]
-use std::io;
-
-//Interactive Tic-Tac-Toe play needs the "rand = "0.8.3" crate.
-//#[cfg(not(test))]
-//extern crate rand;
-//#[cfg(not(test))]
-//use rand::Rng;
-
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct Position {
-    x: u8,
-    y: u8,
-}
-
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub enum Players {
-    Blank,
-    PlayerX,
-    PlayerO,
-}
-
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct SinglePlayAction {
-    position: Position,
-    side: Players,
-}
-
-#[derive(Clone, PartialEq, Debug)]
-pub struct PlayActions {
-    positions: Vec<Position>,
-    side: Players,
-}
-
-#[allow(dead_code)]
-#[cfg(not(test))]
-fn main() {
-    let mut board = vec![vec![Players::Blank; 3]; 3];
-
-    while !available_positions(&board).is_empty()
-        && !win_check(Players::PlayerX, &board)
-        && !win_check(Players::PlayerO, &board)
-    {
-        display_board(&board);
-        println!("Type in coordinate for X mark to be played. ie. a1 etc.");
-        let mut input = String::new();
-        io::stdin()
-            .read_line(&mut input)
-            .expect("Failed to read line");
-
-        let mut move_position: Option<Position> = None;
-        input.make_ascii_lowercase();
-        let bytes = input.trim().trim_start().as_bytes();
-        if bytes.len() as u32 == 2
-            && (bytes[0] as char).is_alphabetic()
-            && (bytes[1] as char).is_numeric()
-        {
-            let column: u8 = bytes[0] - b'a';
-            let row: u8 = bytes[1] - b'1';
-
-            if column <= 2 && row <= 2 {
-                move_position = Some(Position { x: column, y: row });
-            }
-        }
-
-        //Take the validated user input coordinate and use it.
-        if let Some(move_pos) = move_position {
-            let open_positions = available_positions(&board);
-
-            let mut search = open_positions.iter();
-            let result = search.find(|&&x| x == move_pos);
-            if result.is_none() {
-                println!("Not a valid empty coordinate.");
-                continue;
-            } else {
-                board[move_pos.y as usize][move_pos.x as usize] = Players::PlayerX;
-
-                if win_check(Players::PlayerX, &board) {
-                    display_board(&board);
-                    println!("Player X Wins!");
-                    return;
-                }
-            }
-
-            //Find the best game plays from the current board state
-            let recusion_result = minimax(Players::PlayerO, &board);
-            match recusion_result {
-                Some(x) => {
-                    //Interactive Tic-Tac-Toe play needs the "rand = "0.8.3" crate.
-                    //#[cfg(not(test))]
-                    //let random_selection = rand::thread_rng().gen_range(0..x.positions.len());
-                    let random_selection = 0;
-
-                    let response_pos = x.positions[random_selection];
-                    board[response_pos.y as usize][response_pos.x as usize] = Players::PlayerO;
-                    if win_check(Players::PlayerO, &board) {
-                        display_board(&board);
-                        println!("Player O Wins!");
-                        return;
-                    }
-                }
-
-                None => {
-                    display_board(&board);
-                    println!("Draw game.");
-                    return;
-                }
-            }
-        }
-    }
-}
-
-#[allow(dead_code)]
-fn display_board(board: &[Vec<Players>]) {
-    println!();
-    for (y, board_row) in board.iter().enumerate() {
-        print!("{} ", (y + 1));
-        for board_cell in board_row {
-            match board_cell {
-                Players::PlayerX => print!("X "),
-                Players::PlayerO => print!("O "),
-                Players::Blank => print!("_ "),
-            }
-        }
-        println!();
-    }
-    println!("  a b c");
-}
-
-fn available_positions(board: &[Vec<Players>]) -> Vec<Position> {
-    let mut available: Vec<Position> = Vec::new();
-    for (y, board_row) in board.iter().enumerate() {
-        for (x, board_cell) in board_row.iter().enumerate() {
-            if *board_cell == Players::Blank {
-                available.push(Position {
-                    x: x as u8,
-                    y: y as u8,
-                });
-            }
-        }
-    }
-    available
-}
-
-fn win_check(player: Players, board: &[Vec<Players>]) -> bool {
-    if player == Players::Blank {
-        return false;
-    }
-
-    //Check for a win on the diagonals.
-    if (board[0][0] == board[1][1]) && (board[1][1] == board[2][2]) && (board[2][2] == player)
-        || (board[2][0] == board[1][1]) && (board[1][1] == board[0][2]) && (board[0][2] == player)
-    {
-        return true;
-    }
-
-    for i in 0..3 {
-        //Check for a win on the horizontals.
-        if (board[i][0] == board[i][1]) && (board[i][1] == board[i][2]) && (board[i][2] == player) {
-            return true;
-        }
-
-        //Check for a win on the verticals.
-        if (board[0][i] == board[1][i]) && (board[1][i] == board[2][i]) && (board[2][i] == player) {
-            return true;
-        }
-    }
-
-    false
-}
-
-//Minimize the actions of the opponent while maximizing the game state of the current player.
-pub fn minimax(side: Players, board: &[Vec<Players>]) -> Option<PlayActions> {
-    //Check that board is in a valid state.
-    if win_check(Players::PlayerX, board) || win_check(Players::PlayerO, board) {
-        return None;
-    }
-
-    let opposite = match side {
-        Players::PlayerX => Players::PlayerO,
-        Players::PlayerO => Players::PlayerX,
-        Players::Blank => panic!("Minimax can't operate when a player isn't specified."),
-    };
-
-    let positions = available_positions(board);
-    if positions.is_empty() {
-        return None;
-    }
-
-    //Play position
-    let mut best_move: Option<PlayActions> = None;
-
-    for pos in positions {
-        let mut board_next = board.to_owned();
-        board_next[pos.y as usize][pos.x as usize] = side;
-
-        //Check for a win condition before recursion to determine if this node is terminal.
-        if win_check(Players::PlayerX, &board_next) {
-            append_playaction(
-                side,
-                &mut best_move,
-                SinglePlayAction {
-                    position: pos,
-                    side: Players::PlayerX,
-                },
-            );
-            continue;
-        }
-
-        if win_check(Players::PlayerO, &board_next) {
-            append_playaction(
-                side,
-                &mut best_move,
-                SinglePlayAction {
-                    position: pos,
-                    side: Players::PlayerO,
-                },
-            );
-            continue;
-        }
-
-        let result = minimax(opposite, &board_next);
-        let current_score = match result {
-            Some(x) => x.side,
-            _ => Players::Blank,
-        };
-
-        append_playaction(
-            side,
-            &mut best_move,
-            SinglePlayAction {
-                position: pos,
-                side: current_score,
-            },
-        )
-    }
-    best_move
-}
-
-//Promote only better or collate equally scored game plays
-fn append_playaction(
-    current_side: Players,
-    opt_play_actions: &mut Option<PlayActions>,
-    appendee: SinglePlayAction,
-) {
-    if opt_play_actions.is_none() {
-        *opt_play_actions = Some(PlayActions {
-            positions: vec![appendee.position],
-            side: appendee.side,
-        });
-        return;
-    }
-
-    let mut play_actions = opt_play_actions.as_mut().unwrap();
-
-    //New game action is scored from the current side and the current saved best score against the new game action.
-    match (current_side, play_actions.side, appendee.side) {
-        (Players::Blank, _, _) => panic!("Unreachable state."),
-
-        //Winning scores
-        (Players::PlayerX, Players::PlayerX, Players::PlayerX) => {
-            play_actions.positions.push(appendee.position);
-        }
-        (Players::PlayerX, Players::PlayerX, _) => {}
-        (Players::PlayerO, Players::PlayerO, Players::PlayerO) => {
-            play_actions.positions.push(appendee.position);
-        }
-        (Players::PlayerO, Players::PlayerO, _) => {}
-
-        //Non-winning to Winning scores
-        (Players::PlayerX, _, Players::PlayerX) => {
-            play_actions.side = Players::PlayerX;
-            play_actions.positions.clear();
-            play_actions.positions.push(appendee.position);
-        }
-        (Players::PlayerO, _, Players::PlayerO) => {
-            play_actions.side = Players::PlayerO;
-            play_actions.positions.clear();
-            play_actions.positions.push(appendee.position);
-        }
-
-        //Losing to Neutral scores
-        (Players::PlayerX, Players::PlayerO, Players::Blank) => {
-            play_actions.side = Players::Blank;
-            play_actions.positions.clear();
-            play_actions.positions.push(appendee.position);
-        }
-
-        (Players::PlayerO, Players::PlayerX, Players::Blank) => {
-            play_actions.side = Players::Blank;
-            play_actions.positions.clear();
-            play_actions.positions.push(appendee.position);
-        }
-
-        //Ignoring lower scored plays
-        (Players::PlayerX, Players::Blank, Players::PlayerO) => {}
-        (Players::PlayerO, Players::Blank, Players::PlayerX) => {}
-
-        //No change hence append only
-        (_, _, _) => {
-            assert!(play_actions.side == appendee.side);
-            play_actions.positions.push(appendee.position);
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn win_state_check() {
-        let mut board = vec![vec![Players::Blank; 3]; 3];
-        board[0][0] = Players::PlayerX;
-        board[0][1] = Players::PlayerX;
-        board[0][2] = Players::PlayerX;
-        let responses = minimax(Players::PlayerO, &board);
-        assert_eq!(responses, None);
-    }
-
-    #[test]
-    fn win_state_check2() {
-        let mut board = vec![vec![Players::Blank; 3]; 3];
-        board[0][0] = Players::PlayerX;
-        board[0][1] = Players::PlayerO;
-        board[1][0] = Players::PlayerX;
-        board[1][1] = Players::PlayerO;
-        board[2][1] = Players::PlayerO;
-        let responses = minimax(Players::PlayerO, &board);
-        assert_eq!(responses, None);
-    }
-
-    #[test]
-    fn block_win_move() {
-        let mut board = vec![vec![Players::Blank; 3]; 3];
-        board[0][0] = Players::PlayerX;
-        board[0][1] = Players::PlayerX;
-        board[1][2] = Players::PlayerO;
-        board[2][2] = Players::PlayerO;
-        let responses = minimax(Players::PlayerX, &board);
-        assert_eq!(
-            responses,
-            Some(PlayActions {
-                positions: vec![Position { x: 2, y: 0 }],
-                side: Players::PlayerX
-            })
-        );
-    }
-
-    #[test]
-    fn block_move() {
-        let mut board = vec![vec![Players::Blank; 3]; 3];
-        board[0][1] = Players::PlayerX;
-        board[0][2] = Players::PlayerO;
-        board[2][0] = Players::PlayerO;
-        let responses = minimax(Players::PlayerX, &board);
-        assert_eq!(
-            responses,
-            Some(PlayActions {
-                positions: vec![Position { x: 1, y: 1 }],
-                side: Players::Blank
-            })
-        );
-    }
-
-    #[test]
-    fn expected_loss() {
-        let mut board = vec![vec![Players::Blank; 3]; 3];
-        board[0][0] = Players::PlayerX;
-        board[0][2] = Players::PlayerO;
-        board[1][0] = Players::PlayerX;
-        board[2][0] = Players::PlayerO;
-        board[2][2] = Players::PlayerO;
-        let responses = minimax(Players::PlayerX, &board);
-        assert_eq!(
-            responses,
-            Some(PlayActions {
-                positions: vec![
-                    Position { x: 1, y: 0 },
-                    Position { x: 1, y: 1 },
-                    Position { x: 2, y: 1 },
-                    Position { x: 1, y: 2 }
-                ],
-                side: Players::PlayerO
-            })
-        );
-    }
-}
-```

codes/src/algorithms/graph/dijkstra.md

@@ -1,162 +0,0 @@
-# 最短路径-Dijkstra
-
-```rust
-use std::cmp::Reverse;
-use std::collections::{BTreeMap, BinaryHeap};
-use std::ops::Add;
-
-type Graph<V, E> = BTreeMap<V, BTreeMap<V, E>>;
-
-// performs Dijsktra's algorithm on the given graph from the given start
-// the graph is a positively-weighted undirected graph
-//
-// returns a map that for each reachable vertex associates the distance and the predecessor
-// since the start has no predecessor but is reachable, map[start] will be None
-pub fn dijkstra<V: Ord + Copy, E: Ord + Copy + Add<Output = E>>(
-    graph: &Graph<V, E>,
-    start: &V,
-) -> BTreeMap<V, Option<(V, E)>> {
-    let mut ans = BTreeMap::new();
-    let mut prio = BinaryHeap::new();
-
-    // start is the special case that doesn't have a predecessor
-    ans.insert(*start, None);
-
-    for (new, weight) in &graph[start] {
-        ans.insert(*new, Some((*start, *weight)));
-        prio.push(Reverse((*weight, new, start)));
-    }
-
-    while let Some(Reverse((dist_new, new, prev))) = prio.pop() {
-        match ans[new] {
-            // what we popped is what is in ans, we'll compute it
-            Some((p, d)) if p == *prev && d == dist_new => {}
-            // otherwise it's not interesting
-            _ => continue,
-        }
-
-        for (next, weight) in &graph[new] {
-            match ans.get(next) {
-                // if ans[next] is a lower dist than the alternative one, we do nothing
-                Some(Some((_, dist_next))) if dist_new + *weight >= *dist_next => {}
-                // if ans[next] is None then next is start and so the distance won't be changed, it won't be added again in prio
-                Some(None) => {}
-                // the new path is shorter, either new was not in ans or it was farther
-                _ => {
-                    ans.insert(*next, Some((*new, *weight + dist_new)));
-                    prio.push(Reverse((*weight + dist_new, next, new)));
-                }
-            }
-        }
-    }
-
-    ans
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{dijkstra, Graph};
-    use std::collections::BTreeMap;
-
-    fn add_edge<V: Ord + Copy, E: Ord>(graph: &mut Graph<V, E>, v1: V, v2: V, c: E) {
-        graph.entry(v1).or_insert_with(BTreeMap::new).insert(v2, c);
-        graph.entry(v2).or_insert_with(BTreeMap::new);
-    }
-
-    #[test]
-    fn single_vertex() {
-        let mut graph: Graph<usize, usize> = BTreeMap::new();
-        graph.insert(0, BTreeMap::new());
-
-        let mut dists = BTreeMap::new();
-        dists.insert(0, None);
-
-        assert_eq!(dijkstra(&graph, &0), dists);
-    }
-
-    #[test]
-    fn single_edge() {
-        let mut graph = BTreeMap::new();
-        add_edge(&mut graph, 0, 1, 2);
-
-        let mut dists_0 = BTreeMap::new();
-        dists_0.insert(0, None);
-        dists_0.insert(1, Some((0, 2)));
-
-        assert_eq!(dijkstra(&graph, &0), dists_0);
-
-        let mut dists_1 = BTreeMap::new();
-        dists_1.insert(1, None);
-
-        assert_eq!(dijkstra(&graph, &1), dists_1);
-    }
-
-    #[test]
-    fn tree_1() {
-        let mut graph = BTreeMap::new();
-        let mut dists = BTreeMap::new();
-        dists.insert(1, None);
-        for i in 1..100 {
-            add_edge(&mut graph, i, i * 2, i * 2);
-            add_edge(&mut graph, i, i * 2 + 1, i * 2 + 1);
-
-            match dists[&i] {
-                Some((_, d)) => {
-                    dists.insert(i * 2, Some((i, d + i * 2)));
-                    dists.insert(i * 2 + 1, Some((i, d + i * 2 + 1)));
-                }
-                None => {
-                    dists.insert(i * 2, Some((i, i * 2)));
-                    dists.insert(i * 2 + 1, Some((i, i * 2 + 1)));
-                }
-            }
-        }
-
-        assert_eq!(dijkstra(&graph, &1), dists);
-    }
-
-    #[test]
-    fn graph_1() {
-        let mut graph = BTreeMap::new();
-        add_edge(&mut graph, 'a', 'c', 12);
-        add_edge(&mut graph, 'a', 'd', 60);
-        add_edge(&mut graph, 'b', 'a', 10);
-        add_edge(&mut graph, 'c', 'b', 20);
-        add_edge(&mut graph, 'c', 'd', 32);
-        add_edge(&mut graph, 'e', 'a', 7);
-
-        let mut dists_a = BTreeMap::new();
-        dists_a.insert('a', None);
-        dists_a.insert('c', Some(('a', 12)));
-        dists_a.insert('d', Some(('c', 44)));
-        dists_a.insert('b', Some(('c', 32)));
-        assert_eq!(dijkstra(&graph, &'a'), dists_a);
-
-        let mut dists_b = BTreeMap::new();
-        dists_b.insert('b', None);
-        dists_b.insert('a', Some(('b', 10)));
-        dists_b.insert('c', Some(('a', 22)));
-        dists_b.insert('d', Some(('c', 54)));
-        assert_eq!(dijkstra(&graph, &'b'), dists_b);
-
-        let mut dists_c = BTreeMap::new();
-        dists_c.insert('c', None);
-        dists_c.insert('b', Some(('c', 20)));
-        dists_c.insert('d', Some(('c', 32)));
-        dists_c.insert('a', Some(('b', 30)));
-        assert_eq!(dijkstra(&graph, &'c'), dists_c);
-
-        let mut dists_d = BTreeMap::new();
-        dists_d.insert('d', None);
-        assert_eq!(dijkstra(&graph, &'d'), dists_d);
-
-        let mut dists_e = BTreeMap::new();
-        dists_e.insert('e', None);
-        dists_e.insert('a', Some(('e', 7)));
-        dists_e.insert('c', Some(('a', 19)));
-        dists_e.insert('d', Some(('c', 51)));
-        dists_e.insert('b', Some(('c', 39)));
-        assert_eq!(dijkstra(&graph, &'e'), dists_e);
-    }
-}
-```

codes/src/algorithms/graph/index.md

@@ -1,3 +0,0 @@
-# 图论
-
-图论算法在计算机科学中扮演着很重要的角色，它提供了对很多问题都有效的一种简单而系统的建模方式。很多问题都可以转化为图论问题，然后用图论的基本算法加以解决。

codes/src/algorithms/graph/minimum-spanning-tree.md

@@ -1,165 +0,0 @@
-# 最小生成树
-
-```rust
-use std::vec::Vec;
-
-#[derive(Debug)]
-pub struct Edge {
-    source: i64,
-    destination: i64,
-    cost: i64,
-}
-
-impl PartialEq for Edge {
-    fn eq(&self, other: &Self) -> bool {
-        self.source == other.source
-            && self.destination == other.destination
-            && self.cost == other.cost
-    }
-}
-
-impl Eq for Edge {}
-
-impl Edge {
-    fn new(source: i64, destination: i64, cost: i64) -> Self {
-        Self {
-            source,
-            destination,
-            cost,
-        }
-    }
-}
-
-fn make_sets(number_of_vertices: i64) -> Vec<i64> {
-    let mut parent: Vec<i64> = Vec::with_capacity(number_of_vertices as usize);
-    for i in 0..number_of_vertices {
-        parent.push(i);
-    }
-    parent
-}
-
-fn find(parent: &mut Vec<i64>, x: i64) -> i64 {
-    let idx: usize = x as usize;
-    if parent[idx] != x {
-        parent[idx] = find(parent, parent[idx]);
-    }
-    parent[idx]
-}
-
-fn merge(parent: &mut Vec<i64>, x: i64, y: i64) {
-    let idx_x: usize = find(parent, x) as usize;
-    let parent_y: i64 = find(parent, y);
-    parent[idx_x] = parent_y;
-}
-
-fn is_same_set(parent: &mut Vec<i64>, x: i64, y: i64) -> bool {
-    find(parent, x) == find(parent, y)
-}
-
-pub fn kruskal(mut edges: Vec<Edge>, number_of_vertices: i64) -> (i64, Vec<Edge>) {
-    let mut parent: Vec<i64> = make_sets(number_of_vertices);
-
-    edges.sort_unstable_by(|a, b| a.cost.cmp(&b.cost));
-    let mut total_cost: i64 = 0;
-    let mut final_edges: Vec<Edge> = Vec::new();
-    let mut merge_count: i64 = 0;
-    for edge in edges.iter() {
-        if merge_count >= number_of_vertices - 1 {
-            break;
-        }
-
-        let source: i64 = edge.source;
-        let destination: i64 = edge.destination;
-        if !is_same_set(&mut parent, source, destination) {
-            merge(&mut parent, source, destination);
-            merge_count += 1;
-            let cost: i64 = edge.cost;
-            total_cost += cost;
-            let final_edge: Edge = Edge::new(source, destination, cost);
-            final_edges.push(final_edge);
-        }
-    }
-    (total_cost, final_edges)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_seven_vertices_eleven_edges() {
-        let mut edges: Vec<Edge> = Vec::new();
-        edges.push(Edge::new(0, 1, 7));
-        edges.push(Edge::new(0, 3, 5));
-        edges.push(Edge::new(1, 2, 8));
-        edges.push(Edge::new(1, 3, 9));
-        edges.push(Edge::new(1, 4, 7));
-        edges.push(Edge::new(2, 4, 5));
-        edges.push(Edge::new(3, 4, 15));
-        edges.push(Edge::new(3, 5, 6));
-        edges.push(Edge::new(4, 5, 8));
-        edges.push(Edge::new(4, 6, 9));
-        edges.push(Edge::new(5, 6, 11));
-
-        let number_of_vertices: i64 = 7;
-
-        let expected_total_cost = 39;
-        let mut expected_used_edges: Vec<Edge> = Vec::new();
-        expected_used_edges.push(Edge::new(0, 3, 5));
-        expected_used_edges.push(Edge::new(2, 4, 5));
-        expected_used_edges.push(Edge::new(3, 5, 6));
-        expected_used_edges.push(Edge::new(0, 1, 7));
-        expected_used_edges.push(Edge::new(1, 4, 7));
-        expected_used_edges.push(Edge::new(4, 6, 9));
-
-        let (actual_total_cost, actual_final_edges) = kruskal(edges, number_of_vertices);
-
-        assert_eq!(actual_total_cost, expected_total_cost);
-        assert_eq!(actual_final_edges, expected_used_edges);
-    }
-
-    #[test]
-    fn test_ten_vertices_twenty_edges() {
-        let mut edges: Vec<Edge> = Vec::new();
-        edges.push(Edge::new(0, 1, 3));
-        edges.push(Edge::new(0, 3, 6));
-        edges.push(Edge::new(0, 4, 9));
-        edges.push(Edge::new(1, 2, 2));
-        edges.push(Edge::new(1, 3, 4));
-        edges.push(Edge::new(1, 4, 9));
-        edges.push(Edge::new(2, 3, 2));
-        edges.push(Edge::new(2, 5, 8));
-        edges.push(Edge::new(2, 6, 9));
-        edges.push(Edge::new(3, 6, 9));
-        edges.push(Edge::new(4, 5, 8));
-        edges.push(Edge::new(4, 9, 18));
-        edges.push(Edge::new(5, 6, 7));
-        edges.push(Edge::new(5, 8, 9));
-        edges.push(Edge::new(5, 9, 10));
-        edges.push(Edge::new(6, 7, 4));
-        edges.push(Edge::new(6, 8, 5));
-        edges.push(Edge::new(7, 8, 1));
-        edges.push(Edge::new(7, 9, 4));
-        edges.push(Edge::new(8, 9, 3));
-
-        let number_of_vertices: i64 = 10;
-
-        let expected_total_cost = 38;
-        let mut expected_used_edges = Vec::new();
-        expected_used_edges.push(Edge::new(7, 8, 1));
-        expected_used_edges.push(Edge::new(1, 2, 2));
-        expected_used_edges.push(Edge::new(2, 3, 2));
-        expected_used_edges.push(Edge::new(0, 1, 3));
-        expected_used_edges.push(Edge::new(8, 9, 3));
-        expected_used_edges.push(Edge::new(6, 7, 4));
-        expected_used_edges.push(Edge::new(5, 6, 7));
-        expected_used_edges.push(Edge::new(2, 5, 8));
-        expected_used_edges.push(Edge::new(4, 5, 8));
-
-        let (actual_total_cost, actual_final_edges) = kruskal(edges, number_of_vertices);
-
-        assert_eq!(actual_total_cost, expected_total_cost);
-        assert_eq!(actual_final_edges, expected_used_edges);
-    }
-}
-```

codes/src/algorithms/graph/prim.md

@@ -1,203 +0,0 @@
-# Prim算法(最小生成树)
-
-```rust
-use std::cmp::Reverse;
-use std::collections::{BTreeMap, BinaryHeap};
-use std::ops::Add;
-
-type Graph<V, E> = BTreeMap<V, BTreeMap<V, E>>;
-
-fn add_edge<V: Ord + Copy, E: Ord + Add + Copy>(graph: &mut Graph<V, E>, v1: V, v2: V, c: E) {
-    graph.entry(v1).or_insert_with(BTreeMap::new).insert(v2, c);
-    graph.entry(v2).or_insert_with(BTreeMap::new).insert(v1, c);
-}
-
-// selects a start and run the algorithm from it
-pub fn prim<V: Ord + Copy + std::fmt::Debug, E: Ord + Add + Copy + std::fmt::Debug>(
-    graph: &Graph<V, E>,
-) -> Graph<V, E> {
-    match graph.keys().next() {
-        Some(v) => prim_with_start(graph, *v),
-        None => BTreeMap::new(),
-    }
-}
-
-// only works for a connected graph
-// if the given graph is not connected it will return the MST of the connected subgraph
-pub fn prim_with_start<V: Ord + Copy, E: Ord + Add + Copy>(
-    graph: &Graph<V, E>,
-    start: V,
-) -> Graph<V, E> {
-    // will contain the MST
-    let mut mst: Graph<V, E> = Graph::new();
-    // a priority queue based on a binary heap, used to get the cheapest edge
-    // the elements are an edge: the cost, destination and source
-    let mut prio = BinaryHeap::new();
-
-    mst.insert(start, BTreeMap::new());
-
-    for (v, c) in &graph[&start] {
-        // the heap is a max heap, we have to use Reverse when adding to simulate a min heap
-        prio.push(Reverse((*c, v, start)));
-    }
-
-    while let Some(Reverse((dist, t, prev))) = prio.pop() {
-        // the destination of the edge has already been seen
-        if mst.contains_key(t) {
-            continue;
-        }
-
-        // the destination is a new vertex
-        add_edge(&mut mst, prev, *t, dist);
-
-        for (v, c) in &graph[t] {
-            if !mst.contains_key(v) {
-                prio.push(Reverse((*c, v, *t)));
-            }
-        }
-    }
-
-    mst
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{add_edge, prim, Graph};
-    use std::collections::BTreeMap;
-
-    #[test]
-    fn empty() {
-        assert_eq!(prim::<usize, usize>(&BTreeMap::new()), BTreeMap::new());
-    }
-
-    #[test]
-    fn single_vertex() {
-        let mut graph: Graph<usize, usize> = BTreeMap::new();
-        graph.insert(42, BTreeMap::new());
-
-        assert_eq!(prim(&graph), graph);
-    }
-
-    #[test]
-    fn single_edge() {
-        let mut graph = BTreeMap::new();
-
-        add_edge(&mut graph, 42, 666, 12);
-
-        assert_eq!(prim(&graph), graph);
-    }
-
-    #[test]
-    fn tree_1() {
-        let mut graph = BTreeMap::new();
-
-        add_edge(&mut graph, 0, 1, 10);
-        add_edge(&mut graph, 0, 2, 11);
-        add_edge(&mut graph, 2, 3, 12);
-        add_edge(&mut graph, 2, 4, 13);
-        add_edge(&mut graph, 1, 5, 14);
-        add_edge(&mut graph, 1, 6, 15);
-        add_edge(&mut graph, 3, 7, 16);
-
-        assert_eq!(prim(&graph), graph);
-    }
-
-    #[test]
-    fn tree_2() {
-        let mut graph = BTreeMap::new();
-
-        add_edge(&mut graph, 1, 2, 11);
-        add_edge(&mut graph, 2, 3, 12);
-        add_edge(&mut graph, 2, 4, 13);
-        add_edge(&mut graph, 4, 5, 14);
-        add_edge(&mut graph, 4, 6, 15);
-        add_edge(&mut graph, 6, 7, 16);
-
-        assert_eq!(prim(&graph), graph);
-    }
-
-    #[test]
-    fn tree_3() {
-        let mut graph = BTreeMap::new();
-
-        for i in 1..100 {
-            add_edge(&mut graph, i, 2 * i, i);
-            add_edge(&mut graph, i, 2 * i + 1, -i);
-        }
-
-        assert_eq!(prim(&graph), graph);
-    }
-
-    #[test]
-    fn graph_1() {
-        let mut graph = BTreeMap::new();
-        add_edge(&mut graph, 'a', 'b', 6);
-        add_edge(&mut graph, 'a', 'c', 7);
-        add_edge(&mut graph, 'a', 'e', 2);
-        add_edge(&mut graph, 'a', 'f', 3);
-        add_edge(&mut graph, 'b', 'c', 5);
-        add_edge(&mut graph, 'c', 'e', 5);
-        add_edge(&mut graph, 'd', 'e', 4);
-        add_edge(&mut graph, 'd', 'f', 1);
-        add_edge(&mut graph, 'e', 'f', 2);
-
-        let mut ans = BTreeMap::new();
-        add_edge(&mut ans, 'd', 'f', 1);
-        add_edge(&mut ans, 'e', 'f', 2);
-        add_edge(&mut ans, 'a', 'e', 2);
-        add_edge(&mut ans, 'b', 'c', 5);
-        add_edge(&mut ans, 'c', 'e', 5);
-
-        assert_eq!(prim(&graph), ans);
-    }
-
-    #[test]
-    fn graph_2() {
-        let mut graph = BTreeMap::new();
-        add_edge(&mut graph, 1, 2, 6);
-        add_edge(&mut graph, 1, 3, 1);
-        add_edge(&mut graph, 1, 4, 5);
-        add_edge(&mut graph, 2, 3, 5);
-        add_edge(&mut graph, 2, 5, 3);
-        add_edge(&mut graph, 3, 4, 5);
-        add_edge(&mut graph, 3, 5, 6);
-        add_edge(&mut graph, 3, 6, 4);
-        add_edge(&mut graph, 4, 6, 2);
-        add_edge(&mut graph, 5, 6, 6);
-
-        let mut ans = BTreeMap::new();
-        add_edge(&mut ans, 1, 3, 1);
-        add_edge(&mut ans, 4, 6, 2);
-        add_edge(&mut ans, 2, 5, 3);
-        add_edge(&mut ans, 2, 3, 5);
-        add_edge(&mut ans, 3, 6, 4);
-
-        assert_eq!(prim(&graph), ans);
-    }
-
-    #[test]
-    fn graph_3() {
-        let mut graph = BTreeMap::new();
-        add_edge(&mut graph, "v1", "v2", 1);
-        add_edge(&mut graph, "v1", "v3", 3);
-        add_edge(&mut graph, "v1", "v5", 6);
-        add_edge(&mut graph, "v2", "v3", 2);
-        add_edge(&mut graph, "v2", "v4", 3);
-        add_edge(&mut graph, "v2", "v5", 5);
-        add_edge(&mut graph, "v3", "v4", 5);
-        add_edge(&mut graph, "v3", "v6", 2);
-        add_edge(&mut graph, "v4", "v5", 2);
-        add_edge(&mut graph, "v4", "v6", 4);
-        add_edge(&mut graph, "v5", "v6", 1);
-
-        let mut ans = BTreeMap::new();
-        add_edge(&mut ans, "v1", "v2", 1);
-        add_edge(&mut ans, "v5", "v6", 1);
-        add_edge(&mut ans, "v2", "v3", 2);
-        add_edge(&mut ans, "v3", "v6", 2);
-        add_edge(&mut ans, "v4", "v5", 2);
-
-        assert_eq!(prim(&graph), ans);
-    }
-}
-```

codes/src/algorithms/index.md

@@ -1,10 +0,0 @@
-# 算法
-
-算法，一个高大上的词汇，在计算机领域也绝对是凡人的禁忌，但是其实算法又没那么神秘，我们在写代码时，无时无刻都在与算法打交道，只是绝大部分算法我们无法感知到而已，因为这些算法已经很好的被包装在其它库中，我们只需要输入数据然后调用它获得输出数据即可，因此这就引出了算法的基本定义：
-
-计算机算法是以一步接一步的方式来详细描述计算机如何将输入转化为所要求的输出的过程，或者说，算法是对计算机上执行的计算过程的具体描述。（以上内容摘抄自百度百科），简单点说计算机算法就是将输入转化为所要求的输出过程。
-
-既然只要调用别人的算法库即可完成任务，我们为什么要学习算法呢？原因很简单：面试需要。哈哈，开个玩笑，当然面试很重要，但是提升自己的能力也很重要，学习算法往往能提升我们对于代码的深层次理解和认识，你会知道为何要优化代码，该如何优化代码，甚至在真的需要你手撸算法时，心中也有一个明确的思路：我该选择哪个算法，而不是一片茫然，只知道用遍历的方式来完成任务。
-
-所以现在开始我们的算法之旅吧， 本章重点呈现各种常用算法的Rust实现，大部分章节都会链接一篇讲解该算法的文章。
-

codes/src/algorithms/math/extended-euclidean.md

@@ -1,41 +0,0 @@
-# 扩展欧几里得算法
-
-```rust
-fn update_step(a: &mut i32, old_a: &mut i32, quotient: i32) {
-    let temp = *a;
-    *a = *old_a - quotient * temp;
-    *old_a = temp;
-}
-
-pub fn extended_euclidean_algorithm(a: i32, b: i32) -> (i32, i32, i32) {
-    let (mut old_r, mut rem) = (a, b);
-    let (mut old_s, mut coeff_s) = (1, 0);
-    let (mut old_t, mut coeff_t) = (0, 1);
-
-    while rem != 0 {
-        let quotient = old_r / rem;
-
-        update_step(&mut rem, &mut old_r, quotient);
-        update_step(&mut coeff_s, &mut old_s, quotient);
-        update_step(&mut coeff_t, &mut old_t, quotient);
-    }
-
-    (old_r, old_s, old_t)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        assert_eq!(extended_euclidean_algorithm(101, 13), (1, 4, -31));
-        assert_eq!(extended_euclidean_algorithm(123, 19), (1, -2, 13));
-        assert_eq!(extended_euclidean_algorithm(25, 36), (1, 13, -9));
-        assert_eq!(extended_euclidean_algorithm(69, 54), (3, -7, 9));
-        assert_eq!(extended_euclidean_algorithm(55, 79), (1, 23, -16));
-        assert_eq!(extended_euclidean_algorithm(33, 44), (11, -1, 1));
-        assert_eq!(extended_euclidean_algorithm(50, 70), (10, 3, -2));
-    }
-}
-```

codes/src/algorithms/math/greatest-common-divisor.md

@@ -1,88 +0,0 @@
-# 最大公约数
-
-```rust
-/// Greatest Common Divisor.
-///
-/// greatest_common_divisor(num1, num2) returns the greatest number of num1 and num2.
-///
-/// Wikipedia reference: https://en.wikipedia.org/wiki/Greatest_common_divisor
-/// gcd(a, b) = gcd(a, -b) = gcd(-a, b) = gcd(-a, -b) by definition of divisibility
-
-pub fn greatest_common_divisor_recursive(a: i64, b: i64) -> i64 {
-    if a == 0 {
-        b.abs()
-    } else {
-        greatest_common_divisor_recursive(b % a, a)
-    }
-}
-
-pub fn greatest_common_divisor_iterative(mut a: i64, mut b: i64) -> i64 {
-    while a != 0 {
-        let remainder = b % a;
-        b = a;
-        a = remainder;
-    }
-    b.abs()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn positive_number_recursive() {
-        assert_eq!(greatest_common_divisor_recursive(4, 16), 4);
-        assert_eq!(greatest_common_divisor_recursive(16, 4), 4);
-        assert_eq!(greatest_common_divisor_recursive(3, 5), 1);
-        assert_eq!(greatest_common_divisor_recursive(40, 40), 40);
-        assert_eq!(greatest_common_divisor_recursive(27, 12), 3);
-    }
-
-    #[test]
-    fn positive_number_iterative() {
-        assert_eq!(greatest_common_divisor_iterative(4, 16), 4);
-        assert_eq!(greatest_common_divisor_iterative(16, 4), 4);
-        assert_eq!(greatest_common_divisor_iterative(3, 5), 1);
-        assert_eq!(greatest_common_divisor_iterative(40, 40), 40);
-        assert_eq!(greatest_common_divisor_iterative(27, 12), 3);
-    }
-
-    #[test]
-    fn negative_number_recursive() {
-        assert_eq!(greatest_common_divisor_recursive(-32, -8), 8);
-        assert_eq!(greatest_common_divisor_recursive(-8, -32), 8);
-        assert_eq!(greatest_common_divisor_recursive(-3, -5), 1);
-        assert_eq!(greatest_common_divisor_recursive(-40, -40), 40);
-        assert_eq!(greatest_common_divisor_recursive(-12, -27), 3);
-    }
-
-    #[test]
-    fn negative_number_iterative() {
-        assert_eq!(greatest_common_divisor_iterative(-32, -8), 8);
-        assert_eq!(greatest_common_divisor_iterative(-8, -32), 8);
-        assert_eq!(greatest_common_divisor_iterative(-3, -5), 1);
-        assert_eq!(greatest_common_divisor_iterative(-40, -40), 40);
-        assert_eq!(greatest_common_divisor_iterative(-12, -27), 3);
-    }
-
-    #[test]
-    fn mix_recursive() {
-        assert_eq!(greatest_common_divisor_recursive(0, -5), 5);
-        assert_eq!(greatest_common_divisor_recursive(-5, 0), 5);
-        assert_eq!(greatest_common_divisor_recursive(-64, 32), 32);
-        assert_eq!(greatest_common_divisor_recursive(-32, 64), 32);
-        assert_eq!(greatest_common_divisor_recursive(-40, 40), 40);
-        assert_eq!(greatest_common_divisor_recursive(12, -27), 3);
-    }
-
-    #[test]
-    fn mix_iterative() {
-        assert_eq!(greatest_common_divisor_iterative(0, -5), 5);
-        assert_eq!(greatest_common_divisor_iterative(-5, 0), 5);
-        assert_eq!(greatest_common_divisor_iterative(-64, 32), 32);
-        assert_eq!(greatest_common_divisor_iterative(-32, 64), 32);
-        assert_eq!(greatest_common_divisor_iterative(-40, 40), 40);
-        assert_eq!(greatest_common_divisor_iterative(12, -27), 3);
-    }
-}
-```

codes/src/algorithms/math/index.md

@@ -1,2 +0,0 @@
-# 数学
-

codes/src/algorithms/math/pascal-triange.md

@@ -1,55 +0,0 @@
-# 帕斯卡三角
-
-```rust
-/// ## Paslcal's triangle problem
-
-/// pascal_triangle(num_rows) returns the first num_rows of Pascal's triangle.
-/// About Pascal's triangle: https://en.wikipedia.org/wiki/Pascal%27s_triangle
-///
-/// Arguments:
-///     * `num_rows` - number of rows of triangle
-/// Complexity
-///     - time complexity: O(n^2),
-///     - space complexity: O(n^2),
-pub fn pascal_triangle(num_rows: i32) -> Vec<Vec<i32>> {
-    let mut ans: Vec<Vec<i32>> = vec![];
-
-    for i in 1..num_rows + 1 {
-        let mut vec: Vec<i32> = vec![1];
-
-        let mut res: i32 = 1;
-        for k in 1..i {
-            res *= i - k;
-            res /= k;
-            vec.push(res);
-        }
-        ans.push(vec);
-    }
-
-    ans
-}
-
-#[cfg(test)]
-mod tests {
-    use super::pascal_triangle;
-
-    #[test]
-    fn test() {
-        assert_eq!(pascal_triangle(3), vec![vec![1], vec![1, 1], vec![1, 2, 1]]);
-        assert_eq!(
-            pascal_triangle(4),
-            vec![vec![1], vec![1, 1], vec![1, 2, 1], vec![1, 3, 3, 1]]
-        );
-        assert_eq!(
-            pascal_triangle(5),
-            vec![
-                vec![1],
-                vec![1, 1],
-                vec![1, 2, 1],
-                vec![1, 3, 3, 1],
-                vec![1, 4, 6, 4, 1]
-            ]
-        );
-    }
-}
-```

codes/src/algorithms/math/perfect-numbers.md

@@ -1,51 +0,0 @@
-# 寻找完美数
-
-```rust
-pub fn is_perfect_number(num: usize) -> bool {
-    let mut sum = 0;
-
-    for i in 1..num - 1 {
-        if num % i == 0 {
-            sum += i;
-        }
-    }
-
-    num == sum
-}
-
-pub fn perfect_numbers(max: usize) -> Vec<usize> {
-    let mut result: Vec<usize> = Vec::new();
-
-    // It is not known if there are any odd perfect numbers, so we go around all the numbers.
-    for i in 1..max + 1 {
-        if is_perfect_number(i) {
-            result.push(i);
-        }
-    }
-
-    result
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        assert_eq!(is_perfect_number(6), true);
-        assert_eq!(is_perfect_number(28), true);
-        assert_eq!(is_perfect_number(496), true);
-        assert_eq!(is_perfect_number(8128), true);
-
-        assert_eq!(is_perfect_number(5), false);
-        assert_eq!(is_perfect_number(86), false);
-        assert_eq!(is_perfect_number(497), false);
-        assert_eq!(is_perfect_number(8120), false);
-
-        assert_eq!(perfect_numbers(10), vec![6]);
-        assert_eq!(perfect_numbers(100), vec![6, 28]);
-        assert_eq!(perfect_numbers(496), vec![6, 28, 496]);
-        assert_eq!(perfect_numbers(1000), vec![6, 28, 496]);
-    }
-}
-```

codes/src/algorithms/math/prime-check.md

@@ -1,37 +0,0 @@
-# 质数检测
-
-```rust
-pub fn prime_check(num: usize) -> bool {
-    if (num > 1) & (num < 4) {
-        return true;
-    } else if (num < 2) || (num % 2 == 0) {
-        return false;
-    }
-
-    let stop: usize = (num as f64).sqrt() as usize + 1;
-    for i in (3..stop).step_by(2) {
-        if num % i == 0 {
-            return false;
-        }
-    }
-    true
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        assert_eq!(prime_check(3), true);
-        assert_eq!(prime_check(7), true);
-        assert_eq!(prime_check(11), true);
-        assert_eq!(prime_check(2003), true);
-
-        assert_eq!(prime_check(4), false);
-        assert_eq!(prime_check(6), false);
-        assert_eq!(prime_check(21), false);
-        assert_eq!(prime_check(2004), false);
-    }
-}
-```

codes/src/algorithms/math/prime-numbers.md

@@ -1,42 +0,0 @@
-# 质数筛法
-
-```rust
-pub fn prime_numbers(max: usize) -> Vec<usize> {
-    let mut result: Vec<usize> = Vec::new();
-
-    if max >= 2 {
-        result.push(2)
-    }
-    for i in (3..max + 1).step_by(2) {
-        let stop: usize = (i as f64).sqrt() as usize + 1;
-        let mut status: bool = true;
-
-        for j in (3..stop).step_by(2) {
-            if i % j == 0 {
-                status = false
-            }
-        }
-        if status {
-            result.push(i)
-        }
-    }
-
-    result
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        assert_eq!(prime_numbers(0), vec![]);
-        assert_eq!(prime_numbers(11), vec![2, 3, 5, 7, 11]);
-        assert_eq!(prime_numbers(25), vec![2, 3, 5, 7, 11, 13, 17, 19, 23]);
-        assert_eq!(
-            prime_numbers(33),
-            vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
-        );
-    }
-}
-```

codes/src/algorithms/math/trial-division.md

@@ -1,53 +0,0 @@
-# 试除法
-
-```rust
-fn floor(value: f64, scale: u8) -> f64 {
-    let multiplier = 10i64.pow(scale as u32) as f64;
-    (value * multiplier).floor()
-}
-
-fn double_to_int(amount: f64) -> i128 {
-    amount.round() as i128
-}
-
-pub fn trial_division(mut num: i128) -> Vec<i128> {
-    let mut result: Vec<i128> = vec![];
-
-    while num % 2 == 0 {
-        result.push(2);
-        num /= 2;
-        num = double_to_int(floor(num as f64, 0))
-    }
-    let mut f: i128 = 3;
-
-    while f.pow(2) <= num {
-        if num % f == 0 {
-            result.push(f);
-            num /= f;
-            num = double_to_int(floor(num as f64, 0))
-        } else {
-            f += 2
-        }
-    }
-
-    if num != 1 {
-        result.push(num)
-    }
-    result
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        assert_eq!(trial_division(9), vec!(3, 3));
-        assert_eq!(trial_division(10), vec!(2, 5));
-        assert_eq!(trial_division(11), vec!(11));
-        assert_eq!(trial_division(33), vec!(3, 11));
-        assert_eq!(trial_division(2003), vec!(2003));
-        assert_eq!(trial_division(100001), vec!(11, 9091));
-    }
-}
-```

codes/src/algorithms/searching/binary-search-recursive.md

@@ -1,135 +0,0 @@
-# 递归二分查找
-
-```rust
-use std::cmp::Ordering;
-
-pub fn binary_search_rec<T: Ord>(
-    list_of_items: &[T],
-    target: &T,
-    left: &usize,
-    right: &usize,
-) -> Option<usize> {
-    if left >= right {
-        return None;
-    }
-
-    let middle: usize = left + (right - left) / 2;
-    match target.cmp(&list_of_items[middle]) {
-        Ordering::Less => binary_search_rec(list_of_items, target, left, &middle),
-        Ordering::Greater => binary_search_rec(list_of_items, target, &(middle + 1), right),
-        Ordering::Equal => Some(middle),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const LEFT: usize = 0;
-
-    #[test]
-    fn fail_empty_list() {
-        let list_of_items = vec![];
-        assert_eq!(
-            binary_search_rec(&list_of_items, &1, &LEFT, &list_of_items.len()),
-            None
-        );
-    }
-
-    #[test]
-    fn success_one_item() {
-        let list_of_items = vec![30];
-        assert_eq!(
-            binary_search_rec(&list_of_items, &30, &LEFT, &list_of_items.len()),
-            Some(0)
-        );
-    }
-
-    #[test]
-    fn success_search_strings() {
-        let say_hello_list = vec!["hi", "olá", "salut"];
-        let right = say_hello_list.len();
-        assert_eq!(
-            binary_search_rec(&say_hello_list, &"hi", &LEFT, &right),
-            Some(0)
-        );
-        assert_eq!(
-            binary_search_rec(&say_hello_list, &"salut", &LEFT, &right),
-            Some(2)
-        );
-    }
-
-    #[test]
-    fn fail_search_strings() {
-        let say_hello_list = vec!["hi", "olá", "salut"];
-        for target in &["adiós", "你好"] {
-            assert_eq!(
-                binary_search_rec(&say_hello_list, target, &LEFT, &say_hello_list.len()),
-                None
-            );
-        }
-    }
-
-    #[test]
-    fn success_search_integers() {
-        let integers = vec![0, 10, 20, 30, 40, 50, 60, 70, 80, 90];
-        for (index, target) in integers.iter().enumerate() {
-            assert_eq!(
-                binary_search_rec(&integers, target, &LEFT, &integers.len()),
-                Some(index)
-            )
-        }
-    }
-
-    #[test]
-    fn fail_search_integers() {
-        let integers = vec![0, 10, 20, 30, 40, 50, 60, 70, 80, 90];
-        for target in &[100, 444, 336] {
-            assert_eq!(
-                binary_search_rec(&integers, target, &LEFT, &integers.len()),
-                None
-            );
-        }
-    }
-
-    #[test]
-    fn fail_search_unsorted_strings_list() {
-        let unsorted_strings = vec!["salut", "olá", "hi"];
-        for target in &["hi", "salut"] {
-            assert_eq!(
-                binary_search_rec(&unsorted_strings, target, &LEFT, &unsorted_strings.len()),
-                None
-            );
-        }
-    }
-
-    #[test]
-    fn fail_search_unsorted_integers_list() {
-        let unsorted_integers = vec![90, 80, 70, 60, 50, 40, 30, 20, 10, 0];
-        for target in &[0, 80, 90] {
-            assert_eq!(
-                binary_search_rec(&unsorted_integers, target, &LEFT, &unsorted_integers.len()),
-                None
-            );
-        }
-    }
-
-    #[test]
-    fn success_search_string_in_middle_of_unsorted_list() {
-        let unsorted_strings = vec!["salut", "olá", "hi"];
-        assert_eq!(
-            binary_search_rec(&unsorted_strings, &"olá", &LEFT, &unsorted_strings.len()),
-            Some(1)
-        );
-    }
-
-    #[test]
-    fn success_search_integer_in_middle_of_unsorted_list() {
-        let unsorted_integers = vec![90, 80, 70];
-        assert_eq!(
-            binary_search_rec(&unsorted_integers, &80, &LEFT, &unsorted_integers.len()),
-            Some(1)
-        );
-    }
-}
-```

codes/src/algorithms/searching/binary-search.md

@@ -1,78 +0,0 @@
-# 二分搜索
-
-![alt text][binary-image]
-
-From [Wikipedia][binary-wiki]: Binary search, also known as half-interval search or logarithmic search, is a search algorithm that finds the position of a target value within a sorted array. It compares the target value to the middle element of the array; if they are unequal, the half in which the target cannot lie is eliminated and the search continues on the remaining half until it is successful.
-
-__Properties__
-* Worst case performance	O(log n)
-* Best case performance	O(1)
-* Average case performance	O(log n)
-* Worst case space complexity	O(1) 
-
-```rust
-use std::cmp::Ordering;
-
-pub fn binary_search<T: Ord>(item: &T, arr: &[T]) -> Option<usize> {
-    let mut left = 0;
-    let mut right = arr.len();
-
-    while left < right {
-        let mid = left + (right - left) / 2;
-
-        match item.cmp(&arr[mid]) {
-            Ordering::Less => right = mid,
-            Ordering::Equal => return Some(mid),
-            Ordering::Greater => left = mid + 1,
-        }
-    }
-    None
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn empty() {
-        let index = binary_search(&"a", &vec![]);
-        assert_eq!(index, None);
-    }
-
-    #[test]
-    fn one_item() {
-        let index = binary_search(&"a", &vec!["a"]);
-        assert_eq!(index, Some(0));
-    }
-
-    #[test]
-    fn search_strings() {
-        let index = binary_search(&"a", &vec!["a", "b", "c", "d", "google", "zoo"]);
-        assert_eq!(index, Some(0));
-    }
-
-    #[test]
-    fn search_ints() {
-        let index = binary_search(&4, &vec![1, 2, 3, 4]);
-        assert_eq!(index, Some(3));
-
-        let index = binary_search(&3, &vec![1, 2, 3, 4]);
-        assert_eq!(index, Some(2));
-
-        let index = binary_search(&2, &vec![1, 2, 3, 4]);
-        assert_eq!(index, Some(1));
-
-        let index = binary_search(&1, &vec![1, 2, 3, 4]);
-        assert_eq!(index, Some(0));
-    }
-
-    #[test]
-    fn not_found() {
-        let index = binary_search(&5, &vec![1, 2, 3, 4]);
-        assert_eq!(index, None);
-    }
-}
-```
-
-[binary-wiki]: https://en.wikipedia.org/wiki/Binary_search_algorithm
-[binary-image]: https://upload.wikimedia.org/wikipedia/commons/f/f7/Binary_search_into_array.png

codes/src/algorithms/searching/index.md

@@ -1,5 +0,0 @@
-# 查找算法
-
-查找是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是常用的基本运算，例如编译程序中符号表的查找。
-
-把数据按照合适的方式进行排列，往往是查找的关键。

codes/src/algorithms/searching/kth-smallest.md

@@ -1,76 +0,0 @@
-# 查找第K小的元素
-
-```rust
-use crate::sorting::partition;
-use std::cmp::{Ordering, PartialOrd};
-
-/// Returns k-th smallest element of an array, i.e. its order statistics.
-/// Time complexity is O(n^2) in the worst case, but only O(n) on average.
-/// It mutates the input, and therefore does not require additional space.
-pub fn kth_smallest<T>(input: &mut [T], k: usize) -> Option<T>
-where
-    T: PartialOrd + Copy,
-{
-    if input.is_empty() {
-        return None;
-    }
-
-    let kth = _kth_smallest(input, k, 0, input.len() - 1);
-    Some(kth)
-}
-
-fn _kth_smallest<T>(input: &mut [T], k: usize, lo: usize, hi: usize) -> T
-where
-    T: PartialOrd + Copy,
-{
-    if lo == hi {
-        return input[lo];
-    }
-
-    let pivot = partition(input, lo as isize, hi as isize) as usize;
-    let i = pivot - lo + 1;
-
-    match k.cmp(&i) {
-        Ordering::Equal => input[pivot],
-        Ordering::Less => _kth_smallest(input, k, lo, pivot - 1),
-        Ordering::Greater => _kth_smallest(input, k - i, pivot + 1, hi),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn empty() {
-        let mut zero: [u8; 0] = [];
-        let first = kth_smallest(&mut zero, 1);
-
-        assert_eq!(None, first);
-    }
-
-    #[test]
-    fn one_element() {
-        let mut one = [1];
-        let first = kth_smallest(&mut one, 1);
-
-        assert_eq!(1, first.unwrap());
-    }
-
-    #[test]
-    fn many_elements() {
-        // 0 1 3 4 5 7 8 9 9 10 12 13 16 17
-        let mut many = [9, 17, 3, 16, 13, 10, 1, 5, 7, 12, 4, 8, 9, 0];
-
-        let first = kth_smallest(&mut many, 1);
-        let third = kth_smallest(&mut many, 3);
-        let sixth = kth_smallest(&mut many, 6);
-        let fourteenth = kth_smallest(&mut many, 14);
-
-        assert_eq!(0, first.unwrap());
-        assert_eq!(3, third.unwrap());
-        assert_eq!(7, sixth.unwrap());
-        assert_eq!(17, fourteenth.unwrap());
-    }
-}
-```

codes/src/algorithms/searching/linear-search.md

@@ -1,68 +0,0 @@
-# 线性搜索
-
-![alt text][linear-image]
-
-From [Wikipedia][linear-wiki]: linear search or sequential search is a method for finding a target value within a list. It sequentially checks each element of the list for the target value until a match is found or until all the elements have been searched.
-  Linear search runs in at worst linear time and makes at most n comparisons, where n is the length of the list.
-
-__Properties__
-* Worst case performance	O(n)
-* Best case performance	O(1)
-* Average case performance	O(n)
-* Worst case space complexity	O(1) iterative
-
-```rust
-use std::cmp::PartialEq;
-
-pub fn linear_search<T: PartialEq>(item: &T, arr: &[T]) -> Option<usize> {
-    for (i, data) in arr.iter().enumerate() {
-        if item == data {
-            return Some(i);
-        }
-    }
-
-    None
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn search_strings() {
-        let index = linear_search(&"a", &vec!["a", "b", "c", "d", "google", "zoo"]);
-        assert_eq!(index, Some(0));
-    }
-
-    #[test]
-    fn search_ints() {
-        let index = linear_search(&4, &vec![1, 2, 3, 4]);
-        assert_eq!(index, Some(3));
-
-        let index = linear_search(&3, &vec![1, 2, 3, 4]);
-        assert_eq!(index, Some(2));
-
-        let index = linear_search(&2, &vec![1, 2, 3, 4]);
-        assert_eq!(index, Some(1));
-
-        let index = linear_search(&1, &vec![1, 2, 3, 4]);
-        assert_eq!(index, Some(0));
-    }
-
-    #[test]
-    fn not_found() {
-        let index = linear_search(&5, &vec![1, 2, 3, 4]);
-        assert_eq!(index, None);
-    }
-
-    #[test]
-    fn empty() {
-        let index = linear_search(&1, &vec![]);
-        assert_eq!(index, None);
-    }
-}
-```
-
-
-[linear-wiki]: https://en.wikipedia.org/wiki/Linear_search
-[linear-image]: http://www.tutorialspoint.com/data_structures_algorithms/images/linear_search.gif

codes/src/algorithms/sorting/bubble-sort.md

@@ -1,67 +0,0 @@
-# 冒泡排序
-
-```rust
-pub fn bubble_sort<T: PartialOrd>(arr: &mut [T]) {
-    if arr.len() <= 1 {
-        return;
-    }
-
-    let size = arr.len();
-    for i in 0..(size - 1) {
-        // 标记当前循环是否发生元素交换
-        let mut swapped = false;
-
-        // 最后i个元素已经排好了顺序
-        for j in 1..(size - i) {
-            if arr[j - 1] > arr[j] { 
-                arr.swap(j - 1, j);
-                swapped = true;
-            }
-        }
-
-        // 如果当前循环没有发生元素交换，说明数组已经有序
-        if !swapped {
-            break;
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_empty_vec() {
-        let mut empty_vec: Vec<String> = vec![];
-        bubble_sort(&mut empty_vec);
-        assert_eq!(empty_vec, Vec::<String>::new());
-    }
-
-    #[test]
-    fn test_number_vec() {
-        let mut vec = vec![7, 49, 73, 58, 30, 72, 44, 78, 23, 9];
-        bubble_sort(&mut vec);
-        assert_eq!(vec, vec![7, 9, 23, 30, 44, 49, 58, 72, 73, 78]);
-    }
-
-    #[test]
-    fn test_string_vec() {
-        let mut vec = vec![
-            String::from("Bob"),
-            String::from("David"),
-            String::from("Carol"),
-            String::from("Alice"),
-        ];
-        bubble_sort(&mut vec);
-        assert_eq!(
-            vec,
-            vec![
-                String::from("Alice"),
-                String::from("Bob"),
-                String::from("Carol"),
-                String::from("David"),
-            ]
-        );
-    }
-}
-```

codes/src/algorithms/sorting/bucket-sort.md

@@ -1,84 +0,0 @@
-# 桶排序
-
-```rust
-/// Sort a slice using bucket sort algorithm.
-///
-/// Time complexity is `O(n + k)` on average, where `n` is the number of elements,
-/// `k` is the number of buckets used in process.
-///
-/// Space complexity is `O(n + k)`, as it sorts not in-place.
-pub fn bucket_sort(arr: &[usize]) -> Vec<usize> {
-    if arr.is_empty() {
-        return vec![];
-    }
-
-    let max = *arr.iter().max().unwrap();
-    let len = arr.len();
-    let mut buckets = vec![vec![]; len + 1];
-
-    for x in arr {
-        buckets[len * *x / max].push(*x);
-    }
-
-    for bucket in buckets.iter_mut() {
-        super::insertion_sort(bucket);
-    }
-
-    let mut result = vec![];
-    for bucket in buckets {
-        for x in bucket {
-            result.push(x);
-        }
-    }
-
-    result
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::is_sorted;
-    use super::*;
-
-    #[test]
-    fn empty() {
-        let arr: [usize; 0] = [];
-        let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
-    }
-
-    #[test]
-    fn one_element() {
-        let arr: [usize; 1] = [4];
-        let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
-    }
-
-    #[test]
-    fn already_sorted() {
-        let arr: [usize; 3] = [10, 9, 105];
-        let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
-    }
-
-    #[test]
-    fn basic() {
-        let arr: [usize; 4] = [35, 53, 1, 0];
-        let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
-    }
-
-    #[test]
-    fn odd_number_of_elements() {
-        let arr: Vec<usize> = vec![1, 21, 5, 11, 58];
-        let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
-    }
-
-    #[test]
-    fn repeated_elements() {
-        let arr: Vec<usize> = vec![542, 542, 542, 542];
-        let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
-    }
-}
-```

codes/src/algorithms/sorting/cocktail-shaker-sort.md

@@ -1,72 +0,0 @@
-# 鸡尾酒排序
-
-```rust
-pub fn cocktail_shaker_sort<T: Ord>(arr: &mut [T]) {
-    let len = arr.len();
-
-    if len == 0 {
-        return;
-    }
-
-    loop {
-        let mut swapped = false;
-
-        for i in 0..(len - 1).clamp(0, len) {
-            if arr[i] > arr[i + 1] {
-                arr.swap(i, i + 1);
-                swapped = true;
-            }
-        }
-
-        if !swapped {
-            break;
-        }
-
-        swapped = false;
-
-        for i in (0..(len - 1).clamp(0, len)).rev() {
-            if arr[i] > arr[i + 1] {
-                arr.swap(i, i + 1);
-                swapped = true;
-            }
-        }
-
-        if !swapped {
-            break;
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        let mut arr = vec![5, 2, 1, 3, 4, 6];
-        cocktail_shaker_sort(&mut arr);
-        assert_eq!(arr, vec![1, 2, 3, 4, 5, 6]);
-    }
-
-    #[test]
-    fn empty() {
-        let mut arr = Vec::<i32>::new();
-        cocktail_shaker_sort(&mut arr);
-        assert_eq!(arr, vec![]);
-    }
-
-    #[test]
-    fn one_element() {
-        let mut arr = vec![1];
-        cocktail_shaker_sort(&mut arr);
-        assert_eq!(arr, vec![1]);
-    }
-
-    #[test]
-    fn pre_sorted() {
-        let mut arr = vec![1, 2, 3, 4, 5, 6];
-        cocktail_shaker_sort(&mut arr);
-        assert_eq!(arr, vec![1, 2, 3, 4, 5, 6]);
-    }
-}
-```

codes/src/algorithms/sorting/comb-sort.md

@@ -1,49 +0,0 @@
-# 梳排序
-
-```rust
-pub fn comb_sort<T: Ord>(arr: &mut [T]) {
-    let mut gap = arr.len();
-    let shrink = 1.3;
-    let mut sorted = false;
-
-    while !sorted {
-        gap = (gap as f32 / shrink).floor() as usize;
-        if gap <= 1 {
-            gap = 1;
-            sorted = true;
-        }
-        for i in 0..arr.len() - gap {
-            let j = i + gap;
-            if arr[i] > arr[j] {
-                arr.swap(i, j);
-                sorted = false;
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn descending() {
-        //descending
-        let mut ve1 = vec![6, 5, 4, 3, 2, 1];
-        comb_sort(&mut ve1);
-        for i in 0..ve1.len() - 1 {
-            assert!(ve1[i] <= ve1[i + 1]);
-        }
-    }
-
-    #[test]
-    fn ascending() {
-        //pre-sorted
-        let mut ve2 = vec![1, 2, 3, 4, 5, 6];
-        comb_sort(&mut ve2);
-        for i in 0..ve2.len() - 1 {
-            assert!(ve2[i] <= ve2[i + 1]);
-        }
-    }
-}
-```

codes/src/algorithms/sorting/counting-sort.md

@@ -1,92 +0,0 @@
-# 计数排序
-
-```rust
-/// In place counting sort for collections of u32
-/// O(n + maxval) in time, where maxval is the biggest value an input can possibly take
-/// O(maxval) in memory
-/// u32 is chosen arbitrarly, a counting sort probably should'nt be used on data that requires bigger types.
-
-pub fn counting_sort(arr: &mut [u32], maxval: usize) {
-    let mut occurences: Vec<usize> = vec![0; maxval + 1];
-
-    for &data in arr.iter() {
-        occurences[data as usize] += 1;
-    }
-
-    let mut i = 0;
-    for (data, &number) in occurences.iter().enumerate() {
-        for _ in 0..number {
-            arr[i] = data as u32;
-            i += 1;
-        }
-    }
-}
-
-use std::ops::AddAssign;
-/// Generic implementation of a counting sort for all usigned types
-pub fn generic_counting_sort<T: Into<u64> + From<u8> + AddAssign + Copy>(
-    arr: &mut [T],
-    maxval: usize,
-) {
-    let mut occurences: Vec<usize> = vec![0; maxval + 1];
-
-    for &data in arr.iter() {
-        occurences[data.into() as usize] += 1;
-    }
-
-    // Current index in output array
-    let mut i = 0;
-
-    // current data point, necessary to be type-safe
-    let mut data = T::from(0);
-
-    // This will iterate from 0 to the largest data point in `arr`
-    // `number` contains the occurances of the data point `data`
-    for &number in occurences.iter() {
-        for _ in 0..number {
-            arr[i] = data;
-            i += 1;
-        }
-
-        data += T::from(1);
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::super::is_sorted;
-    use super::*;
-
-    #[test]
-    fn counting_sort_descending() {
-        let mut ve1 = vec![6, 5, 4, 3, 2, 1];
-        counting_sort(&mut ve1, 6);
-
-        assert!(is_sorted(&ve1));
-    }
-
-    #[test]
-    fn counting_sort_pre_sorted() {
-        let mut ve2 = vec![1, 2, 3, 4, 5, 6];
-        counting_sort(&mut ve2, 6);
-
-        assert!(is_sorted(&ve2));
-    }
-
-    #[test]
-    fn generic_counting_sort() {
-        let mut ve1: Vec<u8> = vec![100, 30, 60, 10, 20, 120, 1];
-        super::generic_counting_sort(&mut ve1, 120);
-
-        assert!(is_sorted(&ve1));
-    }
-
-    #[test]
-    fn presorted_u64_counting_sort() {
-        let mut ve2: Vec<u64> = vec![1, 2, 3, 4, 5, 6];
-        super::generic_counting_sort(&mut ve2, 6);
-
-        assert!(is_sorted(&ve2));
-    }
-}
-```

codes/src/algorithms/sorting/gnome-sort.md

@@ -1,64 +0,0 @@
-# 地精排序
-
-```rust
-use std::cmp;
-
-pub fn gnome_sort<T>(arr: &[T]) -> Vec<T>
-where
-    T: cmp::PartialEq + cmp::PartialOrd + Clone,
-{
-    let mut arr = arr.to_vec();
-    let mut i: usize = 1;
-    let mut j: usize = 2;
-
-    while i < arr.len() {
-        if arr[i - 1] < arr[i] {
-            i = j;
-            j = i + 1;
-        } else {
-            arr.swap(i - 1, i);
-            i -= 1;
-            if i == 0 {
-                i = j;
-                j += 1;
-            }
-        }
-    }
-    arr
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        let res = gnome_sort(&vec![6, 5, -8, 3, 2, 3]);
-        assert_eq!(res, vec![-8, 2, 3, 3, 5, 6]);
-    }
-
-    #[test]
-    fn already_sorted() {
-        let res = gnome_sort(&vec!["a", "b", "c"]);
-        assert_eq!(res, vec!["a", "b", "c"]);
-    }
-
-    #[test]
-    fn odd_number_of_elements() {
-        let res = gnome_sort(&vec!["d", "a", "c", "e", "b"]);
-        assert_eq!(res, vec!["a", "b", "c", "d", "e"]);
-    }
-
-    #[test]
-    fn one_element() {
-        let res = gnome_sort(&vec![3]);
-        assert_eq!(res, vec![3]);
-    }
-
-    #[test]
-    fn empty() {
-        let res = gnome_sort(&Vec::<u8>::new());
-        assert_eq!(res, vec![]);
-    }
-}
-```

codes/src/algorithms/sorting/heap-sort.md

@@ -1,77 +0,0 @@
-# 堆排序
-
-```rust
-pub fn heap_sort<T: PartialOrd>(arr: &mut [T]) {
-    let size = arr.len();
-    // 构建大根堆
-    for i in (0..size / 2).rev() {
-        heapify(arr, i, size);
-    }
-
-    // 每轮循环将堆顶元素（也就是最大元素）放到最后
-    for i in (1..size).rev() {
-        arr.swap(0, i);
-        // 恢复大根堆
-        heapify(arr, 0, i);
-    }
-}
-
-fn heapify<T: PartialOrd>(arr: &mut [T], root: usize, end: usize) {
-    // 记录父节点和左右节点中最大元素的索引位置
-    let mut largest = root;
-
-    let left_child = 2 * root + 1;
-    if left_child < end && arr[left_child] > arr[largest] {
-        largest = left_child;
-    }
-
-    let right_child = left_child + 1;
-    if right_child < end && arr[right_child] > arr[largest] {
-        largest = right_child;
-    }
-
-    if largest != root {
-        arr.swap(root, largest);
-        heapify(arr, largest, end);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_empty_vec() {
-        let mut empty_vec: Vec<String> = vec![];
-        heap_sort(&mut empty_vec);
-        assert_eq!(empty_vec, Vec::<String>::new());
-    }
-
-    #[test]
-    fn test_number_vec() {
-        let mut vec = vec![7, 49, 73, 58, 30, 72, 44, 78, 23, 9];
-        heap_sort(&mut vec);
-        assert_eq!(vec, vec![7, 9, 23, 30, 44, 49, 58, 72, 73, 78]);
-    }
-
-    #[test]
-    fn test_string_vec() {
-        let mut vec = vec![
-            String::from("Bob"),
-            String::from("David"),
-            String::from("Carol"),
-            String::from("Alice"),
-        ];
-        heap_sort(&mut vec);
-        assert_eq!(
-            vec,
-            vec![
-                String::from("Alice"),
-                String::from("Bob"),
-                String::from("Carol"),
-                String::from("David"),
-            ]
-        );
-    }
-}
-```

codes/src/algorithms/sorting/index.md

@@ -1,4 +0,0 @@
-# 排序算法
-
-所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。
-

codes/src/algorithms/sorting/insertion-sort.md

@@ -1,110 +0,0 @@
-# 插入排序
-
-```rust
-pub fn insertion_sort<T: PartialOrd>(arr: &mut [T]) {
-    // 从第二个元素开始排序
-    for i in 1..arr.len() {
-        // 找到 arr[i] 该插入的位置
-        let mut j = i;
-        while j > 0 && arr[j - 1] > arr[j] {
-            arr.swap(j - 1, j);
-            j -= 1;
-        }
-    }
-}
-
-// 这里需要 T: Ord 是因为 binary_search() 方法的限制
-pub fn insertion_sort_binary_search<T: Ord>(arr: &mut[T]) {
-    // 从第二个元素开始排序
-    for i in 1..arr.len() {
-        // 利用二分查找获取 arr[i] 应该插入的位置
-        let pos = arr[..i].binary_search(&arr[i]).unwrap_or_else(|pos| pos);
-        let mut j = i;
-        while j > pos {
-            arr.swap(j - 1, j);
-            j -= 1;
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    mod insertion_sort {
-        use super::*;
-
-        #[test]
-        fn test_empty_vec() {
-            let mut empty_vec: Vec<String> = vec![];
-            insertion_sort(&mut empty_vec);
-            assert_eq!(empty_vec, Vec::<String>::new());
-        }
-    
-        #[test]
-        fn test_number_vec() {
-            let mut vec = vec![7, 49, 73, 58, 30, 72, 44, 78, 23, 9];
-            insertion_sort(&mut vec);
-            assert_eq!(vec, vec![7, 9, 23, 30, 44, 49, 58, 72, 73, 78]);
-        }
-    
-        #[test]
-        fn test_string_vec() {
-            let mut vec = vec![
-                String::from("Bob"),
-                String::from("David"),
-                String::from("Carol"),
-                String::from("Alice"),
-            ];
-            insertion_sort(&mut vec);
-            assert_eq!(
-                vec,
-                vec![
-                    String::from("Alice"),
-                    String::from("Bob"),
-                    String::from("Carol"),
-                    String::from("David"),
-                ]
-            );
-        }
-    }
-
-    mod insertion_sort_binary_search {
-        use super::*;
-        
-        #[test]
-        fn test_empty_vec() {
-            let mut empty_vec: Vec<String> = vec![];
-            insertion_sort_binary_search(&mut empty_vec);
-            assert_eq!(empty_vec, Vec::<String>::new());
-        }
-    
-        #[test]
-        fn test_number_vec() {
-            let mut vec = vec![7, 49, 73, 58, 30, 72, 44, 78, 23, 9];
-            insertion_sort_binary_search(&mut vec);
-            assert_eq!(vec, vec![7, 9, 23, 30, 44, 49, 58, 72, 73, 78]);
-        }
-    
-        #[test]
-        fn test_string_vec() {
-            let mut vec = vec![
-                String::from("Bob"),
-                String::from("David"),
-                String::from("Carol"),
-                String::from("Alice"),
-            ];
-            insertion_sort_binary_search(&mut vec);
-            assert_eq!(
-                vec,
-                vec![
-                    String::from("Alice"),
-                    String::from("Bob"),
-                    String::from("Carol"),
-                    String::from("David"),
-                ]
-            );
-        }
-    }
-}
-```

codes/src/algorithms/sorting/merge-sort.md

@@ -1,95 +0,0 @@
-# 归并排序
-
-```rust
-pub fn merge_sort<T>(arr: &mut [T])
-where
-    T: PartialOrd + Clone + Default,
-{
-    if arr.len() > 1 {
-        merge_sort_range(arr, 0, arr.len() - 1);
-    }
-}
-
-fn merge_sort_range<T>(arr: &mut [T], lo: usize, hi: usize)
-where
-    T: PartialOrd + Clone + Default,
-{
-    // 只有当元素个数大于一时才进行排序
-    if lo < hi {
-        let mid = lo + ((hi - lo) >> 1);
-        merge_sort_range(arr, lo, mid);
-        merge_sort_range(arr, mid + 1, hi);
-        merge_two_arrays(arr, lo, mid, hi);
-    }
-}
-
-// 合并两个有序数组: arr[lo..=mid], arr[mid + 1..=hi]
-fn merge_two_arrays<T>(arr: &mut [T], lo: usize, mid: usize, hi: usize)
-where
-    T: PartialOrd + Clone + Default,
-{
-    // 这里需要 clone 数组元素
-    let mut arr1 = arr[lo..=mid].to_vec();
-    let mut arr2 = arr[mid + 1..=hi].to_vec();
-
-    let (mut i, mut j) = (0, 0);
-    while i < arr1.len() && j < arr2.len() {
-        if arr1[i] < arr2[j] {
-            arr[i + j + lo] = std::mem::take(&mut arr1[i]);
-            i += 1;
-        } else {
-            arr[i + j + lo] = std::mem::take(&mut arr2[j]);
-            j += 1;
-        }
-    }
-
-    while i < arr1.len() {
-        arr[i + j + lo] = std::mem::take(&mut arr1[i]);
-        i += 1;
-    }
-
-    while j < arr2.len() {
-        arr[i + j + lo] = std::mem::take(&mut arr2[j]);
-        j += 1;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_empty_vec() {
-        let mut empty_vec: Vec<String> = vec![];
-        merge_sort(&mut empty_vec);
-        assert_eq!(empty_vec, Vec::<String>::new());
-    }
-
-    #[test]
-    fn test_number_vec() {
-        let mut vec = vec![7, 49, 73, 58, 30, 72, 44, 78, 23, 9];
-        merge_sort(&mut vec);
-        assert_eq!(vec, vec![7, 9, 23, 30, 44, 49, 58, 72, 73, 78]);
-    }
-
-    #[test]
-    fn test_string_vec() {
-        let mut vec = vec![
-            String::from("Bob"),
-            String::from("David"),
-            String::from("Carol"),
-            String::from("Alice"),
-        ];
-        merge_sort(&mut vec);
-        assert_eq!(
-            vec,
-            vec![
-                String::from("Alice"),
-                String::from("Bob"),
-                String::from("Carol"),
-                String::from("David"),
-            ]
-        );
-    }
-}
-```

codes/src/algorithms/sorting/odd-even.md

@@ -1,62 +0,0 @@
-# 奇偶排序
-
-```rust
-pub fn odd_even_sort<T: Ord>(arr: &mut [T]) {
-    let len = arr.len();
-    if len == 0 {
-        return;
-    }
-
-    let mut sorted = false;
-    while !sorted {
-        sorted = true;
-
-        for i in (1..len - 1).step_by(2) {
-            if arr[i] > arr[i + 1] {
-                arr.swap(i, i + 1);
-                sorted = false;
-            }
-        }
-
-        for i in (0..len - 1).step_by(2) {
-            if arr[i] > arr[i + 1] {
-                arr.swap(i, i + 1);
-                sorted = false;
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        let mut arr = vec![3, 5, 1, 2, 4, 6];
-        odd_even_sort(&mut arr);
-        assert_eq!(arr, vec![1, 2, 3, 4, 5, 6]);
-    }
-
-    #[test]
-    fn empty() {
-        let mut arr = Vec::<i32>::new();
-        odd_even_sort(&mut arr);
-        assert_eq!(arr, vec![]);
-    }
-
-    #[test]
-    fn one_element() {
-        let mut arr = vec![3];
-        odd_even_sort(&mut arr);
-        assert_eq!(arr, vec![3]);
-    }
-
-    #[test]
-    fn pre_sorted() {
-        let mut arr = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-        odd_even_sort(&mut arr);
-        assert_eq!(arr, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-    }
-}
-```

codes/src/algorithms/sorting/quick-sort.md

@@ -1,125 +0,0 @@
-# 快速排序
-
-```rust
-pub fn quick_sort<T: PartialOrd>(arr: &mut [T]) {
-    if arr.len() > 1 {
-        quick_sort_range(arr, 0, arr.len() - 1);
-    }
-}
-
-fn quick_sort_range<T: PartialOrd>(arr: &mut [T], lo: usize, hi: usize) {
-    // 只有当元素个数大于一时才进行排序
-    if lo < hi {
-        let pos = partition(arr, lo, hi);
-        // let pos = partition_random(arr, lo, hi);
-        if pos != 0 {
-            // 如果 pos == 0, pos - 1 会发生溢出错误
-            quick_sort_range(arr, lo, pos - 1);
-        }
-        quick_sort_range(arr, pos + 1, hi);
-    }
-}
-
-fn partition<T: PartialOrd>(arr: &mut [T], lo: usize, hi: usize) -> usize {
-    // 默认选取 lo 作为 pivot
-    let pivot = lo;
-
-    let (mut left, mut right) = (lo, hi);
-    while left < right {
-        // 找到右边第一个不大于等于 arr[pivot] 的元素
-        while left < right && arr[right] >= arr[pivot] {
-            right -= 1;
-        }
-
-        // 找到左边第一个不小于等于 arr[pivot] 的元素
-        while left < right && arr[left] <= arr[pivot] {
-            left += 1;
-        }
-        
-        // 交换前面找到的两个元素
-        if left != right {
-            arr.swap(left, right);
-        }
-    }
-
-    arr.swap(pivot, left);
-
-    // 返回正确的分割位置
-    left
-}
-
-// 随机选取 pivot 的位置
-fn partition_random<T: PartialOrd>(arr: &mut [T], lo: usize, hi: usize) -> usize {
-    // 在 Cargo.toml 的依赖中添加 rand 库
-    use rand::Rng;
-    let mut rng = rand::thread_rng();
-    let pivot = rng.gen_range(lo..=hi);
-
-    // 交换 lo 和 pivot 位置上的元素，从而间接使得 pivot = lo
-    // 因此后序操作和 partition() 函数一致
-    arr.swap(lo, pivot);
-
-    let pivot = lo;
-    let (mut left, mut right) = (lo, hi);
-    while left < right {
-        // 找到右边第一个不大于等于 arr[pivot] 的元素
-        while left < right && arr[right] >= arr[pivot] {
-            right -= 1;
-        }
-
-        // 找到左边第一个不小于等于 arr[pivot] 的元素
-        while left < right && arr[left] <= arr[pivot] {
-            left += 1;
-        }
-        
-        // 交换前面找到的两个元素
-        if left != right {
-            arr.swap(left, right);
-        }
-    }
-
-    arr.swap(pivot, left);
-
-    // 返回正确的分割位置
-    left
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_empty_vec() {
-        let mut empty_vec: Vec<String> = vec![];
-        quick_sort(&mut empty_vec);
-        assert_eq!(empty_vec, Vec::<String>::new());
-    }
-
-    #[test]
-    fn test_number_vec() {
-        let mut vec = vec![7, 49, 73, 58, 30, 72, 44, 78, 23, 9];
-        quick_sort(&mut vec);
-        assert_eq!(vec, vec![7, 9, 23, 30, 44, 49, 58, 72, 73, 78]);
-    }
-
-    #[test]
-    fn test_string_vec() {
-        let mut vec = vec![
-            String::from("Bob"),
-            String::from("David"),
-            String::from("Carol"),
-            String::from("Alice"),
-        ];
-        quick_sort(&mut vec);
-        assert_eq!(
-            vec,
-            vec![
-                String::from("Alice"),
-                String::from("Bob"),
-                String::from("Carol"),
-                String::from("David"),
-            ]
-        );
-    }
-}
-```

codes/src/algorithms/sorting/radix-sort.md

@@ -1,66 +0,0 @@
-# 基数排序
-
-```rust
-/// Sorts the elements of `arr` in-place using radix sort.
-///
-/// Time complexity is `O((n + b) * logb(k))`, where `n` is the number of elements,
-/// `b` is the base (the radix), and `k` is the largest element.
-/// When `n` and `b` are roughly the same maginitude, this algorithm runs in linear time.
-///
-/// Space complexity is `O(n + b)`.
-pub fn radix_sort(arr: &mut [u64]) {
-    let max: usize = match arr.iter().max() {
-        Some(&x) => x as usize,
-        None => return,
-    };
-    // Make radix a power of 2 close to arr.len() for optimal runtime
-    let radix = arr.len().next_power_of_two();
-    // Counting sort by each digit from least to most significant
-    let mut place = 1;
-    while place <= max {
-        let digit_of = |x| x as usize / place % radix;
-        // Count digit occurrences
-        let mut counter = vec![0; radix];
-        for &x in arr.iter() {
-            counter[digit_of(x)] += 1;
-        }
-        // Compute last index of each digit
-        for i in 1..radix {
-            counter[i] += counter[i - 1];
-        }
-        // Write elements to their new indices
-        for &x in arr.to_owned().iter().rev() {
-            counter[digit_of(x)] -= 1;
-            arr[counter[digit_of(x)]] = x;
-        }
-        place *= radix;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::is_sorted;
-    use super::radix_sort;
-
-    #[test]
-    fn empty() {
-        let mut a: [u64; 0] = [];
-        radix_sort(&mut a);
-        assert!(is_sorted(&a));
-    }
-
-    #[test]
-    fn descending() {
-        let mut v = vec![201, 127, 64, 37, 24, 4, 1];
-        radix_sort(&mut v);
-        assert!(is_sorted(&v));
-    }
-
-    #[test]
-    fn ascending() {
-        let mut v = vec![1, 4, 24, 37, 64, 127, 201];
-        radix_sort(&mut v);
-        assert!(is_sorted(&v));
-    }
-}
-```

codes/src/algorithms/sorting/selection-sort.md

@@ -1,63 +0,0 @@
-# 选择排序
-
-```rust
-pub fn selection_sort<T: PartialOrd>(arr: &mut [T]) {
-    if arr.len() <= 1 {
-        return;
-    }
-
-    let size = arr.len();
-    for i in 0..(size - 1) {
-        // 找到最小元素的索引值
-        let mut min_index = i;
-        for j in (i + 1)..size {
-            if arr[j] < arr[min_index] {
-                min_index = j;
-            }
-        }
-
-        if min_index != i {
-            arr.swap(i, min_index);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_empty_vec() {
-        let mut empty_vec: Vec<String> = vec![];
-        selection_sort(&mut empty_vec);
-        assert_eq!(empty_vec, Vec::<String>::new());
-    }
-
-    #[test]
-    fn test_number_vec() {
-        let mut vec = vec![7, 49, 73, 58, 30, 72, 44, 78, 23, 9];
-        selection_sort(&mut vec);
-        assert_eq!(vec, vec![7, 9, 23, 30, 44, 49, 58, 72, 73, 78]);
-    }
-
-    #[test]
-    fn test_string_vec() {
-        let mut vec = vec![
-            String::from("Bob"),
-            String::from("David"),
-            String::from("Carol"),
-            String::from("Alice"),
-        ];
-        selection_sort(&mut vec);
-        assert_eq!(
-            vec,
-            vec![
-                String::from("Alice"),
-                String::from("Bob"),
-                String::from("Carol"),
-                String::from("David"),
-            ]
-        );
-    }
-}
-```

codes/src/algorithms/sorting/shell-sort.md

@@ -1,66 +0,0 @@
-# 希尔排序
-
-```rust
-pub fn shell_sort<T: Ord + Copy>(values: &mut Vec<T>) {
-    // shell sort works by swiping the value at a given gap and decreasing the gap to 1
-    fn insertion<T: Ord + Copy>(values: &mut Vec<T>, start: usize, gap: usize) {
-        for i in ((start + gap)..values.len()).step_by(gap) {
-            let val_current = values[i];
-            let mut pos = i;
-            // make swaps
-            while pos >= gap && values[pos - gap] > val_current {
-                values[pos] = values[pos - gap];
-                pos -= gap;
-            }
-            values[pos] = val_current;
-        }
-    }
-
-    let mut count_sublist = values.len() / 2; // makes gap as long as half of the array
-    while count_sublist > 0 {
-        for pos_start in 0..count_sublist {
-            insertion(values, pos_start, count_sublist);
-        }
-        count_sublist /= 2; // makes gap as half of previous
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::shell_sort;
-
-    #[test]
-    fn basic() {
-        let mut vec = vec![3, 5, 6, 3, 1, 4];
-        shell_sort(&mut vec);
-        for i in 0..vec.len() - 1 {
-            assert!(vec[i] <= vec[i + 1]);
-        }
-    }
-
-    #[test]
-    fn empty() {
-        let mut vec: Vec<i32> = vec![];
-        shell_sort(&mut vec);
-        assert_eq!(vec, vec![]);
-    }
-
-    #[test]
-    fn reverse() {
-        let mut vec = vec![6, 5, 4, 3, 2, 1];
-        shell_sort(&mut vec);
-        for i in 0..vec.len() - 1 {
-            assert!(vec[i] <= vec[i + 1]);
-        }
-    }
-
-    #[test]
-    fn already_sorted() {
-        let mut vec = vec![1, 2, 3, 4, 5, 6];
-        shell_sort(&mut vec);
-        for i in 0..vec.len() - 1 {
-            assert!(vec[i] <= vec[i + 1]);
-        }
-    }
-}
-```

codes/src/algorithms/sorting/stooge-sort.md

@@ -1,67 +0,0 @@
-# 臭皮匠排序
-
-```rust
-fn _stooge_sort<T: Ord>(arr: &mut [T], start: usize, end: usize) {
-    if arr[start] > arr[end] {
-        arr.swap(start, end);
-    }
-
-    if start + 1 >= end {
-        return;
-    }
-
-    let k = (end - start + 1) / 3;
-
-    _stooge_sort(arr, start, end - k);
-    _stooge_sort(arr, start + k, end);
-    _stooge_sort(arr, start, end - k);
-}
-
-pub fn stooge_sort<T: Ord>(arr: &mut [T]) {
-    let len = arr.len();
-    if len == 0 {
-        return;
-    }
-
-    _stooge_sort(arr, 0, len - 1);
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        let mut vec = vec![3, 5, 6, 3, 1, 4];
-        stooge_sort(&mut vec);
-        for i in 0..vec.len() - 1 {
-            assert!(vec[i] <= vec[i + 1]);
-        }
-    }
-
-    #[test]
-    fn empty() {
-        let mut vec: Vec<i32> = vec![];
-        stooge_sort(&mut vec);
-        assert_eq!(vec, vec![]);
-    }
-
-    #[test]
-    fn reverse() {
-        let mut vec = vec![6, 5, 4, 3, 2, 1];
-        stooge_sort(&mut vec);
-        for i in 0..vec.len() - 1 {
-            assert!(vec[i] <= vec[i + 1]);
-        }
-    }
-
-    #[test]
-    fn already_sorted() {
-        let mut vec = vec![1, 2, 3, 4, 5, 6];
-        stooge_sort(&mut vec);
-        for i in 0..vec.len() - 1 {
-            assert!(vec[i] <= vec[i + 1]);
-        }
-    }
-}
-```

codes/src/algorithms/string/burrows-wheeler-transform.md

@@ -1,98 +0,0 @@
-# 数据转换算法(Burrows Wheeler Transform)
-
-```rust
-pub fn burrows_wheeler_transform(input: String) -> (String, usize) {
-    let len = input.len();
-
-    let mut table = Vec::<String>::with_capacity(len);
-    for i in 0..len {
-        table.push(input[i..].to_owned() + &input[..i]);
-    }
-    table.sort_by_key(|a| a.to_lowercase());
-
-    let mut encoded = String::new();
-    let mut index: usize = 0;
-    for (i, item) in table.iter().enumerate().take(len) {
-        encoded.push(item.chars().last().unwrap());
-        if item.eq(&input) {
-            index = i;
-        }
-    }
-
-    (encoded, index)
-}
-
-pub fn inv_burrows_wheeler_transform(input: (String, usize)) -> String {
-    let len = input.0.len();
-    let mut table = Vec::<(usize, char)>::with_capacity(len);
-    for i in 0..len {
-        table.push((i, input.0.chars().nth(i).unwrap()));
-    }
-
-    table.sort_by(|a, b| a.1.cmp(&b.1));
-
-    let mut decoded = String::new();
-    let mut idx = input.1;
-    for _ in 0..len {
-        decoded.push(table[idx].1);
-        idx = table[idx].0;
-    }
-
-    decoded
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        assert_eq!(
-            inv_burrows_wheeler_transform(burrows_wheeler_transform("CARROT".to_string())),
-            "CARROT"
-        );
-        assert_eq!(
-            inv_burrows_wheeler_transform(burrows_wheeler_transform("TOMATO".to_string())),
-            "TOMATO"
-        );
-        assert_eq!(
-            inv_burrows_wheeler_transform(burrows_wheeler_transform("THISISATEST".to_string())),
-            "THISISATEST"
-        );
-        assert_eq!(
-            inv_burrows_wheeler_transform(burrows_wheeler_transform("THEALGORITHMS".to_string())),
-            "THEALGORITHMS"
-        );
-        assert_eq!(
-            inv_burrows_wheeler_transform(burrows_wheeler_transform("RUST".to_string())),
-            "RUST"
-        );
-    }
-
-    #[test]
-    fn special_characters() {
-        assert_eq!(
-            inv_burrows_wheeler_transform(burrows_wheeler_transform("!.!.!??.=::".to_string())),
-            "!.!.!??.=::"
-        );
-        assert_eq!(
-            inv_burrows_wheeler_transform(burrows_wheeler_transform(
-                "!{}{}(((&&%%!??.=::".to_string()
-            )),
-            "!{}{}(((&&%%!??.=::"
-        );
-        assert_eq!(
-            inv_burrows_wheeler_transform(burrows_wheeler_transform("//&$[]".to_string())),
-            "//&$[]"
-        );
-    }
-
-    #[test]
-    fn empty() {
-        assert_eq!(
-            inv_burrows_wheeler_transform(burrows_wheeler_transform("".to_string())),
-            ""
-        );
-    }
-}
-```

codes/src/algorithms/string/index.md

@@ -1,3 +0,0 @@
-# 字符串
-
-字符串相关的算法往往和子串匹配、顺序调整相关，如何高效的处理字符串，有时会成为一个程序性能的关键。

codes/src/algorithms/string/knuth-morris-pratt.md

@@ -1,101 +0,0 @@
-# KMP算法(Knuth Morris Pratt)
-
-```rust
-pub fn knuth_morris_pratt(st: String, pat: String) -> Vec<usize> {
-    if st.is_empty() || pat.is_empty() {
-        return vec![];
-    }
-
-    let string = st.into_bytes();
-    let pattern = pat.into_bytes();
-
-    // build the partial match table
-    let mut partial = vec![0];
-    for i in 1..pattern.len() {
-        let mut j = partial[i - 1];
-        while j > 0 && pattern[j] != pattern[i] {
-            j = partial[j - 1];
-        }
-        partial.push(if pattern[j] == pattern[i] { j + 1 } else { j });
-    }
-
-    // and read 'string' to find 'pattern'
-    let mut ret = vec![];
-    let mut j = 0;
-
-    for (i, &c) in string.iter().enumerate() {
-        while j > 0 && c != pattern[j] {
-            j = partial[j - 1];
-        }
-        if c == pattern[j] {
-            j += 1;
-        }
-        if j == pattern.len() {
-            ret.push(i + 1 - j);
-            j = partial[j - 1];
-        }
-    }
-
-    ret
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn each_letter_matches() {
-        let index = knuth_morris_pratt("aaa".to_string(), "a".to_string());
-        assert_eq!(index, vec![0, 1, 2]);
-    }
-
-    #[test]
-    fn a_few_separate_matches() {
-        let index = knuth_morris_pratt("abababa".to_string(), "ab".to_string());
-        assert_eq!(index, vec![0, 2, 4]);
-    }
-
-    #[test]
-    fn one_match() {
-        let index =
-            knuth_morris_pratt("ABC ABCDAB ABCDABCDABDE".to_string(), "ABCDABD".to_string());
-        assert_eq!(index, vec![15]);
-    }
-
-    #[test]
-    fn lots_of_matches() {
-        let index = knuth_morris_pratt("aaabaabaaaaa".to_string(), "aa".to_string());
-        assert_eq!(index, vec![0, 1, 4, 7, 8, 9, 10]);
-    }
-
-    #[test]
-    fn lots_of_intricate_matches() {
-        let index = knuth_morris_pratt("ababababa".to_string(), "aba".to_string());
-        assert_eq!(index, vec![0, 2, 4, 6]);
-    }
-
-    #[test]
-    fn not_found0() {
-        let index = knuth_morris_pratt("abcde".to_string(), "f".to_string());
-        assert_eq!(index, vec![]);
-    }
-
-    #[test]
-    fn not_found1() {
-        let index = knuth_morris_pratt("abcde".to_string(), "ac".to_string());
-        assert_eq!(index, vec![]);
-    }
-
-    #[test]
-    fn not_found2() {
-        let index = knuth_morris_pratt("ababab".to_string(), "bababa".to_string());
-        assert_eq!(index, vec![]);
-    }
-
-    #[test]
-    fn empty_string() {
-        let index = knuth_morris_pratt("".to_string(), "abcdef".to_string());
-        assert_eq!(index, vec![]);
-    }
-}
-```