feat: add solutions to lcci problems (doocs#1773)

* No.10.11.Peaks and Valleys
* No.16.01.Swap Numbers
* No.16.02.Words Frequency
* No.16.05.Factorial Zeros
* No.16.07.Maximum
* No.16.11.Diving Board
* No.16.14.Best Line
* No.16.15.Master Mind
* No.16.16.Sub Sort
* No.16.17.Contiguous Sequence
* No.16.18.Pattern Matching
* No.16.19.Pond Sizes
* No.16.20.T9
* No.16.21.Sum Swap
* No.16.22.Langtons Ant
* No.16.24.Pairs With Sum

Author: yanglbme

.github/workflows/pretter-lint.yml

@@ -1,8 +1,8 @@
 name: prettier-linter
 
 on:
-    push: {}
-    pull_request: {}
+  push: {}
+  pull_request: {}
 
 jobs:
   prettier:

lcci/10.11.Peaks and Valleys/README_EN.md

@@ -20,6 +20,12 @@
 
 ## Solutions
 
+**Solution 1: Sorting**
+
+We first sort the array, and then traverse the array and swap the elements at even indices with their next element.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(\log n)$. Here, $n$ is the length of the array.
+
 <!-- tabs:start -->
 
 ### **Python3**

lcci/16.01.Swap Numbers/README.md

@@ -19,7 +19,25 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-异或运算。
+**方法一：位运算**
+
+我们可以使用异或运算 $\oplus$ 来实现两个数的交换。
+
+异或运算有以下三个性质。
+
+-   任何数和 $0$ 做异或运算，结果仍然是原来的数，即 $a \oplus 0=a$。
+-   任何数和其自身做异或运算，结果是 $0$，即 $a \oplus a=0$。
+-   异或运算满足交换律和结合律，即 $a \oplus b \oplus a=b \oplus a \oplus a=b \oplus (a \oplus a)=b \oplus 0=b$。
+
+因此，我们可以对 $numbers$ 中的两个数 $a$ 和 $b$ 进行如下操作：
+
+-   $a=a \oplus b$，此时 $a$ 中存储了两个数的异或结果；
+-   $b=a \oplus b$，此时 $b$ 中存储了原来 $a$ 的值；
+-   $a=a \oplus b$，此时 $a$ 中存储了原来 $b$ 的值；
+
+这样，我们就可以实现在不使用临时变量的情况下对两个数进行交换。
+
+时间复杂度 $O(1)$，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

lcci/16.01.Swap Numbers/README_EN.md

@@ -24,6 +24,26 @@
 
 ## Solutions
 
+**Solution 1: Bitwise Operation**
+
+We can use the XOR operation $\oplus$ to implement the swap of two numbers.
+
+The XOR operation has the following three properties:
+
+-   Any number XORed with $0$ remains unchanged, i.e., $a \oplus 0=a$.
+-   Any number XORed with itself results in $0$, i.e., $a \oplus a=0$.
+-   The XOR operation satisfies the commutative and associative laws, i.e., $a \oplus b \oplus a=b \oplus a \oplus a=b \oplus (a \oplus a)=b \oplus 0=b$.
+
+Therefore, we can perform the following operations on two numbers $a$ and $b$ in the array $numbers$:
+
+-   $a=a \oplus b$, now $a$ stores the XOR result of the two numbers;
+-   $b=a \oplus b$, now $b$ stores the original value of $a$;
+-   $a=a \oplus b$, now $a$ stores the original value of $b$;
+
+In this way, we can swap two numbers without using a temporary variable.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

lcci/16.02.Words Frequency/README.md

@@ -5,6 +5,7 @@
 ## 题目描述
 
 <!-- 这里写题目描述 -->
+
 <p>设计一个方法，找出任意指定单词在一本书中的出现频率。</p>
 <p>你的实现应该支持如下操作：</p>
 <ul>
@@ -33,9 +34,11 @@ wordsFrequency.get("pen"); //返回1
 
 **方法一：哈希表**
 
-我们用哈希表 `cnt` 统计每个单词出现的次数，`get` 函数直接返回 `cnt[word]` 即可。
+我们用哈希表 $cnt$ 统计 $book$ 中每个单词出现的次数。
+
+调用 `get` 函数时，我们只需要返回 $cnt$ 中对应的单词的出现次数即可。
 
-初始化哈希表 `cnt` 的时间复杂度为 $O(n)$，其中 $n$ 为 `book` 的长度。`get` 函数的时间复杂度为 $O(1)$。空间复杂度为 $O(n)$。
+时间复杂度方面，初始化哈希表 $cnt$ 的时间复杂度为 $O(n)$，其中 $n$ 为 $book$ 的长度。`get` 函数的时间复杂度为 $O(1)$。空间复杂度为 $O(n)$。
 
 <!-- tabs:start -->
 
@@ -194,7 +197,7 @@ class WordsFrequency {
 ```rust
 use std::collections::HashMap;
 struct WordsFrequency {
-    counter: HashMap<String, i32>
+    cnt: HashMap<String, i32>
 }
 
 
@@ -205,15 +208,15 @@ struct WordsFrequency {
 impl WordsFrequency {
 
     fn new(book: Vec<String>) -> Self {
-        let mut counter = HashMap::new();
+        let mut cnt = HashMap::new();
         for word in book.into_iter() {
-            *counter.entry(word).or_insert(0) += 1;
+            *cnt.entry(word).or_insert(0) += 1;
         }
-        Self { counter }
+        Self { cnt }
     }
 
     fn get(&self, word: String) -> i32 {
-        *self.counter.get(&word).unwrap_or(&0)
+        *self.cnt.get(&word).unwrap_or(&0)
     }
 }
 

lcci/16.02.Words Frequency/README_EN.md

@@ -42,6 +42,14 @@ wordsFrequency.get("pen"); //returns 1
 
 ## Solutions
 
+**Solution 1: Hash Table**
+
+We use a hash table $cnt$ to count the number of occurrences of each word in $book$.
+
+When calling the `get` function, we only need to return the number of occurrences of the corresponding word in $cnt$.
+
+In terms of time complexity, the time complexity of initializing the hash table $cnt$ is $O(n)$, where $n$ is the length of $book$. The time complexity of the `get` function is $O(1)$. The space complexity is $O(n)$.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -195,7 +203,7 @@ class WordsFrequency {
 ```rust
 use std::collections::HashMap;
 struct WordsFrequency {
-    counter: HashMap<String, i32>
+    cnt: HashMap<String, i32>
 }
 
 
@@ -206,15 +214,15 @@ struct WordsFrequency {
 impl WordsFrequency {
 
     fn new(book: Vec<String>) -> Self {
-        let mut counter = HashMap::new();
+        let mut cnt = HashMap::new();
         for word in book.into_iter() {
-            *counter.entry(word).or_insert(0) += 1;
+            *cnt.entry(word).or_insert(0) += 1;
         }
-        Self { counter }
+        Self { cnt }
     }
 
     fn get(&self, word: String) -> i32 {
-        *self.counter.get(&word).unwrap_or(&0)
+        *self.cnt.get(&word).unwrap_or(&0)
     }
 }
 

lcci/16.02.Words Frequency/Solution.py

@@ -1,11 +1,11 @@
-class WordsFrequency:
-    def __init__(self, book: List[str]):
-        self.cnt = Counter(book)
-
-    def get(self, word: str) -> int:
-        return self.cnt[word]
-
-
-# Your WordsFrequency object will be instantiated and called as such:
-# obj = WordsFrequency(book)
-# param_1 = obj.get(word)
+class WordsFrequency:
+    def __init__(self, book: List[str]):
+        self.cnt = Counter(book)
+
+    def get(self, word: str) -> int:
+        return self.cnt[word]
+
+
+# Your WordsFrequency object will be instantiated and called as such:
+# obj = WordsFrequency(book)
+# param_1 = obj.get(word)

lcci/16.02.Words Frequency/Solution.rs

@@ -1,30 +1,30 @@
-use std::collections::HashMap;
-struct WordsFrequency {
-    counter: HashMap<String, i32>
-}
-
-
-/**
- * `&self` means the method takes an immutable reference.
- * If you need a mutable reference, change it to `&mut self` instead.
- */
-impl WordsFrequency {
-
-    fn new(book: Vec<String>) -> Self {
-        let mut counter = HashMap::new();
-        for word in book.into_iter() {
-            *counter.entry(word).or_insert(0) += 1;
-        }
-        Self { counter }
-    }
-
-    fn get(&self, word: String) -> i32 {
-        *self.counter.get(&word).unwrap_or(&0)
-    }
-}
-
-/**
- * Your WordsFrequency object will be instantiated and called as such:
- * let obj = WordsFrequency::new(book);
- * let ret_1: i32 = obj.get(word);
+use std::collections::HashMap;
+struct WordsFrequency {
+    cnt: HashMap<String, i32>
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl WordsFrequency {
+
+    fn new(book: Vec<String>) -> Self {
+        let mut cnt = HashMap::new();
+        for word in book.into_iter() {
+            *cnt.entry(word).or_insert(0) += 1;
+        }
+        Self { cnt }
+    }
+
+    fn get(&self, word: String) -> i32 {
+        *self.cnt.get(&word).unwrap_or(&0)
+    }
+}
+
+/**
+ * Your WordsFrequency object will be instantiated and called as such:
+ * let obj = WordsFrequency::new(book);
+ * let ret_1: i32 = obj.get(word);
  */

lcci/16.05.Factorial Zeros/README_EN.md

@@ -27,6 +27,19 @@
 
 ## Solutions
 
+**Solution 1: Mathematics**
+
+The problem is actually asking for the number of factors of $5$ in $[1,n]$.
+
+Let's take $130$ as an example:
+
+1. Divide $130$ by $5$ for the first time, and get $26$, which means there are $26$ numbers containing a factor of $5$.
+2. Divide $26$ by $5$ for the second time, and get $5$, which means there are $5$ numbers containing a factor of $5^2$.
+3. Divide $5$ by $5$ for the third time, and get $1$, which means there is $1$ number containing a factor of $5^3$.
+4. Add up all the counts to get the total number of factors of $5$ in $[1,n]$.
+
+The time complexity is $O(\log n)$, and the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

lcci/16.07.Maximum/README_EN.md

@@ -16,6 +16,14 @@
 
 ## Solutions
 
+**Solution 1: Bitwise Operation**
+
+We can extract the sign bit $k$ of $a-b$. If the sign bit is $1$, it means $a \lt b$; if the sign bit is $0$, it means $a \ge b$.
+
+Then the final result is $a \times (k \oplus 1) + b \times k$.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**