fix: miss matched md formatting (labuladong#441)

* fix: fix reverse link

- Add title to readme

* fix: md formatting

* fix: md formatting

* fix: md formatting

Co-authored-by: labuladong <labuladong@foxmail.com>

Author: coquer

README.md

@@ -1,19 +1,22 @@
+# Fucking algorithm
+
 English translation is in progress... Some articles are still in Chinese, but most are completed. Please **star** this repo. The full translation will eventually be finished. Enjoy.
 
 These articles go over different kinds of **Algorithmic Thinking**. All are based on LeetCode problems. They are **not only the solution code for the problem, but also WHY the solution works and HOW we can figure it out**.
 
 I don't like one-liners. They can be confusing. I like clear, easily understandable code.
 
-The **Gitbook** has been deployed and will sync with this branch of the repo: https://labuladong.gitbook.io/algo-en/
+The **Gitbook** has been deployed and will sync with this branch of the repo: [https://labuladong.gitbook.io/algo-en/](https://labuladong.gitbook.io/algo-en/)
 
 If you want to clone this repo, please use following command:
 
 ```shell
 git clone --depth 1  --branch english https://github.com/labuladong/fucking-algorithm.git
 ```
+
 This command specifies the `english` branch and will limit the depth of the clone and get rid of the Git commit history, which can be faster to clone.
 
-# Table of Contents
+## Table of Contents
 
 * I. Dynamic Programming
   * [Dynamic Programming in Details](dynamic_programming/AnalysisOfDynamicProgramming.md)

common_knowledge/Cryptology.md

@@ -1,3 +1,5 @@
+# Cryptology
+
 Speaking of cipher, the first thing that comes to our mind is the password to login, but from the point of cryptography， it is the unqualified cipher.
 
 Why? Because the password of our account depends on crypticity, that is I keep the password in my mind and do not let you know,so you can not login in with my account.
@@ -11,9 +13,9 @@ if the receiver know the way to decrypt,the eavesdropper should also know.
 
 In the following **we will introduce symmetric encryption algorithm、key exchange algorithm、asymmetrical encryption algorithm、digital signature、public-key certificate** to explain how we solve the problem of secure transmission.
 
-### First、Symmetric Encryption
+## First, Symmetric Encryption
 
-symmetric ciphers，also called shared key cipher，as the name suggests，it uses the same key to encrypt and decrypt.
+Symmetric ciphers，also called shared key cipher，as the name suggests，it uses the same key to encrypt and decrypt.
 
 First of all,we know information consists of 0/1 bits sequence and the xor of two identical bits sequence is 0.
 
@@ -30,7 +32,7 @@ invulnerable algorithm is broken.
 
 Therefore, the two most common algorithms to solve the key distribution problem are diffie-hellman key exchange algorithm and asymmetric encryption algorithm.
 
-### Second、Key exchange algorithm
+## Second、Key exchange algorithm
 
 The secret key as we say is a big number, the algorithm use this number to encrypt and decrypt. The problem is that transition is insecure and the data can be eavesdropped.In other words, is there a way that it can let two people exchange the key in the front of others?
 
@@ -73,14 +75,14 @@ Above is the basic flow, as for picking which number, it is exquisite and I won'
 Under the premise of the third party's eavesdropping, the algorithm can calculate a secret which can not be calculated by others as the key of symmetric encryption algorithm and start the communication of symmetric encryption.
 
 About this algorithm, Hack come up with a crack way, not to eavesdrop Alice and Bob's communication, but to pretend to be Alice and Bob at the same time, that is man-in-middle attack.
- 
+
 ![](../pictures/密码技术/6.jpg)
 
 In this way, both parties can't realize that they are sharing secrets with Hack. As a result, Hack can decrypt or even modify data.
 
 **So, key exchange algorithm can not perfectly resolve the distribution of the key, the weakness lies in not being able to verify the identity of the receiver**.So, before using exchange key algorithm, we must verify the identity. For example, using the digital signature.
 
-### Third、Asymmetrical encryption
+## Third、Asymmetrical encryption
 
 The thinking of the asymmetrical encryption is that don't sneak around with the transmission key. I separate the encryption key from the decryption key and use the public key to encrypt and the private to decrypt.Only send the public key to the receivers and they can send me encrypted data that I can use my private key to decrypt.About the eavesdropper，it is useless to get the data and the public key, because only the private key can be used to decrypt.
 
@@ -107,7 +109,7 @@ Digital signature takes the advantage of asymmetrical encryption,but reverses th
 
 You may ask what is the purpose? The public key can decrypt the data,but I still encrypt the data and release.Isn't that a superfluous act?
 
-Yes,but ** the digital signature is not used to ensure the confidentiality of the data,but is used to verify your identity,** to prove that the data comes from you.
+Yes,but **the digital signature is not used to ensure the confidentiality of the data,but is used to verify your identity,** to prove that the data comes from you.
 
 You can image the data encrypted by you private key can only be decrypted by you public key,so if the encrypted data can be decrypted by you public key,can't it prove that the data comes from yourself?
 
@@ -120,35 +122,36 @@ Of course,the encrypted data is just a signature that should be released with th
 3 Alice receives the data the the signature and needs to check does the data come from Bob.So he use the public key released by Bob to decrypt and compare the decrypted data with the received data.If they are the same,it proves that the data is origin and comes from Bob.
 
 Why Alice can conclude? After all,the data and the signature,either can be exchanged.The reason is as follows:
-1 If someone modify the data,Alice will know after he decrypt the data and find the difference. 
 
-2 If someone exchange the signature,Alice will get the wrong code after decryption and it is obviously different from the original data.
+1. If someone modify the data,Alice will know after he decrypt the data and find the difference.
 
-3 someone may tend to modify the data and regenerate the signature so that Alice can not find the difference;but he can not generate the signature because he do not have the private key of Bob.
+2. If someone exchange the signature,Alice will get the wrong code after decryption and it is obviously different from the original data.
+
+3. someone may tend to modify the data and regenerate the signature so that Alice can not find the difference;but he can not generate the signature because he do not have the private key of Bob.
 
 In Summary,**digital signature can verify the origin of the data to some degree**.The reason is that it can be cracked by man-in-middle attack. Once it comes to the distribution of the public key, the receiver may receive the fake public key and make the wrong verification, Which can not be avoided.
 
 Ridiculously, digital signature is a way verify the identity of others with the assumption that the identity of others is real.It seems like a dead cycle.**There must exist a trusted origin to verify the identity of others,Or no matter how many processes are used, they are just transferring problems, not really solving them.**
 
-### Fifth、Public-key certificate
+## Fifth, Public-key certificate
 
 **The public-key certificate is the public key plus the signature,issued by a trusted third party certification authority**。Introducing the trusted third part is one of the feasible solution of dependency cycle.
 
 The process of certificate is as follows:
 
-1 Bob goes to the trusted certification authority to verify the identity of himself and provide his public key.
+1. Bob goes to the trusted certification authority to verify the identity of himself and provide his public key.
 
-2 Alice who wants to communicate with Bob, request the public key of Bob from the certification authority and then certification authority will give the certificate of Bob(it contains Bob's public key and the signature of his public key) to Alice.
+2. Alice who wants to communicate with Bob, request the public key of Bob from the certification authority and then certification authority will give the certificate of Bob(it contains Bob's public key and the signature of his public key) to Alice.
 
-3 Alice check the signature adn verify that the public key comes from the certificate authority and not tampered in halfway.
+3. Alice check the signature adn verify that the public key comes from the certificate authority and not tampered in halfway.
 
-4 Alice encrypts the data through this public key and starts to communicate with Bob.
+4. Alice encrypts the data through this public key and starts to communicate with Bob.
 
-![图片来自《图解密码技术》](../pictures/密码技术/7.jpg)
+![llustrated Cryptographic Technology](../pictures/密码技术/7.jpg)
 
-PS: the above is for description.In real,certificate is only installed once instead of request from certificate authority every time and it is the server sends the certificate to client not the certificate authority.
+> PS: the above is for description.In real,certificate is only installed once instead of request from certificate authority every time and it is the server sends the certificate to client not the certificate authority.
 
-Some people may ask if Alice want to verify the validity of the certificate, he must have the public key of the authority.Isn't it the dead cycle mentioned just now? 
+Some people may ask if Alice want to verify the validity of the certificate, he must have the public key of the authority.Isn't it the dead cycle mentioned just now?
 
 The regular browser we pre-installed contains trusted certificate to verity the identity of certificate authority,so the certificate is credible.
 
@@ -158,7 +161,7 @@ Except for the trusted public key of Bob, the communication of Alice and Bob is
 
 Most of the regular websites nowadays apply HTTPS protocol, that adds a SSL/TLS secure layer between the HTTP protocol and the TCP protocol. After the TCP handshake, SSL protocol layer also handshake to exchange secure information including the certificate of the website, so that the browser can verify the website. After SSL layer finish the verification, the data in the HTTP protocol is encrypted to guarantee secure transmission.
 
-### Sixth、Summary
+## Sixth, Summary
 
 Symmetric encryption algorithm use the same secret key to encrypt and decrypt, is hard to crack, encrypt quickly, but has the problem of secret key transmission.
 
@@ -174,4 +177,3 @@ The public-key certificate is the public key plus the signature,issued by a trus
 The SSL/TLS secure layer in HTTPS protocol includes these encryption methods above.**So do not install irregular browser and certificate of unknown source**.
 
 Cryptography is a little part of the security.Even though the HTTPS websites certified by a formal authority are not totally trusted,it only indicates the transition of the data is safe.Technology can not protect you.The most important thing is to improve personal safety awareness,pay more attention and handle sensitive data carefully.
-

common_knowledge/SessionAndCookie.md

@@ -6,7 +6,7 @@
 
 Everyone should be familiar with cookies. For example after logging on the website, you will be asked to log in again. Or some guys play with python, but websites just block your crawlers. These are all related to cookies. If you understand the server backend's processing logic for cookies and sessions, you can explain these phenomena, and even drill some holes indefinitely, let me talk it slowly.
 
-### 1.Introduction to session and cookie
+## 1.Introduction to session and cookie
 
 The emergence of cookie because HTTP is a stateless protocol, In other words, the server can't remember you, and every time you refresh the web page, you have to re-enter your account password to log in. It's hard to accept. Cookie is like the server tagged you, and the server recognizes you every time you make a request to the server.
 
@@ -18,18 +18,18 @@ Cookie can be set on the sever through the “SetCookie” field of HTTP, such a
 
 ```go
 func cookie(w http.ResponseWriter, r *http.Request) {
-    // 设置了两个 cookie 
-	http.SetCookie(w, &http.Cookie{
-		Name:       "name1",
-		Value:      "value1",
-	})
-
-	http.SetCookie(w, &http.Cookie{
-		Name:  "name2",
-		Value: "value2",
-	})
-    // 将字符串写入网页
-	fmt.Fprintln(w, "页面内容")
+    // Set up two cookies
+ http.SetCookie(w, &http.Cookie{
+  Name:       "name1",
+  Value:      "value1",
+ })
+
+ http.SetCookie(w, &http.Cookie{
+  Name:  "name2",
+  Value: "value2",
+ })
+    // Write string back
+ fmt.Fprintln(w, "content")
 }
 ```
 
@@ -65,25 +65,24 @@ This type of plugin can read the browser's cookies on the current web page, open
 
 The above is a brief introduction to cookies and sessions. Cookie is a part of the HTTP protocol and are not complicated. So let's take a look at the code architecture to implement session management in detail.
 
-### 2.Implementation of session
+## 2.Implementation of session
 
 The principle of session is not difficult, but it is very skillful to implement it. Generally, three components are required to complete it. They respectively are`Manager`,`Provider` and  `Session` three classes (interface).
 
 ![](../pictures/session/4.jpg)
 
-1.The browser requests the page resource of the path `/content` rom the server over the HTTP protocol, there is a Handler function on the corresponding path to receive the request, parses the cookie in the HTTP header, and gets the session ID stored in it,then send this ID to the  `Manager`.
+1. The browser requests the page resource of the path `/content` rom the server over the HTTP protocol, there is a Handler function on the corresponding path to receive the request, parses the cookie in the HTTP header, and gets the session ID stored in it,then send this ID to the  `Manager`.
 
-2.`Manager`acts as a session manager, mainly storing some configuration information, such as the lifetime of the session, the name of the cookie, and so on. All sessions are stored in a `Provider` inside the `Manager`.So `Manager` passes the `Sid` (session ID) to the `Provider` to find out which session that ID corresponds to. 
+2. `Manager`acts as a session manager, mainly storing some configuration information, such as the lifetime of the session, the name of the cookie, and so on. All sessions are stored in a `Provider` inside the `Manager`.So `Manager` passes the `Sid` (session ID) to the `Provider` to find out which session that ID corresponds to.
 
-3.`Provider` is a container, most commonly a hash table that maps each `Sid` to its session. After receiving the `Sid` passed by the `Manager`, it finds the session structure corresponding to the `Sid`, which is the session structure, and returns it.
+3. `Provider` is a container, most commonly a hash table that maps each `Sid` to its session. After receiving the `Sid` passed by the `Manager`, it finds the session structure corresponding to the `Sid`, which is the session structure, and returns it.
 
-4.`Session` stores the user's specific information. The logic in the Handler function takes out this information, generates the user's HTML page, and returns it to the client.
+4. `Session` stores the user's specific information. The logic in the Handler function takes out this information, generates the user's HTML page, and returns it to the client.
 
 So you might ask, why make such a trouble, why not directly in the Handler function to get a hash table, and then store the `Sid` and `Session` structure mapping ?
 
 **That's the design trick!** Let's talk about why it is divided into `Manager`、`Provider` and  `Session`。
 
-
 Let's start with `Session` at the bottom. Since session is a key-value pair, why not use a hash table directly, but abstract such a data structure?
 
 First, because the `Session` structure may not only store a hash table, but also some auxiliary data, such as `Sid`, number of accesses, expiration time, or last access time, which is easy to implement algorithms like LRU and LFU.
@@ -94,12 +93,12 @@ Therefore, `Session` structure provides a layer of abstraction to shield the dif
 
 ```go
 type Session interface {
-    // 设置键值对
+    // Set key-value pairs
     Set(key, val interface{})
-    // 获取 key 对应的值
+    // Get the value by key
     Get(key interface{}) interface{}
-    // 删除键 key
-	Delete(key interface{})
+    // Remove key
+ Delete(key interface{})
 }
 ```
 
@@ -111,25 +110,23 @@ Therefore, `Provider` as a container is to shield algorithm details and organize
 
 ```go
 type Provider interface {
-    // 新增并返回一个 session
+    // Add and return session
     SessionCreate(sid string) (Session, error)
-    // 删除一个 session
+    // Delete a session
     SessionDestroy(sid string)
-    // 查找一个 session
+    // Read a session
     SessionRead(sid string) (Session, error)
-    // 修改一个session
+    // Update a session
     SessionUpdate(sid string)
-    // 通过类似 LRU 的算法回收过期的 session
-	SessionGC(maxLifeTime int64)
+    // Recycle expired sessions through an algorithm similar to LRU
+ SessionGC(maxLifeTime int64)
 }
 ```
 
-
 Finally, `Manager`, most of the specific work is delegated to `Session` and the `Provider`, `Manager` is mainly a set of parameters, such as the survival time of the session, the strategy to clean up expired sessions, and the session's available storage methods. `Manager` blocks the specific details of the operation, and we can flexibly configure the session mechanism through `Manager`.
 
 In summary, the main reason for the session mechanism to be divided into several parts is decoupling and customization. I have seen several use Go to implement session services on Github, the source code is very simple, if you are interested you can learn：
 
-https://github.com/alexedwards/scs
-
-https://github.com/astaxie/build-web-application-with-golang
+<https://github.com/alexedwards/scs>
 
+<https://github.com/astaxie/build-web-application-with-golang>