diff --git a/.github/workflows/cos.yaml b/.github/workflows/cos.yaml
index fe5dd1b..282e6e6 100644
--- a/.github/workflows/cos.yaml
+++ b/.github/workflows/cos.yaml
@@ -7,6 +7,7 @@ on:
 
 jobs:
   build:
+    if: github.repository == 'camera-2018/hdu-cs-wiki'
     runs-on: ubuntu-latest
         
     steps:
diff --git a/.github/workflows/link-pr.yaml b/.github/workflows/link-pr.yaml
index 54efb3e..eb4a288 100644
--- a/.github/workflows/link-pr.yaml
+++ b/.github/workflows/link-pr.yaml
@@ -30,11 +30,13 @@ jobs:
           # -i, --insecure               Proceed for server connections considered insecure (invalid TLS)
           # -n, --no-progress            Do not show progress bar.
           # -t, --timeout <timeout>      Website timeout in seconds from connect to response finished [default:20]
-          # --max-concurrency <max-concurrency>    Maximum number of concurrent network requests [default: 128]
-          # -a --accept <accept>                      Comma-separated list of accepted status codes for valid links
-
-          # .vitepress/dist the site directory to check
+          # --max-concurrency <max-concurrency>      Maximum number of concurrent network requests [default: 128]
+          # -a --accept <accept>                     Comma-separated list of accepted status codes for valid links
+          # --max-retries <MAX_RETRIES>              Maximum number of retries per request
+          # -r, --retry-wait-time <RETRY_WAIT_TIME>  Minimum wait time in seconds between retries of failed requests
+          # -u, --user-agent <USER_AGENT>            User agent
           # *.md all markdown files in the root directory
-        args: -E -i -n -t 45 --max-concurrency 64 -a 401,403 -- '.vitepress/dist' '*.md'
+        args: -E -i -n -t 45 -r 3 --max-retries 5 --max-concurrency 64 -a 401,403 -u "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36" -- '.vitepress/dist' '*.md'
+        
       env:
         GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
diff --git a/.github/workflows/link-schedule.yaml b/.github/workflows/link-schedule.yaml
index ea6cabd..b2c25f5 100644
--- a/.github/workflows/link-schedule.yaml
+++ b/.github/workflows/link-schedule.yaml
@@ -1,10 +1,13 @@
-name: links
+name: links schedule
 
 on:
   # repository_dispatch:
   workflow_dispatch:
   schedule:
-    - cron: "30 8 * * *"
+    - cron: "0 0 */3 * *"
+
+permissions:
+  issues: write
 
 jobs:
   linkChecker:
@@ -28,18 +31,19 @@ jobs:
           # -i, --insecure               Proceed for server connections considered insecure (invalid TLS)
           # -n, --no-progress            Do not show progress bar.
           # -t, --timeout <timeout>      Website timeout in seconds from connect to response finished [default:20]
-          # --max-concurrency <max-concurrency>    Maximum number of concurrent network requests [default: 128]
-          # -a --accept <accept>                      Comma-separated list of accepted status codes for valid links
-
-          # .vitepress/dist the site directory to check
-        # *.md all markdown files in the root directory
-        args: -E -i -n -t 45 --max-concurrency 64 -a 401,403 -- '.vitepress/dist' '*.md'
+          # --max-concurrency <max-concurrency>      Maximum number of concurrent network requests [default: 128]
+          # -a --accept <accept>                     Comma-separated list of accepted status codes for valid links
+          # --max-retries <MAX_RETRIES>              Maximum number of retries per request
+          # -r, --retry-wait-time <RETRY_WAIT_TIME>  Minimum wait time in seconds between retries of failed requests
+          # -u, --user-agent <USER_AGENT>            User agent
+          # *.md all markdown files in the root directory
+        args: -E -i -n -t 45 -r 3 --max-retries 5 --max-concurrency 64 -a 401,403 -u "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36" -- '.vitepress/dist' '*.md'
         output: out.md
       env:
         GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: Create Issue From File
-      uses: peter-evans/create-issue-from-file@v3
+      uses: peter-evans/create-issue-from-file@v4
       with:
         title: Broken Link Detected
         content-filepath: out.md
-        assignees: nightwhite
+        assignees: camera-2018
diff --git a/.lycheeignore b/.lycheeignore
index e483565..ba2d947 100644
--- a/.lycheeignore
+++ b/.lycheeignore
@@ -1,2 +1,9 @@
 hdu-cs-wiki/edit
 file://
+https://adworld.xctf.org.cn/challenges/list
+https://e5c78mnhgz.feishu.cn/docx/doxcnxBONvnxSLi0MfaNZWvrcSb
+https://datawhale.feishu.cn/docs/doccn0AOicI3LJ8RwhY0cuDPSOc#
+https://message.hdu-cs.wiki/
+https://adworld.xctf.org.cn/
+http://sequence-gallery.chal.crewc.tf:8080/
+https://www.csie.ntu.edu.tw/~b97053/paper/Rendle2010FM.pdf
\ No newline at end of file
diff --git a/.vitepress/components/CustomSwitchAppearance.vue b/.vitepress/components/CustomSwitchAppearance.vue
new file mode 100644
index 0000000..55c7673
--- /dev/null
+++ b/.vitepress/components/CustomSwitchAppearance.vue
@@ -0,0 +1,183 @@
+<script lang="ts" setup>
+import { ref, onMounted, watch } from 'vue'
+import { useData } from 'vitepress/dist/client/theme-default/composables/data'
+import { APPEARANCE_KEY } from 'vitepress/dist/client/shared'
+import VPSwitch from 'vitepress/dist/client/theme-default/components/VPSwitch.vue'
+import VPIconSun from 'vitepress/dist/client/theme-default/components/icons/VPIconSun.vue'
+import VPIconMoon from 'vitepress/dist/client/theme-default/components/icons/VPIconMoon.vue'
+
+const { site, isDark } = useData()
+const checked = ref(false)
+const toggle = typeof localStorage !== 'undefined' ? useAppearance() : () => {}
+
+onMounted(() => {
+  checked.value = document.documentElement.classList.contains('dark')
+})
+
+// @ts-expect-error: Transition API
+const isAppearanceTransition = document.startViewTransition &&
+  !window.matchMedia(`(prefers-reduced-motion: reduce)`).matches 
+
+function useAppearance() {
+  const query = window.matchMedia('(prefers-color-scheme: dark)')
+  const classList = document.documentElement.classList
+
+  let userPreference = localStorage.getItem(APPEARANCE_KEY)
+
+  let isDark =
+    (site.value.appearance === 'dark' && userPreference == null) ||
+    (userPreference === 'auto' || userPreference == null
+      ? query.matches
+      : userPreference === 'dark')
+
+  query.onchange = (e) => {
+    if (userPreference === 'auto') {
+      setClass((isDark = e.matches))
+    }
+  }
+
+  function toggle(event: MouseEvent) {
+    if (!isAppearanceTransition) {
+      setClass((isDark = !isDark))
+
+      userPreference = isDark
+        ? query.matches ? 'auto' : 'dark'
+        : query.matches ? 'light' : 'auto'
+
+      localStorage.setItem(APPEARANCE_KEY, userPreference)
+
+      return
+    }
+
+    const x = event.clientX
+    const y = event.clientY
+    const endRadius = Math.hypot(
+      Math.max(x, innerWidth - x),
+      Math.max(y, innerHeight - y),
+    )
+
+    // @ts-expect-error: Transition API
+    const transition = document.startViewTransition(() => {
+      setClass((isDark = !isDark))
+
+      userPreference = isDark
+        ? query.matches ? 'auto' : 'dark'
+        : query.matches ? 'light' : 'auto'
+
+      localStorage.setItem(APPEARANCE_KEY, userPreference)
+    })
+
+    transition.ready.then(() => {
+      const clipPath = [
+        `circle(0px at ${x}px ${y}px)`,
+        `circle(${endRadius}px at ${x}px ${y}px)`,
+      ]
+
+      document.documentElement.animate(
+        {
+          clipPath: isDark ? clipPath : [...clipPath].reverse(),
+        },
+        {
+          duration: 300,
+          easing: 'ease-in',
+          pseudoElement: isDark ? '::view-transition-new(root)' : '::view-transition-old(root)',
+        },
+      )
+    })
+  }
+
+  function setClass(dark: boolean): void {
+    const css = document.createElement('style')
+    css.type = 'text/css'
+    css.appendChild(
+      document.createTextNode(
+        `:not(.VPSwitchAppearance):not(.VPSwitchAppearance *) {
+  -webkit-transition: none !important;
+  -moz-transition: none !important;
+  -o-transition: none !important;
+  -ms-transition: none !important;
+  transition: none !important;
+}`
+      )
+    )
+    document.head.appendChild(css)
+
+    checked.value = dark
+    classList[dark ? 'add' : 'remove']('dark')
+
+    const _ = window.getComputedStyle(css).opacity
+    document.head.removeChild(css)
+  }
+
+  return toggle
+}
+
+watch(checked, (newIsDark) => {
+  isDark.value = newIsDark
+})
+</script>
+
+<template>
+  <label title="toggle dark mode">
+    <VPSwitch
+      class="VPSwitchAppearance"
+      :class="{ 'VPSwitchAppearanceTransition': isAppearanceTransition }"
+      :aria-checked="checked"
+      @click="toggle"
+    >
+      <VPIconSun class="sun" />
+      <VPIconMoon class="moon" />
+    </VPSwitch>
+  </label>
+</template>
+
+<style scoped>
+.sun {
+  opacity: 1;
+}
+
+.moon {
+  opacity: 0;
+}
+
+.dark .sun {
+  opacity: 0;
+}
+
+.dark .moon {
+  opacity: 1;
+}
+
+.VPSwitchAppearance.VPSwitchAppearanceTransition {
+  width: 22px;
+}
+
+.dark .VPSwitchAppearance:not(.VPSwitchAppearanceTransition) :deep(.check) {
+  /*rtl:ignore*/
+  transform: translateX(18px);
+}
+</style>
+
+<style>
+::view-transition-old(root),
+::view-transition-new(root) {
+  animation: none;
+  mix-blend-mode: normal;
+}
+
+::view-transition-old(root) {
+  z-index: 9999;
+}
+
+::view-transition-new(root) {
+  z-index: 1;
+}
+
+.dark::view-transition-old(root) {
+  z-index: 1;
+}
+
+.dark::view-transition-new(root) {
+  z-index: 9999;
+}
+</style>
\ No newline at end of file
diff --git a/.vitepress/config.js b/.vitepress/config.js
index 03b383b..e71f13f 100644
--- a/.vitepress/config.js
+++ b/.vitepress/config.js
@@ -1,9 +1,15 @@
 // import { defineConfig } from 'vitepress'
 import { withMermaid } from "vitepress-plugin-mermaid";
 import mathjax3 from 'markdown-it-mathjax3';
-import { main_sidebar, chapter2, chapter3, chapter4, chapter5, chapter6, chapter7, chapter8 } from './sidebar.js';
+import { main_sidebar, chapter2, chapter3, chapter4, chapter5, chapter6, chapter7, chapter8, chapter9 } from './sidebar.js';
 import { nav } from './nav.js';
 import PanguPlugin from 'markdown-it-pangu'
+import { createWriteStream } from 'node:fs'
+import { resolve } from 'node:path'
+import { SitemapStream } from 'sitemap'
+import { fileURLToPath, URL } from 'node:url'
+
+const links = []
 
 const customElements = [
   'mjx-container',
@@ -115,7 +121,9 @@ export default withMermaid({
       '/6.计算机安全/': chapter6(),
       '/7.网络应用开发/': chapter7(),
       '/8.基础学科/': chapter8(),
+      '/9.计算机网络/': chapter9(),
     },
+    outline: [2, 6],
     socialLinks: [
       { icon: 'github', link: 'https://github.com/camera-2018/hdu-cs-wiki' }
     ],
@@ -150,5 +158,35 @@ export default withMermaid({
       },
     },
   },
+  transformHtml: (_, id, { pageData }) => {
+    if (!/[\\/]404\.html$/.test(id))
+      links.push({
+        // you might need to change this if not using clean urls mode
+        url: pageData.relativePath.replace(/((^|\/)index)?\.md$/, '$2'),
+        lastmod: pageData.lastUpdated
+      })
+  },
+  buildEnd: async ({ outDir }) => {
+    const sitemap = new SitemapStream({
+      hostname: 'https://hdu-cs.wiki/'
+    })
+    const writeStream = createWriteStream(resolve(outDir, 'sitemap.xml'))
+    sitemap.pipe(writeStream)
+    links.forEach((link) => sitemap.write(link))
+    sitemap.end()
+    await new Promise((r) => writeStream.on('finish', r))
+  },
+  vite: {
+    resolve: {
+      alias: [
+        {
+          find: /^.*\/VPSwitchAppearance\.vue$/,
+          replacement: fileURLToPath(
+            new URL('./components/CustomSwitchAppearance.vue', import.meta.url)
+          )
+        }
+      ]
+    }
+  }
 })
 
diff --git a/.vitepress/nav.js b/.vitepress/nav.js
index 2775ef7..10a4204 100644
--- a/.vitepress/nav.js
+++ b/.vitepress/nav.js
@@ -12,8 +12,10 @@ export function nav() {
           { text: '6.计算机安全', link: '/6.计算机安全/6.计算机安全' },
           { text: '7.网络应用开发', link: '/7.网络应用开发/7.网络应用开发入门' },
           { text: '8.基础学科', link: '/8.基础学科/8.基础学科' },
+          { text: '9.计算机网络', link: '9.计算机网络/9.计算机网络' },
         ]
     },
+    { text: '博客', link: '/blog/' },
     { text: 'Wiki史', link: '/wiki史' },
     {
       text: '友链', items:
diff --git a/.vitepress/sidebar.js b/.vitepress/sidebar.js
index 847fc95..fe71d60 100644
--- a/.vitepress/sidebar.js
+++ b/.vitepress/sidebar.js
@@ -23,8 +23,7 @@ export function main_sidebar() {
         { text: '1.9问题专题：好想进入实验室', link: '/1.杭电生存指南/1.9问题专题：好想进入实验室' },
         { text: '1.10如何读论文', link: '/1.杭电生存指南/1.10如何读论文' },
         { text: '1.11陷入虚无主义？进来看看吧', link: '/1.杭电生存指南/1.11陷入虚无主义？进来看看吧' },
-        { text: '1.12程序员如何活久一点', link: '/1.杭电生存指南/1.12程序员如何活久一点' },
-        { text: '1.13选课原则与抢课技巧', link: '/1.杭电生存指南/1.13选课原则与抢课技巧' },
+        { text: '1.12选课原则与抢课技巧', link: '/1.杭电生存指南/1.12选课原则与抢课技巧' },
       ]
     },
     {
@@ -68,6 +67,11 @@ export function main_sidebar() {
       collapsed: true,
       items: [{ text: "8.基础学科", link: "/8.基础学科/8.基础学科" }]
     },
+    {
+      text: "9.计算机网络",
+      collapsed: true,
+      items: [{ text: "9.计算机网络", link: "/9.计算机网络/9.计算机网络" }]
+    },
     {
       text: 'Contributors',
       link: '/contributors'
@@ -220,7 +224,8 @@ export function chapter3() {
                 { text: '3.6.4.5阶段五：迭代生成', link: '/3.编程思维体系构建/3.6.4.5阶段五：迭代生成' },
                 { text: '3.6.4.6结语', link: '/3.编程思维体系构建/3.6.4.6结语' },
               ]
-            }
+            },
+            {text: '3.6.5CS61A食用指南',link: '/3.编程思维体系构建/3.6.5CS61A食用指南'}
           ]
         },
         { text: '3.X 聊聊设计模式和程序设计', link: '/3.编程思维体系构建/3.X 聊聊设计模式和程序设计' },
@@ -420,7 +425,8 @@ export function chapter4() {
         { text: '4.9如何做研究', link: '/4.人工智能/4.9如何做研究' },
         { text: '4.10科研论文写作', link: '/4.人工智能/4.10科研论文写作' },
         { text: '4.11从 AI 到 智能系统 —— 从 LLMs 到 Agents', link: '/4.人工智能/4.11从 AI 到 智能系统 —— 从 LLMs 到 Agents' },
-        { text: '4.12本章节内容的局限性', link: '/4.人工智能/4.12本章节内容的局限性' },
+        { text: '4.12LLM Agent之结构化输出', link: '/4.人工智能/4.12LLMAgent之结构化输出' },
+        { text: '4.13本章节内容的局限性', link: '/4.人工智能/4.13本章节内容的局限性' },
         { text: 'SRT社团介绍', link: '/4.人工智能/SRT' },
         {
           text: 'FunRec',
@@ -579,6 +585,7 @@ export function chapter6() {
         },
         { text: '6.3密码学', link: '/6.计算机安全/6.3密码学' },
         { text: '6.4安全杂项', link: '/6.计算机安全/6.4安全杂项' },
+        { text: '6.5学习资料推荐', link: '/6.计算机安全/6.5学习资料推荐' },
       ]
     },
   ]
@@ -637,4 +644,17 @@ export function chapter8() {
       ]
     }
   ]
-}
\ No newline at end of file
+}
+
+export function chapter9() {
+  return [
+    { text: '返回上一层', link: '/简介' },
+    {
+      text: '9.计算机网络',
+      collapsed: false,
+      items: [
+        { text: '9.计算机网络', link: '/9.计算机网络/9.计算机网络' },
+      ]
+    }
+  ]
+}
diff --git a/.vitepress/theme/font/NotoSansMono-Regular.ttf b/.vitepress/theme/font/NotoSansMono-Regular.ttf
new file mode 100644
index 0000000..b7615d8
Binary files /dev/null and b/.vitepress/theme/font/NotoSansMono-Regular.ttf differ
diff --git a/.vitepress/theme/font/NotoSansSC-Bold.otf b/.vitepress/theme/font/NotoSansSC-Bold.otf
new file mode 100644
index 0000000..172eb67
Binary files /dev/null and b/.vitepress/theme/font/NotoSansSC-Bold.otf differ
diff --git a/.vitepress/theme/font/NotoSansSC-Regular.otf b/.vitepress/theme/font/NotoSansSC-Regular.otf
new file mode 100644
index 0000000..d350ffa
Binary files /dev/null and b/.vitepress/theme/font/NotoSansSC-Regular.otf differ
diff --git a/.vitepress/theme/style.css b/.vitepress/theme/style.css
index 87ef58a..8f67acb 100644
--- a/.vitepress/theme/style.css
+++ b/.vitepress/theme/style.css
@@ -2,11 +2,21 @@
  * Customize default theme styling by overriding CSS variables:
  * https://github.com/vuejs/vitepress/blob/main/src/client/theme-default/styles/vars.css
  */
-@import url('https://fonts.loli.net/css2?family=Noto+Color+Emoji&family=Noto+Sans+Mono:wght@400;500;600;700&family=Noto+Sans+SC:wght@400;500;700&display=swap');
 /**
  * Colors
  * -------------------------------------------------------------------------- */
 
+@import url('https://fonts.loli.net/css2?family=Noto+Sans+Mono:wght@400&family=Noto+Sans+SC:wght@400;500;700&display=swap');
+
+@font-face {
+  font-family: 'Noto Color Emoji';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://gstatic.loli.net/s/notocoloremoji/v25/Yq6P-KqIXTD0t4D9z1ESnKM3-HpFabsE4tq3luCC7p-aXxcn.9.woff2) format('woff2');
+  unicode-range: U+200d, U+261d, U+2620, U+2639-263a, U+2665, U+270a-270d, U+2728, U+2763-2764, U+2b50, U+fe0f, U+1f31a-1f31f, U+1f32b, U+1f383, U+1f389, U+1f3fb-1f3ff, U+1f440-1f450, U+1f463-1f465, U+1f479-1f47b, U+1f47d-1f480, U+1f485, U+1f48b-1f48c, U+1f493-1f49f, U+1f4a4-1f4a6, U+1f4a8-1f4ab, U+1f4af, U+1f525, U+1f573, U+1f590, U+1f595-1f596, U+1f5a4, U+1f5e3, U+1f600-1f644, U+1f648-1f64a, U+1f64c, U+1f64f, U+1f90c-1f925, U+1f927-1f92f, U+1f932-1f933, U+1f970-1f976, U+1f978-1f97a, U+1f9a0, U+1f9b4-1f9b7, U+1f9bb, U+1f9be-1f9bf, U+1f9d0, U+1f9e0-1f9e1, U+1fa75-1fa79, U+1fac0-1fac2, U+1fae0-1fae6, U+1fae8, U+1faf0-1faf8;
+}
+
 .dark .vp-doc a,#loading, .dark .vp-doc a>code, .dark .VPNavBarMenuLink.VPNavBarMenuLink:hover, .dark .VPNavBarMenuLink.VPNavBarMenuLink.active, .dark .link.link:hover, .dark .link.link.active, .dark .edit-link-button.edit-link-button, .dark .pager-link .title {
   color: var(--vp-c-brand-lighter);
 }
@@ -25,14 +35,6 @@
   --vp-font-family-base: 'Noto Sans SC', 'Noto Color Emoji', sans-serif;
   --vp-font-family-mono: 'Noto Sans Mono', sans-serif, monospace, consolas;
 }
-/**
- * 这个版本可能有 bug，build 后字体变不了还为 consolas 可能是我自己配的有问题 可能是这个版本拉了 总之就加个临时的
- * -------------------------------------------------------------------------- */
-code { 
-  font-family: 'Noto Sans Mono', sans-serif, monospace, consolas !important;
-  font-weight: 400 !important;
-  font-size: 14px !important;
-}
 
 /**
  * Component: Button
diff --git a/1.杭电生存指南/1.12程序员如何活久一点.md b/1.杭电生存指南/1.12程序员如何活久一点.md
deleted file mode 100644
index 2bbbdcf..0000000
--- a/1.杭电生存指南/1.12程序员如何活久一点.md
+++ /dev/null
@@ -1,41 +0,0 @@
-# 程序员如何活久一点
-### 1. 术语
-
-* ACM: All-Cause Mortality / 全因死亡率
-
-### 2. 目标
-
-* 稳健地活得更久
-
-### 3. 关键结果
-
-* 降低66.67%全因死亡率
-* 增加\~20年预期寿命
-* ~~维持多巴胺于中轴~~
-
-### 4. 分析
-
-* 主要参考：对ACM的学术文献相对较多，可以作为主要参考
-* 增加寿命与ACM关系非线性：显然增加寿命与ACM关系是非线性函数，这里假设 `DeltaLifeSpan=(1/(1+DeltaACM)-1)*10`（DeltaACM为ACM变化值；公式欢迎优化）
-* 变量无法简单叠加：显然各个变量之间并不符合独立同分布假设，变量之间的实际影响也并不明确
-* 存在矛盾观点：所有的证据都有文献/研究对应，但注意到：有些文献之间有显著矛盾的观点（如对于碳水摄入比例的矛盾）；有些文献存在较大争议（如认为22点前睡觉会提升43%全因死亡率）
-* 研究仅表达相关：所有文献表明的更多是相关而非因果，在阅读时要考虑文献是否充分证明了因果 —— 如某文献表明了日均>=7000步的人有显著低的全因死亡率。但步数少的人可能包含更多长期病患，如果没有合理的排除这块数据，那此文献调查失真
-
-### 5. 行动
-
-* 输入
-  * 固体：吃白肉（-11%\~-3% ACM）、蔬果为主（-26%\~-17% ACM），多吃辣（-23% ACM），多吃坚果（-27%\~-4% ACM），*少吃蛋黄（否则+7% ACM/0.5颗/天）（存在争议）*，中量碳水、多吃植物蛋白（-10% ACM），少吃超加工食物（-62%\~-18%）
-  * 液体：喝咖啡（-22%\~-12% ACM），喝牛奶（-17%\~-10% ACM），喝茶（-15%\~-8% ACM），少喝或不喝甜味饮料（否则每天一杯+7% ACM，+多巴胺），戒酒或每周100g（纯酒精量(g)=饮酒量(ml)×酒精浓度(%)×酒精密度0.8g/ml）内（否则+\~50% ACM，无上限）
-  * 气体：不吸烟（否则+~50% ACM，-12\~-11年寿命）
-  * 光照：晒太阳（-~40% ACM）
-  * 药物：二甲双胍（糖尿病人相比正常人可以+3年）、复合维生素（-8%癌症风险）、亚精胺（-60%\~-30% ACM）、葡萄糖胺（-39% ACM）
-* 输出
-  * 运动：每周3次45分钟挥拍运动（-47% ACM）
-  * 日常：刷牙（-25% ACM）
-  * 睡眠：每天睡7小时全因死亡率最低；且22-24点间最好，*早睡+43% ACM，晚睡+15% ACM（存在争议）*
-* 上下文
-  * 体重：减肥（-54% ACM）
-
-::: tip 🧑‍🍳
-全文 [程序员延寿指南 | A programmer's guide to live longer](https://github.com/geekan/HowToLiveLonger)
-:::
diff --git a/1.杭电生存指南/1.13选课原则与抢课技巧.md b/1.杭电生存指南/1.12选课原则与抢课技巧.md
similarity index 98%
rename from 1.杭电生存指南/1.13选课原则与抢课技巧.md
rename to 1.杭电生存指南/1.12选课原则与抢课技巧.md
index 969c6fb..8c4719c 100644
--- a/1.杭电生存指南/1.13选课原则与抢课技巧.md
+++ b/1.杭电生存指南/1.12选课原则与抢课技巧.md
@@ -3,22 +3,30 @@
 > author: ek1ng
 > 
 > 本文编写自2021.07.31，也许有些内容已经过时，请选择性参考。
-
 ## 选课原则
+
 ### 要选哪些课
+
 在杭电，学生必须修读完培养计划上所有的课程才能够毕业，因此选课遵循的唯一纲要便是培养计划，一切以培养计划上的要求为准，体育课、通识必修课、通识选修课、专业选修课、专业必修课等等，请注意任何选课尽可能请以培养计划的课程代码为准，若课程代码不同则需要通过课程替代等方式。
+
 ### 为什么要选课
+
 选课其实是选老师，而选择的选课老师的背后则是课程考核方式、给分高低、成绩占比、课堂签到情况等等。选择正确的老师能够使课堂更加符合你的预期，不论是教学质量还是教学方式亦或期末分数上。
 
 在讨论之前，必须声明一些学校课程的基本要求，例如学校要求老师采取易班点名的方式，所以除了某些老师以外大多数老师都会采取不定次数的课堂点名以及点教室人头的方式作为考核考勤情况的方式。
+
 ### 学校开什么课
+
 学校开展体育课（大一大二4学期分别修读不同类别的体育课程4次）、通识选修课 ~~（通常各专业需要修读人文类、国际类、科技类学分4、4、2个）~~
 :::warning
 2023年更新：现在是国际类、人文类、艺术类、科技类学分4、2、2、2个（不管怎么变应该加起来都是10分）
 :::
+
 ### 选什么课好
 在杭电换客群或者与认识的室友、同学、朋友等等交流开展某课程的某老师教学情况，打听情报以选择合适的老师。此处的情报通常指老师的教学方式如何，采取怎样的签到方式等等。如果曾经上过某老师开展的a课程，那么通常对于他开展的b课程，签到情况和给分情况都仍然能够适用，但是教学情况则未必。
+
 ### 常见问题Q&A
+
 Q1:我该如何安排我这一学期的课程？
 
 A1:尽可能按照培养计划给出的每学期修读建议修读，适当先在大一、大二修读通识选修、体育课以及适量的专业必修专业选修，在大三修读更多的专业课程。当然如果完全打乱培养计划在杭电也是完全允许的，你完全可以在大一、大二修读大三的课程，在大三修读大一的课程，这么做的意义也许是你希望通过修读课程顺序的改变来调整你个人的时间安排，不论如何这是符合学校规章制度的操作，只要你想你就可以这么做。
@@ -27,7 +35,7 @@ Q2:选课所谓第一轮选课第二轮选课到底是如何进行的？
 
 A2:第一轮选课可以选择的课为体育课、通识选修课（英语拓展课、大学军事、公选课都包括在内）、推荐课表上的课程。第二轮选课可以跨年级跨学院跨专业选课，只要能搜到的课都是可以上的，不过请注意，思修近代史毛概马原形策等课程并不能提前修读。第二轮选课通常进行到开学后3周，在开学前3周，可以通过签课的方式即在授课老师、学院的批准通过下选上自己没有抢到的课，理论上任何课（需要注意公选课、体育课一般无法签课，老师是否同意签课通常看老师的个人情况，学院通常会在老师批准的情况下通过批准）只要经过批准都可以签课成功后出现在课表上。请注意，学分上限为32.5（不包括暑假短学期课程），转专业后学分上限自动扩为40，若非转专业学生可以在绩点3.0以上的情况下开学前3周内提出扩学分请求。
 :::warning
-2023年更新：学分上限好像变高了，但我忘了是多少🤡
+Update: 新系统学分上限为36，扩学分后上限为40。
 :::
 
 Q3：大一上如何选课？
@@ -35,20 +43,29 @@ Q3：大一上如何选课？
 A3：大一上选课的安排在最后时间段，体育被默认选了太极拳，并选不到“好”的公选课专业课等等，不太建议选很多课，选一门新生研讨课或者推荐不选课。
 
 ## 抢课技巧
+
 ### 选课背景
+
 2021年上学期的选课中，杭电更换了正方全新的选课平台http://newjw.hdu.edu.cn ，目前选课平台的特性为，在选课时间内开放至公网ip可以访问，可以并发请求，~~并不会网页卡崩~~，抢课全靠手速。
+
 :::tip
 1. 鉴于杭电复杂的网络环境，在**内网**抢课甚至不如**公网**😅，所以建议在寝室里连上网线（公网）抢课。
 
 2. **网页会卡崩**，刚开始选课0~5分钟系统会未响应甚至将你踢出登录，还会让你浏览器爆掉显示 *欧呦，崩溃啦* 之类的字样，一切听天由命。
 :::
+
 ## 具体技巧
+
 #### 系统开放前
+
 通常系统开放前可以查询开课情况，那么可以根据开课情况自己提前规划安排想上的课程。
+
 #### 系统开放时
 
 ##### 第一轮选课、第二轮选课开放系统时
+
 提前在粘贴板中剪切/复制第一手要抢的课程，并且在选课平台开放时间前几秒，不停点击刷新，直至选课平台显示的内容不为非选课时间而是可以搜索，粘贴课程名并且点击抢课即可第一手抢到最想抢的课程，再依次抢接下来准备上的课。若课表上已经被系统默认选的课占了想要选的课的位置，那么就需要先退课再选课。
 
 ##### 假期以及开学前三周
+
 这时候会有同学因为不想选某门课程或者通过将课卡在其他人号上想在假期“转移”到自己号上，选课系统中的课程余量就会时不时出现波动，此时可以上去系统看看说不定能捡漏哦。签课以及扩学分在开学前三周进行，请关注学校通知并且通过签课选上自己没能选上的课程。
diff --git a/1.杭电生存指南/1.2竞赛指北.md b/1.杭电生存指南/1.2竞赛指北.md
index fdf35a6..65ed499 100644
--- a/1.杭电生存指南/1.2竞赛指北.md
+++ b/1.杭电生存指南/1.2竞赛指北.md
@@ -1,8 +1,6 @@
 # 竞赛指北
 
-> 本部分带有强烈主观色彩，仅为笔者作为技术人员参（陪）与（跑）过一年半的竞赛（如新苗、大创、互联网+、服务外包、电商、大小挑等含文本元素的竞赛）的感想。仅供参考。如有其他看法，欢迎留言。
-
-# 竞赛可以带来什么
+## 竞赛可以带来什么
 
 “哪个比赛更有含金量” 的问题应该是很多同学会关心的，然而比赛对人的帮助是因人而异的。比起列一个所谓的比赛含金量排名，笔者认为认清自己想要的是什么，再去评判比赛含金量才是有意义的。
 
@@ -16,17 +14,20 @@
 
 - 如果你想锻炼自己的技术
 
-像 ACM 等纯技术类比赛，利用比赛锻炼技术是完全可行的；如果是含文本元素的竞赛，利用比赛驱动自己学技术相对有利有弊。利在有人催你做项目，你可以直接按照文本给的要求写项目而不用自己想 Idea 。一旦获奖，对做技术的人而言也是正反馈。而且如果团队走的足够远，会有人帮你推广你做的项目。弊端也很明显。很多含文本元素的比赛并不注重具体落地，只要文本写的够好就能入围。这种情况下
+像 ACM、CTF 等纯技术类比赛，利用比赛锻炼技术是完全可行的；如果是含文本元素的竞赛，利用比赛驱动自己学技术相对有利有弊。利在有人催你做项目，你可以直接按照文本给的要求写项目而不用自己想 Idea 。一旦获奖，对做技术的人而言也是正反馈。而且如果团队走的足够远，会有人帮你推广你做的项目。弊端也很明显。很多含文本元素的比赛并不注重具体落地，只要文本写的够好就能入围。这种情况下
+
 1. 有可能组内成员提出一些工作量相当大的需求（例如一个人全栈）或者以现阶段能力完全做不了的需求，来圆上之前画的饼。
 2. 当发现 “只要糊弄一下套个空壳也可以” ，你可能就不想把项目落地了。这会极大地挫伤一个人独立开发完整项目的积极性。
 
+尽管如此，对于多数杭电学生而言，参加竞赛是最好的锻炼技术的方式，对杭电而言，竞赛是不可或缺的一部分。
+
 - 如果你想拓展人脉圈
 
 笔者的很多朋友也都是通过竞赛认识的。通过竞赛认识朋友是很不错的选择，团队项目不仅可以增加彼此之间的交流机会，也可以让你根据这位队友在协作中的表现估摸对方的品行（当你和队友为了赶比赛 DDL 一起 Debug 到两三点、或者你发现队友摆烂什么代码也不写，你大概会更深地理解到为什么这样说）。另外，如果竞赛打的够多，也会有组员主动邀请你参加其他的项目，认识更多的人。
 
 除了志同道合的朋友，其实你也会更容易接触到老师。对于一般路过摆烂大学生来说，见到老师无非就是在讲台上，很少有面对面交流的机会。而在比赛里，你可以和你的指导老师有更深的接触。当然，这些指导老师有很为学生着想的，也有视学生为廉价劳动力的，要注意辨别。
 
-# 项目来源（含文本元素的竞赛）
+## 项目来源（含文本元素的竞赛）
 
 - 祖传项目
 
@@ -52,7 +53,37 @@
 
 不过所有项目都始于初创项目，还是鼓励大家如果有自己的想法可以考虑初创项目。以个人体感而言，参与一个祖传项目虽然获奖相对容易，但作为一个项目的初创人，从组织团队、开发项目、打各大比赛到拿奖加 GPA ，这样的经历哪怕没拿奖也是很不错的锻炼。
 
-# 数据科学竞赛
+## CTF (信息安全竞赛)
+
+> CTF 能满足你对黑客的一切幻想
+
+计算机信息安全竞赛在社会上的知名度并不高，但它和 ACM 一样是强技术竞赛，无任何 PPT 环节以及展示环节（除了一些少数比赛如国赛省赛有知识竞赛这一环节/赛道），技术就是唯一取胜的关键。CTF 是计算机安全竞赛的一种赛制，全称“Capture The Flag”，即夺旗赛，比赛选手需利用自己的计算机安全技术完成挑战，成功拿下题目后会获得一个使用`flag{}`包裹的字符串，这个字符串就是flag，提交到平台上就可以获得一定的分数。
+
+杭电的 CTF 竞赛历史悠久，Vidar-Team 信息安全协会的主打比赛就是 CTF，据本文档编写之时算起已有 15 年的历史，大大小小国内国外获奖无数，本 wiki 的计算机安全部分也由信息安全协会编写。
+![](./static/prize.png)
+
+### 优点
+
+信息安全竞赛是强技术类竞赛，如果你选择计算机安全作为自己的主攻方向，该竞赛将包含几乎所有计算机安全的内容，在一个竞赛里就可以从入门到入土。
+
+CTF 在计算机安全类招聘，以及计算机安全类研究生招生中占有很大作用，安全类企业在招聘时更喜欢 CTF 选手，就好像算法岗更喜欢 ACM 选手一样（虽然现在两者的就业都没有以前好了）。
+
+计算机安全也是一个挑战性很强的领域，在国外有很高的研究热情，如今在国内也受政府大力支持，比如强网杯由河南省政府主办，奖金高达 500 万元，西湖论剑由浙江省政府主办，奖金也很丰厚。除此之外，在计算机安全领域还有漏洞赏金这一说，大型企业都会有 SRC（Security Response Center，安全应急响应中心）这种平台，上交该企业的漏洞就可以获得赏金，比如微软 RDP 远程代码执行漏洞（通过一定手段使得另一台电脑执行任意代码）赏金高达 10 万刀。VMware 虚拟机逃逸（在虚拟机内通过一定的手段可以在主机上执行任意代码）20 万刀等，越有挑战性的领域赏金越高。国内的SRC平台：https://www.anquanke.com/src
+![](./static/src.png)
+
+### 缺点
+
+CTF 的缺点在于受学校支撑不大，学校不重视该比赛（但又有什么关系呢），CTF 浙江省省赛由杭电“主办”，为省A类竞赛，获一等奖可加 0.7 GPA（大约能让你三等奖学金（450元）变一等奖学金（1500元），但奖学金对于找工作其实没啥用），并且每队（3人）奖金 3 千元。全国大学生信息安全竞赛为B类竞赛，和省赛同等待遇。除该两个比赛以外，剩下的比赛学校均不认可（近年来强网杯等政府主办比赛也稍微提高了认可度）。但浙江省省赛在社会上的认可度远不如国赛和其他企业/战队主办的比赛。如果你想依靠竞赛去争取杭电可怜的保研名额，老老实实打数模这种杭州电子数模大学高度认可的比赛，不要选 CTF。
+
+CTF还有的缺点也是目前热门领域的通病：发展速度过快，后来者需要学的东西越来越多越来越难越来越边缘。计算机安全作为一个对抗性比较强的课题（像人工智能里面的对抗性学习一样，两个AI互相下棋），发展速度是日新月异的，所以入行越晚风险越大。
+
+--- 
+
+更多可以参考计算安全章节
+
+[传送门](/6.%E8%AE%A1%E7%AE%97%E6%9C%BA%E5%AE%89%E5%85%A8/6.%E8%AE%A1%E7%AE%97%E6%9C%BA%E5%AE%89%E5%85%A8.html)
+
+## 数据科学竞赛
 
 这个比赛在一些学校相较而言比较冷门，但是含金量不低，奖项也相较而言比较丰厚，如果对数据科学比较感兴趣（4.8章节）的同学可以进一步了解
 
@@ -65,7 +96,7 @@
 竞赛公众号：Coggle数据科学
 知乎专栏：机器学习理论与数据竞赛实战
 
-# 数模竞赛（某学长的建议）
+## 数模竞赛（某学长的建议）
 
 高中阶段，可能大家很多都把很多的精力放在了主修的课程中，常参加竞赛的精力少之又少，而大学和高中很大的一个不同点就在于，我们可以不把所有的精力都放在课程的学习上，还有很多的选择，比如选择一个自己感兴趣的社团，或者选择一个适合自己的竞赛，
 
@@ -86,12 +117,10 @@
 
 最后，祝各位想参赛的学生最后可以拿到自己理想的奖项哦。
 
-# 智能车竞赛简介
+## 智能车竞赛简介
 
 杭电智能车比赛主要分为三大部分：竞速（电磁），竞速（视觉）与创意组.
 
 由于笔者是创意组的，对其他组别不是很了解，就来介绍一下我们组别的情况。我们组别全称是智能车百度创意组，是由百度与鲸鱼机器人赞助的一个比较新的组别（目前是第三年，不过也开始卷起来了），该组别与传统组别的一个比较大的不同是对于硬件方面的要求并不高（但也是需要了解的，像  arduino ，stm32 这些稍微都得玩的起来），侧重会偏向软件算法方向。百度创意组总体分为两个阶段，线上赛和线下赛，线上赛的任务有点像是 kaggle 打榜，不过是百度官方命题，并且在飞浆平台上进行测试的，本质考验的就是你对神经网络的理解和调参（炼丹），如下图所示
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnQe2AYHX93NUz6Sfoq3hUPd.png)
-
-
+![](https://cdn.xyxsw.site/boxcnQe2AYHX93NUz6Sfoq3hUPd.png)
diff --git a/1.杭电生存指南/1.4小心项目陷阱.md b/1.杭电生存指南/1.4小心项目陷阱.md
index 3eee61b..c2c449e 100644
--- a/1.杭电生存指南/1.4小心项目陷阱.md
+++ b/1.杭电生存指南/1.4小心项目陷阱.md
@@ -1,6 +1,6 @@
 # 小心项目陷阱
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnPmQ725zYTxiyo2LqQkphib.png)
+![](https://cdn.xyxsw.site/boxcnPmQ725zYTxiyo2LqQkphib.png)
 
 ## 辨别项目质量
 
@@ -52,7 +52,7 @@
 
 但是大家参与之前你一定要想你的能力是否等于这个项目的量级，一般情况下，要么你技术特别强，要么可能会存在一定的问题。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnPSolGcUy1R0Dk2FUhPaLLc.png)
+![](https://cdn.xyxsw.site/boxcnPSolGcUy1R0Dk2FUhPaLLc.png)
 
 所以说，还是那句话，小心甄别。
 
diff --git a/1.杭电生存指南/1.7杭电出国自救指南.md b/1.杭电生存指南/1.7杭电出国自救指南.md
index c4ecbcc..c3cdb6e 100644
--- a/1.杭电生存指南/1.7杭电出国自救指南.md
+++ b/1.杭电生存指南/1.7杭电出国自救指南.md
@@ -6,13 +6,13 @@
 
 ## 序言：一组数据看出国
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcndFjrKQMhZJsH1vN1fEfaQb.png)
+![](https://cdn.xyxsw.site/boxcndFjrKQMhZJsH1vN1fEfaQb.png)
 
 点开图片可以看到左边是西交利物浦的出国数据，中间是杭电的数据，右边是成都电子科技大学的数据，可以看出西交利物浦每年去名校的数量大概是杭电一年的 20-40 倍，成电是杭电的一年的 10 倍左右，杭电出国数据实际上只有寥寥几个名校，剩下的则是一些英国院校。
 
 这其中原因除了杭电高性价比的就业环境，双非院校选择出国深造的人数较低，我认为比较还有一点则是信息差。优秀的大学都有他们自己的飞跃手册，其中会介绍每个国家的优劣，以及申请的一些注意事项，详见下图。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnKMzGr9LSrXWmKxa1lSM1zJ.png)
+![](https://cdn.xyxsw.site/boxcnKMzGr9LSrXWmKxa1lSM1zJ.png)
 
 优越的校友资源和前人留下的数据和方案，加下信息差的叠加，就像符合幂律分布的无标度网络一样，只会让我们的差距越来越大，在感叹其他学校飞跃手册的优越性的同时也发现了一些不可参考性，因为在其中也存在着很多问题，在这些学校中，可能名校读博就是老师写个推荐信就有了面试的机会，可能去港大 / G5 就是大学四年均分 80 分的难度。有很多资料在不同的角度，我们很难参考，所以我不经会想问？那我们呢，我们考多少多少分能够去什么学校，我们想要直博应该怎么准备，所以我打算完成这份出国留学的手册，能够为学弟学妹们铺路，同样希望后面也能够有学弟学妹做完善和补充。
 
diff --git a/1.杭电生存指南/static/prize.png b/1.杭电生存指南/static/prize.png
new file mode 100644
index 0000000..e6c79d6
Binary files /dev/null and b/1.杭电生存指南/static/prize.png differ
diff --git a/1.杭电生存指南/static/src.png b/1.杭电生存指南/static/src.png
new file mode 100644
index 0000000..bbac714
Binary files /dev/null and b/1.杭电生存指南/static/src.png differ
diff --git a/1.杭电生存指南/static/计算机科学联合会群聊二维码.png b/1.杭电生存指南/static/计算机科学联合会群聊二维码.png
new file mode 100644
index 0000000..9b1ce3b
Binary files /dev/null and b/1.杭电生存指南/static/计算机科学联合会群聊二维码.png differ
diff --git a/2.高效学习/2.1.2浮躁的心理状态.md b/2.高效学习/2.1.2浮躁的心理状态.md
index d31221e..57d8489 100644
--- a/2.高效学习/2.1.2浮躁的心理状态.md
+++ b/2.高效学习/2.1.2浮躁的心理状态.md
@@ -32,4 +32,4 @@
 
 如果实在不行，来找 ZZM 聊聊吧。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnPDWiNgkgppK1XWq5cRQ71b.jpg)
+![](https://cdn.xyxsw.site/boxcnPDWiNgkgppK1XWq5cRQ71b.jpg)
diff --git a/2.高效学习/2.1.3错误的提问姿态.md b/2.高效学习/2.1.3错误的提问姿态.md
index c7ea21d..af709df 100644
--- a/2.高效学习/2.1.3错误的提问姿态.md
+++ b/2.高效学习/2.1.3错误的提问姿态.md
@@ -28,7 +28,7 @@
 
 问题还是没有解决，现在我该怎么做？
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnhuhE7qBLHyJKaesHGC033b.png)
+![](https://cdn.xyxsw.site/boxcnhuhE7qBLHyJKaesHGC033b.png)
 
 欢迎大家阅读
 
diff --git a/2.高效学习/2.1.4书籍的盲目崇拜.md b/2.高效学习/2.1.4书籍的盲目崇拜.md
index 72137aa..5bc2cb0 100644
--- a/2.高效学习/2.1.4书籍的盲目崇拜.md
+++ b/2.高效学习/2.1.4书籍的盲目崇拜.md
@@ -6,7 +6,7 @@
 
 "我们要学 C 语言，我买一本大黑书看看!"
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnqsCWmUTDr5UDLYca9YkhHh.png)
+![](https://cdn.xyxsw.site/boxcnqsCWmUTDr5UDLYca9YkhHh.png)
 
 诚然，上面的各种书写的非常好，但是我们需要思考的是，阅读这些真的能达到我们想要的目标吗？？？
 
diff --git a/2.高效学习/2.1.5错误的学习配比.md b/2.高效学习/2.1.5错误的学习配比.md
index 06ea6a0..982c674 100644
--- a/2.高效学习/2.1.5错误的学习配比.md
+++ b/2.高效学习/2.1.5错误的学习配比.md
@@ -18,4 +18,4 @@
 
 在你完成这份讲义的时候，希望你可以有选择的阅览一部分，然后带着问题去看某些课，效率也会高很多。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnSq1JzWhVrFs3MePPzp5Txg.jpg)
+![](https://cdn.xyxsw.site/boxcnSq1JzWhVrFs3MePPzp5Txg.jpg)
diff --git a/2.高效学习/2.1高效的前提：摆脱高中思维.md b/2.高效学习/2.1高效的前提：摆脱高中思维.md
index 985b6a4..1f44f83 100644
--- a/2.高效学习/2.1高效的前提：摆脱高中思维.md
+++ b/2.高效学习/2.1高效的前提：摆脱高中思维.md
@@ -14,7 +14,7 @@
 
 **并且，全部依赖他人给你指明方向的人生已经结束了！**
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcne9EK3xz8LHOXfM8w9ih5Ig.png)
+![](https://cdn.xyxsw.site/boxcne9EK3xz8LHOXfM8w9ih5Ig.png)
 
 你无法依赖大学里的老师还是家里的父母来为你指明所谓的方向，你的人生只属于你自己，你的道路也只能由你自己来思考。
 
diff --git a/2.高效学习/2.2优雅的使用工具.md b/2.高效学习/2.2优雅的使用工具.md
index 6589dfa..00650f5 100644
--- a/2.高效学习/2.2优雅的使用工具.md
+++ b/2.高效学习/2.2优雅的使用工具.md
@@ -34,7 +34,7 @@ wget http://ftp.gnu.org/gnu/coreutils/coreutils-8.32.tar.xz
 tar -xJf coreutils-8.32.tar.xz
 cd coreutils-8.32/
 # Download patch
-wget https://raw.githubusercontent.com/jarun/advcpmv/master/advcpmv-0.8-8.32.patch
+wget https://ghproxy.com/https://raw.githubusercontent.com/jarun/advcpmv/master/advcpmv-0.8-8.32.patch
 # Patching display with process bar
 patch -p1 -i advcpmv-0.8-8.32.patch
 # Compile then install
@@ -56,7 +56,7 @@ rm coreutils-8.32 coreutils-8.32.tar.xz
 - [思源笔记](https://b3log.org/siyuan/) 一个国产开源的笔记/知识库软件，优势是 本地化、双链、Markdown 语法，与 Obsidian 定位相似，但 Geek 成分和自定义空间相对更高
 - [Zotero](https://www.zotero.org/):协助文献阅读还有写笔记，支持与平板同传（同时他是开源的，所以可以添加一些插件）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnO1PEsVd4KY7reeU64spShf.jpg)
+![](https://cdn.xyxsw.site/boxcnO1PEsVd4KY7reeU64spShf.jpg)
 
 - [Notion](http://notion.so): 笔记终结者，非常强大，（设计理念被钉钉，飞书，我来非常抄袭）。在线就可以使用。
 
diff --git a/2.高效学习/2.5以理工科的方式阅读英语.md b/2.高效学习/2.5以理工科的方式阅读英语.md
index 95de867..d582746 100644
--- a/2.高效学习/2.5以理工科的方式阅读英语.md
+++ b/2.高效学习/2.5以理工科的方式阅读英语.md
@@ -2,7 +2,7 @@
 
 作为一名理工科学生，也许英语并不是你的强势，但往往学习又难以避开英语。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/G6zAbGrTKoBLsfxhmvHcUBVynpc.png)
+![](https://cdn.xyxsw.site/G6zAbGrTKoBLsfxhmvHcUBVynpc.png)
 
 下面提供一些英语阅读的方法：
 
diff --git a/2.高效学习/2.高效学习.md b/2.高效学习/2.高效学习.md
index 8b7559e..908d919 100644
--- a/2.高效学习/2.高效学习.md
+++ b/2.高效学习/2.高效学习.md
@@ -45,7 +45,7 @@ Search the "friendly" website
 
 ## 如果真的不知道怎么解决怎么办？
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnSmy1oqFO1glYIYGRZ9NhEb.jpg)
+![](https://cdn.xyxsw.site/boxcnSmy1oqFO1glYIYGRZ9NhEb.jpg)
 
 来细看看本章节的内容吧！
 
diff --git a/3.编程思维体系构建/3.0 编程入门之道.md b/3.编程思维体系构建/3.0 编程入门之道.md
index 51b4ad3..e84e8a2 100644
--- a/3.编程思维体系构建/3.0 编程入门之道.md	
+++ b/3.编程思维体系构建/3.0 编程入门之道.md	
@@ -38,7 +38,7 @@
 
 这是我的第一个也是最重要的建议。
 
-无论是学一门语言，还是学一个工具：<strong>尽可能地先用最短的时间搞懂这个东西是做什么的，然后以最快的方式把它 “run”起来。</strong>
+无论是学一门语言，还是学一个工具：<strong>尽可能地先用最短的时间搞懂这个东西是做什么的，然后以最快的方式把它“run”起来。</strong>
 
 当你已经能跑起一个语言、一个工具的最简单的示例的时候，再去花时间慢慢了解背后的复杂的内容，再去拓展即可。先用起来，跑起来，带着问题去翻资料。
 
@@ -58,7 +58,7 @@
 
 那么该怎么学呢？
 
-<strong>先简单地会一样东西的最核心的部分，再去找一个实际的编程场景、编程任务、项目。你会在完成这个项目中遇到各种各样的问题，无论是遗漏了知识点还是压根没思路， 这时候不断地用搜索引擎来学习。（ </strong>[2.3 高效的信息检索](../2.%E9%AB%98%E6%95%88%E5%AD%A6%E4%B9%A0/2.3%E9%AB%98%E6%95%88%E7%9A%84%E4%BF%A1%E6%81%AF%E6%A3%80%E7%B4%A2.md)<strong>）</strong>
+<strong>先简单地会一样东西的最核心的部分，再去找一个实际的编程场景、编程任务、项目。你会在完成这个项目中遇到各种各样的问题，无论是遗漏了知识点还是压根没思路，这时候不断地用搜索引擎来学习。（ </strong>[2.3 高效的信息检索](../2.%E9%AB%98%E6%95%88%E5%AD%A6%E4%B9%A0/2.3%E9%AB%98%E6%95%88%E7%9A%84%E4%BF%A1%E6%81%AF%E6%A3%80%E7%B4%A2.md)<strong>）</strong>
 
 举个例子：你想做一个小程序，来检测某电影院的电影预售。程序大概要做到不断刷新网页，一检测到这个电影预售了，就马上发短信给自己手机（或者直接帮你抢）
 
@@ -101,7 +101,7 @@
 
 1. 输入决定输出。开源的代码多是经过检验的牛逼的代码，通过多看看优雅的代码来提高编程能力，比自己无中生有简单地多。
 2. 开源圈牛人多。无论是拓宽视野，还是在 issue 下的交流，还是别人给你的 review 建议，都能学到很多。你会在开源的过程中认识很多的人，很多大厂的人，说不定就是你以后的面试官。
-3. 参与开源社区能极大地锻炼自己的编程能力，能给简历贴金 。
+3. 参与开源社区能极大地锻炼自己的编程能力，能给简历贴金。
 4. 开源是程序员的浪漫。
 
 对于学生而言，可以参加一些仅面向学生开放的开源活动。一般会有一个主办方，然后有许多知名的开源社区报名。他们会罗列出一些有一定难度的任务，学生可以提交申请书，陈述如何完成这个任务。中选后会分配单独的导师来带你，还会发奖金给你，一般是大几千起步。推荐阅读这个系列的文章：[https://erdengk.github.io/gsoc-analyse/](https://erdengk.github.io/gsoc-analyse/)
diff --git a/3.编程思维体系构建/3.1该使用哪个编辑器？？？.md b/3.编程思维体系构建/3.1该使用哪个编辑器？？？.md
index 97bd18e..4f32306 100644
--- a/3.编程思维体系构建/3.1该使用哪个编辑器？？？.md
+++ b/3.编程思维体系构建/3.1该使用哪个编辑器？？？.md
@@ -1,6 +1,6 @@
 # 3.1 该使用哪个编辑器？？？
 
-# 编辑器，编译器，集成开发环境
+## 编辑器，编译器，集成开发环境
 
 我们平时所说的程序，是指双击后就可以直接运行的程序，这样的程序被称为可执行程序（Executable Program）。
 
@@ -12,7 +12,7 @@
 
 （你也不想用一沓纸带写程序吧）
 
-## 什么是编辑器
+### 什么是编辑器
 
 编辑器的概念很简单，百度百科上这么写道：
 
@@ -24,7 +24,7 @@
 - <em>Vim </em>: Vim 是从 vi 发展出来的一个文本编辑器，在程序员中被广泛使用，运行在 Linux 环境下。
 - <em>GNU Emacs</em> : Emacs 是一个轻便、可扩展、免费的编辑器，它比其它的编辑器要更强大，是一个整合环境，或可称它为集成开发环境。它可以处理文字，图像，高亮语法，将代码更直观地展现给开发者。
 
-## 什么是编译器
+### 什么是编译器
 
 C 语言代码由固定的词汇按照固定的格式组织起来，简单直观，程序员容易识别和理解，但是对于 CPU，C 语言代码就是天书，根本不认识，CPU 只认识几百个二进制形式的指令。这就需要一个工具，将 C 语言代码转换成 CPU 能够识别的二进制指令，也就是将代码加工成 .exe 程序；这个工具是一个特殊的软件，叫做编译器（Compiler）。
 编译器能够识别代码中的词汇、句子以及各种特定的格式，并将他们转换成计算机能够识别的二进制形式，这个过程称为编译（Compile）。
@@ -56,7 +56,7 @@ C 语言代码由固定的词汇按照固定的格式组织起来，简单直观
 
 编译器可以 100% 保证你的代码从语法上讲是正确的，因为哪怕有一点小小的错误，编译也不能通过，编译器会告诉你哪里错了，便于你的更改。
 
-## 什么是集成开发环境
+### 什么是集成开发环境
 
 实际开发中，除了编译器是必须的工具，我们往往还需要很多其他辅助软件，例如：
 
@@ -72,11 +72,11 @@ C 语言代码由固定的词汇按照固定的格式组织起来，简单直观
 
 集成开发环境也是这个道理，只有编译器不方便，所以还要增加其他的辅助工具。
 
-# 我的推荐
+## 我的推荐
 
 作为个人使用比较顺手的几款 IDE
 
-Java: [JetBrains](https://www.jetbrains.com/zh-cn/idea/)[ IntelliJ ](https://www.jetbrains.com/zh-cn/idea/)[IDEA](https://www.jetbrains.com/zh-cn/idea/)
+Java: [JetBrains](https://www.jetbrains.com/zh-cn/idea/)[IntelliJ](https://www.jetbrains.com/zh-cn/idea/)[IDEA](https://www.jetbrains.com/zh-cn/idea/)
 
 C:  [Visual Studio(宇宙第一 IDE)](https://visualstudio.microsoft.com/zh-hans/vs/), [JetBrains](https://www.jetbrains.com/zh-cn/clion/)，[Clion](https://www.jetbrains.com/zh-cn/clion/), Visual Studio Code(编辑器 IDE 化需要额外配置)
 
diff --git a/3.编程思维体系构建/3.2.1为什么要选择ACM——谈谈我与ACM.md b/3.编程思维体系构建/3.2.1为什么要选择ACM——谈谈我与ACM.md
index 455ba8b..71047ad 100644
--- a/3.编程思维体系构建/3.2.1为什么要选择ACM——谈谈我与ACM.md
+++ b/3.编程思维体系构建/3.2.1为什么要选择ACM——谈谈我与ACM.md
@@ -2,15 +2,15 @@
 
 author:wenjing
 
-先验条件：保证你可以在每天进行练习和学习此方面内容即使是假期也不能超过三天以上休息,如果你想验证一下这件事当然也可以，注意心态的保持很重要
+先验条件：保证你可以在每天进行练习和学习此方面内容即使是假期也不能超过三天以上休息，如果你想验证一下这件事当然也可以，注意心态的保持很重要
 
-# 将时间花在 ACM 上值得吗？
+## 将时间花在 ACM 上值得吗？
 
 初入大学，摆脱了高中的种种束缚，同学们想必对大学生活有着种种幻想。或许有同学依旧保持着高中的思维，希望刷取高绩点，用好成绩谋求保研。或许也有同学只想将课程草草应付，去探索一些偏实践的方向以谋求一份好工作。
 
 但无论你渴望从大学生活谋求何物，我认为做为一位计算机专业的学生投身于 ACM 算法竞赛学习都是值得，无论你是否得奖。
 
-# ACM 能为我带来什么？
+## ACM 能为我带来什么？
 
 显然，做为一名计算机专业的学生，编程是一项必须掌握的技能。再次引用 Niklaus Emil Wirth 的一句话：<strong>程序=算法 + 数据结构。</strong>例如在大一开设的程序设计基础中，我们需要重点学习链表这一数据结构，熟悉运用分支与循环结构（勉强也算算法吧）。然而，在 ACM 中，这是基础到不值一提的事物，宛如空气与水一般基础。你们是否想过，花了大量课时学习的这些知识，其实小学生也可以学会（看看远处的小学编程补习班吧，家人们）那做为大学生去学习这些知识，是否应当得到一些不止于考试内容的知识呢？
 
@@ -24,7 +24,7 @@ author:wenjing
 
 ③ 假如你有幸活过筛选，并且获得比赛机会，并且得奖，恭喜你，你的绩点将被画上浓墨重彩的一笔。做为大学顶尖赛事，ACM 的奖项可以直接在你的最终绩点上加分（铜 0.5，银 1.0，金 1.5）这意味着你只要主课不要落下太多，奖学金随便拿（比赛获奖本身还有额外奖金）。
 
-# 零基础学习 ACM 是否过于困难？
+## 零基础学习 ACM 是否过于困难？
 
 我并不这么觉得，原因如下
 
@@ -40,7 +40,7 @@ UPD at 2023/7/19：从长期来看，这个结论应该是没有错的，但是
 
 进队的学生零基础偏少，如果你选择这条路你可能需要克服不小的困难
 
-# 我应该以什么态度学习 ACM？
+## 我应该以什么态度学习 ACM？
 
 假如你是一位有信息竞赛基础，且得过省级奖项的前 oier，您也没什么必要看这篇文章，您已经完全熟悉了算法竞赛需要的一切，我希望您不要有太大压力，做最好的自己就行，不要留下遗憾。对于零基础的同学也一样，或许得奖后的绩点加成实在是过于诱人，但竞赛获奖这种事情还是太难强求，让自己压力太大得不偿失。
 
@@ -54,7 +54,7 @@ UPD at 2023/7/19：从长期来看，这个结论应该是没有错的，但是
 
 之后的日子是灰暗的，浑浑噩噩的训练，知难而退放弃最好的高中的特长生名额。故事很长，我只是想说学竞赛不要太功利，竞赛终究是少数高手的游戏，做不到就是做不到，但这也仅仅只代表你的竞赛能力不够，你的人生并不是只有竞赛，大学也不只有 ACM 一条路（这很显然，不然我们社团应该改名为 ACM 社）
 
-# 再谈 ACM 为我带来什么
+## 再谈 ACM 为我带来什么
 
 我初中成绩并不差，但发挥失常的话确实上不了我毕业的高中。我高考发挥失常，竞赛通过杭电三一成为保底。
 
@@ -66,7 +66,7 @@ UPD at 2023/7/19：从长期来看，这个结论应该是没有错的，但是
 
 截止完成这篇文章为止，笔者仍在集训队中，我害怕自己被淘汰，不是因为我害怕自己失去参赛资格，而是我很难想象自己失去 ACM 的生活，我需要一个学习 ACM 的理由。给诸位讲个笑话，某一天我与朋友出门游玩，想不到话题，于是就开始讨论算法题的做法，从正午到日落。
 
-# 算法思维与应试思维
+## 算法思维与应试思维
 
 众所周知，ACM 是开卷竞赛，你可以携带纸质资料进入考场。
 
@@ -88,7 +88,7 @@ UPD at 2023/7/19：从长期来看，这个结论应该是没有错的，但是
 
 也许在一次次陈旧腐朽的选拔性考试中，应试思维取得了压倒性的胜利。但在 ACM 中，算法思维依旧有一片净土。
 
-# 数学与算法思维
+## 数学与算法思维
 
 那么，如何培养算法思维呢？我认为首先我们得学好数学。然而，我最总是在大一中听到这样的声音：“哎呀，烦死了，我们是学编程的，为什么要花那么多精力学数学，还占那么多学分，真讨厌。“然而，比起枯燥乏味的编程课，我最喜欢的还是数学课。数学在算法中无处不体现，可以说学好算法就是要学好数学，我现在复盘我初中 OI 生涯的失败，很大程度归因于数学基础的薄弱。以下为几个体现数学在算法中重要性的例子。
 
@@ -106,6 +106,6 @@ UPD at 2023/7/19：从长期来看，这个结论应该是没有错的，但是
 
 优秀的数学思维能使你在理解算法的路上事半功倍，当然，算法的学习也能加深你对数学的理解。
 
-# 结论
+## 结论
 
 大胆去学 ACM 吧，大一的空闲时间真的很多，去探索新事物，不试试怎么知道自己行不行。
diff --git a/3.编程思维体系构建/3.2.2手把手教你学算法——如何使用OJ（Online Judge）.md b/3.编程思维体系构建/3.2.2手把手教你学算法——如何使用OJ（Online Judge）.md
index 8560f2f..57306b1 100644
--- a/3.编程思维体系构建/3.2.2手把手教你学算法——如何使用OJ（Online Judge）.md	
+++ b/3.编程思维体系构建/3.2.2手把手教你学算法——如何使用OJ（Online Judge）.md	
@@ -2,25 +2,25 @@
 
 在之前的篇章中，我们向新手 acmer 推荐了两个编程网站——Luogu 与 Codeforces，下面由笔者向各位介绍一下网站的详细用法。
 
-# Luogu
+## Luogu
 
 进入 [https://www.luogu.com.cn/](https://www.luogu.com.cn/)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing1.png)
+![](https://cdn.xyxsw.site/wenjing1.png)
 
-## 社交模块
+### 社交模块
 
 做为一个刷题网站，Luogu 提供了符合中文用户习惯的社交模块。体现于左侧边栏的讨论及主页的最近讨论，以及底部的“发射犇犇”系统。但是我并不建议 Acmer 使用该功能，因为 Luogu 主要面向初高中生甚至小学生等参加 NOIP 系列竞赛的用户，讨论不可避免存在一些低龄化现象。对于社交模块的使用，我推荐当且仅当一种做不出题的求助手段，这点放在之后题目模块讲解。
 
-## 题目模块
+### 题目模块
 
 点开题库，我们看见以下界面
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing2.png)
+![](https://cdn.xyxsw.site/wenjing2.png)
 
 在上方我们可以筛选我们想要的题目，接下来我们点开 P1000 为例
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing3.png)
+![](https://cdn.xyxsw.site/wenjing3.png)
 
 右侧三个模块为折叠状态，下面介绍他们的作用
 
@@ -34,17 +34,17 @@
 
 点击提交答案
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing4.png)
+![](https://cdn.xyxsw.site/wenjing4.png)
 
 左侧可以选择语言类型，C++ 用户建议选择 C++14。
 
 O2 优化是一种优化（废话）假如您的代码复杂度正确但 TLE，可以尝试该选项。
 
-## 记录模块
+### 记录模块
 
 怎么知道自己代码的问题出在哪里呢？记录模块是帮助你的好工具。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing5.png)
+![](https://cdn.xyxsw.site/wenjing5.png)
 
 AC：通过该数据点
 
@@ -60,47 +60,47 @@ MLE：空间超限 请检查是否递归爆栈、数组过大
 
 OLE：输出超限 放心你见不到的
 
-## 题单模块
+### 题单模块
 
 点开侧栏题单
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing6.png)
+![](https://cdn.xyxsw.site/wenjing6.png)
 
 建议新手从官方精选题单开始，由浅入深，由简到难。等到对算法形成概念，针对漏洞补习时可以尝试用户分享题单（到那个阶段已经有很多手段去找题了，刘教练的题单就够你做了）
 
-## 比赛模块
+### 比赛模块
 
 点开侧栏就能看见准备举办和已结束的比赛。笔者不建议大家在 Luogu 打比赛，首先赛制不一样，其次出题风格不一样，最后对于初学者 Luogu 比赛的难度曲线过大。
 
-# Codeforces
+## Codeforces
 
 进入 [https://codeforces.com/?locale=en](https://codeforces.com/?locale=en)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing7.png)
+![](https://cdn.xyxsw.site/wenjing7.png)
 
 比起 Luogu，这样的 UI 设计离 CN 互联网已经很远了（然而比起更硬核的一些做题网站，CF 的 UI 真是越看越顺眼）
 
 右上角注册登录切语言（哇塞，可以选俄语，你说的对，但是 CF 是一款由俄罗斯开发的多人在线竞技游戏）
 
-## HOME 模块
+### HOME 模块
 
 主页显示各种数据，主要为近期比赛的一些公告。
 
-## TOP 模块
+### TOP 模块
 
 热帖，如果擅长英语的话，CF 的交流氛围还是不错的，做为一个答疑解惑的论坛肯定比国内强。
 
-## CATALOG 模块
+### CATALOG 模块
 
 文档目录，你可以在这学习算法竞赛入门，体系化学习算法，只要你会英语
 
-## CONTESTS
+### CONTESTS
 
 重中之重！CF 的比赛系统可以说是我们选择这个网站的最大原因！
 
 进入比赛页面
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing8.png)
+![](https://cdn.xyxsw.site/wenjing8.png)
 
 上方为将举办比赛，显示开始时间（UTC+8 也就是我们时区的时间）和持续时间大多都开始的比较晚，例如笔者就没有这么晚学习的习惯，所以一般赛后写题。比赛分为以下几种类型（例如写在括号里的 Div.2）
 
@@ -112,22 +112,22 @@ Div.1、Div.2、Div.3、Div.4 数字越小难度越大。
 
 下面以一场 Div.2 比赛为例，展示我们该如何打一场 CF。
 
-## VP
+### VP
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing9.png)
+![](https://cdn.xyxsw.site/wenjing9.png)
 
 这是一场笔者之前赛后补过的 Div.2，画面右下角分别为赛后公告和题解，右侧便是开启 VP 的按钮。
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing10.png)
+![](https://cdn.xyxsw.site/wenjing10.png)
 
 <em>VP</em><em>模拟赛时的好处就是在虚拟参赛中获得真实比赛才能积累的经验，比如这里笔者发现通过前三题后，我应该先去看看 F 题，因为做出来的人更多，我有更大的可能性做出来，ACM 中题目并不是 100% 按难度排序。</em>
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing11.png)
+![](https://cdn.xyxsw.site/wenjing11.png)
 
 进入 VP 后，我们可以发现比起正常赛后补题有了明显不同。
 
 首先我们可以看见赛时某道题的通过人数，随比赛时间流逝 100% 仿真变化。而且也可以与当时的“虚拟选手”同步竞争，例如笔者这里就复制之前写过的代码荣登榜三（乐）
 
-对于大多数比赛，采用 ICPC 赛制，解决某题得到的分数由该题当前的分数减去(不成功的提交次数)*50，这里某道题的分数是由比赛开始时的分数随时间线性减少得到的。
+对于大多数比赛，采用 ICPC 赛制，解决某题得到的分数由该题当前的分数减去 (不成功的提交次数)*50，这里某道题的分数是由比赛开始时的分数随时间线性减少得到的。
 
 也就是做题越快，错误次数越少，分数和排名就越高，这点大体是与 ACM 赛制相同的。
 
@@ -135,30 +135,30 @@ Div.1、Div.2、Div.3、Div.4 数字越小难度越大。
 
 让我们点开 A 题，来看看如何提交答案
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing12.png)
+![](https://cdn.xyxsw.site/wenjing12.png)
 
 可以看见，右侧有一个 submit，与 luogu 不同的是，你需要上传源代码文件（如 cpp）然后选择 G++17 为语言，提交。
 
 当然，你也可以点开上侧的 submit code
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing13.png)
+![](https://cdn.xyxsw.site/wenjing13.png)
 
 选择题目、语言，填写代码后提交，就和 Luogu 的方式一样了。
 
 同样，在上侧 MY SUBMISSIONS 处可以查看已提交的代码和状态
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing14.png)
+![](https://cdn.xyxsw.site/wenjing14.png)
 
-## PROBLEMSET
+### PROBLEMSET
 
 同样，CF 也有题库
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wenjing15.png)
+![](https://cdn.xyxsw.site/wenjing15.png)
 
 如果你只想做某道题而不是某场比赛，这里也许更适合你。
 
 不过 CF 的题库比较鸡肋，标签筛选也不是很方便（大概是把想要的标签在右上角分隔好）
 
-# 总结
+## 总结
 
 笔者向读者详细介绍了两个 OJ，至于如何让 OJ 更好的辅助你的 ACM 学习，我应该在什么时间节点或训练阶段，出于什么训练目的选择哪个网站，笔者留到下一个篇章继续介绍。
diff --git a/3.编程思维体系构建/3.2.3ACM 竞赛从入门到入坟.md b/3.编程思维体系构建/3.2.3ACM 竞赛从入门到入坟.md
index 6ce1658..67aeedb 100644
--- a/3.编程思维体系构建/3.2.3ACM 竞赛从入门到入坟.md	
+++ b/3.编程思维体系构建/3.2.3ACM 竞赛从入门到入坟.md	
@@ -58,7 +58,7 @@
 
 打完比赛，建议钻研一下自己没做出的前一两题，写个题解。为什么要写题解呢，一个是方便以后来回顾，一个是加深印象，一个是把自己的思维用文字表达出来，这样能发现思维的漏洞（比如证明不严谨之类的）。题解写出来发不发博客就看个人喜好吧。作者以前也是坚持写博客写了很久。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Axiomofchoice_1.png)
+![](https://cdn.xyxsw.site/Axiomofchoice_1.png)
 
 为什么要打 Codeforces 比赛呢？主要原因是打比赛有计时，有压力（怕掉分的压力），能让人提升更快。不要因为怕掉分就不参加了，你要相信只要你一直打比赛，你的 rating 曲线一定是波动上升的。
 
diff --git a/3.编程思维体系构建/3.2算法杂谈.md b/3.编程思维体系构建/3.2算法杂谈.md
index 1541a6e..9157afa 100644
--- a/3.编程思维体系构建/3.2算法杂谈.md
+++ b/3.编程思维体系构建/3.2算法杂谈.md
@@ -1,6 +1,6 @@
 # 3.2 算法杂谈
 
-# 学计算机要先学算法吗？
+## 学计算机要先学算法吗？
 
 也许有的同学在高中阶段接触过信息学奥赛，那么也许你已经对基础的算法知识已经有了一定的了解。
 
@@ -10,19 +10,19 @@
 
 学习算法的基础是拥有最基本的计算机素养，你需要优先学习一些基本的计算机概念、编程语言、简单的数据结构（数组、链表等），这些基本知识是你能够灵活利用算法的基础。
 
-# 学了算法就相当于学好了计算机吗？
+## 学了算法就相当于学好了计算机吗？
 
 学好了算法当然不等于学好了计算机科学。计算机科学是一个非常庞大的知识体系，包括更为底层的计算机组成原理、编译原理等，更为表层的 AI，开发等，是一门综合性学科。总的来说，算法是计算机科学中较为重要的一部分，但<strong>远远</strong>不是全部。
 
-# 学算法就要用《算法导论》一类的书吗？
+## 学算法就要用《算法导论》一类的书吗？
 
-我的答案是否定的。它更适合作为“工具书”（就像你英语的词典那样），而不是一本适合新生入门学习的书。可以使用《我的第一本算法书》一类的更为基础更为有趣的算法内容。相比于完全严谨的逻辑推导, 初学者的诉求是在"看得见, 摸得着的例子和环境下探索和吸收新概念". 像这样的大部头可以在之后进行阅读.
+我的答案是否定的。它更适合作为“工具书”（就像你英语的词典那样），而不是一本适合新生入门学习的书。可以使用《我的第一本算法书》一类的更为基础更为有趣的算法内容。相比于完全严谨的逻辑推导，初学者的诉求是在"看得见，摸得着的例子和环境下探索和吸收新概念". 像这样的大部头可以在之后进行阅读。
 
-# 学算法一定要用 C 语言吗？不用 C 语言可以吗？
+## 学算法一定要用 C 语言吗？不用 C 语言可以吗？
 
 不一定要用 C 语言。但是 C 语言作为一种贴近底层面向过程语言，对日后学习其他的语言会有较大的帮助。你也可以先学习 Python、JAVA 等等。学校的课程仅仅是教授一些比较基础的知识，如果想要真正掌握一门语言，需要在学校课程的基础上更进一大大大步。
 
-# ACM 怎么说？
+## ACM 怎么说？
 
 前情提要，请尽量不要以功利的心态去参加 ACM，你想要的与你能得到的可能存在过大落差
 
@@ -32,6 +32,6 @@ ACM 是美国计算机协会（Association for Computing Machinery）的缩写
 
 在我校，参加 ACM 社团（姑且叫做社团）并不代表能够参加有含金量的团体赛（ICPC、CCPC 等）。你需要先参加由我校教练刘春英老师组织的各种比赛，有资格进入集训队后，才有机会代表学校参加比赛（当然不限名额的个人赛想参加就参加）。
 
-进入集训队后采取末位淘汰制度（最后留下来的人在 20 人左右），最后留下来的人才有机会参加比赛。<strong>因此个人并不推荐 0 基础的同学对于 ACM 过于执着</strong>，有 0 基础的同学最后进入校队的例子，不过这通常意味着你一天至少得刷一道算法题。如果还是想尝试的同学，可以去洛谷(www.luogu.com.cn)、Codeforces(www.codeforces.com)、Atcoder(atcoder.jp)等平台上注册账号，练习题目，参加这些网站定期组织的一些比赛。
+进入集训队后采取末位淘汰制度（最后留下来的人在 20 人左右），最后留下来的人才有机会参加比赛。<strong>因此个人并不推荐 0 基础的同学对于 ACM 过于执着</strong>，有 0 基础的同学最后进入校队的例子，不过这通常意味着你一天至少得刷一道算法题。如果还是想尝试的同学，可以去洛谷 ([www.luogu.com.cn](http://www.luogu.com.cn))、Codeforces([www.codeforces.com](http://www.codeforces.com))、Atcoder([atcoder.jp](https://atcoder.jp/)) 等平台上注册账号，练习题目，参加这些网站定期组织的一些比赛。
 
 如果经过一段时间的练习能够在 Codefoces（[www.codeforces.com](http://www.codeforces.com)）上达到 1400 以上的 Rating，那么可以再观望观望参与 ACM。
diff --git a/3.编程思维体系构建/3.3如何选择编程语言.md b/3.编程思维体系构建/3.3如何选择编程语言.md
index 3e6d9e1..afe19df 100644
--- a/3.编程思维体系构建/3.3如何选择编程语言.md
+++ b/3.编程思维体系构建/3.3如何选择编程语言.md
@@ -1,18 +1,18 @@
 # 3.3 如何选择编程语言
 
-# 编程语言的工具属性
+## 编程语言的工具属性
 
 在回答这个问题之前，需要各位同学明确的一点是，编程并不是一个独立的学科，像数学那样做题是学不好的。
 
 编程语言的选择更像是锤子与扳手之间的选择，更大程度上看的是你需要解决什么样的问题。当你需要砸钉子的时候，使用螺丝刀总归是不顺手的，因此了解不同语言的特性，针对任务进行选择是非常有必要的。
 
-# 编程语言特性
+## 编程语言特性
 
 首先附上一张经典老图
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnW0YQY58RXhwdtRj5k6ndlc.jpeg)
+![](https://cdn.xyxsw.site/boxcnW0YQY58RXhwdtRj5k6ndlc.jpeg)
 
-## C 语言/C++
+### C 语言/C++
 
 C 语言/C 艹一脉同源，从图中来看，C 和 C 艹都像多功能瑞士军刀，说明其是用来做细活的工具，C 上面的优盘说明其可以进行硬件开发的相关工作。
 
@@ -26,7 +26,7 @@ C 语言其实是一门优秀的承上启下的语言，既具有高级语言的
 
 <strong>我们的任务一部分会使用 C 语言，一方面培养大家编程能力，一方面辅助大家期末考试。</strong>
 
-## C++
+### C++
 
 现代 C++ 程序可看成以下三部分组成。
 
@@ -56,6 +56,6 @@ Python 在图里是电锯，适合干比较“狂野”的任务，也是深度
 
 <strong>频繁应用于</strong><strong>W</strong><strong>eb 开发，安卓应用等等。</strong>
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnPv2FcyQxGLjYHThSaJNwRf.jpeg)
+![](https://cdn.xyxsw.site/boxcnPv2FcyQxGLjYHThSaJNwRf.jpeg)
 
 当然还有各种形形色色的编程语言等着同学们去探索。
diff --git a/3.编程思维体系构建/3.4.1FAQ：常见问题.md b/3.编程思维体系构建/3.4.1FAQ：常见问题.md
index 4327261..03b00ff 100644
--- a/3.编程思维体系构建/3.4.1FAQ：常见问题.md
+++ b/3.编程思维体系构建/3.4.1FAQ：常见问题.md
@@ -1,24 +1,24 @@
 # FAQ：常见问题
 
-# 我完全没基础觉得好难呜呜
+## 我完全没基础觉得好难呜呜
 
-教育除了知识的记忆之外, 更本质的是能力的训练, 即所谓的 training. 而但凡 training 就必须克服一定的难度, 否则你就是在做重复劳动, 能力也不会有改变. 如果遇到难度就选择退缩, 或者让别人来替你克服本该由你自己克服的难度, 等于是自动放弃了获得 training 的机会
+教育除了知识的记忆之外，更本质的是能力的训练，即所谓的 training. 而但凡 training 就必须克服一定的难度，否则你就是在做重复劳动，能力也不会有改变。如果遇到难度就选择退缩，或者让别人来替你克服本该由你自己克服的难度，等于是自动放弃了获得 training 的机会
 
-# 我觉得无从下手
+## 我觉得无从下手
 
 尝试借鉴他人的代码也未尝不可，但是要保证每一行都看懂哦
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnQ4rvJqVbXJaWMOwceHdrQb.png)
+![](https://cdn.xyxsw.site/boxcnQ4rvJqVbXJaWMOwceHdrQb.png)
 
-# 我感觉讲义写的不够细
+## 我感觉讲义写的不够细
 
 首先，我无法照顾到每一个人的情况，保证你每一个地方都看懂
 
 其次，很多地方的坑是故意留给你让你尝试独立解决问题的。
 
-# 我觉得我以后不会从事 C 相关的工作
+## 我觉得我以后不会从事 C 相关的工作
 
-这种"只要不影响我现在 survive, 就不要紧"的想法其实非常的利己和短视: 你在专业上的技不如人, 迟早有一天会找上来, 会影响到你个人职业生涯的长远的发展
+这种"只要不影响我现在 survive, 就不要紧"的想法其实非常的利己和短视：你在专业上的技不如人，迟早有一天会找上来，会影响到你个人职业生涯的长远的发展
 
 更严重的是，他可能会透支学校的信誉。
 
@@ -29,11 +29,11 @@
 3. 能够理解其他语言：C 语言是很多编程语言的基础，如 C++、Java、Python 等语言都从 C 语言继承了很多特性。因此，学好 C 语言可以帮助你更好地理解其他编程语言的设计思路和工作原理。
 4. 开发底层软件：由于 C 语言具有高效、灵活、可移植等特点，因此它被广泛用于开发操作系统、嵌入式系统、网络协议、游戏引擎等底层软件。学习好 C 语言可以为你将来从事底层软件开发提供必要的基础知识。
 
-# 我感觉我写了也不会学到啥
+## 我感觉我写了也不会学到啥
 
 复杂的问题总是存在简单的解释，C 语言虽然不擅长带 GUI 界面的编写，但是我们每日在用的都和他息息相关，那些庞大的系统也无非就是由这些简单的东西搭建而成的
 
-# 我觉得我没有学懂 C 语言就开始别的合适吗
+## 我觉得我没有学懂 C 语言就开始别的合适吗
 
 学习本章内容更大程度上是为了让你搞清楚编程世界运行的基本原理
 
@@ -45,19 +45,19 @@ NJU-ICS-PA 南京大学计算机系统基础
 
 但是建议大家大二再进行尝试，非常难
 
-# 我总觉得文章没写清楚
+## 我总觉得文章没写清楚
 
-你毕业后进入公司/课题组, 不会再有讲义具体地告诉你应该做什么, 总有一天你需要在脱离讲义的情况下完成任务. 我们希望你现在就放弃"讲义和框架代码会把我应该做的一切细节清楚地告诉我"的幻想, 为自己的成长负起责任:
+你毕业后进入公司/课题组, 不会再有讲义具体地告诉你应该做什么，总有一天你需要在脱离讲义的情况下完成任务。我们希望你现在就放弃"讲义和框架代码会把我应该做的一切细节清楚地告诉我"的幻想，为自己的成长负起责任：
 
-- 不知道在说什么, 说明你对知识点的理解还不够清楚, 这时候你应该去看书/看手册
-- 不知道要做什么/怎么做, 说明你的系统观好是零碎的, 理解不了系统中各个模块之间的联系, 这时候你应该 RTFSC, 尽自己最大努力梳理并理解系统中的一切细节
-- bug 调不出来, 说明你不清楚程序正确的预期行为, 你需要 RTFSC 理解程序应该如何运行; 此外也说明你不重视工具和方法的使用, 你需要花时间去体验和总结它们
+- 不知道在说什么，说明你对知识点的理解还不够清楚，这时候你应该去看书/看手册
+- 不知道要做什么/怎么做, 说明你的系统观好是零碎的，理解不了系统中各个模块之间的联系，这时候你应该 RTFSC, 尽自己最大努力梳理并理解系统中的一切细节
+- bug 调不出来，说明你不清楚程序正确的预期行为，你需要 RTFSC 理解程序应该如何运行; 此外也说明你不重视工具和方法的使用，你需要花时间去体验和总结它们
 
-如果你发现自己有以上情况, 你还是少抱怨, 多吃苦吧.
+如果你发现自己有以上情况，你还是少抱怨，多吃苦吧。
 
 当然，如果你发现有更好的想法欢迎联系我
 
-# 这些对我太简单了
+## 这些对我太简单了
 
 你可以从广度和深度两个角度对自己进行拔高
 
@@ -65,8 +65,8 @@ NJU-ICS-PA 南京大学计算机系统基础
 
 有且仅有大学有这样好的资源帮助你了
 
-# <strong>坚持了好久还是搞不定, 我想放弃了</strong>
+## <strong>坚持了好久还是搞不定，我想放弃了</strong>
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnuNXrb5zOppCZAlGQ19wuDk.jpg)
+![](https://cdn.xyxsw.site/boxcnuNXrb5zOppCZAlGQ19wuDk.jpg)
 
 也许是你坚持的姿势不对，来和 ZZM 聊聊吧
diff --git a/3.编程思维体系构建/3.4.2用什么写 C 语言.md b/3.编程思维体系构建/3.4.2用什么写 C 语言.md
index b076ad5..0b145db 100644
--- a/3.编程思维体系构建/3.4.2用什么写 C 语言.md	
+++ b/3.编程思维体系构建/3.4.2用什么写 C 语言.md	
@@ -4,29 +4,29 @@
 
 ## Windows-Visual Studio
 
-[vs2022(Visual Studio 2022)指南&&技巧要领](https://www.bilibili.com/video/BV1Xt411g7jT)
+[vs2022(Visual Studio 2022) 指南&&技巧要领](https://www.bilibili.com/video/BV1Xt411g7jT)
 
 <Bilibili bvid='BV1Xt411g7jT'/>
 
-Visual Studio （以下简称 VS ）是 Windows 下最完美的 C/C++ 等语言的开发平台，有“宇宙第一 IDE”之称，功能丰富，开箱即用。目前更新到 2022 版。
+Visual Studio（以下简称 VS）是 Windows 下最完美的 C/C++ 等语言的开发平台，有“宇宙第一 IDE”之称，功能丰富，开箱即用。目前更新到 2022 版。
 
 什么是 IDE，什么是代码编辑器，什么是编译器等等细碎问题参考文档 [3.1 该使用哪个编辑器？？？](3.1%E8%AF%A5%E4%BD%BF%E7%94%A8%E5%93%AA%E4%B8%AA%E7%BC%96%E8%BE%91%E5%99%A8%EF%BC%9F%EF%BC%9F%EF%BC%9F.md) 看不懂的话直接无脑装
 
-## <strong>下载</strong>
+### <strong>下载</strong>
 
 [https://visualstudio.microsoft.com/zh-hans/downloads/](https://visualstudio.microsoft.com/zh-hans/downloads/)
 
 选择社区版
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnhNeAnlrbcdJciMUY9oNTuc.png)
+![](https://cdn.xyxsw.site/boxcnhNeAnlrbcdJciMUY9oNTuc.png)
 
 社区版和专业版等的区别：社区版免费，功能上几乎无差别
 
-## 安装
+### VS 安装
 
 选择 C++ 桌面开发，其他不用选，有需要了再说。另外，Python 开发不好使，不要像我一样选 Python 开发。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnkjmKcCxIgRIzA5kyUZckye.png)
+![](https://cdn.xyxsw.site/boxcnkjmKcCxIgRIzA5kyUZckye.png)
 
 安装完成后，一般来说 VS 不会自动创建桌面快捷方式，你需要到开始菜单中启动 VS。
 
@@ -34,25 +34,25 @@ Visual Studio （以下简称 VS ）是 Windows 下最完美的 C/C++ 等语言
 
 首次打开应该会让你选择开发环境和主题，建议开发环境选择 C++ ，主题根据个人喜好选择。
 
-## 创建项目
+### 创建项目
 
 VS 是项目制，你需要创建一个项目才能开始编写代码并运行。
 
 打开 VS，会打开如下界面（我使用深色主题），在此处单击“创建新项目”
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn6MgNnY2qBd1yAudeirx6Sh.png)
+![](https://cdn.xyxsw.site/boxcn6MgNnY2qBd1yAudeirx6Sh.png)
 
 在创建新项目页面中选择项目模板为控制台应用（空项目亦可，后续手动添加.c 源文件），并单击下一步
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnFwZpWZ3fQkdd3mCO8Mr9Wj.png)
+![](https://cdn.xyxsw.site/boxcnFwZpWZ3fQkdd3mCO8Mr9Wj.png)
 
 为你的项目起一个名字，以及选择项目的位置，一般默认即可，如果你有强迫症，C 盘一定不能放个人数据，请自行修改。完成后单击“创建”
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnkxd472wIT39DbEiBsyPWzf.png)
+![](https://cdn.xyxsw.site/boxcnkxd472wIT39DbEiBsyPWzf.png)
 
 自此就创建了一个项目了，你将会到达如下界面：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnvOGdjKLnvXvJM7nlE8yVcb.png)
+![](https://cdn.xyxsw.site/boxcnvOGdjKLnvXvJM7nlE8yVcb.png)
 
 其中，左侧（如果在一开始没有选择 C++ 开发环境的话可能在右侧）为资源管理器，列出了本项目所用到的所有文件，包括代码（外部依赖项、源文件、头文件），以及将来开发图形化界面所需的资源文件；最中间占据面积最多的是代码编辑器窗口，你以后将会在这里编写你的 C 语言代码。最下面是输出窗口，源代码进行编译时，会在此处给出编译进度以及可能的代码中的错误。
 
@@ -62,89 +62,92 @@ VS 是项目制，你需要创建一个项目才能开始编写代码并运行
 
 注意控制台项目初始源文件后缀为.cpp 为 C++ 文件，如果编写 C 语言<strong>建议将后缀改为.c</strong>。.cpp 存在隐患：如果不小心使用了 C++ 的语法而非 C 存在的语法，编译器并不会报错，且 C 与 C++ 在某些特性存在区别。
 
-## “运行”你的 C 语言代码
+### “运行”你的 C 语言代码
 
 C 语言是编译型语言，因此说“运行”代码其实并不是十分合适，不过我们初学，不用过分抠字眼，知道什么意思即可。
 
 当你编写完自己的代码后，即可单击“本地 Windows 调试器”（或者使用快捷键 F5）进行“运行”。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnhTxhUYMHeYHdrq0zWzLomb.png)
+![](https://cdn.xyxsw.site/boxcnhTxhUYMHeYHdrq0zWzLomb.png)
 
 你可能会发现在“本地 Windows 调试器”右侧还有一个绿色三角形，并且单击这个也可以“运行”，这两个的区别在于“本地 Windows 调试器”是调试运行，右侧那个是不调试直接运行。
 
-## scanf 报错
+### scanf 报错
 
 如果你的代码被 VS 提示“This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.”
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnfrxYjk5CCjMfY0mLK1B1Ze.png)
+![](https://cdn.xyxsw.site/boxcnfrxYjk5CCjMfY0mLK1B1Ze.png)
 
-需要你在项目-xxx 属性（xxx 是你的项目名）-C/C++-代码生成-安全检查里将安全检查禁用
+需要你在项目-xxx 属性（xxx 是你的项目名）-C/C++-代码生成 - 安全检查里将安全检查禁用
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcniHhCIUQY0oB3ALlxqgciLd.png)
+![](https://cdn.xyxsw.site/boxcniHhCIUQY0oB3ALlxqgciLd.png)
 
-## 调试
+### 调试
 
 IDE 相比于代码编辑器，最强大的一点莫过于成熟的调试系统。通过调试，可以快速定位代码中没有被编译器检查出来的逻辑错误。如果需要调试，则可以在这个位置单击，打下断点，并且运行程序，程序运行时，就会在此处暂停下来，暂停时就可以查看各个变量的值了。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnydHyaNPqUEVVWmbdGofX0d.png)
+![](https://cdn.xyxsw.site/boxcnydHyaNPqUEVVWmbdGofX0d.png)
 
-## <strong>深色主题</strong>
+### <strong>深色主题</strong>
 
-需要深色主题请在工具-主题里更改为深色
+需要深色主题请在工具 - 主题里更改为深色
 
-## Tips
+### Tips
 
-### 仔细查看报错
+#### 仔细查看报错
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnC6TAAdtS0P5HzebFgFn2lc.png)
+![](https://cdn.xyxsw.site/boxcnC6TAAdtS0P5HzebFgFn2lc.png)
 
 如果程序代码中出现红色波浪线，则表示该处代码有“错误”，并且该处的错误会同步显示在下面的这个位置，单击即可看到错误详情。如果代码中出现绿色波浪线，则表示该处代码中有警告。警告和错误的区别是警告可以通过编译运行，但编译器认为你这里可能写错了；错误是完全不可以通过编译。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn7zL0QFakVTpYBdpOmmWOvc.png)
+![](https://cdn.xyxsw.site/boxcn7zL0QFakVTpYBdpOmmWOvc.png)
 
-### 善用提示
+#### 善用提示
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn2ouk043lNQEUkVkIS7bSSd.png)
+![](https://cdn.xyxsw.site/boxcn2ouk043lNQEUkVkIS7bSSd.png)
 
 当你打一些函数名或者关键字时，VS 会给出你语法提示，如果这个提示正确，按下 Tab 键即可将这个提示补全到你的代码里；或者你也可以跟着这个提示打一遍，防止打错关键字。
 
-## VS 的缺点
+### VS 的缺点
 
 过于庞大，很多功能对于初学者来说用不上，对电脑的性能也有略微的要求，但瑕不掩瑜，他的开箱即用的使用体验还是很不错的。
 
-# Windows-Visual Studio Code
+## Windows-Visual Studio Code
 
-Visual Studio Code（以下简称 vscode） 和 Visual Studio 都是微软开发的软件，区别在于 Visual Studio Code 是一个比较轻量的代码编辑器，在没有经过配置的情况下一般只能编写和查看代码，而不能运行，并且 Visual Studio Code 跨平台，在安装了丰富的插件后体验不输于一众 IDE。
+Visual Studio Code（以下简称 vscode）和 Visual Studio 都是微软开发的软件，区别在于 Visual Studio Code 是一个比较轻量的代码编辑器，在没有经过配置的情况下一般只能编写和查看代码，而不能运行，并且 Visual Studio Code 跨平台，在安装了丰富的插件后体验不输于一众 IDE。
 
-## 安装
+> NX 的留言：
+> 鄙人认为 C 的初学者应该使用 VSCode 更佳，环境准备可见鄙人博客 [『C/C++』VScode 环境配置](https://nickxu.me/2021/12/31/cc-vscode-huan-jing-pei-zhi/)
 
-### 安装软件本体
+### vscode 安装
+
+#### 安装软件本体
 
 [https://code.visualstudio.com/](https://code.visualstudio.com/)
 
 在该网站进行下载，并安装，安装完成并打开后可以根据右下角的提示来修改显示语言等
 
-### 安装编译器
+#### 安装编译器
 
 如果你电脑上下载有 VS，那么安装编译器这一环节可以省略。如果电脑上没有 VS，则需要安装 VS，或者下载其他 C 语言编译器，如 gcc，clang，icc 等
 
-## 创建“项目”
+### 创建“项目”
 
 vscode 的项目和 VS 不同，vscode 的项目比较松散，并没有 VS 那样是一套非常完善的项目系统。
 
-首先需要一个空文件夹，并在 vscode 里打开这个文件夹。然后点击文件-新建文本文件，并选择语言为 C 语言。此时如果你是第一次创建 C 语言文件，那么右下角会弹出提示，提示你安装 C/C++ 插件，安装即可。
+首先需要一个空文件夹，并在 vscode 里打开这个文件夹。然后点击文件 - 新建文本文件，并选择语言为 C 语言。此时如果你是第一次创建 C 语言文件，那么右下角会弹出提示，提示你安装 C/C++ 插件，安装即可。
 
-## 编写代码并运行
+### 编写代码并运行
 
-编写完代码后，保存文件，并点击运行-启动调试
+编写完代码后，保存文件，并点击运行 - 启动调试
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnim98FJybpkGl8sfqxP9v9b.png)
+![](https://cdn.xyxsw.site/boxcnim98FJybpkGl8sfqxP9v9b.png)
 
 此时会弹出如下选择框，我的电脑上同时安装有 VS 和 gcc 编译器，因此有两个，大部分的电脑上应该只有一个“C++ (Windows)”，选择你电脑上的编译器并运行即可。
 
 至此就已经完成了编程和调试的基本功能。如果你想要更丰富的功能，比如多文件编译等等，可以自行去网上搜索相关的配置教程。vscode 配置好了是非常好用的，但缺点就在于配置比较麻烦。
 
-# Windows-CLion
+## Windows-CLion
 
 CLion 是 jetbrains 家族的 C 语言 IDE
 
@@ -152,38 +155,41 @@ CLion 是 jetbrains 家族的 C 语言 IDE
 
 收费软件，但可以从 GitHub 学生包里白嫖，喜欢折腾或者喜欢 jetbrains 家族软件风格的可以自己去折腾折腾。
 
-# Mac OS-Visual Studio Code
+## Mac OS-Visual Studio Code
 
 用法和 Windows 的差不多，但由于 Mac OS 自带 clang 编译器，所以无需额外安装编译器。
 
-# Mac OS-CLion
+> NX 的留言：
+> 使用自带的 clang 的确没问题，但是如果你想在 macOS 上使用 gcc/g++ ，[可参考鄙人的博客 在 Mac 的 VSC 中使用 g++ 编译器](https://nickxu.me/2023/04/04/%E5%9C%A8Mac%E7%9A%84VSCode%E4%B8%AD%E4%BD%BF%E7%94%A8g-%E7%BC%96%E8%AF%91%E5%99%A8)
+
+## Mac OS-CLion
 
 同样和 Windows 的差不多。
 
-# Mac OS-Xcode
+## Mac OS-Xcode
 
 XCode 是 mac 官方的 IDE，能编写所有 mac 家族设备的软件。但缺点是没有中文。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn05Ca6Wu5TxFMplZCw2N8Jb.png)
+![](https://cdn.xyxsw.site/boxcn05Ca6Wu5TxFMplZCw2N8Jb.png)
 
 打开以后选择 Create a new Xcode project，选择 macOS-Command Line Tool
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnbnrVCmNGfriHhU5pL76gsd.png)
+![](https://cdn.xyxsw.site/boxcnbnrVCmNGfriHhU5pL76gsd.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnnjaObP5JzpICUx1PMO9MQg.png)
+![](https://cdn.xyxsw.site/boxcnnjaObP5JzpICUx1PMO9MQg.png)
 
 两个空里第一个填项目名，第二个随便填就行
 
 next 后选择项目保存的位置，之后即可到达以下界面：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnl06p0ZS8SSQsWJNLQLYIjc.png)
+![](https://cdn.xyxsw.site/boxcnl06p0ZS8SSQsWJNLQLYIjc.png)
 
 点左上方小三角即可运行
 
 在行号上点击并运行即可调试
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnmRygjmZfwFzODP2N6bVoEh.png)
+![](https://cdn.xyxsw.site/boxcnmRygjmZfwFzODP2N6bVoEh.png)
 
-# Linux
+## Linux
 
-## 你都用 Linux 了你还来问我？一边玩去！
+### 你都用 Linux 了你还来问我？一边玩去
diff --git a/3.编程思维体系构建/3.4.3解决编程问题的普适性过程.md b/3.编程思维体系构建/3.4.3解决编程问题的普适性过程.md
index 080412f..cf3bd42 100644
--- a/3.编程思维体系构建/3.4.3解决编程问题的普适性过程.md
+++ b/3.编程思维体系构建/3.4.3解决编程问题的普适性过程.md
@@ -3,7 +3,7 @@
 - 本篇不需要任何前置知识，推荐在学习 C 语言和学完 C 语言后各看一遍。
 - 我们鼓励你在解决问题的时候进行思考，锻炼解决问题的能力，而不只是成为一个做代码翻译工作的“码农”。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/YAOvb6gquofiAYxsn3tcxcCYngf.png)
+![](https://cdn.xyxsw.site/YAOvb6gquofiAYxsn3tcxcCYngf.png)
 
 解决编程问题的常见误区：
 
@@ -13,7 +13,7 @@
 
 如果你计划得足够好并且代码编写得正确，你的代码将在第一次工作。即便它第一次不起作用，那么你至少有一个对于代码如何调试的可靠计划。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/HMipbO4vSoM3jhxSZ7Kcuddqnxh.png)
+![](https://cdn.xyxsw.site/HMipbO4vSoM3jhxSZ7Kcuddqnxh.png)
 
 ## Work an Example Yourself
 
@@ -65,4 +65,3 @@
 ## Debug Program
 
 一旦在代码中发现了问题，就需要修复它，这个过程称为调试。许多新手程序员（甚至一些经验丰富的程序员）以临时方式调试，试图更改代码中的某些内容，并希望它能解决他们的问题。这样的方法很少有效，常常会导致很多挫折。
-
diff --git a/3.编程思维体系构建/3.4.4C语言前置概念学习.md b/3.编程思维体系构建/3.4.4C语言前置概念学习.md
index f4bcf0e..735839f 100644
--- a/3.编程思维体系构建/3.4.4C语言前置概念学习.md
+++ b/3.编程思维体系构建/3.4.4C语言前置概念学习.md
@@ -20,7 +20,7 @@
 
 7.Web：[LinuxC 一站式编程](https://akaedu.github.io/book/)（难度大，枯燥硬核，收获多，基于 linux）
 
-### 学习建议：可以选择其一或多种学习。
+## 学习建议：可以选择其一或多种学习
 
 - 对于缺乏计算机基础（这里的基础指的是计算机的日常使用）的同学，（1、2）是不错的选择，但在学完后要选择 4、5、6 进行补充巩固提高。
 - 对于有一定计算机基础的同学，直接上手 4、5、6 都是很不错的选择。
@@ -36,6 +36,6 @@
 
 计算机思维与计算机科学与编码能力
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Hqzbbs6iYobnxWxz11Ocfa9gnHd.png)
+![](https://cdn.xyxsw.site/Hqzbbs6iYobnxWxz11Ocfa9gnHd.png)
 
 ### <strong>CS education is more than just “learning how to code”!</strong>
diff --git a/3.编程思维体系构建/3.4.5.1C语言自测标准——链表.md b/3.编程思维体系构建/3.4.5.1C语言自测标准——链表.md
index 7c2ce95..17ef4c0 100644
--- a/3.编程思维体系构建/3.4.5.1C语言自测标准——链表.md
+++ b/3.编程思维体系构建/3.4.5.1C语言自测标准——链表.md
@@ -6,13 +6,13 @@
 
 使用链表存储数据，不强制要求数据在内存中集中存储，各个元素可以分散存储在内存中。例如，使用链表存储 {1,2,3}，各个元素在内存中的存储状态可能是：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnuwZzqX4dF8xKTYajwrDSxf.png)
+![](https://cdn.xyxsw.site/boxcnuwZzqX4dF8xKTYajwrDSxf.png)
 
 可以看到，数据不仅没有集中存放，在内存中的存储次序也是混乱的。那么，链表是如何存储数据间逻辑关系的呢？
 
 链表存储数据间逻辑关系的实现方案是：为每一个元素配置一个指针，每个元素的指针都指向自己的直接后继元素，如下图所示：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnAnkVAJmMT0NSNvo6crXYAd.png)
+![](https://cdn.xyxsw.site/boxcnAnkVAJmMT0NSNvo6crXYAd.png)
 
 显然，我们只需要记住元素 1 的存储位置，通过它的指针就可以找到元素 2，通过元素 2 的指针就可以找到元素 3，以此类推，各个元素的先后次序一目了然。像图 2 这样，数据元素随机存储在内存中，通过指针维系数据之间“一对一”的逻辑关系，这样的存储结构就是链表。
 
@@ -20,13 +20,13 @@
 
 在链表中，每个数据元素都配有一个指针，这意味着，链表上的每个“元素”都长下图这个样子：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcncRc5OKZROtxC9rpQYxrjvf.png)
+![](https://cdn.xyxsw.site/boxcncRc5OKZROtxC9rpQYxrjvf.png)
 
 数据域用来存储元素的值，指针域用来存放指针。数据结构中，通常将这样的整体称为结点。
 
 也就是说，链表中实际存放的是一个一个的结点，数据元素存放在各个结点的数据域中。举个简单的例子，图 3 中 {1,2,3} 的存储状态用链表表示，如下图所示：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn0VMYQlez7tQTNkTPDkCsvg.png)
+![](https://cdn.xyxsw.site/boxcn0VMYQlez7tQTNkTPDkCsvg.png)
 
 在 C 语言中，可以用结构体表示链表中的结点，例如：
 
@@ -42,13 +42,13 @@ typedef struct Node* Link;
 
 图 4 所示的链表并不完整，一个完整的链表应该由以下几部分构成：
 
-头指针:是指向链表中一个结点所在存储位置的指针。如果链表中有头结点，则头指针指向头结点；若链表中没有头结点，则头指针指向链表中第一个数据结点（也叫首元结点）。
+头指针：是指向链表中一个结点所在存储位置的指针。如果链表中有头结点，则头指针指向头结点；若链表中没有头结点，则头指针指向链表中第一个数据结点（也叫首元结点）。
 
 链表有头指针，当我们需要使用链表中的数据时，我们可以使用遍历查找等方法，从头指针指向的结点开始，依次搜索，直到找到需要的数据；反之，若没有头指针，则链表中的数据根本无法使用，也就失去了存储数据的意义。
 
 结点：链表中的节点又细分为头结点、首元结点和其它结点：
 
-头结点:位于链表的表头，即链表中第一个结点，其一般不存储任何数据，特殊情况可存储表示链表信息（表的长度等）的数据。
+头结点：位于链表的表头，即链表中第一个结点，其一般不存储任何数据，特殊情况可存储表示链表信息（表的长度等）的数据。
 
 头结点的存在，其本身没有任何作用，就是一个空结点，但是在对链表的某些操作中，链表有无头结点，可以直接影响编程实现的难易程度。
 
@@ -66,7 +66,7 @@ typedef struct Node* Link;
 
 例如，创建一个包含头结点的链表存储 {1,2,3}，如下图所示：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnjAoO54txAhnu7Ry8ExjGvc.png)
+![](https://cdn.xyxsw.site/boxcnjAoO54txAhnu7Ry8ExjGvc.png)
 
 ## 链表的创建
 
@@ -95,7 +95,7 @@ Link* head = (Link*)malloc(sizeof(Link));                //创建头指针
 
 ```c
 Link p;                                                                                        
-while (Judgement)                                                                //for同理
+while (Judgement)                                                                //for 同理
 {
     p = (Link)malloc(sizeof(Node));
     p->elem = element;
@@ -104,14 +104,14 @@ while (Judgement)
 }
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn8ZxT5oMkScArZjZhgM6TYb.png)
+![](https://cdn.xyxsw.site/boxcn8ZxT5oMkScArZjZhgM6TYb.png)
 
 ### 创建结点——尾插法
 
 ```c
 Link p;
 Link r = (*head);           //临时中间结构指针，在尾插法中始终指向最后一个结点
-while (Judgement)           //for同理
+while (Judgement)           //for 同理
 {
     p = (Link)malloc(sizeof(Node));
     p->elem = element;
@@ -121,7 +121,7 @@ while (Judgement)           //for同理
 }
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnnMjc9pwgZgk1GBmBRlBS6d.png)
+![](https://cdn.xyxsw.site/boxcnnMjc9pwgZgk1GBmBRlBS6d.png)
 
 ## 链表的基本操作
 
@@ -141,20 +141,20 @@ while (Judgement)           //for同理
 ```c
 #define error 0
 #define ok 1
-/*用e返回L中第i个数据元素的值*/
+/*用 e 返回 L 中第 i 个数据元素的值*/
 int GetElem(Link *L, int i; int *e)
 {
     Link p;                                        
-    p = (*L)->next;           //p指向第一个结点
+    p = (*L)->next;           //p 指向第一个结点
     int j  = 1;
-    while (p && j  < i)       //p不为空或者计数器j还没有等于i时，循环继续
+    while (p && j  < i)       //p 不为空或者计数器 j 还没有等于 i 时，循环继续
     {
-        p  =  p->next;        //p指向下一个结点
+        p  =  p->next;        //p 指向下一个结点
         j++;
     }
-    if (!p)                   //第i个元素不存在
+    if (!p)                   //第 i 个元素不存在
         return error;
-    *e = p->elem;             //取第i个元素的数据
+    *e = p->elem;             //取第 i 个元素的数据
     return ok;
 }
 ```
@@ -176,19 +176,19 @@ int GetElem(Link *L, int i; int *e)
 
 例如，在链表 `{1,2,3,4}` 的基础上分别实现在头部、中间、尾部插入新元素 5，其实现过程如图所示：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnxjex5Q3Lt9AAx6roN3ClUg.png)
+![](https://cdn.xyxsw.site/boxcnxjex5Q3Lt9AAx6roN3ClUg.png)
 
-从图中可以看出，虽然新元素的插入位置不同，但实现插入操作的方法是一致的，都是先执行步骤 1 ，再执行步骤 2。实现代码如下：
+从图中可以看出，虽然新元素的插入位置不同，但实现插入操作的方法是一致的，都是先执行步骤 1，再执行步骤 2。实现代码如下：
 
 ```c
-/*在L中第i个位置（注意链表中的位置不一定为结点的个数）之前插入新的数据元素e，
-L的长度加一（可以用头结点存储链表长度）*/
+/*在 L 中第 i 个位置（注意链表中的位置不一定为结点的个数）之前插入新的数据元素 e，
+L 的长度加一（可以用头结点存储链表长度）*/
 int ListInsert(Link *L, int i, int e)
 {
-    Link p, r;          //r为临时中间结构指针，用于实现插入
-    p = *L;             //p指向头结点
+    Link p, r;          //r 为临时中间结构指针，用于实现插入
+    p = *L;             //p 指向头结点
     int j  = 1;
-    while (p && j  < i) //寻找第i个结点，
+    while (p && j  < i) //寻找第 i 个结点，
     {
         p  =  p->next;
         j++;
@@ -207,7 +207,7 @@ int ListInsert(Link *L, int i, int e)
 
 对于没有头结点的链表，在头部插入结点比较特殊，需要单独实现。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn1hlL1Fk4kDK4CPT2hJxwnV.png)
+![](https://cdn.xyxsw.site/boxcn1hlL1Fk4kDK4CPT2hJxwnV.png)
 
 和 2)、3) 种情况相比，由于链表没有头结点，在头部插入新结点，此结点之前没有任何结点，实现的步骤如下：
 
@@ -217,8 +217,8 @@ int ListInsert(Link *L, int i, int e)
 实现代码如下：
 
 ```c
-/*在L中第i个位置（注意链表中的位置不一定为结点的个数）之前插入新的数据元素e，
-L的长度加一（可以用头结点存储链表长度）*/
+/*在 L 中第 i 个位置（注意链表中的位置不一定为结点的个数）之前插入新的数据元素 e，
+L 的长度加一（可以用头结点存储链表长度）*/
 int ListInsert(Link *L, int i, int e)
 {
     if (i == 1)
@@ -253,12 +253,12 @@ temp->next=temp->next->next;
 
 例如，从存有 `{1,2,3,4}` 的链表中删除存储元素 3 的结点，则此代码的执行效果如图 3 所示：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnn3QHja0tzEwqJl9Mk4KnCg.png)
+![](https://cdn.xyxsw.site/boxcnn3QHja0tzEwqJl9Mk4KnCg.png)
 
 实现代码如下：
 
 ```c
-/*删除L中的第i个数据元素，并用e返回其值，L的长度减一
+/*删除 L 中的第 i 个数据元素，并用 e 返回其值，L 的长度减一
 （可以用头结点存储链表长度）*/
 int ListDelete(Link *L, int i, int* e)
 {
@@ -271,7 +271,7 @@ int ListDelete(Link *L, int i, int* e)
         j++;
     }
     if (!(p->next))
-        return error;                        //L中不存在第i个元素
+        return error;                        //L 中不存在第 i 个元素
     r = p->next;                             //标记要删除的结点
     p->next =  r->next;                      //移除结点
     *e =  r->elem;                           //返回结点所存数据
@@ -282,12 +282,12 @@ int ListDelete(Link *L, int i, int* e)
 
 对于不带头结点的链表，需要单独考虑删除首元结点的情况，删除其它结点的方式和图 3 完全相同，如下图所示：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnXjwE0yDFvpQxLaPw7FifxV.png)
+![](https://cdn.xyxsw.site/boxcnXjwE0yDFvpQxLaPw7FifxV.png)
 
 实现代码如下：
 
 ```c
-/*删除L中的第i个数据元素，并用e返回其值，L的长度减一
+/*删除 L 中的第 i 个数据元素，并用 e 返回其值，L 的长度减一
 （可以用头结点存储链表长度）*/
 int ListDelete(Link *L, int i, int* e)
 {
@@ -319,7 +319,7 @@ int ListDelete(Link *L, int i, int* e)
 
 如图所示，假设此时圆周周围有 5 个人，要求从编号为 3 的人开始顺时针数数，数到 2 的那个人出列：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcngx7ZPA7pONbJo82LbNCO1g.png)
+![](https://cdn.xyxsw.site/boxcngx7ZPA7pONbJo82LbNCO1g.png)
 
 出列顺序依次为：
 
@@ -339,10 +339,10 @@ int ListDelete(Link *L, int i, int* e)
 
 为了使空链表和非空链表处理一致，我们通常设一个头结点，当然，并不是说，循环链表一定要头结点，这需要注意。循环链表带有头结点的空链表如图所示：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn3l30usevMTgv1ZbZ0mfJdh.png)
+![](https://cdn.xyxsw.site/boxcn3l30usevMTgv1ZbZ0mfJdh.png)
 
 对于非空的循环链表如图所示：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcngoLTiM9wto9uCGzH7nkjkW.png)
+![](https://cdn.xyxsw.site/boxcngoLTiM9wto9uCGzH7nkjkW.png)
 
 循环链表和单链表的主要差异就在于循环的判断条件上，原来是判断 p->next 是否为空，现在则是 p->next 不等于头结点，则循环未结束。
diff --git a/3.编程思维体系构建/3.4.5阶段一：编程属性.md b/3.编程思维体系构建/3.4.5阶段一：编程属性.md
index 2aa777d..9d81388 100644
--- a/3.编程思维体系构建/3.4.5阶段一：编程属性.md
+++ b/3.编程思维体系构建/3.4.5阶段一：编程属性.md
@@ -1,30 +1,30 @@
 # 阶段一：编程属性
 
-# [C 语言任务模块](https://github.com/E1PsyCongroo/HDU_C_Assignments/)
+## [C 语言任务模块](https://github.com/E1PsyCongroo/HDU_C_Assignments/)
 
 作为一名合格的大学生，更应深谙“纸上得来终觉浅，绝知此事要躬行”的道理，编程语言就像是一个工具，无论你如何熟读说明书（语法、特性），未经实践终究是靠不住的。
 
-本模块将以有趣的任务的形式替你检测是否你已经达到了基本掌握C语言语法和一些特性的目的
+本模块将以有趣的任务的形式替你检测是否你已经达到了基本掌握 C 语言语法和一些特性的目的
 
 - 该任务模块旨在帮助巩固 C 语言基础知识，传递一些编程思维，入门学习请看 [3.4.4C 语言前置概念学习](3.4.4C%E8%AF%AD%E8%A8%80%E5%89%8D%E7%BD%AE%E6%A6%82%E5%BF%B5%E5%AD%A6%E4%B9%A0.md)
 - 你可以通过使用 git工具 `git clone https://github.com/E1PsyCongroo/HDU_C_Assignments.git` 获取任务
 - 或者访问https://github.com/E1PsyCongroo/HDU_C_Assignments 学习
 
-# 任务一做前必查
+## 任务一做前必查
 
-1. 理解[3.4.3解决编程问题的普适性过程](3.4.3%E8%A7%A3%E5%86%B3%E7%BC%96%E7%A8%8B%E9%97%AE%E9%A2%98%E7%9A%84%E6%99%AE%E9%80%82%E6%80%A7%E8%BF%87%E7%A8%8B.md) 。
+1. 理解[3.4.3 解决编程问题的普适性过程](3.4.3%E8%A7%A3%E5%86%B3%E7%BC%96%E7%A8%8B%E9%97%AE%E9%A2%98%E7%9A%84%E6%99%AE%E9%80%82%E6%80%A7%E8%BF%87%E7%A8%8B.md) 。
 2. 理解 C 语言语法基础：变量、表达式、函数、判断、循环、常用标准库函数。
 3. 理解 C 语言中的一切都是数字。
 4. 初步理解 C 语言各类数据类型：基本数据类型和复杂自定义数据类型。
 5. 初步理解 C 语言数组及字符串。
 
-# 任务二做前必查
+## 任务二做前必查
 
 1. 深入理解 C 语言指针、数组和字符串。
 2. 理解递归思想。
 3. 理解复杂自定义数据类型。
 
-### 请阅读各个任务的 README.md，了解完成任务所需的前置知识。
+## 请阅读各个任务的 README.md，了解完成任务所需的前置知识
 
 进阶：评价一个程序，大体分为以下四个层次。
 
diff --git a/3.编程思维体系构建/3.4.6.1.开始冒险.md b/3.编程思维体系构建/3.4.6.1.开始冒险.md
index bf4ae6e..a4f7828 100644
--- a/3.编程思维体系构建/3.4.6.1.开始冒险.md
+++ b/3.编程思维体系构建/3.4.6.1.开始冒险.md
@@ -23,7 +23,7 @@ Bye!
 
 尽管可能微不足道，但该程序确实展示 <em>了</em>任何文本冒险中最重要的方面：描述性文本。一个好的故事是制作一款好的冒险游戏的要素之一。
 
-# 为什么要用英文？
+## 为什么要用英文？
 
 因为中文的编码模式可能会带来奇怪的影响。
 
diff --git a/3.编程思维体系构建/3.4.6.10.增添属性.md b/3.编程思维体系构建/3.4.6.10.增添属性.md
index d830f1f..05e01da 100644
--- a/3.编程思维体系构建/3.4.6.10.增添属性.md
+++ b/3.编程思维体系构建/3.4.6.10.增添属性.md
@@ -14,12 +14,12 @@
 
 假设我们的洞口被警卫挡住了。玩家就过不去，我们可以简单地将通道的<em>目的地</em>更改为终点位置（或 <em>NULL</em>），但这会导致对<em>诸如 go cave 和 look cave</em> 这样的命令做出不正确的回应：“你在这里看不到任何洞穴。我们需要一个将通道的实际终点和虚假终点分开的单独属性。为此，我们将引入一个属性 prospect 来表示后者。
 
-1. 在许多冒险中，玩家以及游戏中的 NPC 在携带量方面受到限制。给每件物品一个重量,角色库存中所有物品的总重量不应超过该角色所能承载的最大重量。当然，我们也可以给一个物体一个非常高的重量，使它不可移动（一棵树，一座房子，一座山）。
-2. RPG 式的冒险游戏需要角色的整个属性范围( 玩家与非玩家 )，例如 HP。HP 为零的对象要么死了，要么根本不是角色。
+1. 在许多冒险中，玩家以及游戏中的 NPC 在携带量方面受到限制。给每件物品一个重量，角色库存中所有物品的总重量不应超过该角色所能承载的最大重量。当然，我们也可以给一个物体一个非常高的重量，使它不可移动（一棵树，一座房子，一座山）。
+2. RPG 式的冒险游戏需要角色的整个属性范围 ( 玩家与非玩家 )，例如 HP。HP 为零的对象要么死了，要么根本不是角色。
 
 我们在 object.txt 中定义了七个新属性：
 
-```
+```c
 #include <stdio.h>
 #include "object.h"
 
@@ -115,13 +115,14 @@ extern OBJECT objs[];
      textGo      "Solid rock is blocking the way."
 ```
 
-注意：textGo 不仅对通道对象有用，而且对非通道对象也有用( 在这种情况下,以后我们将介绍“墙”这个概念)
+注意：textGo 不仅对通道对象有用，而且对非通道对象也有用 ( 在这种情况下，以后我们将介绍“墙”这个概念)
 
-思考题：你能否自行实现上述伪代码？
+::: warning 🤔 思考题：你能否自行实现上述伪代码？
+:::
 
-现在，我们已经可以使用新属性(如果你完成了上面的思考题),<strong>details</strong> 用于新识别的命令<em>外观`<object>`</em>，<strong>textGo</strong> 在我们的命令 <em>go</em> 实现中替换固定文本<em>“OK</em>”。
+现在，我们已经可以使用新属性 (如果你完成了上面的思考题),<strong>details</strong> 用于新识别的命令<em>外观`<object>`</em>，<strong>textGo</strong> 在我们的命令 <em>go</em> 实现中替换固定文本<em>“OK</em>”。
 
-# location.c
+## location.c
 
 ```c
 #include <stdbool.h>
@@ -195,7 +196,7 @@ void executeGo(const char *noun)
 
 属性权重和容量一起成为不能将某些对象移动到周围的可能原因。而 HP 检查代替了角色的硬编码白名单。
 
-# move.c
+## move.c
 
 ```c
 #include <stdbool.h>
@@ -264,7 +265,7 @@ void moveObject(OBJECT *obj, OBJECT *to)
 
 这里还有一个模块可以使用 HP 来识别角色。
 
-# inventory.c
+## inventory.c
 
 ```c
 #include <stdbool.h>
@@ -327,7 +328,8 @@ void executeInventory(void)
 }
 ```
 
-思考题：仔细观察这段代码，看看与你写的有何不同？
+::: warning 🤔 思考题：仔细观察这段代码，看看与你写的有何不同？
+:::
 
 权重检查利用了新功能 <em>weightOfContents，</em>它将在<em>misc.c</em>中实现。在同一模块中，我们还对一些现有函数进行了修改，以支持最后几个属性。
 
@@ -335,7 +337,7 @@ void executeInventory(void)
 
 在函数 <em>getPassage</em> 中我们将属性<em>目标</em>替换为 prospect，并改进<em>对所有</em>命令（而不仅仅是 <em>go</em> and <em>look</em>）的响应，这些命令应用于位于“隐藏通道”另一端的位置。
 
-# misc.h
+## misc.h
 
 ```c
 typedef enum {
@@ -357,7 +359,7 @@ extern OBJECT *actorHere(void);
 extern int listObjectsAtLocation(OBJECT *location);
 ```
 
-# misc.c
+## misc.c
 
 ```c
 #include <stdbool.h>
@@ -432,15 +434,15 @@ int listObjectsAtLocation(OBJECT *location)
 }
 ```
 
-思考题：为什么上面的 getPassage 函数使用了函数指针这种语法？
+::: warning 🤔 思考题：
+为什么上面的 getPassage 函数使用了函数指针这种语法？
 
-```
-   函数指针和指针函数有什么区别？
-```
+函数指针和指针函数有什么区别？
+:::
 
 为了使整个画面完整，最好扩展前面生成的地图，我们可以用虚线表示“明显”的通道。
 
-```c
+```awk
 BEGIN     { print "digraph map {"; }
 /^- /     { outputEdges(); delete a; }
 /^[ \t]/  { a[$1] = $2; }
@@ -462,7 +464,7 @@ function outputEdge(from, to, style)
 
 - 尽量不要太担心浪费仅在某些类型的对象中使用的属性上的内存空间（例如，<em>textGo</em>仅用于通道），或者许多重复的字符串文本。
 - 为了演示属性 prospect 的使用，我们使洞穴无法访问。当您查看新<em>地图时，</em>这一点立即变得很明显。进入洞穴的箭头是虚线的，这意味着这是一个虚假的通道，但不是实际的通道。请放心，洞穴将在下一章重新开放。
-- 请注意，更详细的描述往往需要一个更大的字典（更多的对象，更多的标签）。例如，命令 look silver coin 现在返回 "该硬币的正面有一只鹰"。玩家通过输入一个命令 look eagle 来查看银币，但程序并不知道鹰是什么意思(显然这样子是不行的)。
+- 请注意，更详细的描述往往需要一个更大的字典（更多的对象，更多的标签）。例如，命令 look silver coin 现在返回 "该硬币的正面有一只鹰"。玩家通过输入一个命令 look eagle 来查看银币，但程序并不知道鹰是什么意思 (显然这样子是不行的)。
 
 输出样例
 
diff --git a/3.编程思维体系构建/3.4.6.11.设置条件.md b/3.编程思维体系构建/3.4.6.11.设置条件.md
index ce88931..a1659e4 100644
--- a/3.编程思维体系构建/3.4.6.11.设置条件.md
+++ b/3.编程思维体系构建/3.4.6.11.设置条件.md
@@ -7,12 +7,12 @@
 让我们举一个简单的例子。为了越过守卫进入山洞，玩家必须杀死或贿赂守卫（或两者兼而有之，这很有价值）。换句话说：
 
 - 当警卫死亡时（HP=0），入口开放
-- 当警卫拿着银币(贿赂警卫)时，入口开放
+- 当警卫拿着银币 (贿赂警卫) 时，入口开放
 - 两者都不是，入口关闭
 
 打开一个封闭的通道（在这里是进入洞穴）涉及到改变一些属性值：
 
-- 目的地从 NULL(空地点)变为洞穴
+- 目的地从 NULL(空地点) 变为洞穴
 - <strong>textGo</strong>从 "警卫阻止你...... "改为 "你走进山洞"
 - 在一些特殊情况下，描述和细节不需要改变。但对于一个门洞或栅栏，其中之一（或两者）通常会包含一些从 "开放 "到 "关闭 "的文字。
 
@@ -36,7 +36,8 @@ bool intoCaveIsClosed(void)
 }
 ```
 
-思考题：你能仿照上面例子自己写一些条件函数吗？
+::: warning 🤔 思考题：你能仿照上面例子自己写一些条件函数吗？
+:::
 
 新的属性条件是一个指向这样一个函数的指针。
 
@@ -46,9 +47,9 @@ bool (*condition)(void);
 
 接下来，我们可以立即开始为 object.txt 中的新属性分配函数。
 
-# object.txt
+## object.txt
 
-```
+```txt
 - intoCave
      condition   intoCaveIsOpen
      description "a cave entrance to the east"
@@ -68,11 +69,12 @@ bool (*condition)(void);
      textGo      "The guard stops you from walking into the cave.\n"
 ```
 
-思考题：尝试自己实现上面的伪代码
+::: warning 🤔 思考题：尝试自己实现上面的伪代码
+:::
 
 这两个 "条件 "函数是如此具体，每一个条件函数都只用这一次。现在，我们可以在我们需要的地方定义这些函数。许多编程语言都支持匿名函数，像这样：
 
-```
+```txt
 - intoCave
      condition   { return guard->health == 0 || silver->location == guard; }
      ...
@@ -84,9 +86,9 @@ bool (*condition)(void);
 
 所以现在我们可以把额外的段落和条件添加到 object.txt 中，就像前面解释的那样。
 
-# object.txt
+## new object.txt
 
-```
+```txt
 #include <stdbool.h>
 #include <stdio.h>
 #include "object.h"
@@ -193,11 +195,12 @@ extern OBJECT objs[];
      textGo      "Solid rock is blocking the way."
 ```
 
-思考题：尝试自己实现这些功能，并看看与你之前设计的有何不同
+::: warning 🤔 思考题：尝试自己实现这些功能，并看看与你之前设计的有何不同
+:::
 
 为了使这些条件发挥作用，我们需要调整函数 isHolding 和 getDistance。
 
-# misc.c
+## misc.c
 
 ```c
 #include <stdbool.h>
@@ -273,7 +276,8 @@ int listObjectsAtLocation(OBJECT *location)
 }
 ```
 
-思考题：想想我们调整了什么
+::: warning 🤔 思考题：想想我们调整了什么
+:::
 
 注意：
 
@@ -282,7 +286,8 @@ int listObjectsAtLocation(OBJECT *location)
 3. 为了简单起见，条件函数没有参数。实际上，传递一个参数 OBJECT *obj 可能更好；这使得编写更多的通用条件函数成为可能，可以在多个对象中重复使用。
 4. 在理论上，任何对象都可以成为 "条件"。在下一章，你可以看到一个类似的技术被应用于此。
 
-思考题：想一想上面第二点要怎么用 C 来实现？
+::: warning 🤔 思考题：想一想上面第二点要怎么用 C 来实现？
+:::
 
 输出样例
 
diff --git a/3.编程思维体系构建/3.4.6.12.开启关闭.md b/3.编程思维体系构建/3.4.6.12.开启关闭.md
index ee6985d..d352de3 100644
--- a/3.编程思维体系构建/3.4.6.12.开启关闭.md
+++ b/3.编程思维体系构建/3.4.6.12.开启关闭.md
@@ -1,12 +1,12 @@
 # 12.开启关闭
 
-在上一章中，我们使用 "条件 "函数来使对象消失。当然，还有一个更简单的方法来实现同样的目的：只要清除对象的位置属性就可以了!
+在上一章中，我们使用 "条件 "函数来使对象消失。当然，还有一个更简单的方法来实现同样的目的：只要清除对象的位置属性就可以了！
 
 洞口是一个典型的例子，条件函数在那里工作得特别好。这是因为入口受到其他对象（守卫和银币）中的属性的影响；我们可以使用函数使得所有的逻辑都能保持一致。
 
 让我们举一个更直接的例子。假设山洞有一扇门通向一个密室。只是一个简单的门洞，玩家可以打开和关闭。就像前一章一样，我们将使用两个对象来表示这个通道；一个表示打开的门，另一个表示门关闭时。
 
-```
+```txt
 - backroom
      description "a backroom"
      tags        "backroom"
@@ -28,11 +28,12 @@
      textGo      "The door is closed.\n"
 ```
 
-思考题：尝试自己用 C 语言实现
+::: warning 🤔 思考题：尝试自己用 C 语言实现
+:::
 
 自然，门也应该能从另一侧进入。
 
-```
+```txt
 - openDoorToCave
      description "an open door to the north"
      tags        "north", "door", "doorway"
@@ -111,7 +112,8 @@ else
 }
 ```
 
-思考题：你能不能仿照上面的代码实现 close 功能？
+::: warning 🤔 思考题：你能不能仿照上面的代码实现 close 功能？
+:::
 
 为了使事情稍微复杂一些，我们可以在门上或盒子上加一把锁。这需要（至少）三个相互排斥的对象；每个可能的状态都有一个：打开、关闭和锁定。但是我们仍然可以使用同一个函数来交换对象的位置。例如，这里是如何解锁一个上锁的盒子；反之亦然。
 
@@ -132,15 +134,17 @@ else if (obj == lockedBox)
 
 显然，代码的行数与游戏中的门（以及盒子和其他可以打开的物体）的数量成正比。因此，如果你的游戏有不止几扇门，那么选择一个更通用的解决方案是个好主意。顺便说一下，这对每一个命令都是适用的：当它涉及到许多物体时，尽量写通用代码；但当你处理一两个特殊情况时，就坚持使用直接的、专门的代码。
 
-思考题：我们可以使用什么方法来解决这个问题？
+::: warning 🤔 思考题：
+我们可以使用什么方法来解决这个问题？
 
 提示：C++ 中的模板功能（这只是一种选择）
 
 下面我们将揭晓答案
+:::
 
 通用代码通常带有数据驱动的方法。换句话说，我们需要向我们的对象结构添加一个或多个属性。在这种特殊情况下，我们将为我们希望支持的每个命令添加一个函数指针：打开、关闭、锁定和解锁。
 
-# object.txt
+## object.txt
 
 ```c
 #include <stdbool.h>
@@ -354,7 +358,7 @@ extern OBJECT objs[];
 
 为了避免重复的代码，我们这次特意没有使用匿名函数。相反，我们将在一个单独的模块中实现必要的逻辑。函数 swapLocations 也在其中，这不过是一个稍微扩展的版本，它也会向用户输出反馈。
 
-# toggle.h
+## toggle.h
 
 ```c
 extern void cannotBeOpened(void);
@@ -376,7 +380,7 @@ extern void toggleBox(void);
 extern void toggleBoxLock(void);
 ```
 
-# toggle.c
+## toggle.c
 
 ```c
 #include <stdbool.h>
@@ -439,7 +443,7 @@ void toggleBoxLock(void)
 
 正如前面所宣布的，打开、关闭、锁定和解锁这四个命令的实现是完全通用的。
 
-# openclose.h
+## openclose.h
 
 ```c
 extern void executeOpen(const char *noun);
@@ -448,7 +452,7 @@ extern void executeLock(const char *noun);
 extern void executeUnlock(const char *noun);
 ```
 
-# openclose.c
+## openclose.c
 
 ```c
 #include <stdbool.h>
@@ -478,17 +482,18 @@ void executeUnlock(const char *noun)
 {
    OBJECT *obj = reachableObject("what you want to unlock", noun);
    if (obj != NULL) (*obj->unlock)();
+}
 ```
 
 上面，我们使用了一个通用函数 reachableObject 来处理不在这里的对象；其实现见下文。这样，我们就不必把同样的代码写四遍（每个执行函数写一遍）。更多的命令将在第 15 章中加入；这些命令将受益于同样的函数。
 
-# reach.h
+## reach.h
 
 ```c
 extern OBJECT *reachableObject(const char *intention, const char *noun);
 ```
 
-# reach.c
+## reach.c
 
 ```c
 #include <stdbool.h>
@@ -526,7 +531,7 @@ OBJECT *reachableObject(const char *intention, const char *noun)
 
 同样，我们也要对 parsexec.c 进行补充
 
-# parsexec.c
+## parsexec.c
 
 ```c
 #include <stdbool.h>
diff --git a/3.编程思维体系构建/3.4.6.13.编写解析器.md b/3.编程思维体系构建/3.4.6.13.编写解析器.md
index 7a73c4b..03284bc 100644
--- a/3.编程思维体系构建/3.4.6.13.编写解析器.md
+++ b/3.编程思维体系构建/3.4.6.13.编写解析器.md
@@ -1,6 +1,6 @@
 # 13.编写解析器
 
-每个文本冒险都有一个解析器，但是解析器也有高下之分。一个简单的 "动词-名词 "解析器（就像我们从第二章开始一直使用的那个）对于一个精心设计的冒险游戏来说可能已经足够了。
+每个文本冒险都有一个解析器，但是解析器也有高下之分。一个简单的 "动词 - 名词 "解析器（就像我们从第二章开始一直使用的那个）对于一个精心设计的冒险游戏来说可能已经足够了。
 
 然而，Infocom 已经证明，一个更高级的解析器确实有助于制作一个令人愉快的游戏。它不一定要通过图灵测试。
 
@@ -19,7 +19,8 @@ char *noun = strtok(NULL, "\n");
 - 它确实接受多字对象（如银币），但字与字之间的空格必须准确无误。我们的游戏拒绝银币和硬币之间的双空格。
 - 它是区分大小写的；"向北走 "的命令因为大写的 "G "而不被识别。
 
-思考题：你能想到有什么办法解决这些问题吗？
+::: warning 🤔 思考题：你能想到有什么办法解决这些问题吗？
+:::
 
 编写一个好的分析器并不是一件小事，但在这里我将给你一个相对简单的方法，我们将定义一个由模式列表组成的语法，类似于（但比）正则表达式要简单得多。
 
@@ -30,7 +31,8 @@ char *noun = strtok(NULL, "\n");
 
 为了解析用户的输入，我们将从上到下遍历模式列表，依次尝试将用户的输入与每个模式匹配。我们将在发现第一个匹配时停止。为了简单起见，我们将不使用回溯，尽管这可以在以后添加。
 
-思考题：如果我们使用回溯，那该怎么编写代码？
+::: warning 🤔 思考题：如果我们使用回溯，那该怎么编写代码？
+:::
 
 大写字母是我们语法中的非终端符号，它们可以匹配任何标签（任何对象）。当解析器在两个不同的标签（例如 "银币 "和 "银"）之间进行选择时，较长的标签将被优先考虑。
 
@@ -40,7 +42,7 @@ char *noun = strtok(NULL, "\n");
 const char *params[26];
 ```
 
-该数组有 26 个元素；字母表中的每个（大写）字母都有一个，这足以满足一个模式中多达 26 个不同的非终端。对于一个（匹配的）模式中的每个非终端，将通过在非终端的数组元素中填充一个指向该特定标签的指针来 "捕获 "一个匹配的标签。 params[0]（第一个数组元素）捕获非终端 "A"，params[1]捕获 "B"，以此类推。一个简单的宏定义可以用来找到属于某个非终端的数组元素。
+该数组有 26 个元素；字母表中的每个（大写）字母都有一个，这足以满足一个模式中多达 26 个不同的非终端。对于一个（匹配的）模式中的每个非终端，将通过在非终端的数组元素中填充一个指向该特定标签的指针来 "捕获 "一个匹配的标签。params[0]（第一个数组元素）捕获非终端 "A"，params[1]捕获 "B"，以此类推。一个简单的宏定义可以用来找到属于某个非终端的数组元素。
 
 ```c
 #define paramByLetter(letter)   (params + (letter) - 'A')
@@ -52,7 +54,8 @@ const char *params[26];
 
 假设用户打错了字，输入了 "go kave"。问题是，这个命令到底应不应该匹配 "go A "这个命令？如果我们不想出解决办法，那么这个命令将无法匹配任何其他命令，并最终进入一个通用的错误处理程序，它可能会回答 "我不知道如何去 kave "这样的话。这就失去了改进这些 "消极反应 "的所有机会；回答 "我不知道你要去哪里 "已经感觉更自然了。最好的办法是将所有关于命令去向的答复保持在函数 executeGo 内。
 
-停下来想一想，可以怎么解决这个问题？
+::: warning 🤔 停下来想一想，可以怎么解决这个问题？
+:::
 
 有几种方法可以实现这一点，但最简单的方法是允许非终止符匹配任何东西。所以不仅仅是一个有效的标签，也包括完全的胡言乱语、空白或什么都没有这种语句。这种 "无效 "的输入将被捕获为一个空字符串（""）。
 
@@ -73,17 +76,18 @@ const char *params[26];
 
 前两个命令形式可以为任何顺序，但第三个必须在最后。
 
-思考题：你是否有办法解决这个问题？
+::: warning 🤔 思考题：你是否有办法解决这个问题？
+:::
 
 是时候将其付诸行动了。我们将抛弃模块 parsexec.c 的现有内容，用一个新的函数 parseAndExecute 的实现来取代它，该函数使用一个模式列表，应该能够匹配我们到目前为止实现的每一条命令。每个模式都与一个执行相应命令的函数相联系。
 
-# parsexec.c
+## parsexec.c
 
 ```c
 extern bool parseAndExecute(const char *input);
 ```
 
-# parsexec.h
+## parsexec.h
 
 ```c
 #include <ctype.h>
@@ -149,7 +153,7 @@ bool parseAndExecute(const char *input)
 
 最难的部分是函数 matchCommand 的实现。但正如你在下面看到的，这也可以在不到 100 行的代码中完成。
 
-# match.h
+## match.h
 
 ```c
 #define MAX_PARAMS  26
@@ -161,7 +165,7 @@ extern const char *params[];
 extern bool matchCommand(const char *src, const char *pattern);
 ```
 
-# match.c
+## match.c
 
 ```c
 #include <ctype.h>
@@ -242,7 +246,7 @@ bool matchCommand(const char *src, const char *pattern)
 
 我们调整各种命令的实现，以利用新的数组参数。
 
-# <strong>inventory.h</strong>
+## <strong>inventory.h</strong>
 
 ```c
 extern bool executeGet(void);
@@ -252,7 +256,7 @@ extern bool executeGive(void);
 extern bool executeInventory(void);
 ```
 
-# <strong>inventory.c</strong>
+## <strong>inventory.c</strong>
 
 ```c
 #include <stdbool.h>
@@ -323,7 +327,7 @@ bool executeInventory(void)
 
 我们在上一章中添加的模块也是如此。
 
-# opemclose.h
+## opemclose.h
 
 ```c
 extern bool executeOpen(void);
@@ -332,7 +336,7 @@ extern bool executeLock(void);
 extern bool executeUnlock(void);
 ```
 
-# openclose.c
+## openclose.c
 
 ```c
 #include <stdbool.h>
@@ -372,7 +376,7 @@ bool executeUnlock(void)
 
 在 location.c 中，look around 命令被赋予了自己的功能，与检查特定对象的 look 命令分开（见第 7-12 行）。
 
-# location.h
+## location.h
 
 ```c
 extern bool executeLookAround(void);
@@ -380,7 +384,7 @@ extern bool executeLook(void);
 extern bool executeGo(void);
 ```
 
-# location.c
+## location.c
 
 ```c
 #include <stdbool.h>
@@ -453,7 +457,7 @@ bool executeGo(void)
 }
 ```
 
-我们的游戏仍然只接受简单的动词-名词命令，但新的解析器确实有可能接受有多个名词的命令，如 "put coin in box",这将在下一章中演示。
+我们的游戏仍然只接受简单的动词 - 名词命令，但新的解析器确实有可能接受有多个名词的命令，如 "put coin in box",这将在下一章中演示。
 
 新的解析器比原来的解析器有了很大的改进，但以今天的标准来看，它仍然远远不够完美。例如，没有结构性的方法可以用一个命令操纵多个对象（"获得硬币、钥匙和灯"）或连续执行两个或多个命令（"获得钥匙然后向东走"）。这对于一个 RPG 游戏来说限制实在太大了！
 
diff --git a/3.编程思维体系构建/3.4.6.14.丰富命令.md b/3.编程思维体系构建/3.4.6.14.丰富命令.md
index 80f86f0..9ced0d2 100644
--- a/3.编程思维体系构建/3.4.6.14.丰富命令.md
+++ b/3.编程思维体系构建/3.4.6.14.丰富命令.md
@@ -2,7 +2,7 @@
 
 是时候证明新的解析器确实有能力解释更复杂的命令了。
 
-到目前为止，我们的解析器只接受简单的动词-名词命令。让我们试着解析一些更复杂的命令，比如：
+到目前为止，我们的解析器只接受简单的动词 - 名词命令。让我们试着解析一些更复杂的命令，比如：
 
 - get coin from box
 - put coin in box
@@ -16,7 +16,8 @@
 - ask A from B
 - give A to B
 
-思考题：你能否自行实现这些命令
+::: warning 🤔 思考题：你能否自行实现这些命令
+:::
 
 但是正如前一章所解释的，类似的命令（比如 "从 B 中获取 A "和已经存在的 "获取 A"）必须以正确的顺序排列。如果'get A'首先出现，那么它将消耗任何以'get'开头的命令，包括所有应该被新模式匹配的命令。简而言之，"从 B 获取 A "必须出现在 "获取 A "之前。
 
@@ -32,13 +33,13 @@
 
 目前，我们不需要有两个以上非终结点的模式。
 
-# parsexec.h
+## parsexec.h
 
 ```c
 extern bool parseAndExecute(const char *input);
 ```
 
-# parsexec.c
+## parsexec.c
 
 ```c
 #include <ctype.h>
@@ -106,9 +107,9 @@ bool parseAndExecute(const char *input)
 }
 ```
 
-在一个新的模块 inventory2.c 中，我们实现了新的多名词命令 get、drop/put、ask 和 give。现在我们终于可以把金币放回盒子里了(可喜可贺，可喜可贺)。
+在一个新的模块 inventory2.c 中，我们实现了新的多名词命令 get、drop/put、ask 和 give。现在我们终于可以把金币放回盒子里了 (可喜可贺，可喜可贺)。
 
-# inventory2.h
+## inventory2.h
 
 ```c
 extern bool executeGetFrom(void);
@@ -117,7 +118,7 @@ extern bool executeAskFrom(void);
 extern bool executeGiveTo(void);
 ```
 
-# inventory2.c
+## inventory2.c
 
 ```c
 #include <stdbool.h>
@@ -210,11 +211,12 @@ bool executeGiveTo(void)
 
 仔细观察上面的代码，你可能会注意到，像 "把硬币放进森林 "和 "把硬币放进盒子 "这样的命令（当盒子被关闭时）会得到以下奇怪的回答："这太重了。" 这是因为大多数物体（包括封闭的盒子，以及像森林这样的场景）容纳其他物体的能力为零。这是正确的，但这个信息是很不恰当的。为了避免这种情况，我们将为那些容量为零的物体引入一个单独的信息："这样做似乎不太适合。"
 
-先想想有没有什么办法解决？
+::: warning 🤔 先想想有没有什么办法解决？
+:::
 
 然而，当它作为对 "把钥匙放进盒子里 "的回应时，这个特殊的信息是完全误导的。所以我们将为这种特殊的对象组合做一个特殊的例外。
 
-# move.c
+## move.c
 
 ```c
 #include <stdbool.h>
diff --git a/3.编程思维体系构建/3.4.6.15.赋予明暗.md b/3.编程思维体系构建/3.4.6.15.赋予明暗.md
index af0e4e0..d061695 100644
--- a/3.编程思维体系构建/3.4.6.15.赋予明暗.md
+++ b/3.编程思维体系构建/3.4.6.15.赋予明暗.md
@@ -4,11 +4,11 @@
 
 在黑暗中的效果因游戏而异。通常情况下，它使命令 "look "没有效果。在一些游戏中（如 Zork），黑暗是致命的。在其他游戏中，只要你画出了黑暗区域的详细地图，在没有光源的情况下，你仍然可以取得进展。
 
-我们的游戏将保持在这两者之间；在黑暗中不会让你被杀，但你也不能进入任何通道(具有光亮的通道将是一个例外)。对我们来说，让玩家跑进一个黑暗的区域，而没有不让他机会回到他来的地方，似乎是不公平的。
+我们的游戏将保持在这两者之间；在黑暗中不会让你被杀，但你也不能进入任何通道 (具有光亮的通道将是一个例外)。对我们来说，让玩家跑进一个黑暗的区域，而没有不让他机会回到他来的地方，似乎是不公平的。
 
 好吧，所以首先，我们来设计在黑暗中玩家无法看到周围环境。
 
-# location.c
+## location.c
 
 ```c
 #include <stdbool.h>
@@ -90,7 +90,7 @@ bool executeGo(void)
 
 其次，在黑暗中玩家无法看到或使用附近的物体。
 
-# noun.c
+## noun.c
 
 ```c
 #include <stdbool.h>
@@ -193,7 +193,7 @@ OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun)
 
 在这两种情况下，我们都使用了一个函数 isLit。它在 misc.c 中被定义（并且使用量增多了）。
 
-# misc.h
+## misc.h
 
 ```c
 typedef enum {
@@ -216,7 +216,7 @@ extern OBJECT *actorHere(void);
 extern int listObjectsAtLocation(OBJECT *location);
 ```
 
-# misc.c
+## misc.c
 
 ```c
 #include <stdbool.h>
@@ -318,6 +318,7 @@ int listObjectsAtLocation(OBJECT *location)
       }
    }
    return count;
+}
 ```
 
 注意：
@@ -326,13 +327,14 @@ int listObjectsAtLocation(OBJECT *location)
 - isNoticeable 函数相比 isLit 更进一步。它对每个物体都有效，而不仅仅是地点和灯。它还考虑到玩家库存中的物体总是可以被使用，即使是在黑暗中。
 - 第 60 行：附近的物体仍然隐藏在黑暗中，被视为'不在这里'。这自然可以防止游戏泄露玩家不应该知道的物体的信息。
 
-思考题：你还能想到那哪些可以改进的地方吗？
+::: warning 🤔 思考题：你还能想到那哪些可以改进的地方吗？
+:::
 
 我们为实现 isLit 函数的功能从而使用了一个新的属性 light。
 
-# object.awk
+## object.awk
 
-```
+```awk
 BEGIN {
    count = 0;
    obj = "";
@@ -428,11 +430,11 @@ function outputRecord(separator)
 }
 ```
 
-默认情况下，亮度为零意味着一个物体不发光。在大白天的每一个地点（通常是除了地下的所有地点）都会被赋予一个正(大于 0)的光线值。其实是什么值并不重要，只要它不是零就可以了。我们还将添加一盏灯，玩家可以携带它来穿越黑暗区域。
+默认情况下，亮度为零意味着一个物体不发光。在大白天的每一个地点（通常是除了地下的所有地点）都会被赋予一个正 (大于 0) 的光线值。其实是什么值并不重要，只要它不是零就可以了。我们还将添加一盏灯，玩家可以携带它来穿越黑暗区域。
 
-# object.txt
+## object.txt
 
-```
+```txt
 #include <stdbool.h>
 #include <stdio.h>
 #include "object.h"
@@ -658,7 +660,7 @@ extern OBJECT objs[];
 
 我们将添加一些命令，我们可以用来打开和关闭灯。
 
-# parsexec.c
+## parsexec.c
 
 ```c
 #include <ctype.h>
@@ -733,14 +735,14 @@ bool parseAndExecute(const char *input)
 
 下面是这些命令的实现。
 
-# onoff.h
+## onoff.h
 
 ```c
 extern bool executeTurnOn(void);
 extern bool executeTurnOff(void);
 ```
 
-# onoff.c
+## onoff.c
 
 ```c
 #include <stdbool.h>
@@ -789,7 +791,7 @@ bool executeTurnOff(void)
 
 为了打开和关闭灯，我们将使用我们用来打开和关闭门和盒子的相同技巧（见第 13 章）。
 
-# toggle.h
+## toggle.h
 
 ```c
 extern void cannotBeOpened(void);
@@ -813,7 +815,7 @@ extern void toggleBoxLock(void);
 extern void toggleLamp(void);
 ```
 
-# toggle.c
+## toggle.c
 
 ```c
 #include <stdbool.h>
@@ -895,9 +897,9 @@ void toggleLamp(void)
 
 最后，我们将在我们生成的地图上标记出黑暗的位置。
 
-# map.awk
+## map.awk
 
-```c
+```awk
 BEGIN     { print "digraph map {\n\tnode [style=filled]"; }
 /^- /     { outputEdges(); obj = $2; delete a; }
 /^[ \t]/  { a[$1] = $2; }
@@ -929,9 +931,10 @@ function outputNodes()
 }
 ```
 
-思考题：尝试将上面的伪代码用 C 语言实现其功能
+::: warning 🤔 思考题：尝试将上面的伪代码用 C 语言实现其功能
+:::
 
-玩家们，请注意不要把灯关掉，也不要把它丢掉。如果这样做，那么在黑暗中你将永远无法找回它。换言之，你会被困在黑暗之中! 幸运的是，下一章将提供一个撤销笨拙行动的方法。
+玩家们，请注意不要把灯关掉，也不要把它丢掉。如果这样做，那么在黑暗中你将永远无法找回它。换言之，你会被困在黑暗之中！幸运的是，下一章将提供一个撤销笨拙行动的方法。
 
 输出样例：Welcome to Little Cave Adventure.
 You are in an open field.
diff --git a/3.编程思维体系构建/3.4.6.2.探索未知.md b/3.编程思维体系构建/3.4.6.2.探索未知.md
index 46d00e8..0ddcb65 100644
--- a/3.编程思维体系构建/3.4.6.2.探索未知.md
+++ b/3.编程思维体系构建/3.4.6.2.探索未知.md
@@ -1,26 +1,24 @@
 # 2.探索未知
 
-::: tip 提醒
+::: tip <font size=5><strong> 驾驭项目，而不是被项目驾驭</strong></font>
 
-# <strong> 驾驭项目, 而不是被项目驾驭</strong>
+你和一个项目的关系会经历 4 个阶段：
 
-你和一个项目的关系会经历 4 个阶段:
+1. 被驾驭：你对它一无所知
+2. 一知半解：你对其中的主要模块和功能有了基本的了解
+3. 驾轻就熟：你对整个项目的细节都了如指掌
+4. 为你所用：你可以随心所欲地在项目中添加你认为有用的功能
 
-1. 被驾驭: 你对它一无所知
-2. 一知半解: 你对其中的主要模块和功能有了基本的了解
-3. 驾轻就熟: 你对整个项目的细节都了如指掌
-4. 为你所用: 你可以随心所欲地在项目中添加你认为有用的功能
+如果你想要达成第二个阶段，你需要仔细学习不断探索更新的内容，达到第三个阶段的主要手段是独立完成实验内容和独立调试。至于要达到第四个阶段，就要靠你的主观能动性了：代码还有哪里做得不够好？怎么样才算是够好？应该怎么做才能达到这个目标？
 
-如果你想要达成第二个阶段，你需要仔细学习不断探索更新的内容, 达到第三个阶段的主要手段是独立完成实验内容和独立调试. 至于要达到第四个阶段, 就要靠你的主观能动性了: 代码还有哪里做得不够好? 怎么样才算是够好? 应该怎么做才能达到这个目标?
+你毕业后到了工业界或学术界，就会发现真实的项目也都是这样：
 
-你毕业后到了工业界或学术界, 就会发现真实的项目也都是这样:
-
-1. 刚接触一个新项目, 不知道如何下手
+1. 刚接触一个新项目，不知道如何下手
 2. RTFM, RTFSC, 大致明白项目组织结构和基本的工作流程
-3. 运行项目的时候发现有非预期行为(可能是配置错误或环境错误, 可能是和已有项目对接出错, 也可能是项目自身的 bug), 然后调试. 在调试过程中, 对这些模块的理解会逐渐变得清晰.
-4. 哪天需要你在项目中添加一个新功能, 你会发现自己其实可以胜任.
+3. 运行项目的时候发现有非预期行为 (可能是配置错误或环境错误，可能是和已有项目对接出错，也可能是项目自身的 bug), 然后调试。在调试过程中，对这些模块的理解会逐渐变得清晰。
+4. 哪天需要你在项目中添加一个新功能，你会发现自己其实可以胜任。
 
-这说明了: 如果你一遇到 bug 就找大神帮你调试, 你失去的机会和能力会比你想象的多得多
+这说明了：如果你一遇到 bug 就找大神帮你调试，你失去的机会和能力会比你想象的多得多
 
 :::
 文字冒险游戏的基本交互很简单
@@ -31,17 +29,17 @@
 
 那么，当命令很多的时候，如果你将他写在一起，一个文件有五六千行，我相信这样的情况你是不愿意去看的，因此，我们引入了函数的概念。
 
-自行了解函数的概念，同时去了解当我需要引用别的文件的函数时该怎么办？
-
-了解一下什么是“驼峰原则”，我们为什么要依据它命名函数？
+::: warning 🤔 自行了解函数的概念，同时去了解当我需要引用别的文件的函数时该怎么办？
 
+   了解一下什么是“驼峰原则”，我们为什么要依据它命名函数？
+:::
 下面的代码示例包含三个函数，每个步骤一个函数：
 
 1. 函数<em>getInput</em>。
 2. 函数<em>parseAndExecute</em>。
 3. 函数<em>main</em>，负责重复调用其他两个函数。
 
-# main.c
+## main.c
 
 ```c
 #include <stdbool.h>
@@ -55,7 +53,7 @@ static bool getInput(void)
    printf("\n--> ");
    //你可以将他改成你喜欢的内容
    return fgets(input, sizeof input, stdin) != NULL;
-   //fgets用于收集键盘的输入
+   //fgets 用于收集键盘的输入
 }
 
 int main()
@@ -69,23 +67,26 @@ int main()
 
 注意：某些老版本的 C 语言不支持 bool 选项，你将他改为 int 是一样的。
 
-思考题：static 是什么意思？我为什么要用他？
+::: warning 🤔 思考题：static 是什么意思？我为什么要用他？
+:::
 
-# <strong>parsexec.h</strong>
+## <strong>parsexec.h</strong>
 
 ```c
 extern bool parseAndExecute(char *input);
 ```
 
-思考题：extern 是干什么的？.h 文件又在干嘛？
+::: warning 🤔 思考题：
+extern 是干什么的？.h 文件又在干嘛？
 
 哇，我用了一个指针！input 前面是个指针！！！
 
 指针是啥？[C 指针详解](https://www.runoob.com/w3cnote/c-pointer-detail.html) STFW（虽然都给你了）
 
 在这里用指针是为了传参的时候可以传字符串哦
+:::
 
-# <strong>parsexec.c</strong>
+## <strong>parsexec.c</strong>
 
 ```c
 #include <stdbool.h>
@@ -97,11 +98,11 @@ bool parseAndExecute(char *input)
 {
    char *verb = strtok(input, " \n");
    char *noun = strtok(NULL, " \n");
-   //strtok是string库下的一个函数
+   //strtok 是 string 库下的一个函数
    if (verb != NULL)
    {
       if (strcmp(verb, "quit") == 0)
-      //strcmp也是
+      //strcmp 也是
       {
          return false;
       }
@@ -116,18 +117,20 @@ bool parseAndExecute(char *input)
       else
       {
          printf("I don't know how to '%s'.\n", verb);
-         //%s是verb附加参数的占位符
+         //%s是 verb 附加参数的占位符
       }
    }
    return true;
 }
 ```
 
-你的编译器可能会给出警告 the unused variable ‘noun’，这些不用担心，将会在下一章解决。
+你的编译器可能会给出警告 the unused variable‘noun’，这些不用担心，将会在下一章解决。
 
 返回<em>false</em>将导致主循环结束。
 
-RTFM&&STFW 搞懂 strtok 和 strcmp 的用法
+::: warning <font size=5><strong>RTFM&&STFW</strong></font>
+搞懂 strtok 和 strcmp 的用法
+:::
 
 考虑一下 NULL 是干什么的
 
diff --git a/3.编程思维体系构建/3.4.6.3.指明地点.md b/3.编程思维体系构建/3.4.6.3.指明地点.md
index cd4b749..7d6b06b 100644
--- a/3.编程思维体系构建/3.4.6.3.指明地点.md
+++ b/3.编程思维体系构建/3.4.6.3.指明地点.md
@@ -1,12 +1,12 @@
 # 3.指明地点
 
-某种极其糟糕的编程习惯
-
-# Copy-paste
+::: warning <font size=5>某种极其糟糕的编程习惯</font>
+<font size=5><strong>Copy-paste</strong></font>
 
 我们很多同学在编程的过程中，可能会写出一大堆重复性很强的代码，在最近看的 pa 中，举了这样一个例子，你不需要看懂只需要感受到就可：
+:::
 
-```
+```c
 if (strcmp(s, "$0") == 0)
   return cpu.gpr[0]._64;
 else if (strcmp(s, "ra") == 0)
@@ -86,17 +86,18 @@ bx = torch.cat((xs[0], bs[0], xs[1], bs[1], xs[2], bs[2], xs[3], bs[3], xs[4], b
                xs[24], bs[24], xs[25], bs[25], xs[26], bs[26], xs[27], bs[27], xs[28], bs[28], xs[29], bs[29], xs[30], bs[30], xs[31], bs[31]), 1)
 ```
 
-你想想，你遇到这么长的代码，你愿意看他吗？
+::: tip <font size=5>你想想，你遇到这么长的代码，你愿意看他吗？</font>
 
 更可怕的是，这种编码模式可能会导致意想不到的 bug。
 
-当你发现这些代码有 bug 的时候, 噩梦才刚刚开始. 也许花了好几天你又调出一个 bug 的时候, 才会想起这个 bug 你好像之前在哪里调过. 你也知道代码里面还有类似的 bug, 但你已经分辨不出哪些代码是什么时候从哪个地方复制过来的了.
+当你发现这些代码有 bug 的时候，噩梦才刚刚开始。也许花了好几天你又调出一个 bug 的时候，才会想起这个 bug 你好像之前在哪里调过。你也知道代码里面还有类似的 bug, 但你已经分辨不出哪些代码是什么时候从哪个地方复制过来的了。
 
-这种糟糕的编程习惯叫 Copy-Paste, 经过上面的分析, 相信你也已经领略到它的可怕了. 事实上, [周源源教授](https://cseweb.ucsd.edu/~yyzhou/)的团队在 2004 年就设计了一款工具 CP-Miner, 来自动检测操作系统代码中由于 Copy-Paste 造成的 bug. 这个工具还让周源源教授收获了一篇[系统方向顶级会议 OSDI 的论文](http://pages.cs.wisc.edu/~shanlu/paper/OSDI04-CPMiner.pdf), 这也是她当时所在学校 UIUC 史上的第一篇系统方向的顶级会议论文.
+这种糟糕的编程习惯叫 Copy-Paste, 经过上面的分析，相信你也已经领略到它的可怕了。事实上，[周源源教授](https://cseweb.ucsd.edu/~yyzhou/)的团队在 2004 年就设计了一款工具 CP-Miner, 来自动检测操作系统代码中由于 Copy-Paste 造成的 bug. 这个工具还让周源源教授收获了一篇[系统方向顶级会议 OSDI 的论文](http://pages.cs.wisc.edu/~shanlu/paper/OSDI04-CPMiner.pdf), 这也是她当时所在学校 UIUC 史上的第一篇系统方向的顶级会议论文。
 
-后来周源源教授发现, 相比于操作系统, 应用程序的源代码中 Copy-Paste 的现象更加普遍. 于是她们团队把 CP-Miner 的技术应用到应用程序的源代码中, 并创办了 PatternInsight 公司. 很多 IT 公司纷纷购买 PatternInsight 的产品, 并要求提供相应的定制服务, 甚至 PatternInsight 公司最后还被 VMWare 收购了.
+后来周源源教授发现，相比于操作系统，应用程序的源代码中 Copy-Paste 的现象更加普遍。于是她们团队把 CP-Miner 的技术应用到应用程序的源代码中，并创办了 PatternInsight 公司。很多 IT 公司纷纷购买 PatternInsight 的产品，并要求提供相应的定制服务，甚至 PatternInsight 公司最后还被 VMWare 收购了。
 
-这个故事折射出, 大公司中程序员的编程习惯也许不比你好多少, 他们也会写出 Copy-Paste 这种难以维护的代码. 但反过来说, 重视编码风格这些企业看中的能力, 你从现在就可以开始培养.
+这个故事折射出，大公司中程序员的编程习惯也许不比你好多少，他们也会写出 Copy-Paste 这种难以维护的代码。但反过来说，重视编码风格这些企业看中的能力，你从现在就可以开始培养。
+:::
 
 <em>传统上，文本冒险是由（许多）不同位置组成的虚拟世界。虽然这不是必需的（一些冒险发生在一个房间里！），但这是解释</em><em>数据结构</em><em>使用的好方法。</em>
 
@@ -112,13 +113,13 @@ struct location {
      };
 ```
 
-思考题：我们为什么要用结构体来保存位置？
+::: warning 🤔 思考题：
+  我们为什么要用结构体来保存位置？
 
-```
-        这样子做有什么好处？
-```
+  这样子做有什么好处？
 
-const 又是什么？
+  const 又是什么？
+:::
 
 接下来，我们定义一个位置数组。目前，我们保持它非常简单：只有两个位置。
 
@@ -135,9 +136,9 @@ struct location locs[2] = {
 };
 ```
 
-让我们把它付诸实践。在上一章 （<em>parsexec.c）</em> 的代码示例中，我们更改了第 4、18 和 22 行）。
+让我们把它付诸实践。在上一章（<em>parsexec.c）</em> 的代码示例中，我们更改了第 4、18 和 22 行）。
 
-# <strong>parsexec.c</strong>
+## <strong>parsexec.c</strong>
 
 ```c
 #include <stdbool.h>
@@ -174,14 +175,14 @@ bool parseAndExecute(char *input)
 
 接下来，我们将一个新模块添加到项目中
 
-# <strong>location.h</strong>
+## <strong>location.h</strong>
 
 ```c
 extern void executeLook(const char *noun);
 extern void executeGo(const char *noun);
 ```
 
-# <strong>location.c</strong>
+## <strong>location.c</strong>
 
 ```c
 #include <stdio.h>
diff --git a/3.编程思维体系构建/3.4.6.4.创建对象.md b/3.编程思维体系构建/3.4.6.4.创建对象.md
index ee03ffa..3a7d1ab 100644
--- a/3.编程思维体系构建/3.4.6.4.创建对象.md
+++ b/3.编程思维体系构建/3.4.6.4.创建对象.md
@@ -1,6 +1,6 @@
 # 4.创建对象
 
-<em>在我们继续之前，我</em><em>们</em><em>在这里使用的是</em><em>哲学意义上</em><em>的“对象”一词。它与</em><em>面向对象编程</em><em>无关，也与</em><em>Java</em><em>，</em><em>C#</em><em>和</em><em>Python</em><em>等编程语言中预定义的“对象”类型没有任何共同之处。下面，我将定义一个名为 object 的</em><em>结构体。。</em>
+<em>在我们继续之前，我</em><em>们</em><em>在这里使用的是</em><em>[哲学意义上](https://en.wikipedia.org/wiki/Object_(philosophy))</em><em>的“对象”一词。它与</em><em>[面向对象编程](https://en.wikipedia.org/wiki/Object-oriented_programming)</em><em>无关，也与</em><em>Java</em><em>，</em><em>C#</em><em>和</em><em>Python</em><em>等编程语言中预定义的“对象”类型没有任何共同之处。下面，我将定义一个名为 object 的</em><em>结构体。</em>
 
 冒险游戏中的大多数谜题都围绕着<strong>物品</strong>。例子：
 
@@ -47,9 +47,11 @@ objs[] = {
 
 我们发现 OBJECT 的结构体里面有一个指针和自己长得一样，不用担心，这和链表的操作类似。
 
-思考题：链表是什么，为什么要有这么一个操作指针？
+::: warning 🤔 思考题：
+链表是什么，为什么要有这么一个操作指针？
 
 链表和数组有什么异同点，他们分别在增删改查上有什么优劣？
+:::
 
 为了更容易地用那些所谓的物品或者是地点，我们将为每个元素定义一个名字
 
@@ -80,7 +82,8 @@ for (obj = objs; obj < objs + 5; obj++)
 }
 ```
 
-暂停理解一下吧
+::: warning 🤔 暂停理解一下吧
+:::
 
 那么，我们有合并这个物品（或地点）列表有什么好处呢？答案是这会让我们的代码变得更加简单，因为许多函数（如上面的函数通过这样的列表）只需要扫描单个列表就可以实现，而不是三个列表。有人可能会说没必要，因为每个命令仅适用于一种类型的对象：
 
@@ -96,11 +99,12 @@ for (obj = objs; obj < objs + 5; obj++)
 
 将所有对象放在一个大列表中，很容易添加一个名为“type”的属性来<em>构造对象</em>，以帮助我们区分不同类型的对象。
 
-怎么做怎么遍历呢？先思考吧
+::: warning 🤔 怎么做怎么遍历呢？先思考吧
+:::
 
 但是，对象通常具有同样有效的其他特征：
 
-- <strong>Locations： 通过</strong><strong>道路</strong><strong>连接（将在后面介绍）。如果一个物体无法通过一条通道到达，那么它就不是一个位置。就是这么简单。</strong>
+- <strong>Locations：通过</strong><strong>道路</strong><strong>连接（将在后面介绍）。如果一个物体无法通过一条通道到达，那么它就不是一个位置。就是这么简单。</strong>
 - <strong>Items：玩家唯一可以捡起的物品;</strong><strong>可以给他们整一个重量的属性</strong>
 - <strong>Actors：玩家唯一可以与之交谈，交易，战斗的对象;当然，前提是他们还活着！</strong><strong>可以加一个 HP 属性</strong>
 
@@ -122,7 +126,7 @@ player->location->description
 
 是时候把它们放在一起了。我们从对象数组的全新模块开始
 
-# Object.h
+## Object.h
 
 ```c
 typedef struct object {
@@ -143,7 +147,7 @@ extern OBJECT objs[];
 #define endOfObjs  (objs + 6)
 ```
 
-# Object.c
+## Object.c
 
 ```c
 #include <stdio.h>
@@ -163,15 +167,16 @@ OBJECT objs[] = {
 
 以下模块将帮助我们找到与指定名词匹配的对象。
 
-# noun.h
+## noun.h
 
 ```c
 extern OBJECT *getVisible(const char *intention, const char *noun);
 ```
 
-# 指针？函数？希望你已经掌握这是什么了
+::: warning <font size=5><strong>🤔 指针？函数？希望你已经掌握这是什么了</strong></font>
+:::
 
-# noun.c
+## noun.c
 
 ```c
 #include <stdbool.h>
@@ -229,13 +234,13 @@ OBJECT *getVisible(const char *intention, const char *noun)
 
 这是另一个辅助程序的函数。它打印存在于特定位置的对象（物品，NPC）的列表。它将用于函数 <em>executeLook</em>，在下一章中，我们将介绍另一个需要它的命令。
 
-# misc.h
+## misc.h
 
 ```c
 extern int listObjectsAtLocation(OBJECT *location);
 ```
 
-# misc.c
+## misc.c
 
 ```c
 #include <stdio.h>
@@ -251,7 +256,7 @@ int listObjectsAtLocation(OBJECT *location)
       //排除玩家在玩家的位置这种蠢东西
       {
          if (count++ == 0)
-         //我们需要保证找到一个东西之前他不会打印you see
+         //我们需要保证找到一个东西之前他不会打印 you see
          {
             printf("You see:\n");
          }
@@ -265,14 +270,14 @@ int listObjectsAtLocation(OBJECT *location)
 
 在 <em>location.c</em> 中，命令环<em>顾四周的实现</em>，并根据新的数据结构进行调整。旧的位置数组被删除，变量 <em>locationOfPlayer</em> 也是如此。
 
-# location.h
+## location.h
 
 ```c
 extern void executeLook(const char *noun);
 extern void executeGo(const char *noun);
 ```
 
-# location.c
+## location.c
 
 ```c
 #include <stdio.h>
diff --git a/3.编程思维体系构建/3.4.6.5.捡起物品.md b/3.编程思维体系构建/3.4.6.5.捡起物品.md
index 7b626af..a2ea2bb 100644
--- a/3.编程思维体系构建/3.4.6.5.捡起物品.md
+++ b/3.编程思维体系构建/3.4.6.5.捡起物品.md
@@ -8,19 +8,14 @@
 
 玩家属性不再需要存储在单独的变量中;我们可以使用与任何其他对象相同的数据结构。所以玩家，作为一个对象必须具有以下特点：
 
-- 所处位置(我在哪）
+- 所处位置（我在哪）
 - 玩家可能持有的任何物品的位置。
 
 这使得某些常见操作非常容易实现：
 
-```
-                   <strong> Action    </strong>                         <strong>Typical</strong>
-```
-
-<strong>                                                                 command  </strong>              <strong>Example</strong>
-
-| 玩家从一个位置移动到另一个位置 | go        | player->location = cave;             |
+|**Action**|**Typical Command**|**Example**|
 | ------------------------------ | --------- | ------------------------------------ |
+| 玩家从一个位置移动到另一个位置 | go        | player->location = cave;             |
 | 列出某个位置存在的项和参与者   | look      | listObjectsAtLocation(cave);         |
 | 玩家获取物品                   | get       | silver->location = player;           |
 | 玩家掉落物品                   | drop      | silver->location = player->location; |
@@ -31,11 +26,13 @@
 
 你可以尝试去使用这些命令（上面的前两个示例已经在上一章中实现了）。现在，我们将为玩家和非玩家角色介绍一些典型的<strong>物品栏</strong>操作（命令<em>获取</em>、<em>掉落</em>、<em>给予</em>、<em>询问</em>和<em>物品栏</em>）。
 
-思考题：你能不能尝试自己实现一下上面的命令？
+::: warning 🤔 思考题：
+你能不能尝试自己实现一下上面的命令？
 
 如果你可以在不参考下面内容的情况下就写出基本内容会有很大收获的
+:::
 
-# <strong>parsexec.c</strong>
+## <strong>parsexec.c</strong>
 
 ```c
 #include <stdbool.h>
@@ -48,7 +45,7 @@ bool parseAndExecute(char *input)
 {
    char *verb = strtok(input, " \n");
    char *noun = strtok(NULL, " \n");
-   //第二次使用strtok要用NULL传参
+   //第二次使用 strtok 要用 NULL 传参
    if (verb != NULL)
    {
       if (strcmp(verb, "quit") == 0)      
@@ -94,7 +91,7 @@ bool parseAndExecute(char *input)
 
 新命令由以下模块实现。
 
-# <strong>inventory.h</strong>
+## <strong>inventory.h</strong>
 
 ```c
 extern void executeGet(const char *noun);
@@ -104,7 +101,7 @@ extern void executeGive(const char *noun);
 extern void executeInventory(void);
 ```
 
-# <strong>inventory.c</strong>
+## <strong>inventory.c</strong>
 
 ```c
 #include <stdio.h>
@@ -165,19 +162,21 @@ void executeInventory(void)
 
 注意：由于动词名词比较好弄，命令 <em>ask</em> 和 <em>give</em> 只有一个参数：item。
 
-思考题：为什么我们要这样设计？
+::: warning 🤔 思考题：
+为什么我们要这样设计？
 
 你能否为这些命令多加几个参数？
+:::
 
 从本质上讲，<em>get</em>, <em>drop</em>, <em>give</em> and <em>ask 这些命令</em>除了将项目从一个地方移动到另一个地方之外，什么都不做。单个函数 <em>move 对象</em>可以对所有四个命令执行该操作。
 
-# move.h
+## move.h
 
 ```c
 extern void moveObject(OBJECT *obj, OBJECT *to);
 ```
 
-# move.c
+## move.c
 
 ```c
 #include <stdio.h>
@@ -227,18 +226,19 @@ void moveObject(OBJECT *obj, OBJECT *to)
 }
 ```
 
-思考题：识别一些我们拿不了的物品需要考虑什么因素？
+::: warning 🤔 思考题：识别一些我们拿不了的物品需要考虑什么因素？
+:::
 
 命令“get”使用函数<em>getVisible</em>将名词转换为 object，就像命令“go”一样;请参阅上一章。但是对于对玩家（或其他一些参与者）已经持有的对象进行<em>drop</em>, <em>ask</em>, <em>give 等</em>命令时，我们需要稍微不同的东西。我们将在 <em>noun.c</em> 中添加一个函数 <em>getPossession</em>。
 
-# noun.h
+## noun.h
 
 ```c
 extern OBJECT *getVisible(const char *intention, const char *noun);
 extern OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun);
 ```
 
-# noun.c
+## noun.c
 
 ```c
 #include <stdbool.h>
@@ -318,18 +318,18 @@ OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun)
 }
 ```
 
-注意：新函数（45-75 行） <em>getPossession</em> 是 <em>getObject</em> 的装饰器（wrapper ）（参见第 52 行），它要么返回匹配的对象，要么返回 NULL（如果没有合适的对象与名词匹配）。
+注意：新函数（45-75 行） <em>getPossession</em> 是 <em>getObject</em> 的装饰器（wrapper）（参见第 52 行），它要么返回匹配的对象，要么返回 NULL（如果没有合适的对象与名词匹配）。
 
 函数 <em>actor 这里</em>用于命令 <em>give</em> 和 <em>ask</em>，但它也可能由其他命令调用。所以我们在<em>misc.c</em>中定义了它。
 
-# misc.h
+## misc.h
 
 ```c
 extern OBJECT *actorHere(void);
 extern int listObjectsAtLocation(OBJECT *location);
 ```
 
-# misc.c
+## misc.c
 
 ```c
 #include <stdio.h>
@@ -367,7 +367,8 @@ int listObjectsAtLocation(OBJECT *location)
 }
 ```
 
-思考题：上面第四行中的函数 actorHere 返回的指针指向什么？
+::: warning 🤔 思考题：上面第四行中的函数 actorHere 返回的指针指向什么？
+:::
 
 在第 9 行中，有一个详尽的，硬编码的非玩家角色列表（到目前为止，只有一个：<em>守卫</em>）。
 
diff --git a/3.编程思维体系构建/3.4.6.6.绘制地图.md b/3.编程思维体系构建/3.4.6.6.绘制地图.md
index 015960c..882e064 100644
--- a/3.编程思维体系构建/3.4.6.6.绘制地图.md
+++ b/3.编程思维体系构建/3.4.6.6.绘制地图.md
@@ -28,11 +28,12 @@ struct object {
 - 通道总是朝一个方向运行;要双向连接两个位置，我们总是必须创建两个单独的通道。乍一看，这似乎很笨拙，但它确实给了我们很大的灵活性来完善命令“go”的行为
 - 在大地图上，你可能会发现手动创建所有通道很乏味。所以，我强烈建议你使用自定义工具<em>生成</em>地图中重复性更强的部分。这里不会介绍这一点，但您可能会在第 9 章中找到一些灵感，我们将在其中讨论自动胜场。
 
-思考题：为什么创建两个通道可以使我们的程序更加灵活？
+::: warning 🤔 思考题：为什么创建两个通道可以使我们的程序更加灵活？
+:::
 
 接下来我们将展开对象数组
 
-# object.h
+## object.h
 
 ```c
 typedef struct object {
@@ -56,7 +57,7 @@ extern OBJECT objs[];
 #define endOfObjs  (objs + 8)
 ```
 
-# object.c
+## object.c
 
 ```c
 #include <stdio.h>
@@ -76,7 +77,7 @@ OBJECT objs[] = {
 
 我们将在 <em>misc.c</em> 中添加一个小的帮助函数，以确定两个给定位置之间是否存在通道。
 
-# misc.h
+## misc.h
 
 ```c
 extern OBJECT *getPassage(OBJECT *from, OBJECT *to);
@@ -84,7 +85,7 @@ extern OBJECT *actorHere(void);
 extern int listObjectsAtLocation(OBJECT *location);
 ```
 
-# misc.c
+## misc.c
 
 ```c
 #include <stdio.h>
@@ -140,14 +141,14 @@ int listObjectsAtLocation(OBJECT *location)
 
 我们将在命令“go”的实现中使用新功能<em>getPassage</em>来确定是否存在可以将玩家带到所需位置的通道。
 
-# location.h
+## location.h
 
 ```c
 extern void executeLook(const char *noun);
 extern void executeGo(const char *noun);
 ```
 
-# location.c
+## location.c
 
 ```c
 #include <stdio.h>
@@ -177,7 +178,7 @@ void executeGo(const char *noun)
       // already handled by getVisible
    }
    else if (getPassage(player->location, obj) != NULL)
-   //go只会在有地方的时候才会运行起来
+   //go 只会在有地方的时候才会运行起来
    {
       printf("OK.\n");
       player->location = obj;
@@ -202,14 +203,14 @@ void executeGo(const char *noun)
 
 我们还将使用新功能<em>getPassage</em>来确定从玩家站立的位置是否可以看到某个位置。未通过通道连接到当前位置的位置不被视为可见。
 
-# noun.h
+## noun.h
 
 ```c
 extern OBJECT *getVisible(const char *intention, const char *noun);
 extern OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun);
 ```
 
-# noun.c
+## noun.c
 
 ```c
 #include <stdbool.h>
@@ -294,11 +295,12 @@ OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun)
 
 显然，此示例中的地图是微不足道的：只有两个位置，并且它们在两个方向上都连接在一起。第 12 章将增加第三个地点。
 
-思考题：你能否绘制一张更精细的地图，并将其变成对象列表（位置和通道）
+::: warning 🤔 思考题：
+你能否绘制一张更精细的地图，并将其变成对象列表（位置和通道）
 
-```
-         注：不用当成任务，自行实验即可
-```
+注：不用当成任务，自行实验即可
+
+:::
 
 输出样例
 
diff --git a/3.编程思维体系构建/3.4.6.7.增大距离.md b/3.编程思维体系构建/3.4.6.7.增大距离.md
index bcb0ce3..361b834 100644
--- a/3.编程思维体系构建/3.4.6.7.增大距离.md
+++ b/3.编程思维体系构建/3.4.6.7.增大距离.md
@@ -1,6 +1,6 @@
 # 7.增大距离
 
-<em>一个典型的冒险包含许多谜题。</em><em>众所周知，Infocom</em><em>的冒险很难完成。解决每个难题可能需要数周甚至数月的反复试验。</em>
+<em>一个典型的冒险包含许多谜题。</em><em>众所周知，[Infocom](https://en.wikipedia.org/wiki/Infocom)</em><em>的冒险很难完成。解决每个难题可能需要数周甚至数月的反复试验。</em>
 
 <em>当玩家操纵角色失败后，如果只是返回“你</em><em>不能这么操作</em><em>”来回应玩家</em><em>，会很 nt，很没意思</em><em>。</em>
 
@@ -10,7 +10,7 @@
 
 <em>冒险游戏至少应该做的是解释为什么玩家的命令无法完成：“你不能这样做，因为......”这有助于使虚拟世界更具说服力，故事更可信，游戏更有趣。</em>
 
-我们已经付出了相当大的努力让游戏解释<strong>为什么</strong>某些命令是无效的。只需看看<em>名词.c，inventory.c，location.c</em>，<em>move.c</em>中的许多<em>printf</em>调用。 但随着游戏变得越来越复杂，这正成为一个相当大的负担。我们需要一种更结构化的方法来检测和处理错误情况。这就是我们在本章中将要讨论的内容。
+我们已经付出了相当大的努力让游戏解释<strong>为什么</strong>某些命令是无效的。只需看看<em>名词.c，inventory.c，location.c</em>，<em>move.c</em>中的许多<em>printf</em>调用。但随着游戏变得越来越复杂，这正成为一个相当大的负担。我们需要一种更结构化的方法来检测和处理错误情况。这就是我们在本章中将要讨论的内容。
 
 大多数命令对一个或多个对象进行操作，例如：
 
@@ -64,7 +64,8 @@ typedef enum {
 } DISTANCE;
 ```
 
-typedef 以及枚举类 enum 之前有接触过吗？没有接触过的话就去学习一下吧。
+::: warning 💡 typedef 以及枚举类 enum 之前有接触过吗？没有接触过的话就去学习一下吧。
+:::
 
 在最右边的列中，我们为每个情况提出了一个满足条件。通过一些重新洗牌，我们可以很容易地将其转换为计算对象“距离”的函数（从玩家的角度来看）：
 
@@ -84,9 +85,11 @@ DISTANCE getDistance(OBJECT *from, OBJECT *to)
 }
 ```
 
-思考题：你是否有其他方法实现这个功能？
+::: warning 🤔 思考题：
+你是否有其他方法实现这个功能？
 
 注：自行实验即可
+:::
 
 就这样！我们可以调用此函数并对其返回值进行比较。例如，我们在 noun<em>.c</em>中有以下代码：
 
@@ -110,7 +113,7 @@ else if (!(getDistance(player, obj) == distSelf ||
            getDistance(player, obj) == distHere ||
            getDistance(player, obj) == distOverthere ||
            getDistance(player, obj) == distHeldContained ||
-           getDistance(player, obj) == distHereContained)
+           getDistance(player, obj) == distHereContained))
 ```
 
 这可以简化为：
@@ -119,13 +122,14 @@ else if (!(getDistance(player, obj) == distSelf ||
 else if (getDistance(player, obj) >= distNotHere)
 ```
 
-尝试理解一下这样做的意义
+::: warning 🤔 尝试理解一下这样做的意义
+:::
 
 这只是一个例子，让你对这个概念有所了解;您将在下面找到<em>noun.c</em>的实际实现，看起来略有不同。
 
 是时候把事情落实到位了。枚举 <em>DISTANCE</em> 和函数 <em>getDistance</em> 的定义被添加到 <em>misc.h</em> 和 <em>misc.c</em> 中，因为我们将在多个模块中使用它们。
 
-# misc.h
+## misc.h
 
 ```c
 typedef enum {
@@ -150,7 +154,7 @@ extern OBJECT *actorHere(void);
 extern int listObjectsAtLocation(OBJECT *location);
 ```
 
-# misc.c
+## misc.c
 
 ```c
 #include <stdbool.h>
@@ -226,7 +230,7 @@ int listObjectsAtLocation(OBJECT *location)
 
 注意：isHolding 这个函数之后我们将在各个地方使用
 
-# location.h
+## location.h
 
 ```c
 extern void executeLook(const char *noun);
@@ -235,7 +239,7 @@ extern void executeGo(const char *noun);
 
 在函数 <em>executeGo</em> 中，我们可以用检查距离来替换大多数 <em>if</em> 条件。
 
-# location.c
+## location.c
 
 ```c
 #include <stdbool.h>
@@ -290,11 +294,12 @@ void executeGo(const char *noun)
 }
 ```
 
-思考题：你能否为 switch 函数增加更多 case 来完善判断条件？
+::: warning 🤔 思考题：你能否为 switch 函数增加更多 case 来完善判断条件？
+:::
 
 函数 <em>executeGet</em> 也是如此。
 
-# <strong>inventory.h</strong>
+## <strong>inventory.h</strong>
 
 ```c
 extern void executeGet(const char *noun);
@@ -304,7 +309,7 @@ extern void executeGive(const char *noun);
 extern void executeInventory(void);
 ```
 
-# <strong>inventory.c</strong>
+## <strong>inventory.c</strong>
 
 ```c
 #include <stdbool.h>
@@ -369,14 +374,14 @@ void executeInventory(void)
 
 最后，我们将调整 noun<em>.c</em>中的约束。我们正在向函数<em>getObject</em>添加两个参数，以便找到特定名词的匹配项，同时忽略任何被认为不存在的对象。这将在下一章中得到真正的回报，我们将在下一章中介绍具有相同标签的不同对象。
 
-# noun.h
+## noun.h
 
 ```c
 extern OBJECT *getVisible（const char *intention， const char *noun）;
 extern OBJECT *getPossession（OBJECT *from， const char *verb， const char *noun）;
 ```
 
-# noun.c
+## noun.c
 
 ```c
 #include <stdbool.h>
@@ -455,7 +460,8 @@ OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun)
 }
 ```
 
-思考题：你能理解什么时候加 const，什么时候不用吗？
+::: warning 🤔 思考题：你能理解什么时候加 const，什么时候不用吗？
+:::
 
 在本章中，<em>距离</em>的概念主要用于在游戏可以给用户的不同响应之间进行选择。但是，距离的好处并不局限于<strong>输出</strong>端;它可以同样很好地用于在<strong>输入</strong>端进行改进。在下一章中，我们将使用距离来提高对用户输入的名词的识别。
 
diff --git a/3.编程思维体系构建/3.4.6.8.移动方向.md b/3.编程思维体系构建/3.4.6.8.移动方向.md
index 443c99e..a7220d9 100644
--- a/3.编程思维体系构建/3.4.6.8.移动方向.md
+++ b/3.编程思维体系构建/3.4.6.8.移动方向.md
@@ -1,13 +1,14 @@
 # 8.移动方向
 
-<em>传统的文本冒险使用</em><em>指南针方向</em><em>进行导航。</em>
+<em>传统的文本冒险使用</em><em>[指南针方向](https://en.wikipedia.org/wiki/Cardinal_direction)</em><em>进行导航。</em>
 
 例如，我们在第 6 章中绘制的地图上，玩家可能想<strong>向东</strong>移动，从田野移动到洞穴。我们可以通过给连接<strong>Cave</strong>的通道标上“east”来实现这一点。但是，我们首先需要解决两个问题。
 
 1. 我们可能仍然想把这段通道称为“entrance”和“east”。但现在，一个对象只能有一个标签。
 2. 在更大的地图上，具有更多的位置和道路，标签“east”将被定义多次。到目前为止，标签在我们的游戏中是全球独一无二的，没有重复项。
 
-思考题：你能否想出解决办法？
+::: warning 🤔 思考题：你能否想出解决办法？
+:::
 
 这些问题同样适用于其他对象，而不仅仅是通道。
 
@@ -17,11 +18,11 @@
 
 这立即将我们带到了解析器的第三个问题：
 
-1. 一个标签只能是一个单词;“ sliver coin”这是俩单词，他不接受啊
+1. 一个标签只能是一个单词;“sliver coin”这是俩单词，他不接受啊
 
 所有三个问题都将在本章中解决，从问题#1 开始。它通过为每个对象提供一个标签列表来解决，而不仅仅是一个标签。
 
-# object.h
+## object.h
 
 ```c
 typedef struct object {
@@ -47,7 +48,7 @@ extern OBJECT objs[];
 #define endOfObjs  (objs + 10)
 ```
 
-# object.c
+## object.c
 
 ```c
 #include <stdio.h>
@@ -63,7 +64,7 @@ static const char *tags6[] = {"east", "entrance", NULL};
 static const char *tags7[] = {"west", "exit", NULL};
 static const char *tags8[] = {"west", "north", "south", "forest", NULL};
 static const char *tags9[] = {"east", "north", "south", "rock", NULL};
-//我们不固定标签长度，在结束的时候用NULL来标记
+//我们不固定标签长度，在结束的时候用 NULL 来标记
 OBJECT objs[] = {
    {"an open field"              , tags0, NULL , NULL  },
    {"a little cave"              , tags1, NULL , NULL  },
@@ -75,22 +76,22 @@ OBJECT objs[] = {
    {"an exit to the west"        , tags7, cave , field },
    {"dense forest all around"    , tags8, field, NULL  },
    {"solid rock all around"      , tags9, cave , NULL  }
-   //我们用NULL来阻绝进入一个你不知道的地方
+   //我们用 NULL 来阻绝进入一个你不知道的地方
 };
 ```
 
 当然，要让这个改动生效，我们还需要调整<em>noun.c</em>中的<em>objectHasTag</em>函数。
 
-<em>同时，我们将让函数 getVisible</em>和<em>getPossession</em> 告知玩家他必须更具体的选择你到底是银币还是金币 ，而不是随机选择任何一个对象。
+<em>同时，我们将让函数 getVisible</em>和<em>getPossession</em> 告知玩家他必须更具体的选择你到底是银币还是金币，而不是随机选择任何一个对象。
 
-# noun.h
+## noun.h
 
 ```c
 extern OBJECT *getVisible(const char *intention, const char *noun);
 extern OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun);
 ```
 
-# <strong>noun.c</strong>
+## <strong>noun.c</strong>
 
 ```c
 #include <stdbool.h>
@@ -107,7 +108,7 @@ static bool objectHasTag(OBJECT *obj, const char *noun)
       for (tag = obj->tags; *tag != NULL; tag++)
       {
          if (strcmp(*tag, noun) == 0) return true;
-      }//扫描对象的tag列表
+      }//扫描对象的 tag 列表
    }
    return false;
 }
@@ -187,9 +188,9 @@ OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun)
 }
 ```
 
-问题 #3 可以通过从函数<em>parseAndExecute</em>中删除一个 [空格](http://en.wikipedia.org/wiki/Space_(punctuation))字符来解决（下面的第 10 行）。这个解决方案远非完美（'silver' 和 'coin' 之间的双空格是大咩的），但直到我们在第 13 章中让自己成为一个更好的解析器之前。
+问题 #3 可以通过从函数<em>parseAndExecute</em>中删除一个 [空格](http://en.wikipedia.org/wiki/Space_(punctuation))字符来解决（下面的第 10 行）。这个解决方案远非完美（'silver' 和 'coin' 之间的双空格是打咩的），但直到我们在第 13 章中让自己成为一个更好的解析器之前。
 
-# parsexec.c
+## parsexec.c
 
 ```c
 #include <stdbool.h>
@@ -249,4 +250,5 @@ bool parseAndExecute(char *input)
 
 现在对象数组 ( <em>object.c</em> ) 开始在多个维度上增长（特别是在引入多个标签的情况下），我们需要一种使其更易于维护的方法。
 
-猜猜看该怎么办？
+::: warning 🤔 猜猜看该怎么办？
+:::
diff --git a/3.编程思维体系构建/3.4.6.9.练习：生成代码.md b/3.编程思维体系构建/3.4.6.9.练习：生成代码.md
index fe7f8c0..37fae34 100644
--- a/3.编程思维体系构建/3.4.6.9.练习：生成代码.md
+++ b/3.编程思维体系构建/3.4.6.9.练习：生成代码.md
@@ -1,10 +1,10 @@
-# 9.练习:生成代码
+# 9.练习：生成代码
 
-*到目前为止，我们的冒险游戏有10个对象。每个对象由有5 个属性组成。一个真正的文本冒险可能有数百个甚至数千个对象，并且每个对象的属性数量也可能增加（请参阅下一章）。在目前的形式下，维护如此庞大的对象和属性列表将很困难。*
+*到目前为止，我们的冒险游戏有 10 个对象。每个对象由有 5 个属性组成。一个真正的文本冒险可能有数百个甚至数千个对象，并且每个对象的属性数量也可能增加（请参阅下一章）。在目前的形式下，维护如此庞大的对象和属性列表将很困难。*
 
-例如，当我们在添加对象 *wallField* 和 *wallCave* 时，我们必须在三个不同的位置执行此操作：一次在 *object.h* 中（作为*#define*），两次在 *object.c* 中（数组 *objs* 中的一个元素，以及一个单独的标签数组）。这显然十分笨拙并且容易出错。
+例如，当我们在添加对象 *wallField* 和 *wallCave* 时，我们必须在三个不同的位置执行此操作：一次在 *object.h* 中（作为<em>#define</em>），两次在 *object.c* 中（数组 *objs* 中的一个元素，以及一个单独的标签数组）。这显然十分笨拙并且容易出错。
 
-我们将不再手工维护object. h和object. c，而是从更适合我们需要的单一源开始生成文件。这个新的源文件可以用你喜欢的任何语言( 典型的是某些特定领域的语言 )，只要你有工具把它转换回C。下面是一个简单的例子，考虑下列布局来组织我们的对象：
+我们将不再手工维护 object. h 和 object. c，而是从更适合我们需要的单一源开始生成文件。这个新的源文件可以用你喜欢的任何语言 ( 典型的是某些特定领域的语言 )，只要你有工具把它转换回 C。下面是一个简单的例子，考虑下列布局来组织我们的对象：
 
 ```txt
                  /* Raw C code (declarations) */
@@ -21,7 +21,7 @@
 
 根据到目前为止收集的对象，我们可以构造以下源文件。文件名并不重要;我只是简单地将其命名为*object.txt*，以明确它与*object.h*和*object.c*相关。
 
-# object.txt
+## object.txt
 
 ```txt
 #include <stdio.h>
@@ -87,4 +87,5 @@ extern OBJECT objs[];
      location    cave
 ```
 
-思考题：你能否自己用C来实现这段伪代码？
\ No newline at end of file
+::: warning 🤔 思考题：你能否自己用 C 来实现这段伪代码？
+:::
diff --git a/3.编程思维体系构建/3.4.6阶段二：文字冒险（cool）.md b/3.编程思维体系构建/3.4.6阶段二：文字冒险（cool）.md
index e87fd8d..f492b80 100644
--- a/3.编程思维体系构建/3.4.6阶段二：文字冒险（cool）.md
+++ b/3.编程思维体系构建/3.4.6阶段二：文字冒险（cool）.md
@@ -1,6 +1,6 @@
 # 阶段二：文字冒险（cool）
 
-# 前言
+## 前言
 
 本来打算让各位做下面的任务来进行进一步的学习的，但是想了想，实在是，<strong>太无聊啦</strong>！
 
@@ -20,24 +20,24 @@
 
 当然，如果你选择跳过，也不会对 python 开发那里造成非常大的影响但是你会错失一个非常宝贵的学习机会。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnustZBhjMu8FPN0Kxi4Mwvf.jpg)
+![](https://cdn.xyxsw.site/boxcnustZBhjMu8FPN0Kxi4Mwvf.jpg)
 
 在 1980 年代， [文字冒险](http://en.wikipedia.org/wiki/Text_adventure) 是一种受人尊敬的电脑游戏类型。但是时代已经变了，在 21 世纪，它们与 带有 3D 引擎的现代 [MMORPG 相比显得苍白无力。](http://en.wikipedia.org/wiki/Mmorpg)书籍在电影的兴起中幸存下来，而基于文本的游戏很快就输掉了与图形游戏的战斗。“互动小说”由一个活跃的社区保持活力，但它的商业价值早已不复存在。
 
-# 系统调试的黄金法则：KISS 原则
+## 系统调试的黄金法则：KISS 原则
 
-这里的 `KISS` 是 `Keep It Simple, Stupid` 的缩写, 它的中文翻译是: 不要在一开始追求绝对的完美.
+这里的 `KISS` 是 `Keep It Simple, Stupid` 的缩写，它的中文翻译是：不要在一开始追求绝对的完美。
 
-随着以后代码量会越来越多, 各个模块之间的交互也越来越复杂, 工程的维护变得越来越困难, 一个很弱智的 bug 可能需要调好几天.
+随着以后代码量会越来越多，各个模块之间的交互也越来越复杂，工程的维护变得越来越困难，一个很弱智的 bug 可能需要调好几天。
 
-在这种情况下, 系统能跑起来才是王道, 跑不起来什么都是浮云, 追求面面俱到只会增加代码维护的难度.
+在这种情况下，系统能跑起来才是王道，跑不起来什么都是浮云，追求面面俱到只会增加代码维护的难度。
 
-唯一可以把你从 bug 的混沌中拯救出来的就是 KISS 法则, 它的宗旨是<strong>从易到难, 逐步推进</strong>, 一次只做一件事, 少做无关的事.
+唯一可以把你从 bug 的混沌中拯救出来的就是 KISS 法则，它的宗旨是<strong>从易到难，逐步推进</strong>, 一次只做一件事，少做无关的事。
 
-如果你不知道这是什么意思, 我们以可能发生的 `str` 成员缓冲区溢出问题来作为例子. KISS 法则告诉你, 你应该使用 `assert(0)`, 就算不"得体"地处理上述问题, 仍然不会影响表达式求值的核心功能的正确性.
+如果你不知道这是什么意思，我们以可能发生的 `str` 成员缓冲区溢出问题来作为例子。KISS 法则告诉你，你应该使用 `assert(0)`, 就算不"得体"地处理上述问题，仍然不会影响表达式求值的核心功能的正确性。
 
-如果你还记得调试公理, 你会发现两者之间是有联系的: 调试公理第二点告诉你, 未测试代码永远是错的. 与其一下子写那么多"错误"的代码, 倒不如使用 `assert(0)` 来有效帮助你减少这些"错误".
+如果你还记得调试公理，你会发现两者之间是有联系的：调试公理第二点告诉你，未测试代码永远是错的。与其一下子写那么多"错误"的代码，倒不如使用 `assert(0)` 来有效帮助你减少这些"错误".
 
-如果把 KISS 法则放在软件工程领域来解释, 它强调的就是多做[单元测试](http://en.wikipedia.org/wiki/Unit_testing): 写一个函数, 对它进行测试, 正确之后再写下一个函数, 再对它进行测试... 一种好的测试方式是使用 assertion 进行验证,
+如果把 KISS 法则放在软件工程领域来解释，它强调的就是多做[单元测试](http://en.wikipedia.org/wiki/Unit_testing): 写一个函数，对它进行测试，正确之后再写下一个函数，再对它进行测试... 一种好的测试方式是使用 assertion 进行验证，
 
-KISS 法则不但广泛用在计算机领域, 就连其它很多领域也视其为黄金法则, [这里](http://blog.sciencenet.cn/blog-414166-562616.html)有一篇文章举出了很多的例子, 我们强烈建议你阅读它, 体会 KISS 法则的重要性.
+KISS 法则不但广泛用在计算机领域，就连其它很多领域也视其为黄金法则，[这里](http://blog.sciencenet.cn/blog-414166-562616.html)有一篇文章举出了很多的例子，我们强烈建议你阅读它，体会 KISS 法则的重要性。
diff --git a/3.编程思维体系构建/3.4.7.1.1调试理论.md b/3.编程思维体系构建/3.4.7.1.1调试理论.md
index 2a1e2f0..560add4 100644
--- a/3.编程思维体系构建/3.4.7.1.1调试理论.md
+++ b/3.编程思维体系构建/3.4.7.1.1调试理论.md
@@ -1,6 +1,6 @@
 # 调试理论
 
-# 调试公理
+::: warning 🌲 调试公理
 
 - The machine is always right. (机器永远是对的)
 
@@ -9,32 +9,34 @@
 
   - Corollary: Mistakes are likely to appear in the "must-be-correct" code.
 
-这两条公理的意思是: 抱怨是没有用的, 接受代码有 bug 的现实, 耐心调试.
+这两条公理的意思是：抱怨是没有用的，接受代码有 bug 的现实，耐心调试.
+:::
 
-# 如何调试
+::: warning 😋 如何调试
 
 - 不要使用"目光调试法", 要思考如何用正确的工具和方法帮助调试
 
-  - 程序设计课上盯着几十行的程序, 你或许还能在大脑中像 NEMU 那样模拟程序的执行过程; 但程序规模大了之后, 很快你就会放弃的: 你的大脑不可能模拟得了一个巨大的状态机
-  - 我们学习计算机是为了学习计算机的工作原理, 而不是学习如何像计算机那样机械地工作
-- 使用 `assert()` 设置检查点, 拦截非预期情况
+  - 程序设计课上盯着几十行的程序，你或许还能在大脑中像 NEMU 那样模拟程序的执行过程; 但程序规模大了之后，很快你就会放弃的：你的大脑不可能模拟得了一个巨大的状态机
+  - 我们学习计算机是为了学习计算机的工作原理，而不是学习如何像计算机那样机械地工作
+- 使用 `assert()` 设置检查点，拦截非预期情况
 
   - 例如 `assert(p != NULL)` 就可以拦截由空指针解引用引起的段错误
-- 结合对程序执行行为的理解, 使用 `printf()` 查看程序执行的情况(注意字符串要换行)
+- 结合对程序执行行为的理解，使用 `printf()` 查看程序执行的情况 (注意字符串要换行)
 
-  - `printf()` 输出任意信息可以检查代码可达性: 输出了相应信息, 当且仅当相应的代码块被执行
-  - `printf()` 输出变量的值, 可以检查其变化过程与原因
+  - `printf()` 输出任意信息可以检查代码可达性：输出了相应信息，当且仅当相应的代码块被执行
+  - `printf()` 输出变量的值，可以检查其变化过程与原因
 - 使用 GDB 观察程序的任意状态和行为
 
-  - 打印变量, 断点, 监视点, 函数调用栈...
+  - 打印变量，断点，监视点，函数调用栈...
+:::
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnaqLMfwqNMTcYEPuF3vFjqg.png)
+![](https://cdn.xyxsw.site/boxcnaqLMfwqNMTcYEPuF3vFjqg.png)
 
-# 调试理论
+## 什么是调试理论
 
 如果我们能判定任意程序状态的正确性，那么给定一个 failure，我们可以通过二分查找定位到第一个 error 的状态，此时的代码就是 fault (bug)。
 
-# 正确的方法：理解程序的执行过程，弄清楚到底为何导致了 bug
+## 正确的方法：理解程序的执行过程，弄清楚到底为何导致了 bug
 
 - `ssh`：使用 `-v` 选项检查日志
 - `gcc`：使用 `-v` 选项打印各种过程
@@ -44,22 +46,22 @@
 
 各个工具普遍提供调试功能，帮助用户/开发者了解程序的行为
 
-# 错误概念
+## 错误概念
 
-我们来简单梳理一下段错误发生的原因. 首先, 机器永远是对的. 如果程序出了错, 先怀疑自己的代码有 bug . 比如由于你的疏忽, 你编写了 `if (p = NULL)` 这样的代码. 但执行到这行代码的时候, 也只是 `p` 被赋值成 `NULL`, 程序还会往下执行. 然而等到将来对 `p` 进行了解引用的时候, 才会触发段错误, 程序彻底崩溃.
+我们来简单梳理一下段错误发生的原因。首先，机器永远是对的。如果程序出了错，先怀疑自己的代码有 bug . 比如由于你的疏忽，你编写了 `if (p = NULL)` 这样的代码。但执行到这行代码的时候，也只是 `p` 被赋值成 `NULL`, 程序还会往下执行。然而等到将来对 `p` 进行了解引用的时候，才会触发段错误，程序彻底崩溃。
 
-我们可以从上面的这个例子中抽象出一些软件工程相关的概念:
+我们可以从上面的这个例子中抽象出一些软件工程相关的概念：
 
-- Fault: 实现错误的代码, 例如 `if (p = NULL)`
-- Error: 程序执行时不符合预期的状态, 例如 `p` 被错误地赋值成 `NULL`
-- Failure: 能直接观测到的错误, 例如程序触发了段错误
+- Fault: 实现错误的代码，例如 `if (p = NULL)`
+- Error: 程序执行时不符合预期的状态，例如 `p` 被错误地赋值成 `NULL`
+- Failure: 能直接观测到的错误，例如程序触发了段错误
 
-调试其实就是从观测到的 failure 一步一步回溯寻找 fault 的过程, 找到了 fault 之后, 我们就很快知道应该如何修改错误的代码了. 但从上面的例子也可以看出, 调试之所以不容易, 恰恰是因为:
+调试其实就是从观测到的 failure 一步一步回溯寻找 fault 的过程，找到了 fault 之后，我们就很快知道应该如何修改错误的代码了。但从上面的例子也可以看出，调试之所以不容易，恰恰是因为：
 
 - fault 不一定马上触发 error
 - 触发了 error 也不一定马上转变成可观测的 failure
-- error 会像滚雪球一般越积越多, 当我们观测到 failure 的时候, 其实已经距离 fault 非常遥远了
+- error 会像滚雪球一般越积越多，当我们观测到 failure 的时候，其实已经距离 fault 非常遥远了
 
-理解了这些原因之后, 我们就可以制定相应的策略了:
+理解了这些原因之后，我们就可以制定相应的策略了：
 
-- 尽可能把 fault 转变成 error. 这其实就是测试做的事情, 所以我们在上一节中加入了表达式生成器的内容, 来帮助大家进行测试, 后面的实验内容也会提供丰富的测试用例. 但并不是有了测试用例就能把所有 fault 都转变成 error 了, 因为这取决于测试的覆盖度. 要设计出一套全覆盖的测试并不是一件简单的事情, 越是复杂的系统, 全覆盖的测试就越难设计. 但是, 如何提高测试的覆盖度, 是学术界一直以来都在关注的问题.
+- 尽可能把 fault 转变成 error. 这其实就是测试做的事情，所以我们在上一节中加入了表达式生成器的内容，来帮助大家进行测试，后面的实验内容也会提供丰富的测试用例。但并不是有了测试用例就能把所有 fault 都转变成 error 了，因为这取决于测试的覆盖度。要设计出一套全覆盖的测试并不是一件简单的事情，越是复杂的系统，全覆盖的测试就越难设计。但是，如何提高测试的覆盖度，是学术界一直以来都在关注的问题。
diff --git a/3.编程思维体系构建/3.4.7.1GDB初探索（编程可阅览）.md b/3.编程思维体系构建/3.4.7.1GDB初探索（编程可阅览）.md
index ed04eaa..855b24b 100644
--- a/3.编程思维体系构建/3.4.7.1GDB初探索（编程可阅览）.md
+++ b/3.编程思维体系构建/3.4.7.1GDB初探索（编程可阅览）.md
@@ -2,59 +2,63 @@
 
 请在开始进行 C 语言编程之后查阅使用
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnHXggg6eLy86vFmb4shOksh.png)
+![](https://cdn.xyxsw.site/boxcnHXggg6eLy86vFmb4shOksh.png)
 
-# GDB 是什么？
+## GDB 是什么？
 
 调试器，简单来说就是当你代码跑不通时候修正错误用的
 
+[GDB's Mascot?](https://sourceware.org/gdb/mascot/)
+
 可搭配插件 gef pwndbg pwngdb peda
 
-# 基本操作
+## 基本操作
+
+[GDB 快速入门教程](https://www.bilibili.com/video/BV1EK411g7Li/)
 
 ### <strong>GDB 使用表</strong>
 
-<em>run （r）</em>运行程序
+`run (r)`运行程序
 
-<em>b</em>打断点，可以在函数和位置打断点
+`b`打断点，可以在函数和位置打断点
 
-<em>info b</em>查看打断点的位置
+`info b`查看打断点的位置
 
-<em>n</em>下一步，跳过函数的
+`n`下一步，跳过函数的
 
-<em>list</em>查看源代码
+`list`查看源代码
 
-<em>-p</em>走 PID 路线
+`-p`走 PID 路线
 
-edit [file:]function 看现在停下的函数位置
+`edit [file:]function` 看现在停下的函数位置
 
-step 进入任何函数
+`step` 进入任何函数
 
-<em>p</em>打印变量
+`p`打印变量
 
-<em>shell</em>输入命令
+`shell`输入命令
 
-<em>set logging on</em>记录日志
+`set logging on`记录日志
 
-<em>watchpoint</em>观察变量是否变化的观察点
+`watchpoint`观察变量是否变化的观察点
 
-<em>watch</em>设置观察点位置，watch*（地址）
+`watch`设置观察点位置，watch*（地址）
 
-<em>layout split</em>开启 TUI 模式
+`layout split`开启 TUI 模式
 
-<em>whatis</em>查看变量类型
+`whatis`查看变量类型
 
-<em>ptype</em>查看详细信息
+`ptype`查看详细信息
 
 #### <strong>TUI</strong>
 
-<em>ctrl +x +a</em>开启
+`ctrl + x + a`开启
 
-<em>ctrl</em>+<em>p</em>+<em>n</em>往前
+`ctrl + p + n`往前
 
-<em>ctrl</em> +<em>l</em>重新整理页面
+`ctrl + l`重新整理页面
 
-# 官方手册
+## 官方手册
 
 [GDB User Manual](https://sourceware.org/gdb/current/onlinedocs/gdb)
 
diff --git a/3.编程思维体系构建/3.4.7.2C的历史问题：undefined behavior.md b/3.编程思维体系构建/3.4.7.2C的历史问题：undefined behavior.md
index 46b7141..ec8a473 100644
--- a/3.编程思维体系构建/3.4.7.2C的历史问题：undefined behavior.md	
+++ b/3.编程思维体系构建/3.4.7.2C的历史问题：undefined behavior.md	
@@ -1,6 +1,6 @@
 # C 的历史问题：undefined behavior
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnIdOChXQUGMvnxWcB7uTWLh.png)
+![](https://cdn.xyxsw.site/boxcnIdOChXQUGMvnxWcB7uTWLh.png)
 
 简写为 UB
 
@@ -22,7 +22,7 @@ int main(int argc, char **argv) {
 }
 ```
 
-讓我們看看不同編譯器的 Debug 模式下執行的結果
+让我们看看不同编译器的 Debug 模式下执行的结果
 
 Visual C++ 6.0
 
@@ -36,7 +36,7 @@ MinGW(GCC)
 
 > The answer : 25
 
-我們試試看在 Release 下執行的結果
+我们试试看在 Release 下执行的结果
 
 Visual C++ 6.0
 
@@ -50,9 +50,9 @@ MinGW(GCC)
 
 > The answer : 25
 
-C 語言最初為了開發 UNIX 和系統軟體而生，本質是低階的程式語言，
+C 语言最初为了开发 UNIX 和系统软体而生，本质是低阶的程式语言
 
-在語言規範層級存在 UB，可允許編譯器引入更多最佳化。比方說 `X * 2 / 2` 在沒有 overflow 發生的時候，可最佳化為 `X`。
+在语言规范层级存在 UB，可允许编译器引入更多最佳化。比方说 `X * 2 / 2` 在沒有 overflow 发生的時候，可最佳化为 `X`。
 
 而且值得注意的是，在你的程序初始化之前，栈里面塞的一堆东西也是 UB。
 
@@ -64,4 +64,4 @@ C 語言最初為了開發 UNIX 和系統軟體而生，本質是低階的程式
 
 [万恶的未定义行为 | 程式设计 遇上 小提琴](https://blog.ez2learn.com/2008/09/27/evil-undefined-behavior/)
 
-<del>关键是，老师喜欢出题刁难你啊!真烦啊！</del>
+<del>关键是，老师喜欢出题刁难你啊！真烦啊！</del>
diff --git a/3.编程思维体系构建/3.4.7.3C编译器干了什么.md b/3.编程思维体系构建/3.4.7.3C编译器干了什么.md
index 1d7db6a..20267a2 100644
--- a/3.编程思维体系构建/3.4.7.3C编译器干了什么.md
+++ b/3.编程思维体系构建/3.4.7.3C编译器干了什么.md
@@ -1,16 +1,16 @@
 # C 编译器干了什么
 
-# 以 gcc 为例
+## 以 gcc 为例
 
-1、预处理,生成 .i 的文件[预处理器 cpp]
+1、预处理，生成 .i 的文件[预处理器 cpp]
 
-2、将预处理后的文件转换成汇编语言, 生成文件 .s [编译器 egcs]
+2、将预处理后的文件转换成汇编语言，生成文件 .s [编译器 egcs]
 
-3、有汇编变为目标代码(机器代码)生成 .o 的文件[汇编器 as]
+3、有汇编变为目标代码 (机器代码) 生成 .o 的文件[汇编器 as]
 
-4、连接目标代码, 生成可执行程序 [链接器 ld]
+4、连接目标代码，生成可执行程序 [链接器 ld]
 
-# 有啥用
+## 有啥用
 
 有一天你发现，某一段 C 语言只有几行，但是用了大量的魔法宏定义以及魔法操作以及神奇的元编程。
 
@@ -18,10 +18,10 @@
 
 如果有一天你要学习汇编语言，或者说出现了在代码中看不出的 bug，你可能需要翻译成.s 文件
 
-# 了解更多
+## 了解更多
 
 当然不止如此，编译器还承担了优化的过程，有时候同一份代码，经过 O1 和 O2 不同优化可能最后代码都不一样。
 
 推荐阅读
 
-[http://www.ruanyifeng.com/blog/2014/11/compiler.html](http://www.ruanyifeng.com/blog/2014/11/compiler.html)
+[编译器的工作过程](http://www.ruanyifeng.com/blog/2014/11/compiler.html)
diff --git a/3.编程思维体系构建/3.4.7.4Inline Assembly与链接加载.md b/3.编程思维体系构建/3.4.7.4Inline Assembly与链接加载.md
index cd8424d..7613471 100644
--- a/3.编程思维体系构建/3.4.7.4Inline Assembly与链接加载.md	
+++ b/3.编程思维体系构建/3.4.7.4Inline Assembly与链接加载.md	
@@ -1,6 +1,6 @@
 # Inline Assembly 与链接加载
 
-# Inline Assembly
+## Inline Assembly
 
 可以在 C 代码里嵌入汇编语言的骚操作。毕竟编译器本身也就是个复制，翻译，，粘贴的过程。
 
@@ -14,7 +14,7 @@ C 艹可能没那么容易了····比如说虚函数调用，那你就不太
 
 当然这里可以参考 c inline Asm 的教程 但是已经脱离了本文的主题了
 
-这里给指条路 [https://dmalcolm.fedorapeople.org/gcc/2015-08-31/rst-experiment/how-to-use-inline-assembly-language-in-c-code.html](https://dmalcolm.fedorapeople.org/gcc/2015-08-31/rst-experiment/how-to-use-inline-assembly-language-in-c-code.html)
+这里给指条路 [How to Use Inline Assembly Language in C Code](https://dmalcolm.fedorapeople.org/gcc/2015-08-31/rst-experiment/how-to-use-inline-assembly-language-in-c-code.html)
 
 > 诸如 Go 的高级语言 也可以通过 inline C 来 内链汇编
 
@@ -24,17 +24,17 @@ C 艹可能没那么容易了····比如说虚函数调用，那你就不太
 
 当然，你可以通过 RTFM 来将 C 语言的变量塞到汇编中处理。
 
-在 Windows 平台下 VS 没有 Code 可以以 `__asm {}` 代码块来进行实验 但是注意 只能在 x86 模式下使用 x64 不支持 可以参考 [https://docs.microsoft.com/zh-tw/cpp/assembler/inline/asm?view=msvc-170](https://docs.microsoft.com/zh-tw/cpp/assembler/inline/asm?view=msvc-170)
+在 Windows 平台下 VS 没有 Code 可以以 `__asm {}` 代码块来进行实验 但是注意 只能在 x86 模式下使用 x64 不支持 可以参考 [__asm](https://docs.microsoft.com/zh-tw/cpp/assembler/inline/asm?view=msvc-170)
 
 以上两种平台的方案都其实本质是编译器特殊宏 并不包括在 C 的标准内 所以要针对不同的编译器 寻找对应的文档
 
-# 静态链接
+## 静态链接
 
 当你使用 GCC 生成可执行文件./a.out 时，到底发生了什么？
 
 为什么就可以直接执行呢？当你问及这个问题时，那么就大有一番探索的空间了
 
-# 链接器
+## 链接器
 
 链接器的功能：将一个可执行程序所需的目标文件和库最终整合在一起。
 
@@ -42,15 +42,13 @@ C 艹可能没那么容易了····比如说虚函数调用，那你就不太
 
 这个就是帮你和外部库连接起来的重要部分。
 
-一个程序包含三个段：.text 、.data 和 .bss 段。
+一个程序包含三个段：.text、.data 和 .bss 段。
 
-```
 而各目标文件和库都包含这三段，所以，ld 链接器的功能就是将各个目标文件和库的三段合并在一起。
 
-当然，链接器所完成的链接工作并非只是简单地将各个目标文件和库的三段内存堆砌在一起，而是还要完成 “重定位” 的工作。
-```
+当然，链接器所完成的链接工作并非只是简单地将各个目标文件和库的三段内存堆砌在一起，而是还要完成“重定位”的工作。
 
-## 查看二进制文件的工具
+### 查看二进制文件的工具
 
 使用 objdump 查看 data 节的 x，y
 
@@ -60,7 +58,7 @@ C 艹可能没那么容易了····比如说虚函数调用，那你就不太
 
 使用 IDA BinaryNInja 一类反汇编工具
 
-# 动态链接
+## 动态链接
 
 静态链接一次用那么多，实在是太大太大了
 
@@ -74,7 +72,7 @@ Linux 下一般是 .so 如果你看到了 .a 那个一般是 archive 的缩写
 
 使用动态链接的好处在于 可以热加载和热更新
 
-# 共享连接的加载
+## 共享连接的加载
 
 使用 ldd 来查看 a.out 就可以查看动态链接库
 
diff --git a/3.编程思维体系构建/3.4C语言.md b/3.编程思维体系构建/3.4C语言.md
index 79108cb..0e65f08 100644
--- a/3.编程思维体系构建/3.4C语言.md
+++ b/3.编程思维体系构建/3.4C语言.md
@@ -6,7 +6,7 @@
 
 值得一提的是，我不会在本教程讲授过于基础的概念，但是会贴出你可能需要学习的内容。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnAnXUHDqsMYVrDlBfFunoVf.png)
+![](https://cdn.xyxsw.site/boxcnAnXUHDqsMYVrDlBfFunoVf.png)
 
 同时我要说的是：C 语言为了适配多种多样的硬件以及各式各样的操作，他对非常多的 undefined 操作不做太多限制，也就是说你可能会出现各种各样的问题，<del>甚至把你电脑炸了</del>
 
diff --git a/3.编程思维体系构建/3.5git与github.md b/3.编程思维体系构建/3.5git与github.md
index 8c51999..4a151f0 100644
--- a/3.编程思维体系构建/3.5git与github.md
+++ b/3.编程思维体系构建/3.5git与github.md
@@ -4,7 +4,9 @@
 
 ## <strong>光玉</strong>
 
-想象一下你正在玩 Flappy Bird ，你今晚的目标是拿到 100 分，不然就不睡觉。 经过千辛万苦，你拿到了 99 分，就要看到成功的曙光的时候，你竟然失手了！你悲痛欲绝，滴血的心在呼喊着，“为什么上天要这样折磨我？为什么不让我存档？”
+想象一下你正在玩 Flappy Bird，你今晚的目标是拿到 100 分，不然就不睡觉。经过千辛万苦，你拿到了 99 分，就要看到成功的曙光的时候，你竟然失手了！你悲痛欲绝，滴血的心在呼喊着，“为什么上天要这样折磨我？为什么不让我存档？”
+
+[**Play Happy Bird**](https://flappybird.io/)
 
 想象一下你正在写代码，你今晚的目标是实现某一个新功能，不然就不睡觉。经过千辛万苦，你终于把代码写好了，保存并编译运行，你看到调试信息一行一行地在终端上输出。就要看到成功的曙光的时候，竟然发生了错误！你仔细思考，发现你之前的构思有着致命的错误，但之前正确运行的代码已经永远离你而去了。你悲痛欲绝，滴血的心在呼喊着，“为什么上天要这样折磨我？”你绝望地倒在屏幕前 ... ... 这时，你发现身边渐渐出现无数的光玉，把你包围起来，耀眼的光芒令你无法睁开眼睛 ... ... 等到你回过神来，你发现屏幕上正是那份之前正确运行的代码！但在你的记忆中，你确实经历过那悲痛欲绝的时刻 ... ... 这一切真是不可思议啊 ... ...
 
@@ -40,7 +42,7 @@ git config --global user.name "Zhang San"            # your name
 git config --global user.email "zhangsan@foo.com"    # your email
 ```
 
-经过这些配置, 你就可以开始使用 `git` 了。
+经过这些配置，你就可以开始使用 `git` 了。
 
 你会通过 `git clone` 命令来拉取远程仓库的代码，里面已经包含一些 `git` 记录，因此不需要额外进行初始化。如果你想在别的实验、项目中使用 `git` ，你首先需要切换到实验、项目的目录中，然后输入
 
@@ -68,11 +70,11 @@ git log
 git status
 ```
 
-可以得知，与当前存档相比，哪些文件发生了变化.
+可以得知，与当前存档相比，哪些文件发生了变化。
 
 ### 提交
 
-你可以像以前一样编写代码。等到你的开发取得了一些阶段性成果，你应该马上进行 “ 提交（ commit ）”。
+你可以像以前一样编写代码。等到你的开发取得了一些阶段性成果，你应该马上进行“提交（commit）”。
 
 首先你需要使用 `git status` 查看是否有新的文件或已修改的文件未被跟踪；若有，则使用 `git add` 将文件加入跟踪列表，例如
 
@@ -88,7 +90,7 @@ git add -A
 git add .
 ```
 
-但这样可能会跟踪了一些不必要的文件（二进制文件），例如编译产生的 `.o` 文件，和最后产生的可执行文件。事实上，我们只需要跟踪代码源文件即可。为了让 `git` 在添加跟踪文件之前作筛选，你可以编辑 `.gitignore` 文件（ 没有的话手动创建 文件名就叫这个 ），在里面给出需要被 `git` 忽略的文件和文件类型。
+但这样可能会跟踪了一些不必要的文件（二进制文件），例如编译产生的 `.o` 文件，和最后产生的可执行文件。事实上，我们只需要跟踪代码源文件即可。为了让 `git` 在添加跟踪文件之前作筛选，你可以编辑 `.gitignore` 文件（没有的话手动创建 文件名就叫这个），在里面给出需要被 `git` 忽略的文件和文件类型。
 
 [这个网页](https://www.toptal.com/developers/gitignore) 可以根据你搜索的语言来给你创建必要的 `.gitignore` 文件
 
@@ -105,13 +107,13 @@ file.o           # 一个编译后的文件
 
 建议把编译后的文件都加入 `.gitignore` 并在 `README.md` 文件中留下编译的详细操作流程，节省 `.git` 空间、符合提交规范。
 
-把新文件加入跟踪列表后, 使用 `git status` 再次确认. 确认无误后就可以存档了, 使用
+把新文件加入跟踪列表后，使用 `git status` 再次确认。确认无误后就可以存档了，使用
 
 ```bash
 git commit -m "...comment..."
 ```
 
-提交工程当前的状态（注释）。其中 `...comment...` 是你本次提交的注释（ 一般在注释中简略写出本次提交干了什么）以下为注释规范，养成良好习惯请遵守：
+提交工程当前的状态（注释）。其中 `...comment...` 是你本次提交的注释（一般在注释中简略写出本次提交干了什么）以下为注释规范，养成良好习惯请遵守：
 
 ```bash
 模板：
@@ -145,7 +147,7 @@ subject为commit概述
 
 你可以使用 `git log` 查看存档记录，你应该能看到刚才编辑的注释。
 
-### <strong>读档</strong><strong>（ 回溯到某一个 commit ）</strong>
+### <strong>读档</strong><strong>（回溯到某一个 commit）</strong>
 
 如果你遇到了上文提到的让你悲痛欲绝的情况，现在你可以使用光玉来救你一命了。首先使用 `git log` 来查看已有的存档，并决定你需要回到哪个过去。每一份存档都有一个 `hash code`，例如 `b87c512d10348fd8f1e32ddea8ec95f87215aaa5` , 你需要通过 `hash code` 来告诉 `git` 你希望读哪一个档。使用以下命令进行读档：
 
@@ -155,7 +157,7 @@ git reset --hard b87c
 
 其中 `b87c` 是上文 `hash code` 的前缀：你不需要输入整个 hash code. 这时你再看看你的代码，你已经成功地回到了过去！
 
-但事实上, 在使用 `git reset` 的 `hard` 模式之前, 你需要再三确认选择的存档是不是你的真正目标。 如果你读入了一个较早的存档，那么比这个存档新的所有记录都将被删除！这意味着你不能随便回到“将来”了。
+但事实上，在使用 `git reset` 的 `hard` 模式之前，你需要再三确认选择的存档是不是你的真正目标。如果你读入了一个较早的存档，那么比这个存档新的所有记录都将被删除！这意味着你不能随便回到“将来”了。
 
 ### 分支
 
@@ -165,7 +167,7 @@ git reset --hard b87c
 git branch
 ```
 
-查看所有分支. 其中 `master` 是主分支，使用 `git init` 初始化之后会自动建立主分支。
+查看所有分支。其中 `master` 是主分支，使用 `git init` 初始化之后会自动建立主分支。
 
 读档的时候使用以下命令：
 
@@ -190,13 +192,13 @@ git checkout -B 分支名
 
 - 把修改结果保存到一个新的分支中，如果分支已存在，其内容将会被覆盖
 
-不同的分支之间不会相互干扰，这也给项目的分布式开发带来了便利。有了分支功能，你就可以像第三视点那样在一个世界的不同时间 ( 一个分支的多个存档 )，或者是多个平行世界 （ 多个分支 ） 之间来回穿梭了。
+不同的分支之间不会相互干扰，这也给项目的分布式开发带来了便利。有了分支功能，你就可以像第三视点那样在一个世界的不同时间 ( 一个分支的多个存档 )，或者是多个平行世界（多个分支）之间来回穿梭了。
 
 ### <strong>更多功能</strong>
 
 以上介绍的是 `git` 的一些基本功能，`git` 还提供很多强大的功能，例如使用 `git diff` 比较同一个文件在不同版本中的区别，使用 `git bisect` 进行二分搜索来寻找一个 bug 在哪次提交中被引入...
 
-其它功能的使用请参考 `git help` ， `man git` ， 或者在网上搜索相关资料。
+其它功能的使用请参考 `git help` ， `man git` ，或者在网上搜索相关资料。
 
 ## 全球最大男性交友网站 —— Github
 
@@ -205,17 +207,16 @@ git checkout -B 分支名
 
 你把任务分配好让组员去写代码中的某一个模块。组员写好之后发给你。
 
-你一看，通过QQ发过来的是一个文件啊文件  比如说 `学生管理模块.c` 你打开一看，我去是**乱码**。
+你一看，通过 QQ 发过来的是一个文件啊文件  比如说 `学生管理模块.c` 你打开一看，我去是**乱码**。
 
 你废了九牛二虎之力把他的 GBK 编码改成 UTF8 之后，细细地品鉴这段代码，发现我去有严重逻辑错误，而且代码很不规范。
 
-你通过QQ告诉他，这一行有问题，能不能改一下。他说，好的我改一下。
+你通过 QQ 告诉他，这一行有问题，能不能改一下。他说，好的我改一下。
 
 然后又发了文件啊文件给你，如此反复循环，你俩已经互相传了好几百个源代码文件，很没效率！
 :::
 
-
-> 通过Git版本控制管理自己的代码 ，再通过Github来发布、同步互联，是一个很好的解决方案！
+> 通过 Git 版本控制管理自己的代码，再通过 Github 来发布、同步互联，是一个很好的解决方案！
 
 简介
 
@@ -223,7 +224,7 @@ git checkout -B 分支名
 
 页面大概是这样（老图）：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnHemi9HkeAG1fgoznHbHLrc.png)
+![](https://cdn.xyxsw.site/boxcnHemi9HkeAG1fgoznHbHLrc.png)
 
 ### Git 和 Github
 
@@ -241,7 +242,7 @@ git checkout -B 分支名
 
 他会用一个像是命令行交互的方式引导注册，你需要依次填写 `邮箱` 、`密码` 、 `用户名（此为 ID 非昵称）` 、`是否同意邮箱广告推送` 、`机器验证码` 之后创建账户，随后会给你填写的邮箱发送验证码，填写注册。
 
-随后是一个欢迎问卷😋随便填写、如果他问你什么PRO Plan  选择 free 不付费就好。
+随后是一个欢迎问卷😋随便填写、如果他问你什么 PRO Plan  选择 free 不付费就好。
 
 最后你访问[GitHub 官网](https://github.com)应该会显示你的 dashboard 管理台界面
 
@@ -251,7 +252,7 @@ git checkout -B 分支名
 
 如果有就直接跳过这一步
 
-如果没有，打开 Shell（ Windows 下打开 Git Bash <em>前提是你已经安装好了 git 在桌面右键应该会有 Git bash here 选项 </em>），创建 SSH Key：
+如果没有，打开 Shell（Windows 下打开 Git Bash <em>前提是你已经安装好了 git 在桌面右键应该会有 Git bash here 选项 </em>），创建 SSH Key：
 
 ```bash
 ssh-keygen -t rsa -C "youremail@example.com"  # youremail为你注册用的电子邮件地址
@@ -263,11 +264,11 @@ ssh-keygen -t rsa -C "youremail@example.com"  # youremail为你注册用的电
 
 登陆 `GitHub`，点击右上角自己的头像，打开 `settings`
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Snipaste_2023-07-16_17-12-32.png)
+![](https://cdn.xyxsw.site/Snipaste_2023-07-16_17-12-32.png)
 
 然后打开左侧栏 `SSH and GPG`` keys` 页面
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn1HbQct335qvZ71tGNu7jne.png)
+![](https://cdn.xyxsw.site/boxcn1HbQct335qvZ71tGNu7jne.png)
 
 然后，点 `New SSH Key`，填上任意 Title，在 Key 文本框里粘贴 `id_rsa.pub` 文件的内容即可
 
@@ -277,11 +278,11 @@ ssh-keygen -t rsa -C "youremail@example.com"  # youremail为你注册用的电
 
 首先在 GitHub 主页，找到 `New` 或者 `Create repository` 一个绿色的按钮，创建一个新的仓库
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn5sVnE76FYpVW2RDxtWDiZc.png)
+![](https://cdn.xyxsw.site/boxcn5sVnE76FYpVW2RDxtWDiZc.png)
 
 然后填上这个仓库的大名就可以创建了
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnsN133WrLrbxsX8JgvsQmif.png)
+![](https://cdn.xyxsw.site/boxcnsN133WrLrbxsX8JgvsQmif.png)
 
 根据之前学习的方法在本地创建完 git 仓库之后
 
@@ -302,11 +303,9 @@ git clone git@github.com:yourname/gitexample.git
 
 > 以上方法是基于 ssh 方式的，下面方法是基于 HTTPS 方式的
 
-或者你可以跟随新创建之后的指引，`…or create a new repository on the command line` 内他描述了如何创建一个文件夹、创建一个README.md的文件，然后和github仓库绑定。
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Snipaste_2023-07-16_17-19-18.png)
-
+或者你可以跟随新创建之后的指引，`…or create a new repository on the command line` 内他描述了如何创建一个文件夹、创建一个 README.md 的文件，然后和 github 仓库绑定。
 
+![](https://cdn.xyxsw.site/Snipaste_2023-07-16_17-19-18.png)
 
 ### 下载代码——clone
 
@@ -320,7 +319,7 @@ git clone <url>
 
 首先，代码的 url 在下图所示的位置
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnTiaT2EnNfKVkretPsyajVd.png)
+![](https://cdn.xyxsw.site/boxcnTiaT2EnNfKVkretPsyajVd.png)
 
 然后复制完代码后切换回我们的命令行
 
@@ -334,11 +333,11 @@ git clone https://github.com/camera-2018/git-example.git
 >
 > 如果你使用我的仓库的话，你 clone 过后在你自己电脑更改的文件等东西，是没法直接提交回来的（因为你没有我仓库管理权限）
 >
-> 如果你非要给我的仓库添加东西呢 也是可以，参照下面的 PR （Pull Request）教程
+> 如果你非要给我的仓库添加东西呢 也是可以，参照下面的 PR（Pull Request）教程
 
 一阵抽搐过后就下载好了
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn8aRDQpe7uuDxFv9v1WvZ4c.png)
+![](https://cdn.xyxsw.site/boxcn8aRDQpe7uuDxFv9v1WvZ4c.png)
 
 ::: tip
 用完之后别忘记给 camera-2018 点个 follow 😋  `呃呃 follow 没用  star 有用`
@@ -350,7 +349,7 @@ git clone https://github.com/camera-2018/git-example.git
 
 如图 我在仓库里新建了 `helloworld.c` 并且写了一些代码
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnZpPsp4FP78auolzHvCKP0g.png)
+![](https://cdn.xyxsw.site/boxcnZpPsp4FP78auolzHvCKP0g.png)
 
 接下来是提交操作
 
@@ -358,7 +357,7 @@ git clone https://github.com/camera-2018/git-example.git
 git status  #看一下文件暂存区
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnm4R1ZN0WeUBuYht6zge7pd.png)
+![](https://cdn.xyxsw.site/boxcnm4R1ZN0WeUBuYht6zge7pd.png)
 
 红色表示文件没有提交到暂存区 我们要提交
 
@@ -368,7 +367,7 @@ git status  #看一下文件暂存区
 git add . #将没有提交的所有文件加入暂存区
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnYHd076RAqfDmHjbUkeNSvg.png)
+![](https://cdn.xyxsw.site/boxcnYHd076RAqfDmHjbUkeNSvg.png)
 
 绿色表示所有文件已加入暂存
 
@@ -378,18 +377,18 @@ git commit -m "feat(helloworld): add helloworld file"
 
 将刚才加入暂区的文件发起了一个提交，提交注释（commit message）是 `feat(helloworld): add helloworld file`
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcni2dupDzNO8qTWPAxS5c67b.png)
+![](https://cdn.xyxsw.site/boxcni2dupDzNO8qTWPAxS5c67b.png)
 
-1. 如果这是你自己的仓库有权限（本人仓库或 Collaborators 有权限的情况下）你就可以直接使用 
+1. 如果这是你自己的仓库有权限（本人仓库或 Collaborators 有权限的情况下）你就可以直接使用
 
     ```bash
-    git push origin main  # origin是第四步里remote add起的远程名字
-                        # main是分支名
+    git push origin main  # origin 是第四步里 remote add 起的远程名字
+                        # main 是分支名
     ```
 
     上传本次提交
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnNBu1EJnva4EkyQZAVlwGMe.png)
+    ![](https://cdn.xyxsw.site/boxcnNBu1EJnva4EkyQZAVlwGMe.png)
 
 2. 如果你没有本仓库的主分支提交权限 可以提交 PR（Pull Requests）
 
@@ -397,7 +396,7 @@ git commit -m "feat(helloworld): add helloworld file"
 
     首先创建一个新分支 命名为 `yourname-dev`
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnaS7aOzdt31vsZZx8R1s33e.png)
+    ![](https://cdn.xyxsw.site/boxcnaS7aOzdt31vsZZx8R1s33e.png)
 
     然后按照上面的方法 `git clone` 并切换到你刚创建的分支
 
@@ -405,75 +404,74 @@ git commit -m "feat(helloworld): add helloworld file"
     git switch camera-2018-dev
     ```
 
-    然后提交一个文件，这里直接使用 vscode 自带的 git 工具试试 （很方便、不用敲命令行）
+    然后提交一个文件，这里直接使用 vscode 自带的 git 工具试试（很方便、不用敲命令行）
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnmwlYWOzwPbNqTAuSZK9dW3.png)
+    ![](https://cdn.xyxsw.site/boxcnmwlYWOzwPbNqTAuSZK9dW3.png)
 
     点暂存所有更改 写好 comment 之后点提交
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnfcCnAdtdX2oyLIC3NibVnf.png)
+    ![](https://cdn.xyxsw.site/boxcnfcCnAdtdX2oyLIC3NibVnf.png)
 
     最后点同步更改上传
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn9DSPlFgG2WMZhTOE9Zhzgb.png)
+    ![](https://cdn.xyxsw.site/boxcn9DSPlFgG2WMZhTOE9Zhzgb.png)
 
     如果是你提交 在 github 上会显示这个 快捷创建 pr 的按钮
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnHd7Qfi8C0Y7V2Ot5ii4vpf.png)
+    ![](https://cdn.xyxsw.site/boxcnHd7Qfi8C0Y7V2Ot5ii4vpf.png)
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnyt3eeZQyN8b1xM1WjDrTGe.png)
+    ![](https://cdn.xyxsw.site/boxcnyt3eeZQyN8b1xM1WjDrTGe.png)
 
     点它创建 PR
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnJOjh1Zfp9tCd3llL9NsEzb.png)
+    ![](https://cdn.xyxsw.site/boxcnJOjh1Zfp9tCd3llL9NsEzb.png)
 
     这样管理本仓库的人看到 pr 请求就可以 merge 合并辣
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnBMq0sw6c48jvjdPJwmAGtZ.png)
+    ![](https://cdn.xyxsw.site/boxcnBMq0sw6c48jvjdPJwmAGtZ.png)
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcngNZOSnYUtCKH6pm8UaUMNd.png)
+    ![](https://cdn.xyxsw.site/boxcngNZOSnYUtCKH6pm8UaUMNd.png)
 
     实际合作过程中可能会出现代码冲突无法 merge 的情况 😋 遇到了自己去 STFW 吧
 
     **第二种情况：我不是协作者、我什么权限也没有，我看了这个 public 项目后觉得很好但是有一些问题，我要给他贡献一些代码**
 
-    可以点击仓库右上角的 fork 
+    可以点击仓库右上角的 fork
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Snipaste_2023-07-16_17-34-21.png)
+    ![](https://cdn.xyxsw.site/Snipaste_2023-07-16_17-34-21.png)
 
     这样会在你的名下多出来一份这个同名仓库，而这个仓库你是拥有所有权限的，你可以 clone 你这个同名仓库，更改代码，提交代码之后
 
     回到源仓库点击 Pull Request 然后创建 PR `New pull request` 
 
-    最上面会提示你说 
+    最上面会提示你说
 
     Comparing changes
     Choose two branches to see what’s changed or to start a new pull request. If you need to, you can also    **compare across forks** .
 
-    点击小蓝字 `compare across forks` 这会让你对比你fork仓库和源代码仓库的提交记录，之后就可以创建 PR 了，原作者看到了会合并。
-
+    点击小蓝字 `compare across forks` 这会让你对比你 fork 仓库和源代码仓库的提交记录，之后就可以创建 PR 了，原作者看到了会合并。
 
 ### 其他功能
 
-问题跟踪：GitHub的问题跟踪功能可用于报告软件中的问题、错误和功能请求，并进行讨论、分配和解决。
+问题跟踪：GitHub 的问题跟踪功能可用于报告软件中的问题、错误和功能请求，并进行讨论、分配和解决。
 
-Wiki页面：用户可以创建和编辑与存储库相关的Wiki页面，用于提供项目的文档、指南、示例代码等。
+Wiki 页面：用户可以创建和编辑与存储库相关的 Wiki 页面，用于提供项目的文档、指南、示例代码等。
 
-Pull请求（Pull Requests）：使用者可以将自己的代码变更提交给其他项目的所有者，并请求合并到主干代码中。
+Pull 请求（Pull Requests）：使用者可以将自己的代码变更提交给其他项目的所有者，并请求合并到主干代码中。
 
-项目管理：GitHub提供项目管理功能，包括任务管理、里程碑（milestones）、项目板（project boards）等工具，可用于组织和跟踪项目的进展。
+项目管理：GitHub 提供项目管理功能，包括任务管理、里程碑（milestones）、项目板（project boards）等工具，可用于组织和跟踪项目的进展。
 
-部署功能：GitHub可以与各种持续集成和部署（CI/CD）工具集成，帮助开发人员自动化构建、测试和部署他们的应用程序。
+部署功能：GitHub 可以与各种持续集成和部署（CI/CD）工具集成，帮助开发人员自动化构建、测试和部署他们的应用程序。
 
-统计信息：GitHub提供有关存储库活动和贡献者的统计信息，例如提交图表、活动日历等，有助于跟踪和分析项目的发展。
+统计信息：GitHub 提供有关存储库活动和贡献者的统计信息，例如提交图表、活动日历等，有助于跟踪和分析项目的发展。
 
 社交功能：用户可以关注其他用户、存储库和组织，接收他们的更新和活动通知，并与他们进行交流和讨论。
 
-代码审核（Code Review）：GitHub的Pull请求功能允许团队成员对代码进行审查和讨论，以确保代码质量和最佳实践。
+代码审核（Code Review）：GitHub 的 Pull 请求功能允许团队成员对代码进行审查和讨论，以确保代码质量和最佳实践。
 
-集成和扩展：GitHub支持与其他工具和服务的集成，例如持续集成（CI）工具、代码质量检查工具、项目管理工具等。
+集成和扩展：GitHub 支持与其他工具和服务的集成，例如持续集成（CI）工具、代码质量检查工具、项目管理工具等。
 
-页面托管：GitHub Pages功能使您可以托管静态网站和文档，这在展示和共享项目文档、演示和博客等方面非常有用。
+页面托管：GitHub Pages 功能使您可以托管静态网站和文档，这在展示和共享项目文档、演示和博客等方面非常有用。
 
 然后还有一些比如说 Copilot 之类的有用的功能。
 
@@ -485,22 +483,23 @@ Copilot 可以根据上下文和输入的提示，为开发人员生成代码建
 
 你需要学生认证你的 Github 账号。
 
-地址在 https://education.github.com/students 点击 `Sign up for Global Campus` 来开始认证，下面会让你输入学校，绑定学校邮箱（杭电为 @hdu.edu.cn 结尾的邮箱）（如果你是杭电新生的话，可能要等到智慧杭电账号发放时才能注册杭电邮箱）并上传**学生证明**（从21年开始这个验证越来越严，如果不过的话你可以尝试 `学生证第一页`、`学生证第一页英文翻译（像有道翻译那样 P 图上去）`、`学信网学籍证明英文翻译（英文也是 P 上去）`）
+地址在 [https://education.github.com/students](https://education.github.com/students) 点击 `Sign up for Global Campus` 来开始认证，下面会让你输入学校，绑定学校邮箱（杭电为 @hdu.edu.cn 结尾的邮箱）（如果你是杭电新生的话，可能要等到智慧杭电账号发放时才能注册杭电邮箱）并上传**学生证明**（从 21 年开始这个验证越来越严，如果不过的话你可以尝试 `学生证第一页`、`学生证第一页英文翻译（像有道翻译那样 P 图上去）`、`学信网学籍证明英文翻译（英文也是 P 上去）`）
 
 通过了的话你的账户会有 Pro 标识 然后你可以享受的 Github 学生包里包含[这些东西](https://education.github.com/pack)
 
-里面比较有用的有 
-- JETBRAINS 全家桶的免费用（我没用，我用的是jb自己家的验证方式，不是github）
+里面比较有用的有
+
+- JETBRAINS 全家桶的免费用（我没用，我用的是 jb 自己家的验证方式，不是 github）
 - name.com 家的一个一年期的免费域名（大概价值吧 六七十块钱？）
 - github 的容量扩容和 actions 时间扩容、Codespaces 时间延长、Pages 扩容（没啥用倒是）
-- Termius 学生包，这是我很喜欢用的终端软件，有学生包可以多端同步ssh的账号密码啥的，很方便。
+- Termius 学生包，这是我很喜欢用的终端软件，有学生包可以多端同步 ssh 的账号密码啥的，很方便。
 - Sentry 容量扩容
 - Copilot 免费用
 
-你可以在 `settings` 里看到你的copilot ，配置如下
+你可以在 `settings` 里看到你的 copilot，配置如下
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Snipaste_2023-07-16_17-59-49.png)
+![](https://cdn.xyxsw.site/Snipaste_2023-07-16_17-59-49.png)
 
 然后就可以在你喜欢的 IDE 或编辑器上下载 Copilot 插件，来启用他。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Snipaste_2023-07-16_18-02-19.png)
+![](https://cdn.xyxsw.site/Snipaste_2023-07-16_18-02-19.png)
diff --git a/3.编程思维体系构建/3.6.1从CS61A看编程语言学习.md b/3.编程思维体系构建/3.6.1从CS61A看编程语言学习.md
index 38a92fb..886f0ce 100644
--- a/3.编程思维体系构建/3.6.1从CS61A看编程语言学习.md
+++ b/3.编程思维体系构建/3.6.1从CS61A看编程语言学习.md
@@ -1,18 +1,16 @@
 # 从 CS61A 看编程语言学习
 
-
-
-# 什么是 CS61A
+## 什么是 CS61A
 
 首先声明，本教程的 python 部分很多内容摘自 CS61A
 
 如果你看过 CS 自学指南，想必你在第一页就看过这样的描述
 
-> 大一入学时我是一个对计算机一无所知的小白，装了几十个 G 的 Visual Studio 天天和 OJ 你死我活。凭着高中的数学底子我数学课学得还不错，但在专业课上对竞赛大佬只有仰望。提到编程我只会打开那笨重的 IDE，新建一个我也不知道具体是干啥的命令行项目，然后就是 `cin`, `cout`, `for` 循环，然后 CE, RE, WA 循环。当时的我就处在一种拼命想学好但不知道怎么学，课上认真听讲但题还不会做，课后做作业完全是用时间和它硬耗的痛苦状态。我至今电脑里还存着自己大一上学期计算概论大作业的源代码 —— 一个 1200 行的 C++ 文件，没有头文件、没有类、没有封装、没有 unit test、没有 Makefile、没有 Git，唯一的优点是它确实能跑，缺点是“能跑”的补集。我一度怀疑我是不是不适合学计算机，因为童年对于极客的所有想象，已经被我第一个学期的体验彻底粉碎了。<br/>这一切的转机发生在我大一的寒假，我心血来潮想学习 Python。无意间看到知乎有人推荐了 CS61A 这门课，说是 UC Berkeley 的大一入门课程，讲的就是 Python。我永远不会忘记那一天，打开 [CS61A](https://cs61a.org/) 课程网站的那个瞬间，就像哥伦布发现了新大陆一样，我开启了新世界的大门。<br/>我一口气 3 个星期上完了这门课，它让我第一次感觉到原来 CS 可以学得如此充实而有趣，原来这世上竟有如此精华的课程。<br/>为避免有崇洋媚外之嫌，我单纯从一个学生的视角来讲讲自学 CS61A 的体验：<br/>- 独立搭建的课程网站: 一个网站将所有课程资源整合一体，条理分明的课程 schedule、所有 slides, hw, discussion 的文件链接、详细明确的课程给分说明、历年的考试题与答案。这样一个网站抛开美观程度不谈，既方便学生，也让资源公正透明。<br/>- 课程教授亲自编写的教材：CS61A 这门课的开课老师将 MIT 的经典教材 Structure and Interpretation of Computer Programs (SICP) 用 Python 这门语言进行改编（原教材基于 Scheme 语言），保证了课堂内容与教材内容的一致性，同时补充了更多细节，可以说诚意满满。而且全书开源，可以直接线上阅读。<br/>- 丰富到让人眼花缭乱的课程作业：14 个 lab 巩固随堂知识点，10 个 homework，还有 4 个代码量均上千行的 project。与大家熟悉的 OJ 和 Word 文档式的作业不同，所有作业均有完善的代码框架，保姆级的作业说明。每个 Project 都有详尽的 handout 文档、全自动的评分脚本。CS61A 甚至专门开发了一个[自动化的作业提交评分系统](https://okpy.org/)（据说还发了论文）。当然，有人会说“一个 project 几千行代码大部分都是助教帮你写好的，你还能学到啥？”。此言差矣，作为一个刚刚接触计算机，连安装 Python 都磕磕绊绊的小白来说，这样完善的代码框架既可以让你专注于巩固课堂上学习到的核心知识点，又能有“我才学了一个月就能做一个小游戏了！”的成就感，还能有机会阅读学习别人高质量的代码，从而为自己所用。我觉得在低年级，这种代码框架可以说百利而无一害。唯一的害也许是苦了老师和助教，因为开发这样的作业可想而知需要相当的时间投入。<br/>- 每周 Discussion 讨论课，助教会讲解知识难点和考试例题：类似于北京大学 ICS 的小班研讨，但习题全部用 LaTeX 撰写，相当规范且会明确给出 solution。<br/>这样的课程，你完全不需要任何计算机的基础，你只需要努力、认真、花时间就够了。此前那种有劲没处使的感觉，那种付出再多时间却得不到回报的感觉，从此烟消云散。这太适合我了，我从此爱上了自学。<br/>试想如果有人能把艰深的知识点嚼碎嚼烂，用生动直白的方式呈现给你，还有那么多听起来就很 fancy，种类繁多的 project 来巩固你的理论知识，你会觉得他们真的是在倾尽全力想方设法地让你完全掌握这门课，你会觉得不学好它简直是对这些课程建设者的侮辱。<br/>如果你觉得我在夸大其词，那么不妨从 [CS61A](https://cs61a.org/) 开始，因为它是我的梦开始的地方。
+> 大一入学时我是一个对计算机一无所知的小白，装了几十个 G 的 Visual Studio 天天和 OJ 你死我活。凭着高中的数学底子我数学课学得还不错，但在专业课上对竞赛大佬只有仰望。提到编程我只会打开那笨重的 IDE，新建一个我也不知道具体是干啥的命令行项目，然后就是 `cin`, `cout`, `for` 循环，然后 CE, RE, WA 循环。当时的我就处在一种拼命想学好但不知道怎么学，课上认真听讲但题还不会做，课后做作业完全是用时间和它硬耗的痛苦状态。我至今电脑里还存着自己大一上学期计算概论大作业的源代码 —— 一个 1200 行的 C++ 文件，没有头文件、没有类、没有封装、没有 unit test、没有 Makefile、没有 Git，唯一的优点是它确实能跑，缺点是“能跑”的补集。我一度怀疑我是不是不适合学计算机，因为童年对于极客的所有想象，已经被我第一个学期的体验彻底粉碎了。<br/>这一切的转机发生在我大一的寒假，我心血来潮想学习 Python。无意间看到知乎有人推荐了 CS61A 这门课，说是 UC Berkeley 的大一入门课程，讲的就是 Python。我永远不会忘记那一天，打开 [CS61A](https://cs61a.org/) 课程网站的那个瞬间，就像哥伦布发现了新大陆一样，我开启了新世界的大门。<br/>我一口气 3 个星期上完了这门课，它让我第一次感觉到原来 CS 可以学得如此充实而有趣，原来这世上竟有如此精华的课程。<br/>为避免有崇洋媚外之嫌，我单纯从一个学生的视角来讲讲自学 CS61A 的体验：<br/>- 独立搭建的课程网站：一个网站将所有课程资源整合一体，条理分明的课程 schedule、所有 slides, hw, discussion 的文件链接、详细明确的课程给分说明、历年的考试题与答案。这样一个网站抛开美观程度不谈，既方便学生，也让资源公正透明。<br/>- 课程教授亲自编写的教材：CS61A 这门课的开课老师将 MIT 的经典教材 Structure and Interpretation of Computer Programs (SICP) 用 Python 这门语言进行改编（原教材基于 Scheme 语言），保证了课堂内容与教材内容的一致性，同时补充了更多细节，可以说诚意满满。而且全书开源，可以直接线上阅读。<br/>- 丰富到让人眼花缭乱的课程作业：14 个 lab 巩固随堂知识点，10 个 homework，还有 4 个代码量均上千行的 project。与大家熟悉的 OJ 和 Word 文档式的作业不同，所有作业均有完善的代码框架，保姆级的作业说明。每个 Project 都有详尽的 handout 文档、全自动的评分脚本。CS61A 甚至专门开发了一个[自动化的作业提交评分系统](https://okpy.org/)（据说还发了论文）。当然，有人会说“一个 project 几千行代码大部分都是助教帮你写好的，你还能学到啥？”。此言差矣，作为一个刚刚接触计算机，连安装 Python 都磕磕绊绊的小白来说，这样完善的代码框架既可以让你专注于巩固课堂上学习到的核心知识点，又能有“我才学了一个月就能做一个小游戏了！”的成就感，还能有机会阅读学习别人高质量的代码，从而为自己所用。我觉得在低年级，这种代码框架可以说百利而无一害。唯一的害也许是苦了老师和助教，因为开发这样的作业可想而知需要相当的时间投入。<br/>- 每周 Discussion 讨论课，助教会讲解知识难点和考试例题：类似于北京大学 ICS 的小班研讨，但习题全部用 LaTeX 撰写，相当规范且会明确给出 solution。<br/>这样的课程，你完全不需要任何计算机的基础，你只需要努力、认真、花时间就够了。此前那种有劲没处使的感觉，那种付出再多时间却得不到回报的感觉，从此烟消云散。这太适合我了，我从此爱上了自学。<br/>试想如果有人能把艰深的知识点嚼碎嚼烂，用生动直白的方式呈现给你，还有那么多听起来就很 fancy，种类繁多的 project 来巩固你的理论知识，你会觉得他们真的是在倾尽全力想方设法地让你完全掌握这门课，你会觉得不学好它简直是对这些课程建设者的侮辱。<br/>如果你觉得我在夸大其词，那么不妨从 [CS61A](https://cs61a.org/) 开始，因为它是我的梦开始的地方。
 
-如果看完了这些，你可能会震惊，会怀疑并且试着打开它并且去尝试这门课程，但是也有可能你会被纯英文的视频或者油管劝退，也有可能你会怀疑我在使用别人的课程体系的前提下仍然要把它放到自己的内容里面的目的，That's all right,我会在下面对她讲的东西进行一定的补充，并且附着上自己的学习建议以及学习思考。
+如果看完了这些，你可能会震惊，会怀疑并且试着打开它并且去尝试这门课程，但是也有可能你会被纯英文的视频或者油管劝退，也有可能你会怀疑我在使用别人的课程体系的前提下仍然要把它放到自己的内容里面的目的，That's all right，我会在下面对她讲的东西进行一定的补充，并且附着上自己的学习建议以及学习思考。
 
-# 错误的学习方式
+## 错误的学习方式
 
 很多人看到要自学 python 之后，第一时间想到的是，我要去 B 站/百度搜一搜，然后一般搜出来就是菜鸟教程，然后就是一连串枯燥乏味的知识堆叠，或者说是培训班的网课，给我们一种知识好像就是这么枯燥乏味以及自己好像学到了很多但是真的用起来却一无所知痛苦万分的感觉。
 
@@ -24,17 +22,17 @@
 
 是很好。
 
-但是为什么坚持不下来呢?
+但是为什么坚持不下来呢？
 
 根据我的统计，原因无外乎是以下几点：英语太难太劝退了！课程设置太难，好像听懂了但是写起东西来却还是推行不下去！我不知道学了这个能干什么，所以没有动力！学了一两章虽然好像学到了东西，但是感觉有很多东西学了却记不住，导致难度曲线陡增了！<del>游戏太好玩了！</del>
 
 舒适区看起来很难打破！
 
-# 正确的思考方式
+## 正确的思考方式
 
 面对英语，我们前文有过一而再再而三的提醒过使用正确的工具，但是不得不说的是，在翻译的过程中可能难免丢失了一定的信息，使得我们在困惑中可能变得没有了前进的动力，或者从另一个角度来说我们没有动力是因为没有足够的原因来告诉我们的意识，我们到底应该在做这个超过看菜鸟教程所需精力好多倍的工作，到底能得到除了一点新奇感以外的什么东西，以此来给我们更为充分的理由支撑自己学习完成。
 
-# 建立正确的认知论
+## 建立正确的认知论
 
 编程思想本身远比学习某一门编程语言的具体内容更为重要，我们很多的同学在进行这方面内容的时候总是只想着记忆某一门语言的某些内容，然后学的非常的痛苦。
 
@@ -42,12 +40,10 @@
 
 但是编程语言的设计思想一般不会出现太大的波动，并且就算是发展也有其适配的场景和知识脉络的，如果你乐于去发掘这个知识脉络和思想，那么你就可以优雅的掌握一种思维方式而不是简单的拧螺丝一样的机械化工作。而好的思考方式往往是可以应用在同类的所有语言甚至是在所有的更多的
 
-# 更有趣的练习方式
+## 更有趣的练习方式
 
 我不得不承认的一点是，越痛苦的练习往往可以让你获得更大的提升模拟的成长往往与你面对苦难以及解决他的时间是成正比的。
 
 不过遗憾的是，我们大多数的同学是在面对跳起来都够不到的反馈的时候，会选择放弃。（除非你有 M 的倾向）
 
 因此，有时候我们说大道至简。好的东西往往是能让人们快速理解的东西，我觉得 61A 的难度梯度设计，就是兼具了趣味性和间接性的，并且全面优于互联网上的非常多的教程，比硬啃要给我们更多的正反馈（当然，改变思维和学习方式是很重要的。
-
-#
diff --git a/3.编程思维体系构建/3.6.2环境配置.md b/3.编程思维体系构建/3.6.2环境配置.md
index 6dd9660..db7792d 100644
--- a/3.编程思维体系构建/3.6.2环境配置.md
+++ b/3.编程思维体系构建/3.6.2环境配置.md
@@ -2,7 +2,7 @@
 
 当你开始制作大型项目或者复现论文时，环境配置就开始变得至关重要。
 
-# 什么是环境？
+## 什么是环境？
 
 环境是<strong>包的集合</strong>，我们一般用 Anaconda 来配置虚拟环境。
 
@@ -10,42 +10,36 @@
 
 装下来之后具体操作可以看[安装教程](https://blog.csdn.net/in546/article/details/117400839)，如果自动配置环境变量的选项是灰色的话，请按照下面的教程把下面的几个文件路径加入环境变量。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn3PLPIvKSSvYiCnwx50FYvf.png)
+![](https://cdn.xyxsw.site/boxcn3PLPIvKSSvYiCnwx50FYvf.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnvTQPcmPpUonmDZFZXNnGWd.png)
+![](https://cdn.xyxsw.site/boxcnvTQPcmPpUonmDZFZXNnGWd.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn6ZnAzhaj2Tj7xk9K6FxBJh.png)
+![](https://cdn.xyxsw.site/boxcn6ZnAzhaj2Tj7xk9K6FxBJh.png)
 
 在里面添加并写入文件路径加入就好了~
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnnsuoHmhK4dBCLHlKhpRWIe.png)
+![](https://cdn.xyxsw.site/boxcnnsuoHmhK4dBCLHlKhpRWIe.png)
 
 然后打开 Pycharm，创建新项目，设置按照以下方式操作，记得挂梯子。
 
 如果不挂梯子，请按照教程配置清华源。[我是教程](https://blog.csdn.net/jasneik/article/details/114227716)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnTfvjYweuIZFKlcH78X38Pd.png)
+![](https://cdn.xyxsw.site/boxcnTfvjYweuIZFKlcH78X38Pd.png)
 
 然后一个新的环境就创建好辣~
 
-# 如何配置环境
+## 如何配置环境
 
-## 1.配置你自己的环境
+### 1.配置你自己的环境
 
 你可以尝试命令 `pip install <包的名字>` 或者 `conda install <包的名字>`
 
-```
-    在下载某个包失败的时候可以查一查有没有人写相关攻略~
-```
+> 在下载某个包失败的时候可以查一查有没有人写相关攻略~
 
 你可以用 `conda list` 查看你这个环境已有的包。你也可以在包的名字后面加上 `==版本号` 来指定版本。
 
-```
-   请注意各个包之间的依赖关系，否则容易导致无法运行或效果变差！
-```
+> 请注意各个包之间的依赖关系，否则容易导致无法运行或效果变差！
 
-## 2.复现论文代码时配置环境
+### 2.复现论文代码时配置环境
 
-```
-   一般我们可以在Github的README中找到环境的配置方法，遇到难以下载的特殊版本包时可以考虑下载它的源码手动编译，具体流程不展开了，可以自行搜索
-```
+> 一般我们可以在 Github 的 README 中找到环境的配置方法，遇到难以下载的特殊版本包时可以考虑下载它的源码手动编译，具体流程不展开了，可以自行搜索
diff --git a/3.编程思维体系构建/3.6.3安装python.md b/3.编程思维体系构建/3.6.3安装python.md
index 91d14e0..371ff94 100644
--- a/3.编程思维体系构建/3.6.3安装python.md
+++ b/3.编程思维体系构建/3.6.3安装python.md
@@ -1,6 +1,6 @@
 # 安装 python
 
-教程
+::: warning 😍 教程
 
 [Python 小白必看，非常生动的 Pycharm 与 Anaconda 安装教学，干货！_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1Bp4y117UW)
 
@@ -9,8 +9,9 @@
 [Win10 下 Conda-Pycharm-Pytorch 的安装_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV15U4y1J7Ss)
 
 <Bilibili bvid='BV15U4y1J7Ss'/>
+:::
 
-# 巧妇难为无米之炊
+## 巧妇难为无米之炊
 
 你可以在终端上用 Python 解释器
 
@@ -20,9 +21,9 @@
 
 我们推荐你都进行一波尝试，同样这也会作为一个任务
 
-# 解释器
+::: warning <font size=5>😐 解释器</font>
 
-# Windows 用户
+<font size=5><strong>Windows 用户</strong></font>
 
 打开 [Python 官方网站](https://www.python.org/)，找到“Download”里的“Latest: Python 3.x.y”。
 
@@ -30,17 +31,17 @@
 
 <strong>注意：windows11 安装好后 命令行输入 python 可能会跳到 Microsoft 应用商店 可在 customize installation（自定义安装）next  勾选 install for all users</strong>
 
-## GNU/Linux 系统
+<font size=5><strong>GNU/Linux 系统</strong></font>
 
 在终端输入 `sudo apt install python3` 即可完成 Python3 的全部安装流程
 
 可以输入 `python3 --version` 检验是否成功。
+:::
+![](https://cdn.xyxsw.site/boxcn95LbcwuMC2dIViOxWk8BFb.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn95LbcwuMC2dIViOxWk8BFb.png)
+::: warning 🤔 Jupyter Notebook
 
-# Jupyter Notebook
-
-[官方网站](https://jupyter.org/) Jupyter Notebook 是基于网页的用于交互计算的应用程序。其可被应用于全过程计算：开发、文档编写、运行代码和展示结果。——[Jupyter ](https://link.zhihu.com/?target=https%3A//jupyter-notebook.readthedocs.io/en/stable/notebook.html)
+[官方网站](https://jupyter.org/) Jupyter Notebook 是基于网页的用于交互计算的应用程序。其可被应用于全过程计算：开发、文档编写、运行代码和展示结果。——[Jupyter](https://link.zhihu.com/?target=https%3A//jupyter-notebook.readthedocs.io/en/stable/notebook.html)
 
 你在一个框框中直接输入代码，运行，它立马就在下面给你输出。怎么样，是不是很酷？
 
@@ -53,7 +54,8 @@
 jupyter notebook
 
 进行使用
+:::
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnfwk8gnFAHu5JzVUiugJjQe.png)
+![](https://cdn.xyxsw.site/boxcnfwk8gnFAHu5JzVUiugJjQe.png)
 
 [Pycharm](https://www.jetbrains.com/zh-cn/pycharm/)：可能很多同学已经用上了，我在这里不做更多解释
diff --git a/3.编程思维体系构建/3.6.4.0阶段零：Python解释器.md b/3.编程思维体系构建/3.6.4.0阶段零：Python解释器.md
index 53c6e11..117ef0b 100644
--- a/3.编程思维体系构建/3.6.4.0阶段零：Python解释器.md
+++ b/3.编程思维体系构建/3.6.4.0阶段零：Python解释器.md
@@ -1,10 +1,11 @@
 # 阶段零：Python 解释器
 
-可参考资料
+::: warning 😍 可参考资料
 
 [官方文档](https://wiki.python.org/moin/BeginnersGuide)
 
 [菜鸟教程](https://www.runoob.com/python3/python3-interpreter.html)
+:::
 
 你可以在终端与解释器进行交互
 
@@ -14,65 +15,44 @@
 
 你可以自己把玩一下
 
-```
+```python
 >>> 1 + 2
-```
-
-```
 3
 ```
 
-```
+```python
 >>> 3 - 2
-```
-
-```
 1
 ```
 
-```
+```python
 >>> 5 * 6
-```
-
-```
 30
 ```
 
-```
+```python
 >>> 7 / 4
-```
-
-```
 1.75
 ```
 
-```
+```python
 >>> 7 // 4
-```
-
-```
 1
 ```
 
-```
+```python
 >>> 7 % 4
-```
-
-```
 3
 ```
 
-```
->>> 4**3
-```
-
-```
+```python
+>>> 4 ** 3
 64
 ```
 
 同时可以输入 `exit``()` 或按 Ctrl+D 退出交互
 
-同学们可能已经发现 python 这门编程语言的神奇之处了
+:::: warning 🤔 同学们可能已经发现 python 这门编程语言的神奇之处了
 
 在这里留一个思考题
 
diff --git a/3.编程思维体系构建/3.6.4.1阶段一：熟悉语句.md b/3.编程思维体系构建/3.6.4.1阶段一：熟悉语句.md
index 6040d5c..b30ce7c 100644
--- a/3.编程思维体系构建/3.6.4.1阶段一：熟悉语句.md
+++ b/3.编程思维体系构建/3.6.4.1阶段一：熟悉语句.md
@@ -1,10 +1,11 @@
 # 阶段一：熟悉语句
 
-在进行本章之前，请你谨记一个原则：基本所有的功能都被人提前实现好了
+::: warning 🐱 在进行本章之前，请你谨记一个原则：基本所有的功能都被人提前实现好了
 
 你需要关心的仅仅是逻辑该如何设立
 
 在做本章任务前，请熟悉 python 的函数，循环和判断语句即可
+:::
 
 P1：请仅使用一行语句求出三个数的最小平方和
 
@@ -30,7 +31,7 @@ def two_of_three(x, y, z):
     return _____
 ```
 
-提示：可以使用 max()函数哦
+提示：可以使用 `min()` 函数哦
 
 P2：下降阶乘
 
diff --git a/3.编程思维体系构建/3.6.4.2阶段二：递归操作.md b/3.编程思维体系构建/3.6.4.2阶段二：递归操作.md
index 8826120..59f856e 100644
--- a/3.编程思维体系构建/3.6.4.2阶段二：递归操作.md
+++ b/3.编程思维体系构建/3.6.4.2阶段二：递归操作.md
@@ -2,17 +2,15 @@
 
 什么是递归呢？
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnCNpeAE9Hy61cyvtxfioIHg.png)
+![](https://cdn.xyxsw.site/boxcnCNpeAE9Hy61cyvtxfioIHg.png)
 
-# 
-
-# 释义
+## 释义
 
 递归是在函数主体中重复调用函数的基本方案
 
 让我们来看一个经典的例子
 
-> 阶乘，即 n！=n*(n-1)*......*2*1<br/>例如： `5! = 5 * 4 * 3 * 2 * 1 = 120`.
+> 阶乘，即 n! =n \* (n - 1) \*...... \* 2 \* 1<br/>例如：5! = 5 \* 4 \* 3 \* 2 \* 1 = 120.
 
 而阶乘的代码如下编辑
 
@@ -29,9 +27,9 @@ def factorial(n):
 - 想想在最简单的情况下函数将如何跳转
 - 考虑使用问题的更简单版本来进行解决问题
 
-# 任务
+## 任务
 
-P4：编写一个递归函数 `skip_add`，它接受一个参数 n 并返回 `n + n-2 + n-4 + n-6 + ... + 0`。假设 n 是非负数。
+P4：编写一个递归函数 `skip_add`，它接受一个参数 n 并返回 `n + n-2 + n-4 + n-6 +...+ 0`。假设 n 是非负数。
 
 ```python
 def skip_add(n):
diff --git a/3.编程思维体系构建/3.6.4.3阶段三：数据抽象.md b/3.编程思维体系构建/3.6.4.3阶段三：数据抽象.md
index 4258b78..27b8096 100644
--- a/3.编程思维体系构建/3.6.4.3阶段三：数据抽象.md
+++ b/3.编程思维体系构建/3.6.4.3阶段三：数据抽象.md
@@ -1,12 +1,13 @@
 # 阶段三：数据抽象
 
-数据抽象（Data Abstraction)
+数据抽象 (Data Abstraction)
 
-[可参考教程](https://zhuanlan.zhihu.com/p/343133774)
+::: warning 🐱 [可参考教程](https://zhuanlan.zhihu.com/p/343133774)
 
 各位需要认真了解以下内容，他们是构建任何大厦的基石
+:::
 
-# Data Abstraction
+## Data Abstraction
 
 数据抽象是一个伟大的概念，它允许程序员将代码以对象的形式进行看待，并且从更高的层面去审视问题。
 
@@ -14,14 +15,14 @@
 
 举个例子：你在开车时，如果要控制发动机的活塞怎么动，对你来说是否有些太过于困难了。因此将其抽象成了离合器，油门，刹车这些较为简单的操作。
 
-# 组成
+## 组成
 
 一个抽象的数据类型（ADT）由两个主要部分组成
 
 - Constructors:架构抽象数据类型的主要函数
 - Selectors:操作数据类型的各式方法
 
-# 列表与元组
+## 列表与元组
 
 列表是可以存储多个元素的 Python 数据结构。每个元素可以是任何类型，甚至可以是另一个列表！
 
@@ -37,12 +38,12 @@
 
 ```python
 tup = (1, 2, 3, 4)
-new_tup = tup + (5, ) # 创建新的元组new_tup，并依次填充原元组的值
+new_tup = tup + (5, ) # 创建新的元组 new_tup，并依次填充原元组的值
 new _tup
 (1, 2, 3, 4, 5)
 
 l = [1, 2, 3, 4]
-l.append(5) # 添加元素5到原列表的末尾
+l.append(5) # 添加元素 5 到原列表的末尾
 l
 [1, 2, 3, 4, 5]
 ```
@@ -69,13 +70,14 @@ l
 3
 ```
 
-思考题：
+::: warning 🤔 思考题：
 
 列表和元组在性能上有什么差异呢？
 
 他们对应的使用场景有哪些呢？
+:::
 
-# 字典与集合
+## ;ltyi 字典与集合
 
 字典是一系列由键（key）和值（value）配对组成的元素的集合，在 Python3.7+，字典被确定为有序
 
@@ -112,21 +114,22 @@ d
 {'name': 'jason', 'age': 20, 'gender': 'male'}
 
 s = {1, 2, 3}
-s.add(4) # 增加元素4到集合
+s.add(4) # 增加元素 4 到集合
 s
 {1, 2, 3, 4}
-s.remove(4) # 从集合中删除元素4
+s.remove(4) # 从集合中删除元素 4
 s
 {1, 2, 3}
 ```
 
-思考题：
+::: warning 🤔 思考题：
 
 字典和集合分别是什么原理呢？
 
 字典可以是一个列表吗？为什么？
+:::
 
-# 可变性
+## 可变性
 
 我们说如果一个对象可以由代码进行操作而改变那么我们称其具有可变性。
 
@@ -176,15 +179,16 @@ False
 True
 ```
 
-思考题，你能否从指针的角度去理解可变性呢？
+::: warning 🤔 思考题，你能否从指针的角度去理解可变性呢？
+:::
 
-# 任务
+## 任务
 
-P7：9*9 乘法表
+P7:9*9 乘法表
 
-可能现在对你来说，构建像下图这样的 99 乘法表已经是非常容易的一件事了，可是如果我要求你使用 python 的列表推导式(list comprehension)，在两行以内完成呢？
+可能现在对你来说，构建像下图这样的 99 乘法表已经是非常容易的一件事了，可是如果我要求你使用 python 的列表推导式 (list comprehension)，在两行以内完成呢？
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnccDSRQj5W3lZWEUkCOHz2b.png)
+![](https://cdn.xyxsw.site/boxcnccDSRQj5W3lZWEUkCOHz2b.png)
 
 P8：couple 情侣
 
@@ -235,40 +239,40 @@ make_city(name, lat, lon)
 
 ```python
 def make_city(name, lat, lon):
-    <em>"""</em>
-<em>    >>> city = make_city('Berkeley', 0, 1)</em>
-<em>    >>> get_name(city)</em>
-<em>    'Berkeley'</em>
-<em>    >>> get_lat(city)</em>
-<em>    0</em>
-<em>    >>> get_lon(city)</em>
-<em>    1</em>
-<em>    """</em>
-<em>    </em>return [name, lat, lon]
+    """
+    >>> city = make_city('Berkeley', 0, 1
+    >>> get_name(city)
+    'Berkeley
+    >>> get_lat(city)
+    0
+    >>> get_lon(city)
+    1
+    """    
+    return [name, lat, lon]
 
 def get_name(city):
-    <em>"""</em>
-<em>    >>> city = make_city('Berkeley', 0, 1)</em>
-<em>    >>> get_name(city)</em>
-<em>    'Berkeley'</em>
-<em>    """</em>
-<em>    </em>return city[0]
+    """
+    >>> city = make_city('Berkeley', 0, 1)
+    >>> get_name(city)
+    'Berkeley'
+    """
+    return city[0]
 
 def get_lat(city):
-    <em>"""</em>
-<em>    >>> city = make_city('Berkeley', 0, 1)</em>
-<em>    >>> get_lat(city)</em>
-<em>    0</em>
-<em>    """</em>
-<em>    </em>return city[1]
+    """
+    >>> city = make_city('Berkeley', 0, 1)
+    >>> get_lat(city)
+    0
+    """
+    return city[1]
 
 def get_lon(city):
-    <em>"""</em>
-<em>    >>> city = make_city('Berkeley', 0, 1)</em>
-<em>    >>> get_lon(city)</em>
-<em>    1</em>
-<em>    """</em>
-<em>    </em>return city[2]
+    """
+    >>> city = make_city('Berkeley', 0, 1)
+    >>> get_lon(city)
+    1
+    """
+    return city[2]
 ```
 
 首先你试试求出两个地方的距离。
diff --git a/3.编程思维体系构建/3.6.4.4阶段四：高阶函数.md b/3.编程思维体系构建/3.6.4.4阶段四：高阶函数.md
index d603583..e4ca206 100644
--- a/3.编程思维体系构建/3.6.4.4阶段四：高阶函数.md
+++ b/3.编程思维体系构建/3.6.4.4阶段四：高阶函数.md
@@ -1,24 +1,25 @@
 # 阶段四：高阶函数
 
-阅读以及完成本部分内容可以帮助你有效减少代码冗余。
+::: warning 🐱 阅读以及完成本部分内容可以帮助你有效减少代码冗余。
 
 让你完成更为优雅的代码
 
 各位要记住的是
 
-# 代码首先是给人看的
+<font size=5><strong>代码首先是给人看的</strong></font>
 
 机器看的永远只是你的机器码。
 
 可参考教程 [Lambda](https://zhuanlan.zhihu.com/p/80960485)
+:::
 
-# Lambda 介绍
+## Lambda 介绍
 
 Lambda 表达式是通过指定两件事来评估函数的表达式：参数和返回表达式。
 
 请尝试阅读以下英文表格，对比函数与 lambda 表达式的不同
 
-# Lambda 实验
+## Lambda 实验
 
 以下代码 python 会显示什么？通过对这些代码的实验，加深你对代码的学习
 
@@ -74,7 +75,7 @@ ______
 ______
 ```
 
-# 任务
+## 任务
 
 P9:我们发现以下两个函数看起来实现的非常相似，是否可以进行改进，将其整合？
 
@@ -113,11 +114,11 @@ def is_prime(n):
 
 需求：
 
-你需要通过自己写一个函数： `count_cond` ，来接受一个含有两个参数的函数 `condition(n, i)`(使用lambda表达式)，
+你需要通过自己写一个函数： `count_cond` ，来接受一个含有两个参数的函数 `condition(n, i)`(使用 lambda 表达式)，
 
-且`condition`函数应该满足第一个参数为N，而第二个参数将会在`condition`函数中遍历 1 to N。  
+且`condition`函数应该满足第一个参数为 N，而第二个参数将会在`condition`函数中遍历 1 to N。  
 
-`count_cond` 将返回一个单参数函数(ps：一个匿名函数)，此单参数函数将会在被调用时返回 1 to N 中所有满足`condition`的数字的个数(如：1到n中素数的个数)。
+`count_cond` 将返回一个单参数函数 (ps：一个匿名函数)，此单参数函数将会在被调用时返回 1 to N 中所有满足`condition`的数字的个数 (如：1 到 n 中素数的个数)。
 
 ```python
 def count_cond(condition):
diff --git a/3.编程思维体系构建/3.6.4.5阶段五：迭代生成.md b/3.编程思维体系构建/3.6.4.5阶段五：迭代生成.md
index a268330..c59468a 100644
--- a/3.编程思维体系构建/3.6.4.5阶段五：迭代生成.md
+++ b/3.编程思维体系构建/3.6.4.5阶段五：迭代生成.md
@@ -1,6 +1,6 @@
 # 阶段五：迭代生成
 
-# 前言
+## 前言
 
 在写乘法表的时候，你可能写过类似
 
@@ -18,13 +18,13 @@ for (int i = 0; i < n; i ++)
 
 但是，你想过 Python 在处理 for in 语句的时候，具体发生了什么吗？什么样的对象可以被 for in 来枚举呢？
 
-# 容器迭代
+## 容器迭代
 
 容器这个概念非常好理解。
 
 在 Python 中一切皆对象，对象的抽象就是类，而对象的集合就是容器。
 
-列表（list: [0, 1, 2]），元组（tuple: (0, 1, 2)），字典（dict: {0:0, 1:1, 2:2}），集合（set: set([0, 1, 2])）都是容器。
+列表`list: [0, 1, 2]`，元组`tuple: (0, 1, 2)`，字典`dict: {0:0, 1:1, 2:2}`，集合`set: set([0, 1, 2])`都是容器。
 
 对于容器，你可以很直观地想象成多个元素在一起的单元；而不同容器的区别，正是在于内部数据结构的实现方法。
 
@@ -74,11 +74,11 @@ StopIteration
 [1, 2, 3, 4]
 ```
 
-# 英语练习，对迭代器的类比
+## 英语练习，对迭代器的类比
 
 <strong>Analogy</strong>: An iterable is like a book (one can flip through the pages) and an iterator for a book would be a bookmark (saves the position and can locate the next page). Calling `iter` on a book gives you a new bookmark independent of other bookmarks, but calling `iter` on a bookmark gives you the bookmark itself, without changing its position at all. Calling `next` on the bookmark moves it to the next page, but does not change the pages in the book. Calling `next` on the book wouldn't make sense semantically. We can also have multiple bookmarks, all independent of each other.
 
-# 生成器：懒人迭代器！
+## 生成器：懒人迭代器!
 
 ```python
 def test_iterator():
@@ -114,7 +114,8 @@ Wall time: 12.5 s
 
 声明一个迭代器很简单，[i for i in range(100000000)]就可以生成一个包含一亿元素的列表。每个元素在生成后都会保存到内存中，你通过代码可以看到，它们占用了巨量的内存，内存不够的话就会出现 OOM 错误。
 
-了解下 yield（）函数吧，他可以返回一个生成器对象，试试看懂这个
+::: warning 🤔 了解下 yield（）函数吧，他可以返回一个生成器对象，试试看懂这个
+:::
 
 ```python
 >>> def gen_list(lst):
@@ -133,7 +134,7 @@ Wall time: 12.5 s
 StopIteration
 ```
 
-# 思考题：python 会显示什么？为什么？
+## 思考题：python 会显示什么？为什么？
 
 ```python
 >>> s = [1, 2, 3, 4]
@@ -185,9 +186,9 @@ ______
 ______
 ```
 
-# 任务
+## 任务
 
-P10：实现 `count`，它接受一个迭代器 `t` 并返回该值 `x` 出现在 的第一个 n 个元素中的次数 `t`
+P10：实现 `count`，它接受一个迭代器 `t` 并返回该值 `x` 出现在的前 n 个元素中的次数 `t`
 
 ```python
 def count(t, n, x):
diff --git a/3.编程思维体系构建/3.6.4.6结语.md b/3.编程思维体系构建/3.6.4.6结语.md
index 27fb94b..d70bdb5 100644
--- a/3.编程思维体系构建/3.6.4.6结语.md
+++ b/3.编程思维体系构建/3.6.4.6结语.md
@@ -1,6 +1,6 @@
 # 结语
 
-# 感觉学了不少内容，又感觉什么都没学？
+## 感觉学了不少内容，又感觉什么都没学？
 
 确实，这也是学习过程中一个非常普遍存在的状态，你学了五个非常重要的 python 语言的特性，但是在你用他们真正来优化代码解决代码之前，你都无法真正的掌握他们。
 
@@ -10,11 +10,11 @@
 
 同时，python 的核心特性就这些吗？远远不止呢，这些只是你入手其的敲门砖，我在下面会列举一些别的特性，你可以自行前去了解，也可以等到你真正遇到问题的时候去思考？
 
-# 为什么没有突出面向对象
+## 为什么没有突出面向对象
 
 因为代码量实在是太少了，当你去理解面向对象的时候的伟大意义时，最好与 C 语言这种面向过程的语言进行对比，不过，如果你完成了我们的文字冒险小游戏的时候，你可能会有非常深刻的体验。
 
-# 还有什么是我值得注意的？
+## 还有什么是我值得注意的？
 
 这些内容值得你去学习与思考，但是碍于各种因素，我暂时没有详细介绍
 
@@ -30,9 +30,9 @@
 
 如果有机会，我会继续补充相关内容
 
-值得一提的是:后面人工智能模块，我们将以 python 为主去进行编程，这对完成了所有任务的你一定是 a piece of cake!
+值得一提的是：后面人工智能模块，我们将以 python 为主去进行编程，这对完成了所有任务的你一定是 a piece of cake!
 
-# 一些不错的补充
+## 一些不错的补充
 
 [WTF for python](https://github.com/robertparley/wtfpython-cn)
 
diff --git a/3.编程思维体系构建/3.6.4Python for fun.md b/3.编程思维体系构建/3.6.4Python for fun.md
index 0310404..c5f7df7 100644
--- a/3.编程思维体系构建/3.6.4Python for fun.md	
+++ b/3.编程思维体系构建/3.6.4Python for fun.md	
@@ -1,6 +1,6 @@
 # Python for fun
 
-值得一提的是,Python 是面向对象的编程语言，与你之前书写的 C 语言（面向过程）有非常多的不同。
+值得一提的是，Python 是面向对象的编程语言，与你之前书写的 C 语言（面向过程）有非常多的不同。
 
 我们为什么要选择要使用 Python 来首先讲解面向对象这个概念？
 
diff --git a/3.编程思维体系构建/3.6.5.1CS61A Sec1.md b/3.编程思维体系构建/3.6.5.1CS61A Sec1.md
new file mode 100644
index 0000000..a14bee7
--- /dev/null
+++ b/3.编程思维体系构建/3.6.5.1CS61A Sec1.md	
@@ -0,0 +1,420 @@
+# CS61A Sec1
+
+<strong>观前须知：</strong>
+
+本章节内容基于 Berkeley 大学的教材 [Composing Programs](http://www.composingprograms.com/) by [John DeNero](http://www.denero.org/)，并在此基础上做了部分修改，是在[知识共享协议](https://creativecommons.org/licenses/by-nc-sa/3.0/deed.zh)下所许可的。
+
+计算机科学的高生产力之所以可能，是因为该学科是建立在一套优雅而强大的基本思想之上。所有的程序都从信息的表示开始，然后寻找一种逻辑来处理这些信息，并设计抽象概念来解释和控制这种逻辑。有了这些认识后，我们就需要准确的理解计算机是如何解释我们写的程序并进行计算的。
+
+> A language isn't something you learn so much as something you join.<br/>—[Arika Okrent](http://arikaokrent.com/)
+
+为了定义计算过程，我们需要一种编程语言；最好是许多人类和大量的计算机都能理解的语言。所以在 cs61a 中，伯克利主要使用 Python 语言来进行教学。
+
+（在之前的 cs61a 课程中，Berkeley 大学主要使用 Scheme 来进行教学，(可能会写一篇文章来说说 Python 和 Scheme 语言和编程上的区别？) 不过在现在的课程中还是有关于 Scheme 的内容，所以并不用太过伤心？🙄）
+
+## 学习目标
+
+在这一部分我们要学习的内容主要是函数（Functions）和控制（Control）
+
+### 一个简单的例子
+
+为了给 Python 一个适当的介绍，我们将从一个使用几种语言特征的例子开始。
+
+Python 内置了对广泛的常见编程的支持，如操作文本、显示图形和通过互联网进行通信。
+
+```python
+from urllib.request import urlopen
+```
+
+这个 Python 代码是一个导入语句，加载了在互联网上访问数据的功能。实际上，它提供了一个叫做 urlopen 的函数，它可以在一个[统一资源定位符（URL）](https://developer.mozilla.org/zh-CN/docs/Learn/Common_questions/Web_mechanics/What_is_a_URL)上访问内容，可以通过它来访问互联网上的数据。
+
+<strong>语句和表达式</strong>
+
+Python 代码由语句和表达式组成。大体上，计算机程序由以下指令组成
+
+1. 计算一些值
+2. 进行一些操作
+
+语句通常描述行动；当 Python 解释器执行一个语句时，它执行相应的动作。另一方面，表达式通常描述的是计算；当 Python 评估一个表达式时，它计算该表达式的值。在这篇文章下，介绍了几种类型的声明和表达方式。
+
+<strong>赋值语句</strong>
+
+```python
+shakespeare = urlopen('http://www.composingprograms.com/shakespeare.txt')
+```
+
+注意：在伯克利大学的教材中，上述代码中的 url 并没有添加"www."，导致现在（至少在写这篇文章的时候）无法打开原文中的 url（可能还会写一篇文章来讲解"www."?）
+
+将变量名 `shakespeare` 用 `=` 和后面的表达式的值联系起来。该表达式将 `urlopen` 函数应用于一个 URL，该 URL 包含威廉 - 莎士比亚 37 部戏剧的完整文本，全部保存在一个文本文件中。
+
+<strong>函数</strong>
+
+函数封装了操作数据的逻辑。
+
+这句话告诉我们，可以从两个角度来看函数：
+
+- 在调用函数的时候，我们关注的是要处理的数据
+- 在定义函数的时候，我们关注的是如何处理数据
+
+```python
+shakespeare = urlopen('http://www.composingprograms.com/shakespeare.txt')
+```
+
+`urlopen` 是一个函数。一个网络地址是一种数据，而莎士比亚戏剧的文本是另一种数据。从网络地址到文本的过程可能很复杂，但我们可以只用一个简单的表达式来应用这个过程，因为这个复杂性被藏在一个函数中。
+
+你可能不了解 `urlopen` 这个函数背后的逻辑，但这不影响你去调用这个函数，这就是函数封装的好处之一。
+
+<strong>因此，函数是本章节关注的重点。</strong>
+
+我们来看另一个赋值语句：
+
+```python
+words = set(shakespeare.read().decode().split())
+```
+
+这个语句将名字词与莎士比亚戏剧中出现的所有出现过的词（重复出现的词只统计一次）的集合联系起来，其中有 33,721(?) 个词。上述语句包含一个读取、解码和分割的命令链，每个命令都在一个中间计算实体上操作：我们从打开的 URL 中读取数据，然后将数据解码成文本，最后将文本分割成单词。所有这些词都被放在一个集合（Set，Python 中的一种数据类型）中。
+
+<strong>对象</strong>
+
+前文中提到的 Set，不仅仅是数据类型，也是一个对象。对象用一种能同时处理两者复杂性的方式，把数据和操作该数据的逻辑无缝衔接在一起。
+
+对象会是我们后面章节所要讨论的内容。
+
+现在让我们来看这个例子中的最后一个语句：
+
+```python
+>>> {w for w in words if len(w) == 6 and w[::-1] in words}
+{'redder', 'drawer', 'reward', 'diaper', 'repaid'}
+```
+
+第一行的">>>"表示输入，第二行则是交互式会话的输出
+
+这是一个复合表达式，其值是所有长度为 6 的、本身和反向拼写都在原集合中的词组成的集合。其中的 `w[::-1]` 是一种隐式表达，它枚举了 `w` 中的所有字母，但因为 `step = -1` 规定了步长是反方向的。
+
+<strong>解释器</strong>
+
+计算复合表达式需要一个精确的程序，以可预测的方式解释代码。一个能实现程序和计算符合表达式的程序被称为解释器；没错，其实解释器是程序（可能再写一篇文章来讲讲解释器和编译器的区别？）
+
+与其他计算机程序相比，编程语言的解释器在通用性方面是独一无二的。Python 的设计没有考虑到莎士比亚，然而，它的不可思议的灵活性使我们能够只用几个语句和表达式来处理大量的文本。
+
+最后，我们会发现所有这些核心概念都是密切相关的：函数是对象，对象是函数，而解释器是两者的实例。然而，要掌握编程的艺术，关键是要清楚地理解每个概念及其在组织代码中的作用。
+
+解释器的设计和实现也是我们之后的主要议题。
+
+### 编程原本
+
+编程语言不仅仅是指示计算机执行任务的一种手段，同时也是一个框架，我们在这个框架内组织我们关于计算过程的想法。程序的作用是在编程社区的成员之间交流这些想法，所以，编写的程序必须让人们容易阅读，而且只是顺便让机器执行。
+
+当我们描述一种语言时，我们应该特别注意该语言为结合简单的想法以形成更复杂的想法所提供的手段。
+
+每种强大的语言都有三种这样的机制：
+
+- <strong>原始的表达式和语句</strong>，代表了该语言提供的最简单的构建模块。
+- <strong>组合的方式</strong>，由较简单的元素建立成复合元素。
+- <strong>抽象的手段</strong>，通过它，复合元素可以作为单位被命名和操作。
+
+在编程中，我们处理两种元素：函数和数据。（很快就会发现，它们其实并不那么明显）。不那么正式地说，数据是我们想要操作的东西，而函数描述了操作数据的规则。因此，任何强大的编程语言都应该能够描述原始数据和原始函数，以及有一些方法来组合和抽象函数和数据。
+
+在上一小节中对 Python 解释器进行了实验后，我们现在重新开始，有条不紊地逐个开发 Python 语言元素。如果例子看起来很简单，那就耐心一点，因为更多令人兴奋的点很快就会出现。
+
+我们从原始表达式开始。一种原始表达式是数字。更确切地说，你输入的表达式由代表十进制的数字组成。
+
+```python
+>>> 42
+42
+```
+
+代表数字的表达式可以与数学运算符相结合，形成一个复合表达式，解释器将对其进行计算。
+
+```python
+>>> -1 - -1
+0
+>>> 1/2 + 1/4 + 1/8 + 1/16 + 1/32 + 1/64 + 1/128
+0.9921875
+```
+
+这些数学表达式使用<em>中缀</em>符号，其中<em>运算符</em>（例如，+，-，*，或/）出现在<em>操作数</em>（数字）之间。Python 包括许多形成复合表达式的方法。我们不会试图立即列举它们，而是会随着我们的学习引入新的表达形式，以及它们所支持的语言特性。
+
+最重要的一种复合表达式是<em>调用表达式</em>，它将一个函数应用于一些参数。回顾一下代数，函数的数学概念是一个从一些自变量到因变量的映射。例如，一个求最大值的函数将其的多个输入映射到当中最大值的一个单一的输出。Python 表达函数应用的方式与传统数学中相同。
+
+```python
+>>> max(7.5, 9.5)
+9.5
+```
+
+这个调用表达式有子表达式：<em>操作符</em>是括号前的表达式，它包含了一个用逗号分隔的<em>操作数</em>列表。
+
+![](static/call_expression.png)
+
+运算符指定了一个<em>函数</em>。当这个调用表达式被评估时，我们说对<em>参数</em>`7.5` 和 `9.5`<em>调用</em>函数 `max`，并<em>返回</em>一个 9.5 的<em>返回值</em>。
+
+调用表达式中参数的顺序很重要。例如，函数 `pow` 计算第一个参数的第二个参数次方。
+
+```python
+>>> pow(100, 2)
+10000
+>>> pow(2, 100)
+1267650600228229401496703205376
+```
+
+与中缀表示法的数学约定相比，函数表示法有三个主要优点。首先，函数可以接受任意数量的参数：
+
+```python
+>>> max(1, -2, 3, -4)
+3
+```
+
+不会产生歧义，因为函数名总是优先于其参数。
+
+此外，函数符号以一种直接的方式延伸到<em>嵌套表达式</em>，其中的元素本身就是复合表达式。在嵌套的调用表达式中，与复合的中缀表达式不同，嵌套的结构在括号中是完全明确的。
+
+```python
+>>> max(min(1, -2), min(pow(3, 5), -4))
+-2
+```
+
+对于这种嵌套的深度以及 Python 解释器可以计算的表达式的整体复杂性，（原则上）没有限制。然而，人类很快就会被多级嵌套所迷惑。作为一个程序员，你的一个重要作用是构造表达式，使它们仍然可以由你自己、你的编程伙伴和其他将来可能阅读你的表达式的人来解释。
+
+同时，数学符号有各种各样的形式：乘法出现在术语之间，指数显示为上标，除法显示为斜杠，平方根显示为有斜边的屋顶。其中一些符号是很难打出来的！然而，所有这些复杂性都可以通过调用表达式的符号来统一。虽然 Python 支持使用中缀表达式的常见数学运算符（如 `+` 和 `-`），但任何运算符都可以表示为一个有名称的函数。
+
+### 导入库函数
+
+Python 定义了大量的函数，包括上一节中提到的运算符函数，但默认不提供它们的所有名称。作为替代，它将函数和其他量组织到模块中，这些模块共同构成了 Python 库。为了使用这些元素，人们将它们导入。例如，数学模块提供了各种熟悉的数学相关的函数。
+
+```python
+>>> from math import sqrt
+>>> sqrt(256)
+16.0
+```
+
+而运算符模块提供了对应于中缀表达式的函数的访问：
+
+```python
+>>> from operator import add, sub, mul
+>>> add(14, 28)
+42
+>>> sub(100, mul(7, add(8, 4)))
+16
+```
+
+一个导入语句指定了一个模块的名称（例如，`operator` 或 `math`），然后列出要导入的该模块的命名属性（例如，`sqrt`）。一旦一个函数被导入，它可以被多次调用。
+
+使用这些运算符函数（如 `add`）和运算符符号本身（如 `+`）之间没有区别。传统上，大多数程序员使用符号和中缀表达式来表达简单的算术。
+
+[Python 3 库文档](https://docs.python.org/3/library/index.html)列出了每个模块所定义的功能，如[数学模块](https://docs.python.org/3/library/math.html)。然而，这个文档是为那些对整个语言很了解的开发者编写的。现在，你可能会发现，对一个函数进行实验比阅读文档能告诉你更多关于它的行为。随着你对 Python 语言和词汇的熟悉，这个文档将成为有价值的参考来源。
+
+### 变量名和环境
+
+编程语言的一个关键方面是它提供了使用变量名来指代计算对象的手段。如果一个值被赋予了一个变量名，我们就说这个变量名与这个值<em>绑定</em>了。
+
+在 Python 中，我们可以使用赋值语句建立新的绑定，其中包含左边的变量名 `=` 右边的值。
+
+```python
+>>> radius = 10
+>>> radius
+10
+>>> 2 * radius
+20
+```
+
+变量名也是可以通过导入语句来绑定的。
+
+```python
+>>> from math import pi
+>>> pi * 71 / 223
+1.0002380197528042
+```
+
+`=` 符号在 Python（以及许多其他语言）中被称为<em>赋值</em>操作符。赋值是我们最简单的抽象手段，因为它允许我们使用简单的名称来指代复合操作的结果。用这种方式，复杂的程序就是通过一步一步地建立复杂度越来越高的计算对象来构建的。
+
+将变量名与值绑定，然后通过变量名检索这些值意味着解释器必须保持某种内存，以跟踪变量名、值和绑定。这样的内存空间被称为<em>环境</em>。
+
+变量名也可以被绑定到函数上。例如，变量名 `max` 与我们使用的求最大值的函数绑定。与数字不同的是，函数在呈现为文本时很棘手，所以当被要求描述一个函数时，Python 会打印一个识别描述。
+
+```python
+>>> max
+<built-in function max>
+```
+
+我们可以使用赋值语句给现有的函数起别名。
+
+函数也可以看作是值。
+
+```python
+>>> f = max
+>>> f
+<built-in function max>
+>>> f(2, 3, 4)
+4
+```
+
+在同一个环境下的连续的赋值语句可以将一个名字重新绑定到一个新的值。
+
+```python
+>>> f = 2
+>>> f
+2
+```
+
+在 Python 中，名称通常被称为<em>变量名</em>或<em>变量</em>，因为它们在执行程序的过程中可能被绑定到不同的值。当一个名称通过赋值被绑定到一个新的值时，它就不再被绑定到任何以前的值。人们甚至可以将内置名称与新值绑定。
+
+```python
+>>> max = 5
+>>> max
+5
+```
+
+在将 `max` 赋值为 5 后，`max` 这个名称不再与函数绑定，因此试图调用 `max(2, 3, 4)` 会造成错误。
+
+在执行赋值语句时，Python 在改变对左边变量名的绑定之前，对 `=` 右边的表达式进行计算。因此，人们可以在右侧表达式中引用一个变量名，即使它是要被赋值语句绑定的变量名。
+
+```python
+>>> x = 2
+>>> x = x + 1
+>>> x
+3
+```
+
+我们还可以在一个语句中给多个变量名赋值，其中左边的变量名和右边的表达式分别用逗号隔开。
+
+```python
+>>> area, circumference = pi * radius * radius, 2 * pi * radius
+>>> area
+314.1592653589793
+>>> circumference
+62.83185307179586
+```
+
+改变一个变量的值并不影响其他变量。下面，尽管变量名 `area` 被绑定到一个最初以 `radius` 定义的值，但 `area` 的值并没有改变。更新 `area` 的值需要另一个赋值语句。
+
+```python
+>>> radius = 11
+>>> area
+314.1592653589793
+>>> area = pi * radius * radius
+380.132711084365
+```
+
+通过多重赋值的语句，在左边的任何变量名被绑定到这些值之前，右边的所有表达式都将被计算。由于这个规则，交换绑定在两个变量名上的值可以在一个语句中进行。
+
+```python
+>>> x, y = 3, 4.5
+>>> y, x = x, y
+>>> x
+4.5
+>>> y
+3
+```
+
+### 计算嵌套表达式
+
+我们在本小节的目标之一是分离出关于像程序一样思考的问题。从下面这个例子中，我们应该意识到，在计算嵌套调用表达式时，解释器本身是在遵循某种步骤。
+
+为了计算一个调用表达式，Python 将做按以下规则来工作：
+
+1. 计算运算符和操作数的子表达式，然后
+2. 将作为运算符子表达式的值的函数应用于作为运算符子表达式的值的参数。
+
+即使这是个简单的程序也说明了关于一般过程的一些重要观点。第一步决定了为了完成一个调用表达式的计算过程，我们必须首先计算其他表达式。因此，计算过程在本质上是<em>递归的</em>；也就是说，作为其步骤之一，它也包括调用规则本身。
+
+例如，计算
+
+```python
+>>> sub(pow(2, add(1, 10)), pow(2, 5))
+2016
+```
+
+需要这个按照上述过程重复四次。如果我们画出每个被计算的表达式，我们就可以直观地看到这个过程的层次结构。
+
+![](static/expression_tree.png)
+
+这张插图被称为<em>表达式树</em>。在计算机科学中，树（Tree，一种数据结构，我们将在后续的章节中进行讨论）通常是自上而下生长的。树中每一点的对象被称为节点；在这张插图的情况下，节点是与值配对的表达式。
+
+计算它的根，即顶部的完整表达式，需要首先计算作为其子表达式的分支。叶表达式（即没有分支的节点）代表函数或数字。内部节点有两个部分：我们的计算规则所适用的调用表达式，以及该表达式的结果。从这棵树的计算来看，我们可以想象操作数的值是向上渗滤的，从末端节点开始，然后在越来越高的层级上进行组合。
+
+接下来，观察一下，步骤一的重复应用使我们需要计算的不是调用表达式，而是数字（如 `2`）和名称（如 `add`）等原始表达式。
+
+我们通过规定以下几点来处理这种情况：
+
+- 数字计算为它的名称所代表的数量
+- 名称计算为与当前环境中的名称相关的值。
+
+请注意环境在决定表达式中符号的含义方面的重要作用。在 Python 中，在没有给定环境或是明确所有名称所指代的内容时，谈论一个表达式的价值是没有意义的，比如
+
+```python
+>>> add(x, 1)
+```
+
+而不指定任何关于环境为名称 `x`（甚至是名称 `add`）提供意义的信息。环境提供了计算发生的背景，这对我们理解程序执行起着重要作用。
+
+上述的计算过程不足以计算所有的 Python 代码，只计算调用表达式、数字和名称。
+
+例如，它不处理赋值语句
+
+```python
+>>> x = 3
+```
+
+这个语句不返回一个值，也不在某些参数上调用一个函数，因为赋值的目的是将一个变量名绑定到一个值上。
+
+一般来说，赋值语句不是被计算而是<em>被执行</em>；它们不产生一个值，而是做一些改变。每种类型的表达式或语句都有自己的计算或执行过程。
+
+### 纯函数和非纯函数
+
+在本小节中，我们将区分两种函数
+**纯函数**
+函数有一些输入（它们的参数）并返回一些输出（应用它们的结果）。
+例如内置函数
+
+```python
+>>> abs(-2)
+2
+```
+
+可以被描述为一台接受输入并产生输出的小型机器。
+![](static/function_abs.png)
+函数 `abs` 是*纯函数*。纯函数的特性是，调用它们除了返回一个值之外没有任何影响。此外，当用相同的参数调用两次时，一个纯函数必须总是返回相同的值。
+
+**非纯函数**
+除了返回一个值之外，应用一个非纯函数会产生副作用，从而使解释器或计算机的状态发生一些变化。一个常见的副作用是，使用`print`函数，在返回值之外产生额外的输出。
+
+```python
+>>> print(1, 2, 3)
+1 2 3
+```
+
+虽然`print`和`abs`在这些例子中可能看起来很相似，但它们的工作方式根本不同。打印返回的值总是`None`，这是一个特殊的 Python 值，不代表任何东西。交互式 Python 解释器不会自动打印值`None`。在`print`的情况下，函数本身是打印输出，也是被调用的副作用。
+![](static/function_print.png)
+
+对`print`函数的嵌套调用突出了纯函数和非纯函数的区别
+
+```python
+>>> print(print(1), print(2))
+1
+2
+None None
+```
+
+如果你发现这个输出出乎意料，可以画一个表达式树来弄清楚为什么计算这个表达式会产生这个奇特的输出。
+
+请注意！`print`函数的返回值`None`意味着它*不应该*是赋值语句中的表达式。
+
+```python
+>>> two = print(2)
+2
+>>> print(two)
+None
+```
+
+纯函数是被限制的，因为它们不能有副作用或随时间改变行为。施加这些限制会产生巨大的好处。
+首先，纯函数可以更可靠地组成复合调用表达式。我们可以在上面的非纯函数例子中看到，`print`在操作数表达式中使用时并没有返回一个我们期望的结果。另一方面，我们已经看到，像`max`、`pow`和`sqrt`这样的函数可以有效地用于嵌套表达式。
+其次，纯函数往往更容易测试。一个参数列表将总是导致相同的返回值，这可以与预期返回值进行比较。关于测试将在之后的章节详细讨论。
+
+在之后的章节中，我们将说明纯函数对于编写并发程序的重要性，其中多个调用表达式可以同时被计算。
+与之对应的，我们也将研究非纯函数并了解他们的用途。
+
+出于这些问题的考虑，我们将在下一章节中着重讨论创建和使用纯函数。`print`函数的使用只是为了让我们看到计算的中间结果。
+
+## 课后作业
+
+一个好的课程怎么能少得了精心准备的课后作业呢？🤗
diff --git a/3.编程思维体系构建/3.6.5.1lab00：让我们开始吧.md b/3.编程思维体系构建/3.6.5.1lab00：让我们开始吧.md
deleted file mode 100644
index f1f21cc..0000000
--- a/3.编程思维体系构建/3.6.5.1lab00：让我们开始吧.md
+++ /dev/null
@@ -1,625 +0,0 @@
-# lab00：让我们开始吧
-
-# 介绍
-
-本 lab 将介绍如何设置计算机以完成作业，并介绍 Python 的一些基础知识。
-
-这个 lab 是必需的。这个设置对于完全课程中的所有其他作业是必要的。
-
-这个 lab 看起来非常长，但它主要是设置和学习如何使用这个课程的基本工具。这些现在看起来有点困难，但随着我们进一步进入课程，很快就会变得熟悉起来。
-
-以下是实验室的主要部分：
-
-- <strong>设置</strong>：设置课程的基本软件。这将需要几个组件，如下所列。
-
-  - <strong>安装终端</strong>：安装终端，以便你可以与本课程中的文件进行交互并运行 OK 命令。如果你的计算机上有终端并且使用起来很舒服，则可以跳过这一部分。
-  - <strong>安装 Python 3</strong>：将 Python 编程语言安装到你的计算机上。如果你已经安装了 Python 3.7 或更高版本（最好是 Python 3.9），则可以跳过这部分。
-  - <strong>安装文本编辑器</strong>：安装软件来编辑 `.py` 本课程的文件（例如 VSCode、Atom 等）。如果你已经有了自己喜欢的文本编辑器，则可以跳过这一部分。
-- <strong>演练：使用终端</strong>：本节将引导你完成如何使用终端和 Python 解释器。如果你已经能熟练使用这两者并感到轻松，则无需阅读本节。
-- <strong>演练：组织文件</strong>：本节将指导你完成如何使用终端来组织和导航本课程的文件。<strong>每个人都应该至少浏览一下这一部分</strong>，因为它包含特定于此类的重要信息，但是如果你已经习惯使用终端浏览目录结构，那么其中的大部分内容都会很熟悉。
-- <strong>复习：Python 基础知识</strong>：这是对讲座中介绍的 Python 的许多基本组件的复习。你应该已经看过此材料，但我们希望在每个 lab 中包含对相关内容的简要回顾，以备你需要复习任何内容。
-- <strong>要求：完成作业</strong>：你必须完成此部分才能获得作业分数。在这里，你将练习本课程的 lab、hw 和 proj 中要求你完成的不同类型的问题。本作业的主要目的是让你练习使用我们的软件。
-- <strong>要求：提交作业</strong>：你必须完成此部分才能获得作业分数。这将引导你了解如何在完成上一节后上交作业，以及如何验证你的作业是否已在 OKPY 上上交。（即使我们没有注册账户，也可以在本地运行 ok）
-- <strong>附录：有用的 Python 命令行选项</strong>：这些命令对调试你的工作很有用，但不是完成本实验所必需的。我们将它们包括在内是因为我们认为它们可能会在整个课程中对你有所帮助。
-
-## 设置
-
-### 安装终端
-
-终端是一个程序，允许你通过输入命令与你的计算机进行交互。
-
-#### macOS/Linux
-
-如果你使用的是 Mac 或正在使用某种形式的 Linux（例如 Ubuntu），则你 `Terminal` 的计算机上已经有一个名为或类似名称的程序。打开它，你应该可以开始了。
-
-#### 视窗
-
-<strong>选项 1 (WSL)：</strong>你可以使用适用于 Linux 的 Windows 子系统或 WSL 在 Windows 上获得终端。这可以通过终端程序访问 `Ubuntu`，该程序模拟 Windows 计算机上的 Ubuntu 操作系统 (OS)。这将使我们的大部分作业在你的设备上顺利进行。
-
-要安装适用于 Windows 的 Ubuntu，请单击开始并搜索 PowerShell。右键单击并选择“以管理员身份运行”。然后，在 PowerShell 窗口中，键入 `wsl --install` 并按 Enter。该命令必须按照准确的顺序输入。这应该会自动完成设置过程（按照屏幕上可能给出的任何说明进行操作）。
-
-接下来， [从 Windows 商店下载 Ubuntu](https://apps.microsoft.com/store/detail/ubuntu/9PDXGNCFSCZV?hl=en-us&gl=US)，或者你可以运行：
-
-```sql
-wsl --install -d ubuntu
-```
-
-你可能还会发现访问 [Ubuntu 的下载指南](https://ubuntu.com/tutorials/install-ubuntu-on-wsl2-on-windows-10#1-overview)很有帮助。
-
-安装完成后，在开始菜单中搜索 Ubuntu。第一次启动可能需要几分钟，但后续启动应该很快。
-
-<strong>替代选项：</strong>如果你在安装 WSL 时遇到问题，你可以跳过此步骤并使用 Windows PowerShell 代替 61A。PowerShell 预装在 Windows 上，无需额外设置。你可以简单地从“开始”菜单启动它。`cd` 像和 这样的简单命令 `ls` 将起作用（`python` 将在设置后起作用），其中包含本课程所需的大部分 Bash 命令。
-
-### 安装 Python 3
-
-Python 3 是本课程中使用的主要编程语言。使用下面的说明安装 Python 3。（这些说明可能适用于旧版本的 Python 3，但步骤相似。）
-
-<strong>重要提示：</strong>如果你已经安装了旧版本的 Python，请确保下载并安装 Python 3.9。你可以使用 来检查你的 Python 版本 `python3 ––version`。
-
-#### macOs
-
-下载并安装 [Python 3（64 位）](https://www.python.org/ftp/python/3.9.6/python-3.9.6-macosx10.9.pkg)。你可能需要右键单击下载图标并选择“打开”。安装后，请关闭并重新打开你的终端。
-
-如果你安装了 Homebrew，你也可以通过运行安装 Python3 `brew install python3`。
-
-#### Windows
-
-<strong>如果你将使用 PowerShell 而不是 WSL，请打开 Microsoft Store 并搜索“python”。</strong>安装 Python Software Foundation 提供的 Python 3.9（这应该是第一个结果）。然后你可以跳过本节的其余部分。（重要提示：如果你以后决定以不同方式重新安装 Python，<strong>请先从 Microsoft Store 卸载它。）</strong>
-
-否则，如果你使用的是 WSL，请在 Ubuntu 中键入 `sudo apt install python3` 并点击 `enter`. 安装完成后，你可以通过键入来测试它是否安装正确 `python3 --version`。你应该会在响应中看到一条消息，显示你的 python3 版本： `Python 3.9.6`。
-
-#### Linux
-
-运行 `sudo apt install python3`(Ubuntu)、`sudo pacman -S python3`(Arch) 或适用于你的发行版的命令。
-
-#### 其他
-
-[从下载页面下载 Python](https://www.python.org/downloads/)。
-
-### 安装文本编辑器
-
-<strong>你刚刚安装的 Python 解释器</strong>允许你<em>运行</em>Python 代码。你还需要一个<strong>文本编辑器</strong>，你将在其中<em>编写</em>Python 代码。
-
-[Visual Studio Code (VS Code)](https://code.visualstudio.com/)是这门课程编写 Python 的最流行的选择。下面还列出了员工使用的其他一些编辑器。
-
-<strong>如果你使用的是 Windows</strong>并遵循我们的 Python 设置过程，VS Code 将最适合你（因为它具有 WSL 支持）。安装 VS Code 后，安装 [Remote Development 扩展包](https://aka.ms/vscode-remote/download/extension)。[然后，你可以使用 VS Code 文档这一部分](https://code.visualstudio.com/docs/remote/wsl#_open-a-remote-folder-or-workspace)中的说明在 VS Code 中打开 WSL 文件夹。
-
-<strong>我们强烈建议在本课程中使用 VS Code。</strong>这将帮助我们为你提供最好的支持，因为大多数员工也使用 VS Code。
-
-VS Code 的另一个不错的功能是它具有“嵌入式终端”。因此，在为此类运行终端命令时，你可以在 VS Code 中管理所有内容，而不是在 VS Code 和单独的终端应用程序之间来回导航。`Terminal > New Terminal` 你可以通过转到 VS Code 的导航栏中打开嵌入式终端 。
-
-> 警告：请不要使用 Microsoft Word 等文字处理器来编辑程序。文字处理器可以向文档添加额外的内容，这会使解释器感到困惑。
-
-为了你的参考，我们还编写了一些使用流行的文本编辑器的指南。完成实验室后，如果你有兴趣，可以看看：
-
-- [Visual Studio Code](https://inst.eecs.berkeley.edu/~cs61a/fa22/articles/vscode)：一个功能齐全的桌面编辑器，具有许多可用于支持不同语言的扩展。
-- [Atom](https://inst.eecs.berkeley.edu/~cs61a/fa22/articles/atom)：一个更轻量级的桌面编辑器。
-- [Vim](https://inst.eecs.berkeley.edu/~cs61a/fa22/articles/vim)：命令行编辑器。
-- [Emacs](https://inst.eecs.berkeley.edu/~cs61a/fa22/articles/emacs)：命令行编辑器。
-
-其他编译器：
-
-- [PyCharm](https://www.jetbrains.com/pycharm/)：专为 Python 设计的桌面编辑器。
-- [Sublime Text](https://www.sublimetext.com/)：一个使用代码的文本编辑器。
-
-### 结对编程
-
-在整个课程中，你将有很多机会在实验室和项目中与其他人协作编码。我们建议你现在下载这些结对编程扩展以备将来使用。
-
-要共享代码，你可以按照你选择的编辑器的说明进行操作：
-
-- [VS Code](https://inst.eecs.berkeley.edu/~cs61a/fa22/articles/vscode#pair-programming)
-- [Atom](https://inst.eecs.berkeley.edu/~cs61a/fa22/articles/atom#pair-programming)
-
-### 备份设置
-
-如你你在安装 Python 解释器、文本编辑器和终端时遇到问题，或者如果你使用的东西不允许你安装软件，比如 iPad，你可以作为临时措施使用以下一些来完成作业在你获得更合适的硬件时执行的步骤。
-
-#### Soda 实验室计算机
-
-你将需要一个指导帐户，该帐户允许你登录并使用 Soda 中的任何实验室计算机。你可以访问以下网址查看你现有的教学帐户并为适用的课程创建新的教学帐户：https: [//inst.eecs.berkeley.edu/connecting.html](https://inst.eecs.berkeley.edu/connecting.html)。
-
-你可以通过你的 CalNet ID 登录该站点。要创建本课程的教学帐户，请单击以“cs61a”为目的的行的“获取新帐户”。
-
-创建帐户后，你可以使用它登录 Soda 实验室计算机，并使用该计算机完成课程作业。
-
-#### 在线编辑器作为备份
-
-> 重要提示： 下面列出的两种替代方法都不适合在本课程中使用。我们建议能够使用您自己的本地设置或使用 Soda 中的实验室计算机（您可以使用您的课程教学帐户访问）。
-
-<strong>61A 代码：</strong>
-
-您可以使用 [61A 代码](https://code.cs61a.org/)，这是一个在线课程环境，您可以在其中编辑、运行、调试、可视化程序并与教职员工共享程序。可在此处找到 61A 代码的文档： [61A 代码文档](https://cs61a.org/articles/61a-code-docs/)。
-
-> 注意： 您将无法 `ok` 在 61A 代码中运行命令，解锁测试、运行测试和提交作业需要执行这些命令。
-
-在 61A Code 上完成此作业的步骤：
-
-1. 访问 [61A 代码](https://code.cs61a.org/)。
-2. 打开现有文件：进入您的 `cs61a` 文件夹，然后是作业文件夹 ( `lab00`)，您可以在其中找到该作业的文件。
-3. 系统将提示您授权编辑器。您可以点击“确认”。回到编辑器本身，然后您可以打开要编辑的文件。
-4. 要打开终端，请单击“控制台”。
-5. 您可以使用编辑器编写代码，使用控制台运行代码。
-
-<strong>数据中心：</strong>
-
-在本地工作的另一种选择是使用加州大学伯克利分校的 Datahub。
-
-在 Datahub 上完成作业的步骤：
-
-1. 访问[数据中心](https://datahub.berkeley.edu/)。
-2. 将作业 zip 文件上传到数据中心。
-3. 通过按左上角的“新建”并选择终端来打开终端。
-4. 导航到 zip 文件所在的位置并运行 `unzip lab00.zip`。
-5. 打开代码文件 ( `lab00.py`) 并在其中键入，然后保存。
-6. 现在您可以提交实验。
-
-## 演练：使用终端
-
-首先，打开一个终端窗口。
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/L5HvblSuYonJn4x03a4cMLKknrh.png)
-
-#### 主目录
-
-当您第一次打开终端时，您将从“主目录”开始。主<strong>目录</strong>由 `~` 符号表示，您可能会在提示符处看到它。
-
-> 如果您的终端窗口看起来不完全相同，请不要担心。重要的部分是提示符显示 `$`（表示 Bash）或 `%` （表示 zsh）。
-
-尝试跑步 `echo "$HOME"`。该命令应显示您的主目录的完整路径。它应该看起来像这样：
-
-`/Users/OskiBear`
-
-#### 小路
-
-PATH 就像一个地址：它告诉您和计算机到某个文件夹的完整路径（或路由）。请记住，您可以通过两种不同的方式访问计算机上的文件和目录（文件夹）。您可以使用终端（这是一个<strong>命令行</strong>界面或 CLI），也可以使用 Finder <strong>。</strong>Finder 是<strong>图形</strong>用户<strong>界面</strong>（或 GUI）的一个 例子<strong>。</strong>导航技术不同，但文件相同。例如，这是我的 CS 61A 实验室文件夹在我的 GUI 中的样子：
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/CWDhbW6gzogyMFxtd6kcnPBunv2.png)
-
-这是完全相同的文件夹在终端中的外观：
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/HZNMbzGZOoQGAhxQ29gcM5V4nNd.png)
-
-请注意，在这两种情况下，黄色框都显示了 PATH，紫色椭圆显示了“labs”文件夹的内容。
-
-#### 终端与 Python 解释器
-
-让我们停下来思考一下终端和 Python 解释器之间的区别。
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/HgTfbMhCGodZbzxBNh9crH3cnCe.png)
-
-1. 哪个是终端？
-2. 哪个是 Python 解释器？
-3. 哪个是我的代码编辑器？
-4. 你怎么知道？
-
-A 和 D 都是我的终端。在这里您可以运行 bash 命令，例如 `cd` 和 `ls`。D 是 VS Code 内置的终端。
-
-B 是 Python 解释器。你可以从 >>> 提示中看出这意味着你已经启动了一个 Python 解释器。您还可以判断，因为启动它的命令是可见的：`python3`。该 `python3` 命令启动 Python 解释器。如果您在 Python 解释器中键入 bash 命令，您可能会遇到语法错误！这是一个例子：
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/GEN5b1HHdoDegPxAp8WcQDGknoc.png)
-
-C 是我的代码编辑器。这是我可以编写 Python 代码以通过我的终端执行的地方。
-
-## 演练：组织文件
-
-在本节中，您将学习如何使用终端命令管理文件。
-
-> 确保您的提示包含 `$` 其中的某处并且不以 `>>>`. 如果它以 `>>>` 您仍在 Python shell 中开头，您需要退出。见上文了解如何。
-
-### 目录
-
-您将使用的第一个命令是 `ls`. 尝试在您的终端中输入：
-
-```
-ls
-```
-
-该 `ls` 命令<strong>列出</strong>了当前目录中<strong>的</strong>所有文件和文件夹。目录是文件夹（如文件夹）的另一个 <strong>名称</strong>`Documents`。
-
-#### macOS/Linux
-
-由于您现在位于主目录中，因此在您键入后 `ls` 您应该会看到主目录的内容。
-
-#### 视窗
-
-`~` 在 Ubuntu 中，当您键入 时，您将看不到任何文件 `ls`。相反，您首先需要更改目录（见下文）。
-
-### 更改目录
-
-要移动到另一个目录，请使用 `cd` 命令 ( <strong>c</strong> hange <strong>directory</strong> )。
-
-#### macOS/Linux
-
-让我们尝试进入您的 `Desktop` 目录。首先，确保您位于主目录中（检查 `~` 命令行中的 ）并使用 `ls` 查看该 `Desktop` 目录是否存在。
-
-尝试在您的终端中键入以下命令，这应该会将您移至该目录：
-
-```
-cd Desktop
-```
-
-如果您<em>不在</em>您的主目录中，请尝试 `cd ~/Desktop`. 这是告诉终端你想去的路径。
-
-#### Windows
-
-在 Windows 上，首先切换到您的主目录。
-
-```
-cd /mnt/c/Users/
-```
-
-现在尝试 `ls` 之前的命令。您应该会看到一些文件夹。其中一个文件夹应与您的用户名匹配。例如，假设您的用户名是 `OskiBear`，您应该会看到一个名为 的文件夹 `OskiBear`。（请注意，您的 Windows 用户名可能与您的 Ubuntu 用户名不同）让我们切换到该文件夹：
-
-```
-cd /mnt/c/Users/OskiBear/Desktop
-```
-
-如果仍然找不到桌面目录，请在 Piazza 或办公时间寻求帮助。
-
-### 制作新目录
-
-下一个命令称为 `mkdir`，<strong>它</strong>创建<strong>一个</strong>新 <strong>目录</strong>。让我们在您的目录中创建一个名为的目录来存储此类的所有作业：`cs61aDesktop`
-
-```
-mkdir cs61a
-```
-
-名为的文件夹 `cs61a` 将出现在您的桌面上。`ls` 您可以通过再次使用该命令或使用资源管理器 (Windows) 或 Finder (Mac) 检查您的桌面来验证这一点。
-
-在这一点上，让我们创建更多的目录。首先，确保您位于 `cs61a` 目录中（mac: `~/Desktop/cs61a`, Windows: `/mnt/c/Users/Desktop/cs61a`）。然后，创建两个新文件夹，一个名为 `projects`，另一个名为 `lab`. 两者都应该在您的 `cs61a` 文件夹中：
-
-#### macOS/Linux
-
-```
-cd ~/Desktop/cs61a
-mkdir projects
-mkdir lab
-```
-
-#### Windows
-
-```
-cd /mnt/c/Users/OskiBear/Desktop/cs61a
-mkdir projects
-mkdir lab
-```
-
-现在，如果您列出目录的内容（使用 `ls`），您将看到两个文件夹，`projects` 和 `lab`.
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Cpfzb9oK2oMyGxxgkqVceE8DnId.png)
-
-### 更多目录更改
-
-有几种方法可以返回主目录：
-
-- `cd ..`（两个点）。意思 `..` 是“父目录”，或当前目录之上的一个目录。
-- `cd ~`（代字号）。请记住，这 `~` 意味着主目录，因此此命令将始终更改为您的主目录。
-- `cd`（只有 `cd`）。只输入 `cd` 是输入 `cd ~` 的捷径。
-
-> 如果您愿意，您不必将文件保留在桌面上。您将文件保存在本地的位置不会影响您的成绩。做对您来说最简单、最方便的事情！
-
-### 下载作业
-
-如果您还没有，请下载 zip 存档 [lab00.zip](https://inst.eecs.berkeley.edu/~cs61a/fa22/lab/lab00/lab00.zip)，其中包含本 lab 所需的所有文件。完成后，让我们找到下载的文件。在大多数计算机上，`lab00.zip` 它可能位于一个名为 `Downloads` 您的主目录的目录中。使用 `ls` 命令检查：
-
-```
-ls ~/Downloads
-```
-
-如果您没有看到 `lab00.zip`，请在 Piazza 或办公时间寻求帮助。在某些版本的 Safari 上，文件可能会为您解压缩，在这种情况下，您只会看到一个名为 `lab00`.
-
-### 提取启动文件
-
-您必须先展开 zip 存档，然后才能处理实验室文件。不同的操作系统和不同的浏览器有不同的解压方式。在 Mac 中单击 .zip 文件将自动解压缩。在 Windows 上，您需要先单击 .zip 文件，然后选择“全部解压”。如果遇到麻烦，可以在线搜索如何解压缩文件。
-
-这是使用终端解压缩的一种方法：
-
-> 使用终端，您可以从命令行解压缩 zip 文件。首先，`cd` 进入包含 zip 文件的目录：<br/>``<br/>cd ~/Downloads<br/>`` 现在，`unzip` 使用 zip 文件的名称运行命令：<br/>``<br/>unzip lab00.zip<br/>``
-
-您只需要解压缩文件一次。
-
-解压缩后 `lab00.zip`，您将拥有一个名为的新文件夹 `lab00`，其中包含以下文件（使用 `cd lab00` 和检查 `ls`）：
-
-- `lab00.py`：您要将代码添加到的模板文件
-- `ok`: 用于测试和提交作业的程序
-- `lab00.ok`: 配置文件 `ok`
-
-### 移动文件
-
-将实验室文件移动到您之前创建的实验室文件夹中：
-
-<strong>macOS/Linux</strong>
-
-```
-mv ~/Downloads/lab00 ~/Desktop/cs61a/lab
-```
-
-Windows
-
-```
-mv /mnt/c/Users/Desktop/lab00 /mnt/c/Users/Desktop/cs61a/lab
-```
-
-该 `mv` 命令会将文件夹移动到<strong>文件</strong>夹<strong>中</strong>。如果您愿意，还可以通过将文件拖放到图形文件资源管理器中的正确文件夹中来移动文件，这可能更常见，并且会产生完全相同的结果。`~/Downloads/lab00~/Desktop/cs61a/lab`
-
-现在，转到 `lab00` 您刚刚移动的文件夹。尝试使用 `cd` 自己的方式导航！如果卡住了，可以使用以下命令：
-
-<strong>macOS/Linux</strong>
-
-```
-cd ~/Desktop/cs61a/lab/lab00
-```
-
-Windows
-
-```
-cd /mnt/c/Users/Desktop/cs61a/lab/lab00
-```
-
-### 概括
-
-以下是我们刚刚完成的命令摘要，供您参考：
-
-- `ls`: 列出当前目录下的所有文件
-- `cd <path to directory>`: 改变进入指定目录
-- `mkdir <directory name>`: 使用给定名称创建一个新目录
-- `mv <source path> <destination path>`: 将给定地址的文件移动到给定的目录
-
-最后，您可以开始编辑实验室文件了！如果这看起来很复杂，请不要担心——随着时间的推移，它会变得容易得多。只要继续练习！您还可以查看我们的 [UNIX 教程](https://inst.eecs.berkeley.edu/~cs61a/fa22/articles/unix)，了解有关终端命令的更详细说明。
-
-## 回顾：Python 基础知识
-
-程序由表达式和语句组成。表达式是一段计算出某个值的代码，而<em>语句是使程序</em>中发生某事的一行或多行代码。
-
-当您将 Python 表达式输入交互式 Python 解释器时，将显示其值。当您阅读以下示例时，请在您自己的 Python 解释器上尝试一些类似的表达式，您可以通过在终端中输入以下内容来启动它：
-
-```
-python3
-```
-
-您将在本课程中学习各种类型的表达式和语句。现在，让我们看一下完成本实验所需的内容。
-
-#### 原始表达式
-
-原始表达式只需要一步来计算。这些包括数字和布尔值，它们只是对自己求值。
-
-```python
->>> 3
-3
->>> 12.5
-12.5
->>> True
-True
-```
-
-#### 算术表达式
-
-数字可以与数学运算符组合以形成复合表达式。除了 `+` 运算符（加法）、`-` 运算符（减法）、`*` 运算符（乘法）和 `**` 运算符（求幂）之外，还有三个类似除法的运算符需要记住：
-
-- 浮点数除法 ( `/`)：将第一个数字除以第二个数字，计算结果为带小数点的数字，<em>即使数字被整除也是如此</em>。
-- 整除 ( `//`)：用第一个数字除以第二个数字，然后向下舍入，计算结果为整数。
-- 模 ( `%`)：计算除法剩余的正余数。
-
-括号可用于将子表达式组合在一起；整个表达式按 PEMDAS（括号、求幂、乘法/除法、加法/减法）顺序求值。
-
-```python
->>> 7 / 4
-1.75
->>> (2 + 6) / 4
-2.0
->>> 7 // 4        # Floor division (rounding down)
-1
->>> 7 % 4         # Modulus (remainder of 7 // 4)
-3
-```
-
-#### 字符串
-
-字符串由用单引号 ( `''`) 或双引号 ( `""`) 包裹的一个或多个字符组成。字符串实际上与原始表达式略有不同，但出于此赋值的目的，可以将其视为对自身求值的表达式。在接下来的几周中，您将在本课程中了解更多关于字符串的复杂性！
-
-```python
->>> "hello"       # Both single and double quotes work!'hello'>>> 'world!''world'
-```
-
-#### 赋值语句
-
-赋值语句由名称和表达式组成。它通过计算符号右侧的表达式 `=` 并将其值<em>绑定</em>到左侧的名称来更改程序的状态。
-
-```python
->>> a = (100 + 50) // 2
-```
-
-现在，如果我们计算 `a`，解释器将显示值 75。
-
-```python
->>> a
-75
-```
-
-## 要求：完成作业
-
-> 在处理作业时，请确保您终端的工作目录是正确的（这个目录可能是您解压缩作业的位置）。
-
-### Python 会做什么？(WWPD)
-
-实验室作业的一个组成部分是预测 Python 解释器的行为方式。
-
-> 在您的终端中输入以下内容以开始此部分：<br/>``<br/>python3 ok -q python-basics -u<br/>`` 系统将提示您输入各种语句/表达式的输出。您必须正确输入它们才能继续，但错误答案不会受到惩罚。<br/>第一次运行 Ok 时，系统将提示您输入 bCourses 电子邮件。请遵循[这些指示](https://inst.eecs.berkeley.edu/~cs61a/fa22/articles/using-ok/#signing-in-with-ok)。我们在评分时使用此信息将您的代码与您相关联。
-
-```python
->>> 10 + 2
-______
->>> 7 / 2
-______
->>> 7 // 2
-______
->>> 7 % 2  # 7 modulo 2, the remainder when dividing 7 by 2.
-______
-```
-
-```python
->>> x = 20>>> x + 2
-______
->>> x
-______
->>> y = 5>>> y = y + 3>>> y * 2
-______
->>> y = y // 4>>> y + x
-______
-```
-
-### 代码编写题
-
-#### 理解问题
-
-实验室还将包括函数编写问题。在你的文本编辑器中打开 `lab00.py`。您可以 `open .` 在 MacOS 或 `start .` Windows 上键入以在 Finder/文件资源管理器中打开当前目录。然后双击或右键单击以在文本编辑器中打开文件。你应该看到这样的东西：
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/FkOybDwtnoQeRyxejlwcjhQ2nch.png)
-
-三引号中的行 `"""` 称为<strong>文档字符串（Docstring）</strong>，它描述了函数应该做什么。在 61A 中编写代码时，您应该始终阅读文档字符串！
-
-开头的行 `>>>` 称为<strong>文档测试模块（Doctest）</strong>。回想一下，当使用 Python 解释器时，您在旁边编写 Python 表达式 `>>>`，输出打印在该行下方。文档测试模块通过显示实际的 Python 代码来解释函数的作用。它回答了这个问题：“如果我们输入这段 Python 代码，预期的输出应该是什么？”
-
-在这里，我们圈出了文档字符串和文档测试，以便于查看：
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/MF4ZbUZ0qo70gRxeNGocsYvmnwe.png)
-
-在 `twenty_twenty_two`,
-
-- 文档字符串告诉你“想出最有创意的表达式，计算到 2022 年”，但你只能使用数字和算术运算符 `+`(add)、`*`(multiply) 和 `-`(subtract)。
-- doctest 检查函数调用 `twenty_twenty_two()` 是否应返回数字 2022。
-
-> 你不应该修改文档字符串，除非你想添加你自己的测试！除非另有说明，否则您需要编辑的唯一部分是代码。
-
-#### 编写代码
-
-了解问题的含义后，您就可以开始编写代码了！您应该将中的下划线替换 `return ______` 为计算结果为 2022 的表达式。您能想出的最有创意的表达式是什么？
-
-> 编辑后不要忘记保存您的作业！在大多数文本编辑器中，您可以通过导航到“文件”>“保存”或在 MacOS 上按 Command-S 或在 Windows 上按 Ctrl-S 来保存。
-
-### 运行测试
-
-在 CS 61A 中，我们将使用一个名为 的程序 `ok` 来测试我们的代码。`ok` 将包含在本课程的每项作业中。
-
-> 为了快速生成 ok 命令，您现在可以使用 [ok 命令生成器](https://go.cs61a.org/ok-help)。
-
-返回终端——确保您位于 `lab00` 我们之前创建的目录中（请记住，该 `cd` 命令允许您[更改目录](https://inst.eecs.berkeley.edu/~cs61a/fa22/lab/lab00/#changing-directories)）。
-
-在该目录中，您可以键入 `ls` 以验证是否存在以下三个文件：
-
-- `lab00.py`：您刚刚编辑的起始文件
-- `ok`: 我们的测试程序
-- `lab00.ok`: Ok 的配置文件
-
-现在，让我们测试我们的代码以确保它能正常工作。您可以 `ok` 使用此命令运行：
-
-```
-python3 ok
-```
-
-> 请记住，如果您使用的是 Windows 而该 `python3` 命令不起作用，请尝试仅使用 `python` 或 `py`。有关详细信息，请参阅[安装 Python 3](https://inst.eecs.berkeley.edu/~cs61a/fa22/lab/lab00/#install-python-3) 部分，如果遇到困难，请寻求帮助！
-
-如果您正确编写了代码并完成了测试解锁，您应该会看到一个成功的测试：
-
-```sql
-=====================================================================
-Assignment: Lab 0
-Ok, version v1.18.1
-=====================================================================
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Running tests
-
----------------------------------------------------------------------
-Test summary
-    3 test cases passed! No cases failed.
-```
-
-如果您没有通过测试，`ok` 则会向您显示如下内容：
-
-```python
----------------------------------------------------------------------
-Doctests for twenty_twenty_two
-
->>> from lab00 import *
->>> twenty_twenty_two()
-2013
-
-# Error: expected
-#     2022
-# but got
-#     2013
-
----------------------------------------------------------------------
-Test summary
-    0 test cases passed before encountering first failed test case
-```
-
-在您的文本编辑器中修复您的代码，直到测试通过。
-
-> 每次运行 Ok 时，Ok 都会尝试备份您的工作。如果它说“连接超时”，请不要担心。我们不会使用您的备份进行评分。<br/>虽然是 CS 61A 中的主要作业“autograder”，但有时您可能会发现以[文档测试模块](https://inst.eecs.berkeley.edu/~cs61a/fa22/lab/lab00/#understanding-problems)的形式编写一些您自己的测试很有用。然后，您可以使用 `-m doctest` 命令来测试代码。[Python 命令](https://inst.eecs.berkeley.edu/~cs61a/fa22/lab/lab00/#appendix-useful-python-command-line-options)）。
-
-## 要求：提交作业
-
-现在您已经完成了第一个 CS 61A 作业，是时候上交了。您可以按照以下后续步骤提交您的作业并获得分数。
-
-### 第 1 步：提交 `ok`
-
-在您的终端中，确保您位于包含 `ok`. 如果你还没有，你可以使用这个命令：
-
-```
-cd ~/Desktop/cs61a/lab/lab00
-```
-
-接下来，使用 `ok` 选项 `--submit`：
-
-```sql
-python3 ok --submit
-```
-
-如果您之前没有运行过，这将提示您输入电子邮件地址。请按照[这些说明](https://inst.eecs.berkeley.edu/~cs61a/fa22/articles/using-ok/#signing-in-with-ok)进行操作，如果遇到问题，请参阅该页面上的故障排除步骤。之后，Ok 将打印出如下消息：
-
-```
-Submitting... 100% complete
-Submission successful for user: ...
-URL: https://okpy.org/...
-```
-
-### 第 2 步：验证您的提交
-
-您可以点击 Ok 打印出来的链接来查看您的最终提交，或者您可以转到 [okpy.org](https://okpy.org/)。您将能够在登录后查看您提交的内容。
-
-> 请确保你用你在终端运行 `ok` 时提供的相同电子邮件登录!
-
-您应该会看到 Lab 0 的成功提交。
-
-<strong>恭喜</strong>，您刚刚提交了第一份 CS 61A 作业！
-
-> 有关 Ok 的更多信息，请参见[此处](https://inst.eecs.berkeley.edu/~cs61a/fa22/articles/using-ok/)。您还可以使用 `--help` 标志：<br/>``sql<br/>python3 ok --help<br/>`` 这个标志的作用就像我们之前使用的 UNIX 命令一样。
-
-## 附录：有用的 Python 命令行选项
-
-运行 Python 文件时，您可以使用命令行选项进一步检查代码。这里有一些会派上用场。如果您想了解有关其他 Python 命令行选项的更多信息，请查看[文档](https://docs.python.org/3.9/using/cmdline.html)。
-
-- 不使用命令行选项将运行您提供的文件中的代码并返回到命令行。例如，如果我们想以 `lab00.py` 这种方式运行，我们将在终端中写入：
-
-```
-python3 lab00.py
-```
-
-- <strong>-i</strong>：该 `-i` 选项运行您的 Python 脚本，然后打开交互式会话。在交互式会话中，您逐行运行 Python 代码并获得即时反馈，而不是一次运行整个文件。要退出，请 `exit()` 在解释器提示符中键入。`Ctrl-D` 您还可以在 Linux/Mac 计算机或 Windows 上使用键盘快捷键 `Ctrl-Z Enter`。
-- 如果您在交互式运行 Python 文件时对其进行编辑，则需要退出并重新启动解释器才能使这些更改生效。
-- 以下是我们如何以交互方式运行 `lab00.py`：
-
-```
-python3 -i lab00.py
-```
-
-- <strong>-m doctest</strong>：在特定文件中运行 doctests。Doctests 在函数中被三重引号 ( `"""`) 包围。
-- 文件中的每个测试都包含 `>>>` 一些 Python 代码和预期的输出（尽管 `>>>` 在 doctest 命令的输出中看不到）。
-- 要为 运行 doctests `lab00.py`，我们可以运行：
-
-```
-python3 -m doctest lab00.py
-```
diff --git a/3.编程思维体系构建/3.6.5CS61A食用指南.md b/3.编程思维体系构建/3.6.5CS61A食用指南.md
new file mode 100644
index 0000000..b630d34
--- /dev/null
+++ b/3.编程思维体系构建/3.6.5CS61A食用指南.md
@@ -0,0 +1,129 @@
+# CS61A 食用指南
+
+## 关于 CS61A
+
+这是 CS 61A Fall 2022 的网站：
+
+[https://inst.eecs.berkeley.edu/~cs61a/fa22/](https://inst.eecs.berkeley.edu/~cs61a/fa22/)
+
+在这个目录下的文章上传的 pdf 基本都是英文的，还请做好准备。
+
+在每个 disc、lab、hw 和 proj 下，都会有相对应的.zip 文件，文件里装的是在学习过程中所需要的代码。
+
+在文章的最后会附上 sol。
+
+当然，在没有头绪的时候，你可以选择参考 sol，也可以重新学习视频和教科书，也可以改变做题的顺序。
+
+ps：哪怕是 cs61a 这样优秀的课程，给出的解决方案里也会有不是那么正确的代码（它并不能处理所有的情况）
+
+pps：如果你找到了 sol 里不是那么正确的代码，请联系我们，我们将新建一个文档来记录 sol 中这些“错误”的代码
+
+ppps：当然存在“错误”的代码的概率很小，你发现它们的概率就更小了
+
+pppps：不只是在 sol 文件中，youtube 上的视频中的代码也可能会出现一些小问题
+
+## 为什么要学 CS61A？
+
+简单来说，学校的编程课只能教会你一些最基本的语法和代码逻辑，从学校的课程中，你很难学到一些实用的编程思想 (甚至一些老师自己也讲不明白)。一部分原因当然是老师上课完全没有想过如何渗透这些编程思想；还有一部分原因我认为是课后作业是在过于随意了，PTA 上的课后作业只是用来检测你是否掌握了一些最基础的语法，这样的题目是很难培养学生的编程思想的。
+
+## 从 CS61A 中能学到什么？
+
+分语言来看，cs61a 讲了这三种语言：
+
+1. Python
+2. Scheme
+3. SQL
+
+分章节来看，cs61a 主要教了以下这些内容：
+
+1. 用函数构建抽象关系
+
+   1. 函数与函数设计
+   2. 控制
+   3. 高级函数
+   4. 递归函数
+2. 用数据构建抽象关系
+
+   1. 数据抽象
+   2. 可变数据
+   3. 面向对象编程
+3. 解释计算机程序
+
+   1. 函数式编程
+   2. 异常
+   3. 解释器的开发
+4. 数据处理
+
+   1. 声明式编程
+
+## CS61A 好在哪里？
+
+~~暂且不考虑由于是伯克利大学的课程所以视频资料和教科书全是英文~~
+
+每一节课程都有完备的视频资料和相对应的教科书，还有精心设计的 lab、hw、disc、proj
+
+所有题目都有完善的说明、例子、半自动的测试和批改，哪怕英语不是很好的同学也能理解到题目所要表达的意思
+
+课程的设计目的是引导学生像计算机那样思考，在课程网站上有相当多的交互式页面来帮助你学习（不过因为我们没有伯克利大学的账号无法使用 🤪）
+
+课程中还推荐了一个学习 python 很好的网站，可以用来绘制环境图：[Python Tutor](http://tutor.cs61a.org/)
+
+~~（不像某些学校只会把学生丢进水池里，没淹死的都是学会游泳的好学生）~~
+
+John Denero 教授的网课也是非常的有趣，如果你的英语够好，还能发现藏在视频里的一些小彩蛋 🤤
+
+## 如何学习 CS61A？
+
+cs61a 绝对是一个挑战，但是我们都希望你学习并且成功，所以这里有一些可能对你的旅程有所帮助的小贴士：
+
+- 在 61A 中成功的方法有很多 ーー 我们发现下面的建议适用于几乎所有的学生，但是对不同的人最有效的方法是不同的，我们建议探索不同的学习和工作策略。~~如果你想和助教谈谈你的方法，我们有专门的~~~~咨询办公时间~~~~做这些事情！~~
+- 问问题
+
+  - 如果你遇到一些你不知道或不确定的概念或问题，_那就来问吧_~~。我们是来帮助你们学习的，如果你们提出一个问题，我们会告诉你们在哪些方面我们可以帮助你们理解这些材料。~~提出问题的过程本身也有助于你自己弄清楚你特别想问什么，从而找出你认为你可以学到更多的概念。
+- 小组学习
+
+  - 再次强调，这门课对于大多数学生来说都不是一门简单的课程，你可能会感到不知所措。给你的小伙伴们发送一个信息，并与班上的其他同学取得联系; 一起完成作业或一起学习准备考试，只要你不违反课程大纲中规定的诚实学习的[课程政策](https://inst.eecs.berkeley.edu/~cs61a/fa22/articles/about/#academic-misconduct)。
+- 当遇到问题时，试着组织语言来解释你遇到困难的地方。
+
+  - 这并不需要一个找到懂得如何解决问题的人 (或者甚至是一个人——这种做法通常被称为**橡皮鸭**，因为你可以把一只橡皮鸭当作你的练习对象) ，因为主要目标是让你弄清楚你自己的想法，弄清楚你的理解和代码到底在哪里卡住了。从那里你可以专注于那一部分，以便更好地理解。
+- 做所有的 hw(或者至少认真地尝试)。我们没有给出很多 hw 问题，但那些我们给你的可能会发现是具有挑战性、耗时且有回报的。
+- 做所有的 lab。其中大部分的设计更多的是作为一个课程材料的介绍，并可能需要半个小时左右的时间。这是一个熟悉新的知识点的好时机。
+
+因为伯克利大学有着非常好的软硬件设施，所以在他们的课程体系中有助教和专门的论坛来辅助学习。杭电实在是没有这样的资源 🥲，所以在遇到问题的时候请先尝试独立解决，然后再和小伙伴们一起讨论，如果遇到实在解决不了的难题就来参考前人的 [GitHub](https://github.com/E1PsyCongroo/CS61A-FA22) 吧
+
+## 如何使用 ok 进行代码测试？
+
+在 61a 中，我们使用一个名为 ok 的程序对 lab，hw 和 proj 进行自动评分。在你下载的每一份代码文件中，都应该找到 ok 程序。
+
+确保在终端打开的路径下，包含 ok 和要测试的代码。
+
+要使用 Ok 来运行指定函数的 doctests，请运行以下命令
+
+```python3 ok -q <specified function> #会和你要补充的代码一起给出```
+
+默认情况下，只有没有通过的测试才会出现。你可以使用-v 选项来显示所有的测试，包括你已经通过的测试
+
+```python3 ok -v```
+
+有时我们会看到类似这样的 ok 指令
+
+```python3 ok -q control -u```
+
+在终端中输入后，需要按照要求回答问题，有些时候会做为某些函数测试的前置条件
+
+一般情况下，执行上述 ok 指令后，都会在终端里提示输入 Berkeley 账号进行提交，这时候输入 `Ctrl+C` 退出即可；不过我们可以在代码后面加上 `--local` 进行本地测试；所有的测试都可以本地完成，不需要联网
+
+![图片丢失](static/ok01.jpg)
+
+关于使用 Ok 命令的更多信息，请在[此处](https://inst.eecs.berkeley.edu/~cs61a/fa22/articles/using-ok/)了解更多
+
+## 在学习过程中，你可以能会遇到的问题和解决方法
+
+1. 在 CS61A 的学习过程中，你可能会找不到 61A 的每一个 lab、hw、disc、proj 的答案，这是因为 61A 是不断更新并进行授课的，所以每过一个季度 61A 是会进行换季的，所以为了避免这个问题，请尽早将 61A 主页的每一个答案保存下来。如果你已经遇到了这种问题，那么向已经学习了这门课的学长学姐求助是个不错的选择。
+2. 如果出现以下情况，这说明你的并没有在测试对象的目录进行测试，最简单解决办法就是在你对应位置的目录进行鼠标右键点击“在终端中打开”进行输入测试。
+
+![图片丢失](static/ok02.png)
+
+1. 如果输入了命令后回车没有任何反应，请试试将测试代码的 python3 变为 python 或者 py 进行操作，如果还没有解决请仔细阅读 61A hw 部分的 Using ok，链接一般位于 HW 01 的开头。
+
+英文学习的痛苦比不上接触国外优秀课程带来的快乐，请保持初心，砥砺前进，祝愿同学们都能有一个有趣的学习体验 🥰
diff --git a/3.编程思维体系构建/3.6.5关于CS61A.md b/3.编程思维体系构建/3.6.5关于CS61A.md
deleted file mode 100644
index 0d6e800..0000000
--- a/3.编程思维体系构建/3.6.5关于CS61A.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# 关于 CS61A
-
-这是 CS 61A Fall 2022 的网站：
-
-[https://inst.eecs.berkeley.edu/~cs61a/fa22/](https://inst.eecs.berkeley.edu/~cs61a/fa22/)
-
-在这个目录下的文章上传的 pdf 基本都是英文的，还请做好准备。
-
-在每个 disc、lab、hw 和 proj 下，都会有相对应的.zip 文件，文件里装的是在学习过程中所需要的代码。
-
-在文章的最后会附上 sol。
-
-当然，在没有头绪的时候，你可以选择参考 sol，也可以重新学习视频和教科书，也可以改变做题的顺序。
-
-ps：哪怕是 cs61a 这样优秀的课程，给出的解决方案里也会有不是那么正确的代码（它并不能处理所有的情况）
-
-pps：如果你找到了 sol 里不是那么正确的代码，请联系我们，我们将新建一个文档来记录 sol 中这些“错误”的代码
-
-ppps：当然存在“错误”的代码的概率很小，你发现它们的概率就更小了
diff --git a/3.编程思维体系构建/3.X 聊聊设计模式和程序设计.md b/3.编程思维体系构建/3.X 聊聊设计模式和程序设计.md
index 0cdee98..9abf2f6 100644
--- a/3.编程思维体系构建/3.X 聊聊设计模式和程序设计.md	
+++ b/3.编程思维体系构建/3.X 聊聊设计模式和程序设计.md	
@@ -69,9 +69,9 @@ walk(dir);
 
 此外，还有广义的设计模式，这块内容就很多了，但也是讨论如何降低代码复杂度的，包括：
 
-1. 程序代码怎么组织（在开发 web 应用时这块经常有争议，可以参考 [https://cloud.tencent.com/developer/article/1837487](https://cloud.tencent.com/developer/article/1837487)）
+1. 程序代码怎么组织（在开发 web 应用时这块经常有争议，可以参考 [浅析整洁架构之道 (二) 初步了解 The Clean Architecture](https://cloud.tencent.com/developer/article/1837487)）
 2. 程序之间怎么组织（是放在一个编成个大的，还是微服务，还是用 FaaS 之类的变体）
-3. 一些帮助减少程序复杂度的代码原则：[https://zhuanlan.zhihu.com/p/82324809](https://zhuanlan.zhihu.com/p/82324809)
+3. 一些帮助减少程序复杂度的代码原则：[设计模式之 SOLID 原则](https://zhuanlan.zhihu.com/p/82324809)
 
 这部分的学习不能操之过急。个人的建议是：
 
diff --git a/3.编程思维体系构建/3.Y 附加模块：Linux.md b/3.编程思维体系构建/3.Y 附加模块：Linux.md
index 76e748f..6cd2248 100644
--- a/3.编程思维体系构建/3.Y 附加模块：Linux.md	
+++ b/3.编程思维体系构建/3.Y 附加模块：Linux.md	
@@ -1,14 +1,15 @@
 # 附加模块：Linux
 
-本来这个模块在编程模块内，但是鉴于大家都反应做这一块非常难，因此我将他提出作为一个额外的附加模块。
+::: warning 😇 本来这个模块在编程模块内，但是鉴于大家都反应做这一块非常难，因此我将他提出作为一个额外的附加模块。
 
 如果你想尝试使用 Linux 编程或者想了解更多计算机科学领域知识，你可以学习并阅览本部分内容。
 
 当然你也可以先尝试完成第三部分的一些内容再回过头解决本部分的内容。
 
 可能会花费你大量的时间，并且让你感受到非常困难，但是可以保证的是：你的一切投入，都是有收获的。
+:::
 
-# What???Linux???
+## What???Linux???
 
 大家可能知道我们的电脑是 Windows 作为操作系统的。
 
@@ -16,12 +17,12 @@
 
 它既免费也自由 (能知道它内部的实现)，而且互联网上有丰富的 (英文) 文档。
 
-它的设计继承自 “Keep it simple, stupid” 的 UNIX，这个经典的设计背后的动机反而更容易为第一次接触操作系统的初学者所理解。让我们看看它的威力：
+它的设计继承自“Keep it simple, stupid”的 UNIX，这个经典的设计背后的动机反而更容易为第一次接触操作系统的初学者所理解。让我们看看它的威力：
 
 - 首先，操作系统里的一切对象都用文件表示 (Everything is a file)。进程、设备……都可以在任何编程语言里用文件 API 访问。
-- Linux 的命令行 Shell 是一门编程语言——没错，你每天都在 “编程”！更准确地说，Shell 的功能就是把你想要做的事情 (类似自然语言描述的代码) 翻译成操作系统能看懂的文件/进程管理 API 调用。
+- Linux 的命令行 Shell 是一门编程语言——没错，你每天都在“编程”！更准确地说，Shell 的功能就是把你想要做的事情 (类似自然语言描述的代码) 翻译成操作系统能看懂的文件/进程管理 API 调用。
 
-# Why Linux??？
+## Why Linux???
 
 作为一个双系统用户体验者来说，他除了玩游戏不那么方便以外，可以更为高效且便捷的办到 Windows 费很大力气才能办到的事情。
 
@@ -29,11 +30,11 @@
 
 并且目前，服务器上为了保证低损耗，高效率，基本上百分之九十九都是 Linux 的系统，实验室的服务器也是 Linux 系统。
 
-简单来说就是，你如果想干点事情，肯定要靠 Linux,因此学会 Linux 的操作是不可或缺的
+简单来说就是，你如果想干点事情，肯定要靠 Linux，因此学会 Linux 的操作是不可或缺的
 
-而且我个人认为，linux的自由性对于CSer来说非常适合，他不会阻止你干任何操作，你可以充分体会所以你的命令带来的影响（rm -rf /)
+而且我个人认为，linux 的自由性对于 CSer 来说非常适合，他不会阻止你干任何操作，你可以充分体会所以你的命令带来的影响 (rm -rf /)
 
-## GUI 与 CLI
+### GUI 与 CLI
 
 诚然，我们现在的图形化界面（GUI）已经深入到了生活的方方面面，但是优劣如何对比呢？
 
@@ -41,15 +42,15 @@
 
 这篇文章详细对比了图形化界面和单纯的终端命令的优劣
 
-# How Linux???
+## How Linux???
 
 那么这么好的东西哪里可以获得呢？
 
 因为 Linux 有诸多发行版本，我在这里建议大家使用 Ubuntu22.04  作为主要版本进行使用
 
-如果你很猛，去试试arch!
+如果你很猛，去试试 arch!
 
-任务：装 Ubuntu22.04或者debian，如果你想删了自己的系统，可以试试deepin，当然，也会有一些兼容性问题，不过很支持一些中文软件
+任务：装 Ubuntu22.04 或者 debian，如果你想删了自己的系统，可以试试 deepin，当然，也会有一些兼容性问题，不过会支持一些中文软件
 
 tip1：推荐这个 [3.Y.1VMware 的安装与安装 ubuntu22.04 系统](3.Y.1VMware%E7%9A%84%E5%AE%89%E8%A3%85%E4%B8%8E%E5%AE%89%E8%A3%85Ubuntu22.04%E7%B3%BB%E7%BB%9F.md)
 
@@ -57,10 +58,4 @@ tip2：可以使用 WSL[3.Y.2WSL 的安装](3.Y.2WSL%E7%9A%84%E5%AE%89%E8%A3%85.
 
 tip3：前两个 tip 二选一
 
-任务:阅读 GUI 与命令行之间对比的文章，尝试开始阅读英文文章
-
-# 教程推荐
-
-[https://missing-semester-cn.github.io/](https://missing-semester-cn.github.io/)
-
-计算机教育中缺失的一课
+任务：阅读 GUI 与命令行之间对比的文章，尝试开始阅读英文文章
diff --git a/3.编程思维体系构建/3.Y.0计算机教育中缺失的一课.md b/3.编程思维体系构建/3.Y.0计算机教育中缺失的一课.md
new file mode 100644
index 0000000..fc4069a
--- /dev/null
+++ b/3.编程思维体系构建/3.Y.0计算机教育中缺失的一课.md
@@ -0,0 +1,31 @@
+# 计算机教育中缺失的一课
+
+Author : ek1ng , Data : 2023.07.24 , Mail : <ek1ng@qq.com>
+
+## 计算机教育中缺失的一课
+>
+> [https://missing-semester-cn.github.io/](https://missing-semester-cn.github.io/)
+> [https://ek1ng.com/Missing%20Semester.html](https://ek1ng.com/Missing%20Semester.html)
+
+这是一份国外的课程，主要专注于各类工具的使用，可以看一看课程的介绍：
+
+>大学里的计算机课程通常专注于讲授从操作系统到机器学习这些学院派的课程或主题，而对于如何精通工具这一主题则往往会留给学生自行探索。在这个系列课程中，我们讲授命令行、强大的文本编辑器的使用、使用版本控制系统提供的多种特性等等。学生在他们受教育阶段就会和这些工具朝夕相处（在他们的职业生涯中更是这样）。
+>因此，花时间打磨使用这些工具的能力并能够最终熟练地、流畅地使用它们是非常有必要的。
+
+以及相应的目录：
+
+- **1/13**: [课程概览与 shell](https://missing-semester-cn.github.io/2020/course-shell/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//course-shell-solution)
+- **1/14**: [Shell 工具和脚本](https://missing-semester-cn.github.io/2020/shell-tools/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//shell-tools-solution)
+- **1/15**: [编辑器 (Vim)](https://missing-semester-cn.github.io/2020/editors/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//editors-solution)
+- **1/16**: [数据整理](https://missing-semester-cn.github.io/2020/data-wrangling/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//data-wrangling-solution)
+- **1/21**: [命令行环境](https://missing-semester-cn.github.io/2020/command-line/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//command-line-solution)
+- **1/22**: [版本控制 (Git)](https://missing-semester-cn.github.io/2020/version-control/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//version-control-solution)
+- **1/23**: [调试及性能分析](https://missing-semester-cn.github.io/2020/debugging-profiling/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//debugging-profiling-solution)
+- **1/27**: [元编程](https://missing-semester-cn.github.io/2020/metaprogramming/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//metaprogramming-solution)
+- **1/28**: [安全和密码学](https://missing-semester-cn.github.io/2020/security/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)[![](https://img.shields.io/badge/Solution-%E2%9C%94-green)](https://missing-semester-cn.github.io/missing-notes-and-solutions/2020/solutions//security-solution)
+- **1/29**: [大杂烩](https://missing-semester-cn.github.io/2020/potpourri/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)![](https://img.shields.io/badge/Solution-%E2%9C%98-orange)
+- **1/30**: [提问&回答](https://missing-semester-cn.github.io/2020/qa/)![](https://img.shields.io/badge/Chinese-%E2%9C%94-green)![](https://img.shields.io/badge/Update-%E2%9C%94-green)![](https://img.shields.io/badge/Solution-%E2%9C%98-orange)
+
+目录中的内容和这份`Wiki`中不少内容重合，当然我觉得作为一份校园学生为爱发电多人合作编辑的`Wiki`，内容有重复冗余再所难免。我比较推荐以这份教材作为计算机工具的学习，下面是我大一时学习课程的一些记录，这些课程都比较缺少一些中文的文章，能够直接看英文的一些材料当然很好，但是如果遇到一些困难，也许你可以在这里找到我先前所踩的坑。
+
+> [The Missing Semester of Your CS Education](https://ek1ng.com/Missing%20Semester.html)
diff --git a/3.编程思维体系构建/3.Y.1VMware的安装与安装Ubuntu22.04系统.md b/3.编程思维体系构建/3.Y.1VMware的安装与安装Ubuntu22.04系统.md
index 6665f59..e88b0e7 100644
--- a/3.编程思维体系构建/3.Y.1VMware的安装与安装Ubuntu22.04系统.md
+++ b/3.编程思维体系构建/3.Y.1VMware的安装与安装Ubuntu22.04系统.md
@@ -1,6 +1,7 @@
 # VMware 的安装与安装 Ubuntu22.04 系统
 
-与 wsl 安装二选一 安装了 wsl 不用 VMware
+::: warning 💡 与 wsl 安装二选一 安装了 wsl 不用 VMware
+:::
 
 首先下载 VMware
 
@@ -8,37 +9,37 @@
 
 如果是 pro17 版本（key <strong>JU090-6039P-08409-8J0QH-2YR7F</strong><strong> </strong>）
 
-本文写的时候用的版本是 pro16 ，但目前已经更新到 pro17 所以来更新个 key  （如下安装与 16 版本无异）
+本文写的时候用的版本是 pro16，但目前已经更新到 pro17 所以来更新个 key（如下安装与 16 版本无异）
 
 [https://www.vmware.com/products/workstation-pro/workstation-pro-evaluation.html](https://www.vmware.com/products/workstation-pro/workstation-pro-evaluation.html)
 
 一路下一步
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcntUYJNAaOwB8L6KSEhJJojh.png)
+![](https://cdn.xyxsw.site/boxcntUYJNAaOwB8L6KSEhJJojh.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnQkVQ4uyYCveO6toBujoGOc.png)
+![](https://cdn.xyxsw.site/boxcnQkVQ4uyYCveO6toBujoGOc.png)
 
 这俩我推荐勾掉
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcndgDKfTuio3nF0QboemIPHe.png)
+![](https://cdn.xyxsw.site/boxcndgDKfTuio3nF0QboemIPHe.png)
 
 安装过后点许可证    输上面的 key 激活
 
-[https://mirror.nju.edu.cn/ubuntu-releases/22.04/ubuntu-22.04.1-desktop-amd64.iso](https://mirror.nju.edu.cn/ubuntu-releases/22.04/ubuntu-22.04.1-desktop-amd64.iso)
+[https://mirror.nju.edu.cn/ubuntu-releases/22.04/ubuntu-22.04.2-desktop-amd64.iso](https://mirror.nju.edu.cn/ubuntu-releases/22.04/ubuntu-22.04.2-desktop-amd64.iso)
 
 去这里下载 Ubuntu22.04 镜像包 iso
 
 下好回到 VMware
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnGHnjgZvtcBrm0XXitFl4Jg.png)
+![](https://cdn.xyxsw.site/boxcnGHnjgZvtcBrm0XXitFl4Jg.png)
 
-创建新的虚拟机-典型（推荐）-下一步-安装程序 iso 选中你刚下的 iso  下一步
+创建新的虚拟机 - 典型（推荐）- 下一步 - 安装程序 iso 选中你刚下的 iso  下一步
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnXilUhHNEyU4r95FxiVgCdg.png)
+![](https://cdn.xyxsw.site/boxcnXilUhHNEyU4r95FxiVgCdg.png)
 
 这里填你一会儿要登录 linux 的个人信息
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnp33Oc3Ia2HzASTZJNOhEWb.png)
+![](https://cdn.xyxsw.site/boxcnp33Oc3Ia2HzASTZJNOhEWb.png)
 
 这里建议把位置改到其他盘
 
@@ -46,21 +47,21 @@
 
 启动后进入 Ubuntu 安装
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn5Uk41JyjjdTzXWQqUkexzc.png)
+![](https://cdn.xyxsw.site/boxcn5Uk41JyjjdTzXWQqUkexzc.png)
 
 键盘映射  直接 continue
 
 接下来一路 continue  install now
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnLxZnyFN3ohE8zrTwNaCA8e.png)
+![](https://cdn.xyxsw.site/boxcnLxZnyFN3ohE8zrTwNaCA8e.png)
 
 最后 restart
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnLguvbHihJ3ngqrtyGLI6zf.png)
+![](https://cdn.xyxsw.site/boxcnLguvbHihJ3ngqrtyGLI6zf.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnCX92JHjg8PU3quKs4GziZb.png)
+![](https://cdn.xyxsw.site/boxcnCX92JHjg8PU3quKs4GziZb.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnL5Jn3g7AdzVzoBb6ZINs1f.png)
+![](https://cdn.xyxsw.site/boxcnL5Jn3g7AdzVzoBb6ZINs1f.png)
 
 这个 skip
 
@@ -68,15 +69,15 @@
 
 点右上角 settings
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn85Yb3JIQ3520KeaSoyPVDd.png)
+![](https://cdn.xyxsw.site/boxcn85Yb3JIQ3520KeaSoyPVDd.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnZLHO1JGWoSqhM9zEEhSMAd.png)
+![](https://cdn.xyxsw.site/boxcnZLHO1JGWoSqhM9zEEhSMAd.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnvLxCTKYfogPm9GNaKmusEf.png)
+![](https://cdn.xyxsw.site/boxcnvLxCTKYfogPm9GNaKmusEf.png)
 
 然后按指引 restart 系统
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn30VJILYpO81pq89mAmzjTf.png)
+![](https://cdn.xyxsw.site/boxcn30VJILYpO81pq89mAmzjTf.png)
 
 会提示你要不要重新命名这些用户下的文件夹
 
@@ -84,27 +85,27 @@
 
 如果你的语言还没有变过来的话
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnKzJjY8Dvj13A49bnMAztPg.png)
+![](https://cdn.xyxsw.site/boxcnKzJjY8Dvj13A49bnMAztPg.png)
 
 点击这个他会安装语言
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcndHnAuGC7TXhQgLkpLkHghf.png)
+![](https://cdn.xyxsw.site/boxcndHnAuGC7TXhQgLkpLkHghf.png)
 
 把汉语拖到英文之上 点应用到整个系统
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnltCL3atXHtC3BUj5VI1Lqf.png)
+![](https://cdn.xyxsw.site/boxcnltCL3atXHtC3BUj5VI1Lqf.png)
 
 右上角 logout 重新登陆 就是中文辣
 
-最后在设置-电源把息屏改成从不
+最后在设置 - 电源把息屏改成从不
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnnLCJzGoFrUbWIMAPGFkxcb.png)
+![](https://cdn.xyxsw.site/boxcnnLCJzGoFrUbWIMAPGFkxcb.png)
 
 <strong>至此 恭喜安装完成！</strong>
 
 之后就可以在桌面上右键
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnG6z1VpAYUGMSkSwDBUxEvf.png)
+![](https://cdn.xyxsw.site/boxcnG6z1VpAYUGMSkSwDBUxEvf.png)
 
 打开命令行
 
diff --git a/3.编程思维体系构建/3.Y.2WSL的安装.md b/3.编程思维体系构建/3.Y.2WSL的安装.md
index 3afe3ca..e70a953 100644
--- a/3.编程思维体系构建/3.Y.2WSL的安装.md
+++ b/3.编程思维体系构建/3.Y.2WSL的安装.md
@@ -1,6 +1,7 @@
 # WSL 的安装
 
-与 VMware 安装二选一 安装了 VMware 不用 wsl
+::: warning 💡与 VMware 安装二选一 安装了 VMware 不用 wsl
+:::
 
 先说<strong>坏处</strong>：
 
@@ -15,10 +16,10 @@
 
 （现在可能是只开 `适用于Linux的windows子系统`）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnYVkEecWdUs710e8h6G9GTh.png)
+![](https://cdn.xyxsw.site/boxcnYVkEecWdUs710e8h6G9GTh.png)
 
 如果你的 windows 版本为<strong>家庭版</strong>  那么 hyperv 选项是没有的
 
 你需要右键以管理员权限打开以下脚本来强行开启 hyperv
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnoCF5MilDma33yviwRGdDHe.png)
+![](https://cdn.xyxsw.site/boxcnoCF5MilDma33yviwRGdDHe.png)
diff --git a/3.编程思维体系构建/3.Y.3Linux初探索.md b/3.编程思维体系构建/3.Y.3Linux初探索.md
index 55e0b8f..94327f8 100644
--- a/3.编程思维体系构建/3.Y.3Linux初探索.md
+++ b/3.编程思维体系构建/3.Y.3Linux初探索.md
@@ -1,131 +1,134 @@
 # Linux 初探索
 
-如果你是第一次接触link，请一边仔细阅读，一边尝试敲命令在终端内。
+如果你是第一次接触 link，请一边仔细阅读，一边尝试敲命令在终端内。
 
 有一点非常重要，这章节的内容到后面会略为困难，并且 linux 知识繁杂多样。
 
 希望你可以参考这个链接！
 [一些基本常识](https://linux.cn/article-6160-1.html)
 
-当然，你也可以从蓝桥云课开始，不过学会linux的最好办法是删掉你的windows换一个linux系统当开发环境，比任何临时的训练都有效！
+当然，你也可以从蓝桥云课开始，不过学会 linux 的最好办法是删掉你的 windows 换一个 linux 系统当开发环境，比任何临时的训练都有效！
 
-# 探索命令行
+[蓝桥云课-Linux 基础入门](https://www.lanqiao.cn/courses/1)
 
-Linux 命令行中的命令使用格式都是相同的:
+## 探索命令行
 
-```
+Linux 命令行中的命令使用格式都是相同的：
+
+```bash
 命令名称 参数1 参数2 参数3 ...
 ```
 
-参数之间用任意数量的空白字符分开. 关于命令行, 可以先阅读[一些基本常识](https://linux.cn/article-6160-1.html). 然后我们介绍最常用的一些命令:
+参数之间用任意数量的空白字符分开。关于命令行，可以先阅读[一些基本常识](https://linux.cn/article-6160-1.html). 然后我们介绍最常用的一些命令：
 
 - （重要）首先教一个命令 `sudo su` 进入 root 账户（敲完之后会让你敲当前登录账户的密码 密码敲得过程中没有*****这种传统敲密码的提示 为 linux 传统艺能 其实是敲进去了），因为本身普通账户没什么权限，会出现处处的权限提示，建议直接使用 root 账户。
 
-```
-这里有一个彩蛋 （如果你用的是centos的话）
-<strong>当用户第一次使用sudo权限时CentOS的系统提示：</strong>
+```txt
+这里有一个彩蛋（如果你用的是 centos 的话）
+当用户第一次使用 sudo 权限时 CentOS 的系统提示：
 我们信任您已经从系统管理员那里了解了日常注意事项。
 总结起来无外乎这三点：
 #1) 尊重别人的隐私。
-#2) 输入前要先考虑(后果和风险)。
+#2) 输入前要先考虑 (后果和风险)。
 #3) 权力越大，责任越大。
 ```
 
-- `ls` 用于列出当前目录(即"文件夹")下的所有文件(或目录). 目录会用蓝色显示. `ls -l` 可以显示详细信息.
-- `pwd` 能够列出当前所在的目录.
-- `cd DIR` 可以切换到 `DIR` 目录. 在 Linux 中, 每个目录中都至少包含两个目录: `.` 指向该目录自身, `..` 指向它的上级目录. 文件系统的根是 `/`.
-- `touch NEWFILE` 可以创建一个内容为空的新文件 `NEWFILE`, 若 `NEWFILE` 已存在, 其内容不会丢失.
-- `cp SOURCE DEST` 可以将 `SOURCE` 文件复制为 `DEST` 文件; 如果 `DEST` 是一个目录, 则将 `SOURCE` 文件复制到该目录下.
-- `mv SOURCE DEST` 可以将 `SOURCE` 文件重命名为 `DEST` 文件; 如果 `DEST` 是一个目录, 则将 `SOURCE` 文件移动到该目录下.
-- `mkdir DIR` 能够创建一个 `DIR` 目录.
-- `rm FILE` 能够删除 `FILE` 文件; 如果使用 `-r` 选项则可以递归删除一个目录. 删除后的文件无法恢复, 使用时请谨慎!
-- `man` 可以查看命令的帮助. 例如 `man ls` 可以查看 `ls` 命令的使用方法. 灵活应用 `man` 和互联网搜索, 可以快速学习新的命令.
+- `ls` 用于列出当前目录 (即"文件夹") 下的所有文件 (或目录). 目录会用蓝色显示。`ls -l` 可以显示详细信息。
+- `pwd` 能够列出当前所在的目录。
+- `cd DIR` 可以切换到 `DIR` 目录。在 Linux 中，每个目录中都至少包含两个目录：`.` 指向该目录自身，`..` 指向它的上级目录。文件系统的根是 `/`.
+- `touch NEWFILE` 可以创建一个内容为空的新文件 `NEWFILE`, 若 `NEWFILE` 已存在，其内容不会丢失。
+- `cp SOURCE DEST` 可以将 `SOURCE` 文件复制为 `DEST` 文件; 如果 `DEST` 是一个目录，则将 `SOURCE` 文件复制到该目录下。
+- `mv SOURCE DEST` 可以将 `SOURCE` 文件重命名为 `DEST` 文件; 如果 `DEST` 是一个目录，则将 `SOURCE` 文件移动到该目录下。
+- `mkdir DIR` 能够创建一个 `DIR` 目录。
+- `rm FILE` 能够删除 `FILE` 文件; 如果使用 `-r` 选项则可以递归删除一个目录。删除后的文件无法恢复，使用时请谨慎！
+- `man` 可以查看命令的帮助。例如 `man ls` 可以查看 `ls` 命令的使用方法。灵活应用 `man` 和互联网搜索，可以快速学习新的命令。
 
-`man` 的功能不仅限于此. `man` 后可以跟两个参数, 可以查看不同类型的帮助(请在互联网上搜索). 例如当你不知道 C 标准库函数 `freopen` 如何使用时, 可以键入命令
+`man` 的功能不仅限于此。`man` 后可以跟两个参数，可以查看不同类型的帮助 (请在互联网上搜索). 例如当你不知道 C 标准库函数 `freopen` 如何使用时，可以键入命令
 
-```
+```bash
 man 3 freopen
 ```
 
-## <strong>统计代码行数</strong>
+### <strong>统计代码行数</strong>
 
-第一个例子是统计一个目录中(包含子目录)中的代码行数. 如果想知道当前目录下究竟有多少行的代码, 就可以在命令行中键入如下命令:
+第一个例子是统计一个目录中 (包含子目录) 中的代码行数。如果想知道当前目录下究竟有多少行的代码，就可以在命令行中键入如下命令：
 
-```
+```bash
 find . | grep '\.c$\|\.h$' | xargs wc -l
 ```
 
-如果用 `man find` 查看 `find` 操作的功能, 可以看到 `find` 是搜索目录中的文件. Linux 中一个点 `.` 始终表示 Shell 当前所在的目录, 因此 `find .` 实际能够列出当前目录下的所有文件. 如果在文件很多的地方键入 `find .`, 将会看到过多的文件, 此时可以按 `CTRL + c` 退出.
+如果用 `man find` 查看 `find` 操作的功能，可以看到 `find` 是搜索目录中的文件。Linux 中一个点 `.` 始终表示 Shell 当前所在的目录，因此 `find .` 实际能够列出当前目录下的所有文件。如果在文件很多的地方键入 `find .`, 将会看到过多的文件，此时可以按 `CTRL + c` 退出。
 
-同样, 用 `man` 查看 `grep` 的功能——"print lines matching a pattern". `grep` 实现了输入的过滤, 我们的 `grep` 有一个参数, 它能够匹配以 `.c` 或 `.h` 结束的文件. 正则表达式是处理字符串非常强大的工具之一, 每一个程序员都应该掌握其相关的知识. ? 上述的 `grep` 命令能够提取所有 `.c` 和 `.h` 结尾的文件.
+同样，用 `man` 查看 `grep` 的功能——"print lines matching a pattern". `grep` 实现了输入的过滤，我们的 `grep` 有一个参数，它能够匹配以 `.c` 或 `.h` 结束的文件。正则表达式是处理字符串非常强大的工具之一，每一个程序员都应该掌握其相关的知识。? 上述的 `grep` 命令能够提取所有 `.c` 和 `.h` 结尾的文件。
 
-刚才的 `find` 和 `grep` 命令, 都从标准输入中读取数据, 并输出到标准输出. 关于什么是标准输入输出, 请参考[这里](http://en.wikipedia.org/wiki/Standard_streams). 连接起这两个命令的关键就是管道符号 `|`. 这一符号的左右都是 Shell 命令, `A | B` 的含义是创建两个进程 `A` 和 `B`, 并将 `A` 进程的标准输出连接到 `B` 进程的标准输入. 这样, 将 `find` 和 `grep` 连接起来就能够筛选出当前目录(`.`)下所有以 `.c` 或 `.h` 结尾的文件.
+刚才的 `find` 和 `grep` 命令，都从标准输入中读取数据，并输出到标准输出。关于什么是标准输入输出，请参考[这里](http://en.wikipedia.org/wiki/Standard_streams). 连接起这两个命令的关键就是管道符号 `|`. 这一符号的左右都是 Shell 命令，`A | B` 的含义是创建两个进程 `A` 和 `B`, 并将 `A` 进程的标准输出连接到 `B` 进程的标准输入。这样，将 `find` 和 `grep` 连接起来就能够筛选出当前目录 (`.`) 下所有以 `.c` 或 `.h` 结尾的文件。
 
-我们最后的任务是统计这些文件所占用的总行数, 此时可以用 `man` 查看 `wc` 命令. `wc` 命令的 `-l` 选项能够计算代码的行数. `xargs` 命令十分特殊, 它能够将标准输入转换为参数, 传送给第一个参数所指定的程序. 所以, 代码中的 `xargs wc -l` 就等价于执行 `wc -l aaa.c bbb.c include/ccc.h ...`, 最终完成代码行数统计.
+我们最后的任务是统计这些文件所占用的总行数，此时可以用 `man` 查看 `wc` 命令。`wc` 命令的 `-l` 选项能够计算代码的行数。`xargs` 命令十分特殊，它能够将标准输入转换为参数，传送给第一个参数所指定的程序。所以，代码中的 `xargs wc -l` 就等价于执行 `wc -l aaa.c bbb.c include/ccc.h ...`, 最终完成代码行数统计。
 
-## <strong>统计磁盘使用情况</strong>
+### <strong>统计磁盘使用情况</strong>
 
-以下命令统计 `/usr/share` 目录下各个目录所占用的磁盘空间:
+以下命令统计 `/usr/share` 目录下各个目录所占用的磁盘空间：
 
-```
+```bash
 du -sc /usr/share/* | sort -nr
 ```
 
-`du` 是磁盘空间分析工具, `du -sc` 将目录的大小顺次输出到标准输出, 继而通过管道传送给 `sort`. `sort` 是数据排序工具, 其中的选项 `-n` 表示按照数值进行排序, 而 `-r` 则表示从大到小输出. `sort` 可以将这些参数连写在一起.
+`du` 是磁盘空间分析工具，`du -sc` 将目录的大小顺次输出到标准输出，继而通过管道传送给 `sort`. `sort` 是数据排序工具，其中的选项 `-n` 表示按照数值进行排序，而 `-r` 则表示从大到小输出。`sort` 可以将这些参数连写在一起。
 
-然而我们发现, `/usr/share` 中的目录过多, 无法在一个屏幕内显示. 此时, 我们可以再使用一个命令: `more` 或 `less`.
+然而我们发现，`/usr/share` 中的目录过多，无法在一个屏幕内显示。此时，我们可以再使用一个命令：`more` 或 `less`.
 
-```
+```bash
 du -sc /usr/share/* | sort -nr | more
 ```
 
-此时将会看到输出的前几行结果. `more` 工具使用空格翻页, 并可以用 `q` 键在中途退出. `less` 工具则更为强大, 不仅可以向下翻页, 还可以向上翻页, 同样使用 `q` 键退出. 这里还有一个[关于 less 的小故事](http://en.wikipedia.org/wiki/Less_(Unix)).
+此时将会看到输出的前几行结果。`more` 工具使用空格翻页，并可以用 `q` 键在中途退出。`less` 工具则更为强大，不仅可以向下翻页，还可以向上翻页，同样使用 `q` 键退出。这里还有一个[关于 less 的小故事](http://en.wikipedia.org/wiki/Less_(Unix)).
 
-## <strong>在 Linux 下编写 Hello World 程序</strong>
+### <strong>在 Linux 下编写 Hello World 程序</strong>
 
-Linux 中用户的主目录是 `/home/用户名称`, 如果你的用户名是 `user`, 你的主目录就是 `/home/user`. 用户的 `home` 目录可以用波浪符号 `~` 替代, 例如临时文件目录 `/home/user/Templates` 可以简写为 `~/Templates`. 现在我们就可以进入主目录并编辑文件了. 如果 `Templates` 目录不存在, 可以通过 `mkdir` 命令创建它:
+Linux 中用户的主目录是 `/home/用户名称`, 如果你的用户名是 `user`, 你的主目录就是 `/home/user`. 用户的 `home` 目录可以用波浪符号 `~` 替代，例如临时文件目录 `/home/user/Templates` 可以简写为 `~/Templates`. 现在我们就可以进入主目录并编辑文件了。如果 `Templates` 目录不存在，可以通过 `mkdir` 命令创建它：
 
-```
+```bash
 cd ~
 mkdir Templates
 ```
 
-创建成功后, 键入
+创建成功后，键入
 
-```
+```bash
 cd Templates
 ```
 
-可以完成目录的切换. 注意在输入目录名时, `tab` 键可以提供联想.
+可以完成目录的切换。注意在输入目录名时，`tab` 键可以提供联想。
 
-##### <strong> 你感到键入困难吗?</strong>
+#### <strong> 你感到键入困难吗？</strong>
 
-你可能会经常要在终端里输入类似于
+::: warning 💡 你可能会经常要在终端里输入类似于
 
 cd AVeryVeryLongFileName
 
-的命令, 你一定觉得非常烦躁. 回顾上面所说的原则之一: 如果你感到有什么地方不对, 就一定有什么好办法来解决. 试试 `tab` 键吧.
+的命令，你一定觉得非常烦躁。回顾上面所说的原则之一：如果你感到有什么地方不对，就一定有什么好办法来解决。试试 `tab` 键吧。
 
-Shell 中有很多这样的小技巧, 你也可以使用其他的 Shell 例如 zsh, 提供更丰富好用的功能. 总之, 尝试和改变是最重要的.
+Shell 中有很多这样的小技巧，你也可以使用其他的 Shell 例如 zsh, 提供更丰富好用的功能。总之，尝试和改变是最重要的。
+:::
 
-进入正确的目录后就可以编辑文件了, 开源世界中主流的两大编辑器是 `vi(m)` 和 `emacs`, 你可以使用其中的任何一种. 如果你打算使用 `emacs`, 你还需要安装它
+进入正确的目录后就可以编辑文件了，开源世界中主流的两大编辑器是 `vi(m)` 和 `emacs`, 你可以使用其中的任何一种。如果你打算使用 `emacs`, 你还需要安装它
 
-```
+```bash
 apt-get install emacs
 ```
 
-`vi` 和 `emacs` 这两款编辑器都需要一定的时间才能上手, 它们共同的特点是需要花较多的时间才能适应基本操作方式(命令或快捷键), 但一旦熟练运用, 编辑效率就比传统的编辑器快很多.
+`vi` 和 `emacs` 这两款编辑器都需要一定的时间才能上手，它们共同的特点是需要花较多的时间才能适应基本操作方式 (命令或快捷键), 但一旦熟练运用，编辑效率就比传统的编辑器快很多。
 
-进入了正确的目录后, 输入相应的命令就能够开始编辑文件. 例如输入
+进入了正确的目录后，输入相应的命令就能够开始编辑文件。例如输入
 
-```
+```bash
 vi hello.c
 或emacs hello.c
 ```
 
-就能开启一个文件编辑. 例如可以键入如下代码(对于首次使用 `vi` 或 `emacs` 的同学, 键入代码可能会花去一些时间, 在编辑的同时要大量查看网络上的资料):
+就能开启一个文件编辑。例如可以键入如下代码 (对于首次使用 `vi` 或 `emacs` 的同学，键入代码可能会花去一些时间，在编辑的同时要大量查看网络上的资料):
 
-```
+```c
 #include <stdio.h>
 int main(void) {
   printf("Hello, Linux World!\n");
@@ -134,23 +137,22 @@ int main(void) {
 ```
 
 > 相信你在写完代码之后苦于不知道怎么保存并退出，不用担心，这个是正常的，毕竟上面提到的两个文本编辑器都是以入门时的学习曲线及其陡峭而著称。
-> 对于 vi(m)风格的编辑器，你需要先按 `ESC` 返回 NORMAL 模式（具体处于那个模式可以观察窗口左下角，NORMAL 模式是空白的），再输入 `:wq` 来保存并退出（注意 `:` 是输入的一部分 )（`:q 仅退出` `:q! 不保存退出` ）
+> 对于 vi(m) 风格的编辑器，你需要先按 `ESC` 返回 NORMAL 模式（具体处于那个模式可以观察窗口左下角，NORMAL 模式是空白的），再输入 `:wq` 来保存并退出（注意 `:` 是输入的一部分）（`:q 仅退出` `:q! 不保存退出` ）
 >
 > [【保姆级入门】Vim 编辑器](https://www.bilibili.com/video/BV13t4y1t7Wg)
 >
 > <Bilibili bvid='BV13t4y1t7Wg'/>
 
-保存后就能够看到 `hello.c` 的内容了. 终端中可以用 `cat hello.c` 查看代码的内容. 如果要将它编译, 可以使用 `gcc` 命令:
+保存后就能够看到 `hello.c` 的内容了。终端中可以用 `cat hello.c` 查看代码的内容。如果要将它编译，可以使用 `gcc` 命令：
 
-```
+```bash
 gcc hello.c -o hello
 ```
 
-`gcc` 的 `-o` 选项指定了输出文件的名称, 如果将 `-o hello` 改为 `-o hi`, 将会生成名为 `hi` 的可执行文件. 如果不使用 `-o` 选项, 则会默认生成名为 `a.out` 的文件, 它的含义是 [assembler output](http://en.wikipedia.org/wiki/A.out). 在命令行输入
+`gcc` 的 `-o` 选项指定了输出文件的名称，如果将 `-o hello` 改为 `-o hi`, 将会生成名为 `hi` 的可执行文件。如果不使用 `-o` 选项，则会默认生成名为 `a.out` 的文件，它的含义是 [assembler output](http://en.wikipedia.org/wiki/A.out). 在命令行输入
 
-```
+```bash
 ./hello
 ```
 
-就能够运行改程序. 命令中的 `./` 是不能少的, 点代表了当前目录, 而 `./hello` 则表示当前目录下的 `hello` 文件. 与 Windows 不同, Linux 系统默认情况下并不查找当前目录, 这是因为 Linux 下有大量的标准工具(如 `test` 等), 很容易与用户自己编写的程序重名, 不搜索当前目录消除了命令访问的歧义.
-
+就能够运行改程序。命令中的 `./` 是不能少的，点代表了当前目录，而 `./hello` 则表示当前目录下的 `hello` 文件。与 Windows 不同，Linux 系统默认情况下并不查找当前目录，这是因为 Linux 下有大量的标准工具 (如 `test` 等), 很容易与用户自己编写的程序重名，不搜索当前目录消除了命令访问的歧义。
diff --git a/3.编程思维体系构建/3.Y.4Vim初探索.md b/3.编程思维体系构建/3.Y.4Vim初探索.md
index eb75c52..0c67c33 100644
--- a/3.编程思维体系构建/3.Y.4Vim初探索.md
+++ b/3.编程思维体系构建/3.Y.4Vim初探索.md
@@ -1,29 +1,31 @@
 # Vim 初探索
 
-# 下载 vim
+## 下载 vim
 
 vim 被称为编辑器之神
 
-看到这一句可能就激发了你学习 vim 的热情，但是看完整篇文章和文章里面的所有参考资料，可能这股来之不易的热情也早就消失了。为了避免这种情况，我给一个小小的建议：
+::: warning 💡 看到这一句可能就激发了你学习 vim 的热情，但是看完整篇文章和文章里面的所有参考资料，可能这股来之不易的热情也早就消失了。为了避免这种情况，我给一个小小的建议：
 
 1. 首先学会盲打，不会的话，不是很建议用 vim / Emacs 这样的编辑器，还是拥抱鼠标吧
 2. 学习使用 hjklia 这六个键，然后理解插入模式和普通模式，再了解怎么退出
 3. 使用 vim 作为日常的编辑工具，在你所有的代码编辑器里面都装上 vim 插件并使用，强迫自己习惯 hjkl 的移动和带模式的输入，习惯按 `<ESC>`
 4. 到这个时候你就会感觉的确可以不用鼠标了，但是有的时候会比较别扭，比如想新建一行时，得按 L 移到行尾，然后按 a 追加，再按回车，远远比鼠标麻烦有没有，这种情况就可以上网查询，`vim 如何新建一行`，就会学到 o 可以向下新建一行，O 可以向上新建一行，然后你就能自然地学会更多的操作。
+:::
 
 因为其具有着非常完整的生态以及诸多配套的插件，但是第一次使用得你可能感觉很不习惯。
 
 讲一个笑话，你如何获得一个随机字符串，只要让新人使用 vim 就好了。
 
-不开玩笑，为了让你不小心在命令行模式下进入 vim 又不知道怎么退出时不需要拔电源来退出，先按几次 `<ESC>` 键（避免你之前不小心按到了 i 或 a 或 o 或等等按键）进入普通模式，然后顺序敲击 `:q`(冒号 和 q 两个按键 )，再按回车就可以退出了。
+::: waning 💡 不开玩笑，为了让你不小心在命令行模式下进入 vim 又不知道怎么退出时不需要拔电源来退出，先按几次 `<ESC>` 键（避免你之前不小心按到了 i 或 a 或 o 或等等按键）进入普通模式，然后顺序敲击 `:q`(冒号 和 q 两个按键 )，再按回车就可以退出了。
+:::
 
-```
+```bash
 apt-get install vim
 ```
 
 但是我仍然推荐你尝试使用或者结合 VSC 一起使用，使用习惯后将有效提高你的开发效率。
 
-# 如何学习 vim
+## 如何学习 vim
 
 作为程序员，我们大部分时间都花在代码编辑上，所以花点时间掌握某个适合自己的编辑器是非常值得的。通常学习使用一个新的编辑器包含以下步骤：
 
@@ -33,25 +35,25 @@ apt-get install vim
 
 如果您能够遵循上述步骤，并且坚持使用新的编辑器完成您所有的文本编辑任务，那么学习一个复杂的代码编辑器的过程一般是这样的：头两个小时，您会学习到编辑器的基本操作，例如打开和编辑文件、保存与退出、浏览缓冲区。当学习时间累计达到 20 个小时之后，您使用新编辑器的效率应该已经和使用老编辑器一样快。在此之后，其益处开始显现：有了足够的知识和肌肉记忆后，使用新编辑器将大大节省你的时间。而现代文本编辑器都是些复杂且强大的工具，永远有新东西可学：学的越多，效率越高。
 
-# <strong>Vim 的哲学</strong>
+## <strong>Vim 的哲学</strong>
 
-在编程的时候，你会把大量时间花在阅读/编辑而不是在写代码上。所以，Vim 是一个_多模态_编辑 器：它对于插入文字和操纵文字有不同的模式。Vim 是可编程的（可以使用 Vimscript 或者像 Python 一样的其他程序语言），Vim 的接口本身也是一个程序语言：键入操作（以及其助记名） 是命令，这些命令也是可组合的。Vim 避免了使用鼠标，因为那样太慢了；Vim 甚至避免用 上下左右键因为那样需要太多的手指移动。
+在编程的时候，你会把大量时间花在阅读/编辑而不是在写代码上。所以，Vim 是一个_多模态_编辑 器：它对于插入文字和操纵文字有不同的模式。Vim 是可编程的（可以使用 Vimscript 或者像 Python 一样的其他程序语言），Vim 的接口本身也是一个程序语言：键入操作（以及其助记名）是命令，这些命令也是可组合的。Vim 避免了使用鼠标，因为那样太慢了；Vim 甚至避免用 上下左右键因为那样需要太多的手指移动。
 
 这样的设计哲学使得 Vim 成为了一个能跟上你思维速度的编辑器。
 
-# 学习 Vim
+## 学习 Vim
 
 如果想要使用他最基本的操作的话，在电脑上键入 vimtutor
 
 会有官方的教程进行引导哦。
 
-# 配置 vim
+## 配置 vim
 
 vim 有大量的配置，通过更改./vimrc 文件或者安装插件都可以有效提高你的开发效率，定制属于你个人的编辑器哦~
 
 快去试试吧
 
-# 任务
+## 任务
 
 定制 vim 成为你喜欢的模样，加装足够多的插件和更改足够多的配置让他满足以下几点或以上
 
@@ -67,7 +69,7 @@ vim 有大量的配置，通过更改./vimrc 文件或者安装插件都可以
 
 [vim awesome](https://vimawesome.com/)
 
-# 拓展阅读
+## 拓展阅读
 
 [Learn-Vim(the Smart Way) 中文翻译](https://github.com/wsdjeg/Learn-Vim_zh_cn)
 
diff --git a/3.编程思维体系构建/3.Y.5linux小任务.md b/3.编程思维体系构建/3.Y.5linux小任务.md
index 33fecfb..fa93a8d 100644
--- a/3.编程思维体系构建/3.Y.5linux小任务.md
+++ b/3.编程思维体系构建/3.Y.5linux小任务.md
@@ -6,19 +6,19 @@
 4. 用 `touch` 在 `missing` 文件夹中新建一个叫 `semester` 的文件。
 5. 将以下内容一行一行地写入 `semester` 文件：
 
-```
+```bash
 #!/bin/sh
  curl --head --silent https://missing.csail.mit.edu
 ```
 
-第一行可能有点棘手， `#` 在 Bash 中表示注释，而 `!` 即使被双引号（`"`）包裹也具有特殊的含义。 单引号（`'`）则不一样，此处利用这一点解决输入问题。更多信息请参考 <u>Bash quoting 手册</u>
+第一行可能有点棘手， `#` 在 Bash 中表示注释，而 `!` 即使被双引号（`"`）包裹也具有特殊的含义。单引号（`'`）则不一样，此处利用这一点解决输入问题。更多信息请参考 <u>Bash quoting 手册</u>
 
 1. 尝试执行这个文件。例如，将该脚本的路径（`./semester`）输入到您的 shell 中并回车。如果程序无法执行，请使用 `ls` 命令来获取信息并理解其不能执行的原因。
-2. 查看 `chmod` 的手册(例如，使用 `man chmod` 命令)
+2. 查看 `chmod` 的手册 (例如，使用 `man chmod` 命令)
 3. 使用 `chmod` 命令改变权限，使 `./semester` 能够成功执行，不要使用 `sh semester` 来执行该程序。您的 shell 是如何知晓这个文件需要使用 `sh` 来解析呢？更多信息请参考：<u>shebang</u>
 4. 使用 `|` 和 `>` ，将 `semester` 文件输出的最后更改日期信息，写入主目录下的 `last-modified.txt` 的文件中
 5. 写一段命令来从 `/sys` 中获取笔记本的电量信息，或者台式机 CPU 的温度
-6. 使用shell编程写一个类似脚本的图书管理系统，包含增删改查四个功能
+6. 使用 shell 编程写一个类似脚本的图书管理系统，包含增删改查四个功能
 
 当然，可能会有点困难我在这里附上一段参考代码
 
@@ -124,4 +124,3 @@ search()
 }
 
 ```
-
diff --git a/3.编程思维体系构建/3.编程思维体系构建.md b/3.编程思维体系构建/3.编程思维体系构建.md
index 3fdccb0..9e44401 100644
--- a/3.编程思维体系构建/3.编程思维体系构建.md
+++ b/3.编程思维体系构建/3.编程思维体系构建.md
@@ -8,7 +8,7 @@
 
 但是，他作为一个交通工具，你不开你就得腿着去学校。想想如果你从杭电走到西湖只能走着去，那是多么恐怖的一件事。
 
-（当然，现在GPT的强大功能可以帮大伙解决相当多的工作，因此，我们可能需要掌握更多的逻辑思维能力和分解问题的能力，将问题简化之后用GPT解决也不失为一个选择）
+（当然，现在 GPT 的强大功能可以帮大伙解决相当多的工作，因此，我们可能需要掌握更多的逻辑思维能力和分解问题的能力，将问题简化之后用 GPT 解决也不失为一个选择）
 
 因此本章节的目标是让大家面对一个实际问题，有使用编程解决的思路和能力。
 
@@ -16,37 +16,34 @@
 
 本章提供了非常多的软实力文章，阅读相关软实力文章，你可以根据自己的情况构建适合自己一通百通的学习编程知识的方法论。
 
-本章提供了相当完善的，足够面对多数需求的C语言体系结构，通过完成C语言的体系，你可以较为熟练地掌握C语言，并且对构建一个较小规模的项目组织和项目拆分有一定的理解
+本章提供了相当完善的，足够面对多数需求的 C 语言体系结构，通过完成 C 语言的体系，你可以较为熟练地掌握 C 语言，并且对构建一个较小规模的项目组织和项目拆分有一定的理解
 
-python内容完成后，基本学习到如何使用python当一门工具使用，当有具体的需求可以进行后续的补充学习
+python 内容完成后，基本学习到如何使用 python 当一门工具使用，当有具体的需求可以进行后续的补充学习
 
-与此同时，Git or Linux也是作为一个CSer 或者说想要提升自身效率的程序员，不可或缺的一个内容，希望你能掌握
+与此同时，Git or Linux 也是作为一个 CSer 或者说想要提升自身效率的程序员，不可或缺的一个内容，希望你能掌握
 
-如果你要开始，推荐你从3.0开始阅读，然后挑选你喜欢的内容
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnOrKXUsIPJAUXyGB3Txewve.png)
+如果你要开始，推荐你从 3.0 开始阅读，然后挑选你喜欢的内容
 
+![](https://cdn.xyxsw.site/boxcnOrKXUsIPJAUXyGB3Txewve.png)
 
 ## 本章参考内容
 
 [cs61a](https://cs61a.org/)
 
-[CS自学指南](https://csdiy.wiki/)
+[CS 自学指南](https://csdiy.wiki/)
 
 [MIT-Missing-Semester](https://missing.csail.mit.edu/2020/)
 
 [Introductory C Programming](https://www.coursera.org/specializations/c-programming)
 
-[一生一芯nemu](https://ysyx.oscc.cc/)
+[一生一芯 nemu](https://ysyx.oscc.cc/)
 
-[jyy的OS课程](https://jyywiki.cn/)
+[jyy 的 OS 课程](https://jyywiki.cn/)
 
-[迷宫game](https://github.com/helderman/htpataic)
+[迷宫 game](https://github.com/helderman/htpataic)
 
 [GDB User Manual](https://www.sourceware.org/gdb/)
 
 [learn vim](https://github.com/wsdjeg/Learn-Vim_zh_cn)
 
 Book：教材替换用书——《C Primer Plus》
-
-
diff --git a/3.编程思维体系构建/static/call_expression.png b/3.编程思维体系构建/static/call_expression.png
new file mode 100644
index 0000000..cfdd487
Binary files /dev/null and b/3.编程思维体系构建/static/call_expression.png differ
diff --git a/3.编程思维体系构建/static/expression_tree.png b/3.编程思维体系构建/static/expression_tree.png
new file mode 100644
index 0000000..0da9aca
Binary files /dev/null and b/3.编程思维体系构建/static/expression_tree.png differ
diff --git a/3.编程思维体系构建/static/function_abs.png b/3.编程思维体系构建/static/function_abs.png
new file mode 100644
index 0000000..ab459aa
Binary files /dev/null and b/3.编程思维体系构建/static/function_abs.png differ
diff --git a/3.编程思维体系构建/static/function_print.png b/3.编程思维体系构建/static/function_print.png
new file mode 100644
index 0000000..b75e447
Binary files /dev/null and b/3.编程思维体系构建/static/function_print.png differ
diff --git a/3.编程思维体系构建/static/ok01.jpg b/3.编程思维体系构建/static/ok01.jpg
new file mode 100644
index 0000000..5b0d2f3
Binary files /dev/null and b/3.编程思维体系构建/static/ok01.jpg differ
diff --git a/3.编程思维体系构建/static/ok02.png b/3.编程思维体系构建/static/ok02.png
new file mode 100644
index 0000000..6939594
Binary files /dev/null and b/3.编程思维体系构建/static/ok02.png differ
diff --git a/4.人工智能/4.11从 AI 到 智能系统 —— 从 LLMs 到 Agents.md b/4.人工智能/4.11从 AI 到 智能系统 —— 从 LLMs 到 Agents.md
index 8e0576c..4c538e7 100644
--- a/4.人工智能/4.11从 AI 到 智能系统 —— 从 LLMs 到 Agents.md	
+++ b/4.人工智能/4.11从 AI 到 智能系统 —— 从 LLMs 到 Agents.md	
@@ -219,13 +219,13 @@ ICL（In-Context Learning，上下文学习）和 COT（Chain of Thought，思
 
 虽然学界对此没有太大的共识，但其原理无非在于给予 LLMs 更翔实的上下文，让输出与输入有着更紧密的关联与惯性。（从某种意义上来说，也可以将其认为是一种图灵机式的编程）
 
-> ICL：<br/>![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Xjw5bXgRNolw6OxBiEecfOUTn5b.png)
+> ICL：<br/>![](https://cdn.xyxsw.site/Xjw5bXgRNolw6OxBiEecfOUTn5b.png)
 
 ICL 为输出增加惯性
 
 > 可以简单认为，通过 ICL Prompt，能强化人类输入到机器输出的连贯性，借以提升输出的确定性。<br/>在经过“回答”的 finetune 之前，大模型的原始能力就是基于给定文本进行接龙，而 ICL 的引入则在“回答”这一前提条件下，降低了机器开始接龙这一步骤中的语义跨度，从而使得输出更加可控。<br/>
 
-COT：<br/>![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/NT04baWdNoYzRrxjJFfcXCgbnLh.png)
+COT：<br/>![](https://cdn.xyxsw.site/NT04baWdNoYzRrxjJFfcXCgbnLh.png)
 
 COT 为输出增加关联
 
@@ -240,7 +240,7 @@ COT 为输出增加关联
 
 （需要注意的是，TaskMatrix.AI 更大程度上是一个愿景向的调研案例，尚未正式落地生态）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/GlM9be7Hvo4EepxQfEOcRvzpnKd.png)
+![](https://cdn.xyxsw.site/GlM9be7Hvo4EepxQfEOcRvzpnKd.png)
 
 TaskMatrix 的生态愿景
 
@@ -275,7 +275,7 @@ TaskMatrix 的生态愿景
 - Usage Example：API 的调用方法样例
 - Composition Instruction：API 的使用贴士，如应该与其它什么 API 组合使用，是否需要手动释放等
 
-> 样例：打开文件 API<br/>![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/IFWXbgiy8oOj5axvJd8cJu6pnVb.png)
+> 样例：打开文件 API<br/>![](https://cdn.xyxsw.site/IFWXbgiy8oOj5axvJd8cJu6pnVb.png)
 
 基于此类文档内容和 ICL 的能力，LLMs 能从输入中习得调用 API 的方法，依此快速拓展了其横向能力
 
@@ -287,11 +287,11 @@ COT for TaskMatrix
 
 在 TaskMatirx 中，通过该模式，让 MCFM 将任务转化为待办大纲，并最终围绕大纲检索并组合 API，完成整体工作
 
-> 样例：写论文<br/>构建完成工作大纲<br/>![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/GAeJbok1FoTFLixLQAlcxdAPned.png)
+> 样例：写论文<br/>构建完成工作大纲<br/>![](https://cdn.xyxsw.site/GAeJbok1FoTFLixLQAlcxdAPned.png)
 
 TaskMatrix 自动围绕目标拆解任务
 
-> 自动调用插件和组件<br/>![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/PUHZbzk7jo5Avuxo1g6cgD9snXg.png)
+> 自动调用插件和组件<br/>![](https://cdn.xyxsw.site/PUHZbzk7jo5Avuxo1g6cgD9snXg.png)
 
 TaskMatrix 自动为任务创建 API 调用链
 
@@ -313,7 +313,7 @@ TaskMatrix 自动为任务创建 API 调用链
 
 Decomp 的核心思想为将复杂问题通过 Prompt 技巧，将一个复杂的问题由 LLMs 自主划分为多个子任务。随后，我们通过 LLMs 完成多个任务，并将过程信息最终组合并输出理想的效果
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/X7iLbYOcpoXZy7xuhorc71LSnod.png)
+![](https://cdn.xyxsw.site/X7iLbYOcpoXZy7xuhorc71LSnod.png)
 
 几种 Prompt 方法图示
 
@@ -321,7 +321,7 @@ Decomp 的核心思想为将复杂问题通过 Prompt 技巧，将一个复杂
 
 而对于 Decomp 过程，则又是由一个原始的 Decomp Prompt 驱动
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/A7OubowqYo11O3xn0KbcRoscnEh.png)
+![](https://cdn.xyxsw.site/A7OubowqYo11O3xn0KbcRoscnEh.png)
 
 Decomp 方法执行样例
 
@@ -347,7 +347,7 @@ Decomp 的原始功能实际上并不值得太过关注，但我们急需考虑
 
 通过问题的分解和通过“专用函数”的执行，我们可以轻易让 LLMs 实现自身无法做到的调用 API 工作，例如主动从外部检索获取回答问题所需要的知识。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/N1z8bU7dzoD6x1xKtT3cpm9Pnpe.png)
+![](https://cdn.xyxsw.site/N1z8bU7dzoD6x1xKtT3cpm9Pnpe.png)
 
 Decomp 方法调用外部接口样例
 
@@ -359,7 +359,7 @@ Decomp 方法调用外部接口样例
 
 [HuggingGPT](https://arxiv.org/abs/2303.17580) 一文也许并未直接参考 Decomp 方法，而是用一些更规范的手法完成该任务，但其充分流水线化的 Prompt 工程无疑是 Decomp 方法在落地实践上的最佳注脚
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Uct8bXhTgocChExgmiWcQTbSnGb.png)
+![](https://cdn.xyxsw.site/Uct8bXhTgocChExgmiWcQTbSnGb.png)
 
 HuggingGPT
 
@@ -407,7 +407,7 @@ Generative Agents 构建了一套框架，让 NPC 可以感知被模块化的世
 
 - 一方面，其包含场景中既有对象，包括建筑和摆件等的基础层级信息
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/BKZPbpDrIo95amxDZANccwHZnpd.png)
+![](https://cdn.xyxsw.site/BKZPbpDrIo95amxDZANccwHZnpd.png)
 
 Generative Agents 的场景信息管理
 
@@ -627,7 +627,7 @@ AutoGPT 主要特性如下：
 
 ## 意识理论之于 AI：全局工作空间理论
 
-全局工作空间理论（英语：Global workspace theory，GWT）是美国心理学家[伯纳德·巴尔斯](https://zh.wikipedia.org/w/index.php?title=%E4%BC%AF%E7%BA%B3%E5%BE%B7%C2%B7%E5%B7%B4%E5%B0%94%E6%96%AF&action=edit&redlink=1)提出的[意识](https://zh.wikipedia.org/wiki/%E6%84%8F%E8%AF%86)模型。该理论假设意识与一个全局的“广播系统”相关联，这个系统会在整个大脑中广播资讯。大脑中专属的智能处理器会按照惯常的方式自动处理资讯，这个时候不会形成[意识](https://zh.wikipedia.org/wiki/%E6%84%8F%E8%AF%86)。当人面对新的或者是与习惯性刺激不同的事物时，各种专属智能处理器会透过合作或竞争的方式，在全局工作空间中对新事物进行分析以获得最佳结果，而意识正是在这个过程中得以产生。
+全局工作空间理论（英语：Global workspace theory，GWT）是美国心理学家伯纳德·巴尔斯提出的[意识](https://zh.wikipedia.org/wiki/%E6%84%8F%E8%AF%86)模型。该理论假设意识与一个全局的“广播系统”相关联，这个系统会在整个大脑中广播资讯。大脑中专属的智能处理器会按照惯常的方式自动处理资讯，这个时候不会形成[意识](https://zh.wikipedia.org/wiki/%E6%84%8F%E8%AF%86)。当人面对新的或者是与习惯性刺激不同的事物时，各种专属智能处理器会透过合作或竞争的方式，在全局工作空间中对新事物进行分析以获得最佳结果，而意识正是在这个过程中得以产生。
 
 这通常被认为是 神经科学家接受度最高的哲学理论
 
@@ -635,7 +635,7 @@ AutoGPT 主要特性如下：
 
 其提醒我们，就连我们的意识主体性，也只是陈述自我的一个表述器而已。我们是否应当反思对语言能力的过度迷信，从而相信我们能通过训练模型构建 All in One 的智能实体？
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/ED4qbjSrMoR2sQxJnGEcCtvjn8d.png)
+![](https://cdn.xyxsw.site/ED4qbjSrMoR2sQxJnGEcCtvjn8d.png)
 
 全局工作空间理论
 
@@ -905,7 +905,7 @@ AutoGPT 的核心记忆设计依赖于预包装的 Prompt 本体，这一包装
 
 Generative Agent 通过自动化评估记忆的价值，并构建遗忘系统、关注系统等用于精准从自己繁杂的记忆中检索对于当前情景有用的信息。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/StjCbHn2BoqTrNxF64ScvrPInCe.png)
+![](https://cdn.xyxsw.site/StjCbHn2BoqTrNxF64ScvrPInCe.png)
 
 Generative Agents ：基于 Reflection 构建记忆金字塔
 
diff --git a/4.人工智能/4.12LLMAgent之结构化输出.md b/4.人工智能/4.12LLMAgent之结构化输出.md
new file mode 100644
index 0000000..8677ab5
--- /dev/null
+++ b/4.人工智能/4.12LLMAgent之结构化输出.md
@@ -0,0 +1,261 @@
+# LLM Agent之结构化输出
+
+author:Marlene
+
+<em>Last revised 2023/07/26</em>
+
+## 引言
+
+自去年年底以来，GPT的迅速发展诞生了一系列大模型。出现了更新、更大、更强的GPT-4。OpenAI不断推出GPT-4，ChatGPT Plugins，代码解释器，Function calling,图片处理等等。7月的WAIC上，笔者也有幸见到了国内一众企业相继展示自家的大模型。在这段时间里，LLM从最初的PE工程走向智能体交互。而笔者从最开始考虑LLM能不能多人协作，思考”一个专家完成所有任务好还是很多人分工完成好“，到各种论文层出不穷，到如今火热的LLM Agent开发模式。可以说，如果你从大学里随便问某个人都知道GPT，甚至大部分都用过。
+
+好了，前言少叙。进入正题。众所周知，Agent 基本= LLM（大型语言模型）+ 记忆 + 规划技能 + 工具使用。
+
+想要使用工具，让GPT掌握如何使用工具，常见的方法是告知GPT工具（通常是一个可以调用的函数）的参数，让GPT生成这些参数即可。那么如何让GPT可靠的生成这些规定的参数呢？换一种说法，如何让GPT输出结构化的数据信息呢？
+
+## 原理及相关框架
+
+现如今大部分的结构化输出工具的原理都是：告诉GPT要输出一个怎么样的结构即可。没错~当然，为什么会出现这么多开发工具都用来解决这个问题，明明是一个简单的原理呢？
+
+```
+1. 通过 prompt 告知 LLM 我们所需要的返回格式，并进行生成。
+2. 通过一些规则来检查返回结果，如果不符合格式，生成相关错误信息。
+3. 将上一次的生成内容和检查的错误信息告知 LLM，进行下一次的修正生成。
+4. 重复 2-3 步骤，直到生成的内容完全符合我们的要求。
+```
+
+首先，关于怎样描述这样一个结构的prompt模板，众口难调。有些人认为结构就应该用自然语言描述，这样足够简单，上手难度足够低，方便快速迭代开发。有些人认为结构描述？JSON Schema不就够了？有些人觉得YAML也可以。有些人觉得上面这些对于我的需求还是够不着啊，于是自己造了一个伪代码描述。
+其次，自动处理修正机制也可以做很多文章。还有许多对性能和开销的优化。
+下文就是关于一众框架的简单分析。希望会对选择困难症的你有所帮助。
+
+### **guardrails**
+
+guardrails这个项目，就是将上述的步骤做了进一步的抽象与封装，提供更加 high level 的配置与 API 来完成整个过程。
+优点：
+
+1. 定义了一套RAIL spec
+2. 更聚焦于错误信息
+
+```markdown
+<rail version="0.1">
+
+<output>
+    <object name="patient_info">
+        <string name="gender" description="Patient's gender" />
+        <integer name="age" format="valid-range: 0 100" />
+        <list
+            name="symptoms"
+            description="Symptoms that the patient is currently experiencing. Each symptom should be classified into a separate item in the list.">
+            <object>
+                <string name="symptom" description="Symptom that a patient is experiencing"/>
+                <string
+                    name="affected area"
+                    description="What part of the body the symptom is affecting"
+                    format="valid-choices: {['head', 'neck', 'chest']}"
+                    on-fail-valid-choices="reask"
+                />
+            </object>
+        </list>
+        <list name="current_meds" description="Medications the patient is currently taking and their response">
+            <object>
+                <string name="medication" description="Name of the medication the patient is taking" />
+                <string
+                    name="response"
+                    description="How the patient is responding to the medication"
+                />
+            </object>
+        </list>
+    </object>
+</output>
+
+<prompt>
+
+Given the following doctor's notes about a patient, please extract a dictionary that contains the patient's information.
+
+{{doctors_notes}}
+
+@complete_json_suffix_v2
+</prompt>
+</rail>
+```
+
+可以看到，guardrails定义了一套类似xml的语言用于结构化输出，又结合了自然语言的prompt。虽然比起常见的模板语言要更加“繁琐”，但可以包含的内容也可以更加完善。比如可以提供字段的描述信息，检查规范，一定程度上也能帮助 LLM 更好地理解需求，生成预期的结果。
+
+```markdown
+I was given the following JSON response, which had problems due to incorrect values.
+
+{
+  "patient_info": {
+    "symptoms": [
+      {
+        "affected area": {
+          "incorrect_value": "face & hair",
+          "error_message": "Value face & hair is not in choices ['head', 'neck', 'chest']."
+        }
+      },
+      {
+        "affected area": {
+          "incorrect_value": "beard, eyebrows & nares",
+          "error_message": "Value beard, eyebrows & nares is not in choices ['head', 'neck', 'chest']."
+        }
+      }
+    ]
+  }
+}
+
+Help me correct the incorrect values based on the given error messages.
+```
+
+后续 LLM 的返回可以仅针对这部分问题的修正，而不需要再重复生成整个 json。生成的新结果会由 guardrails 再自动填写回原来的位置，非常丝滑。除了 json 格式的检查外，RAIL spec 中还提供了通过脚本检查的扩展支持，可以用来检查更加复杂的内容，例如 Python 代码是否合法，结果中是否有敏感信息，甚至通过 LLM 再来检查生成的内容是否有害，做结果过滤等。
+
+### **NeMo-Guardrails**
+
+来自 Nvidia 的一个同名项目，其目标相比 guardrails 更有野心，想要确保 LLM 应用整体的可信度，无害性以及数据安全性等，而不仅仅只是输出的结构化检查和修复。因此其实现思路上也复杂不少，设计了一种专门的 Colang 语言，来支持更加通用多样的业务流，而不仅仅是生成 -> 检查 -> 修复。不过它的设计都是基于对话做的。实际开发应用可能不太合适。
+
+```markdown
+define user ask capabilities
+  "What can you do?"
+  "What can you help me with?"
+  "tell me what you can do"
+  "tell me about you"
+  "How can I use your help?"
+
+define flow
+  user ask capabilities
+  bot inform capabilities
+
+define bot inform capabilities
+  "I am an AI assistant which helps answer questions based on a given knowledge base. For this interaction, I can answer question based on the job report published by US Bureau of Labor Statistics."
+```
+
+从代码可以看出其结合了python和自然语言，方便相似度检索。
+其整体的运作流程如下：
+
+1. 根据用户输入识别用户意图。在这一步，系统会将用户的输入在 flow 定义的各种用户回复文本中做相似性查找，也就是上面文件中“What can you do?”这一连串内容。这些检索到的预设用户意图内容，结合其它信息如对话样例，最近聊天记录等，形成整体的 prompt，发给 LLM 来生成回复。最终再从回复中提取用户意图。
+2. 根据意图，判断下一步操作动作。这一步有两种做法，一是当前的状态能够匹配上预定义的 flow。例如用户就是提了一个 bot 能力的问题，那么就会匹配上面定义的user ask capabilities，下一步动作自然就是bot inform capabilities。如果没有匹配上，就要由 LLM 自己来决定下一步动作，这时候也会跟生成用户意图一样，对于 flow 定义做一个相似性查找，将相关信息发给 LLM 来做生成。
+3. 生成 bot 回复。如果上一步生成的 bot 回复意图已经有明确定义了（例如上面的 bot 能力的回复），那么就直接用预定义的回复内容来回复用户。如果没有，就跟生成用户意图一样，做意图的相似性查找，将相关信息给 LLM 来生成回复。注意到很多动态的问题例如 QA 场景，是很难预先定义好回复内容的，这里也支持对接知识库，同样是做 vector search 之后，将相关 context 信息发给 LLM 来生成具体回复。
+
+### guidance
+
+之前在 guardrails 中的做法是在 prompt 中给出说明和示范，希望 LLM 能够遵循指令来输出。但现实中往往会出现各种问题，例如额外带了一些其它的文字说明，或者生成的 json 格式不正确等，所以需要后续的 ReAsk 来进行修正。LangChain 里也提供了各种 output parser 来帮忙提取回复中的结构化信息部分，但也经常容易运行失败。
+
+在 guidance 中，也是通过“模板语言”来定义 LLM 的输出结构，以确保输出格式的正确性。
+
+```markdown
+# load a model locally (we use LLaMA here)
+guidance.llm = guidance.llms.Transformers("your_local_path/llama-7b", device=0)
+
+# we can pre-define valid option sets
+valid_weapons = ["sword", "axe", "mace", "spear", "bow", "crossbow"]
+
+# define the prompt
+program = guidance("""The following is a character profile for an RPG game in JSON format.
+json
+{
+    "description": "{{description}}",
+    "name": "{{gen 'name'}}",
+    "age": {{gen 'age' pattern='[0-9]+' stop=','}},
+    "armor": "{{#select 'armor'}}leather{{or}}chainmail{{or}}plate{{/select}}",
+    "weapon": "{{select 'weapon' options=valid_weapons}}",
+    "class": "{{gen 'class'}}",
+    "mantra": "{{gen 'mantra'}}",
+    "strength": {{gen 'strength' pattern='[0-9]+' stop=','}},
+    "items": [{{#geneach 'items' num_iterations=3}}
+        "{{gen 'this'}}",{{/geneach}}
+    ]
+}""")
+
+# execute the prompt
+program(description="A quick and nimble fighter.", valid_weapons=valid_weapons)
+```
+
+在之前传统的做法中，这一整个 json 都需要由 LLM 来生成。但是 json 的结构是我们预先定义的，例如有哪些字段，开闭的花括号等，其实都不需要 LLM 来生成。
+优点：
+
+1. 生成的 json 结构是保证合法且可控的，不会出现语法错误或者缺失/错误字段等。
+2. 通过 LLM 生成的 token 数量减少了，理论上可以提升生成速度。
+
+除了prompt模板，它还提供了：
+
+- 支持 hidden block，例如 LLM 的一些推理过程可能并不需要暴露给最终用户，就可以灵活利用这个特性来生成一些中间结果。
+- Generation caching，自动把已经生成过的结果缓存起来，提升速度。
+- 支持 HuggingFace 模型的 guidance acceleration，进一步提升生成速度。
+- Token healing，不看这个我还不知道 LLM 有这种问题……
+- Regex pattern guide，在模板的基础上进一步通过正则表达来限定生成的内容规范。
+
+从项目代码来看，还是有比较浓的“research 味道”的，可读性并不好。实际测试结果也比较翻车。
+
+### lmql
+
+在 guidance 的基础上，lmql这个项目进一步把“prompt 模板”这个概念推进到了一种新的编程语言。从官网能看到给出的一系列示例。语法结构看起来有点像 SQL，但函数与缩进都是 Python 的风格。
+![](https://marlene-1254110372.cos.ap-shanghai.myqcloud.com/blog/%7B92E71406-7249-4345-894C-AC646F47D05A%7D.png)
+从支持的功能来看，相比 guidance 毫不逊色。例如各种限制条件，代码调用，各种 caching 加速，工具集成等基本都具备。这个框架的格式化输出是其次，其各种可控的输出及语言本身或许更值得关注。
+
+### TypeChat
+
+TypeChat 将 prompt 工程替换为 schema 工程：无需编写非结构化的自然语言 prompt 来描述所需输出的格式，而是编写 TS 类型定义。TypeChat 可以帮助 LLM 以 JSON 的形式响应，并且响应结果非常合理：例如用户要求将这句话「我可以要一份蓝莓松饼和一杯特级拿铁咖啡吗？」转化成 JSON 格式，TypeChat 响应结果如下：
+![](https://marlene-1254110372.cos.ap-shanghai.myqcloud.com/blog/%7BECFBBC78-BFE8-45d0-99EF-5E13E30E2A18%7D.png)
+其本质原理是把interface之类的ts代码作为prompt模板。因此它不仅可以对输出结果进行ts校验，甚至能够输入注释描述，不可谓非常方便js开发者。不过，近日typechat爆火，很多开发者企图尝试将typechat移植到python，笔者认为这是缘木求鱼，因为其校验本身依赖的是ts。笔者在开发过程中，将typechat融合到自己的库中，效果不错。但是它本身自带的prompt和笔者输入的prompt还是存在冲突，还是需要扣扣源码。
+
+### Langchain
+
+如果你关注了过去几个月中人工智能的爆炸式发展，那你大概率听说过 LangChain。简单来说，LangChain 是一个 Python 和 JavaScript 库，由 Harrison Chase 开发，用于连接 OpenAI 的 GPT API（后续已扩展到更多模型）以生成人工智能文本。
+
+langchain具有特别多的结构化输出工具。例如使用yaml定义Schema，输出结构化JSON。使用zodSchema定义Schema，输出结构化JSON。使用FunctionParameters定义Schema，输出结构化JSON。
+
+但是笔者这里不打算介绍langchain。究其原因，是笔者被langchain折磨不堪。明明可以几行代码写清楚的东西，langchain可以各种封装，花了好几十行才写出来。更何况，笔者是用ts开发，开发时甚至偷不了任何懒，甚至其文档丝毫不友好。这几天，《机器之心》发布文章表示放弃langchain。要想让 LangChain 做笔者想让它做的事，就必须花大力气破解它，这将造成大量的技术负担。因为使用人工智能本身就需要花费足够的脑力。LangChain 是为数不多的在大多数常用情况下都会增加开销的软件之一。所以笔者建议非必要，不使用langchain。
+
+## LLM对于结构化信息的理解
+
+LLM 的可控性、稳定性、事实性、安全性等问题是推进企业级应用中非常关键的问题，上面分享的这些项目都是在这方面做了很多探索，也有很多值得借鉴的地方。总体思路上来说，主要是：
+
+- 提供一套 prompt 模板定义，允许用户指定 LLM 生成的格式或内容主题。
+- 在模板基础上，也有不少项目进一步设计了相应的编程语言，让 LLM 与确定性程序的交互更加直观。
+- 提供各类 validator，保证生成内容符合预期，并且提供了自动处理/修正机制。
+- 更进一步，也可以在生成前进行干预，例如在 prompt 中给近似案例，修改模型 decode 时的概率分布等。
+- 其它在可控性基础上做的各种性能与开销的优化，例如缓存，减少 token 消耗量，对开源模型能力的挖掘等。
+
+即使我们不直接使用上述的项目做开发，也可以从中学习到很多有用的思路。当然也非常期待这个领域出现更多有意思的想法与研究，以及 prompt 与编程语言结合能否碰撞出更多的火花。
+
+同时笔者认为自动处理机制、自己设计的编程语言等等内容，随着时间发展，一定会层出不穷，不断迭代更新。笔者抛去这些时效性较弱的内容，从描述信息和位置信息两方面思考peompt模板该如何设计，当然只是浅浅的抛砖引玉一下。
+
+### 描述信息
+
+到底哪种方式更容易于LLM去理解？我们不谈框架的设计，只考虑prompt的设计。上述框架关于这方面有一些参考，例如有些直接拿json作为prompt模板，有些拿xml作为prompt模板，有些拿自己设计的语言作为prompt，有些拿自然语言作为prompt模板。时至今日，选用哪种最适合LLM去理解格式化的信息，输出格式化的内容完全没有盖棺定论。甚至时至今日，格式化输出问题还是没有得到可靠稳定的解决，要不然笔者肯定不会介绍这么多框架实践了。
+
+笔者认为不管哪种方式，都可以从两个方面考量：更简单，更结构。如果想要在开发的时候更简单，或者在使用时更简单，选择md、yaml方式描述结构化信息更合适。如果想要更结构化的方式，选择json、xml、ts，输出都能更有结构，甚至之后做结构校验都更方便。
+
+想要LLM结构化输出更加稳定和理想，笔者认为选择prompt模板时必须考虑每个字段是否有足够的辅助信息。例如xml描述时，每个标签都有一个描述属性描述这个标签时什么意思。
+
+#### 额外引申
+
+笔者之前在开发LLM应用时，也曾思考类似的问题。笔者需要将多模态的数据进行结构化的标注，方便LLM去理解。但是标注成什么样却是一个很大的难题。笔者选择的是JSON。但是，关于里面许多内容的标注。笔者在众多方案中徘徊。在细节处深挖，如何设计一种既简单，又能表示各种结构复杂关系，还能够节约token的方案及其的难。
+> 关于后续如何解决，请容笔者卖个关子sai~
+
+### 位置信息
+
+是否有人注意到llm对于关键信息在prompt中的位置会对结果产生影响呢？在设计 prompt 方面，人们通常建议为语言模型提供详尽的任务描述和背景信息。近期的一些语言模型有能力输入较长的上下文，但它究竟能多好地利用更长的上下文？这一点却相对少有人知。近日，有学者研究发现如果上下文太长，语言模型会更关注其中的前后部分，中间部分却几乎被略过不看，导致模型难以找到放在输入上下文中部的相关信息。下文部分是该论文一些核心内容：
+![](https://marlene-1254110372.cos.ap-shanghai.myqcloud.com/blog/%7B59E03114-A066-4394-B1F0-B09357F76B39%7D.png)
+这是由其本身训练和结构设计有关的，但却对于我们开发有着莫大的帮助和指导意义。
+![](https://marlene-1254110372.cos.ap-shanghai.myqcloud.com/blog/%7B9EA47A4E-3EF3-4800-99F4-109EE713746B%7D.png)
+相比之下，在多文档问答任务上，查询感知型上下文化的影响很小。特别指出，当相关信息位于输入上下文的最开始时，它可以提高性能，但在其他设置中会稍微降低性能。借此，我们可以认为，将重要的信息放在开头，结尾放置结构化模板，或许是一种优质选择。
+
+那么如果真的为其提供这么多 token，那会真的有用吗？这个问题的答案是：由下游任务决定。因为这取决于所添加上下文的边际价值以及模型有效使用长输入上下文的能力。所以如果能有效地对检索文档排序（让相关信息与输入上下文的起始处更近）或对已排序的列表进行截断处理（必要时返回更少的文档），那么也许可以提升基于语言模型的阅读器使用检索上下文的能力。
+
+## 题外话
+
+之前，妙鸭相机突然爆火。其只需9.9即可生成同款数字分身，效果拔群。但是很多人发现，其生成的内容极其容易造成肖像权侵犯，这显然是有问题的。更有甚至的是，用户发现妙鸭相机的用户协议存在问题。根据该应用最初版本的用户服务协议，用户需授权妙鸭相机在全世界（包括元宇宙等虚拟空间）范围内享有永久的、不可撤销的、可转让的、可转授权的、免费的和非独家的许可，使得妙鸭相机可以任何形式、任何媒体或技术（无论现在已知或以后开发）使用用户的内容。对于上述内容，妙鸭相机称系“为了使我方能够提供、确保和改进本服务（包括但不限于使用AI生成内容作为再训练数据等）”。
+
+一句话理解，就是你的肖像它随便用，与你无关。
+
+这不禁让我联想到一部非常发人深省的剧作：《黑镜》。它的第六季第一集讲述的同样是隐私的问题。该集中，主人公的生活隐私由于同意了用户协议，被无时无刻搜集。然后当天晚上就发现流媒体电视上居然出现了跟她同名的电视剧，内容与它当天的生活一模一样，台词甚至更加夸张。于是她的不方便公之于众的生活变得一塌涂地，但她甚至没有办法打官司，因为肯定会输。更令人深省的是，电视剧的主人公是AI生成的视频，其肖像确是根据现实存在的明星生成的。那位明星也无法对她的肖像有任何权利。这样一个荒诞的故事，但是仔细想想，却又非常可能发生。
+
+如今的社会出现了各种大模型。大模型的发展必定需要大数据的支撑。企业为了盈利必定会想方设法的搜集数据，然后肆意使用，转卖。而很多用户对此不自知，更有甚至是非常乐意。例如抖音、B站，当你对其交互时，你希望它推荐更适合你的视频，它也在搜集你的数据，这是明知且主动的。
+
+隐私的掠夺是无声的。你认为你的一下点击是没啥价值的隐私数据，殊不知这正中了资本家的下怀。几年前，我也是这样的。高中的大门出现了闸机，可以刷脸进校园。我当时以为这需要像手机解锁一样需要扫描人脸ID。结果发现，我可以直接进去，闸机上甚至会出现我的照片。我仔细看了看，发现是我入学的证件照。原来一张照片就能刷脸进校园。原来就连学校也可以不经同学同意，将照片用作其他用途。那更何况其他的呢。
+我想，未来，这样的隐私问题会越来越多。
+
+## 参考
+<https://mp.weixin.qq.com/s?__biz=MzA3MzI4MjgzMw==&mid=2650885029&idx=4&sn=ac01576a8957b41529dd3c877d262d5e&chksm=84e48fdbb39306cd8979a4fa7f7da14a9428dc28ccc47880d668ef6293b1a8b7b0964569ec36&mpshare=1&scene=23&srcid=0725w9FPsVnOOzkPGPB7lH8h&sharer_sharetime=1690303766527&sharer_shareid=d2396b329b12f49d34967e2b183540dd#rd>
+<https://mp.weixin.qq.com/s/BngY2WgCcpTOlvdyBNJxqA>
+<https://microsoft.github.io/TypeChat/>
+<https://mp.weixin.qq.com/s?__biz=MzA3MzI4MjgzMw==&mid=2650885029&idx=4&sn=ac01576a8957b41529dd3c877d262d5e&chksm=84e48fdbb39306cd8979a4fa7f7da14a9428dc28ccc47880d668ef6293b1a8b7b0964569ec36&mpshare=1&scene=23&srcid=0725w9FPsVnOOzkPGPB7lH8h&sharer_sharetime=1690303766527&sharer_shareid=d2396b329b12f49d34967e2b183540dd#rd>
diff --git a/4.人工智能/4.12本章节内容的局限性.md b/4.人工智能/4.13本章节内容的局限性.md
similarity index 97%
rename from 4.人工智能/4.12本章节内容的局限性.md
rename to 4.人工智能/4.13本章节内容的局限性.md
index ada5f72..f4f1424 100644
--- a/4.人工智能/4.12本章节内容的局限性.md
+++ b/4.人工智能/4.13本章节内容的局限性.md
@@ -60,4 +60,4 @@ ZZM 曾经尝试过投入大量时间去钻研数学以及机器学习相关的
 
 联系 ZZM，我努力改
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnfYSoVgoERduiWP0jWNWMxf.jpg)
+![](https://cdn.xyxsw.site/boxcnfYSoVgoERduiWP0jWNWMxf.jpg)
diff --git a/4.人工智能/4.1前言.md b/4.人工智能/4.1前言.md
index fc05421..9b5f9bf 100644
--- a/4.人工智能/4.1前言.md
+++ b/4.人工智能/4.1前言.md
@@ -1,49 +1,56 @@
-# 对AI大致方向的概述
+# 对 AI 大致方向的概述
 
+## 前言
 
-# 前言
+在这个时代，相关内容是非常泛滥的，我们在本章内容中，大致的写一些目前比较有名的方向以及它的简介（也许会比 wiki 和百度有趣一点？）
 
-在这个时代，相关内容是非常泛滥的，我们在本章内容中，大致的写一些目前比较有名的方向以及它的简介（也许会比wiki和百度有趣一点？）
-
-# 深度学习 的大致方向分类
+## 深度学习 的大致方向分类
 
 本模块会粗略地介绍目前审读学习的研究与应用领域，在这里提前说明：笔者也只是一名普通的杭电学生，视野与认知有限，某些领域我们了解较多就会介绍地更加详细，某些领域了解较少或笔者中无人从事相关研究，就难免会简略介绍甚至有所偏颇，欢迎大家的指正。
 
-## CV(计算机视觉)
+### CV(计算机视觉)
 
 计算机视觉旨在<strong>用计算机模拟人类处理图片信息的能力</strong>，就比如这里有一张图片——手写数字 9
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnvQiaAx6WgPx64s8fBklVwh.png)
+![](https://cdn.xyxsw.site/boxcnvQiaAx6WgPx64s8fBklVwh.png)
 
 对我们人类而言，能够很轻松地知道这张图片中包含的信息（数字 9），而对计算机来说这只是一堆像素。计算机视觉的任务就是让计算机能够从这堆像素中得到‘数字 9’这个信息。
 
 相信你通过上面简单的介绍应该能够了解到计算机视觉是在干嘛了，接下来我会举几个相对复杂的例子来让大家了解一下目前的 cv 是在做怎样的研究：
 
-<strong>图像分割</strong>是在图片中对物体分类，并且把它们所对应的位置标示出来。下图就是把人的五官，面部皮肤和头发分割出来，效(小)果(丑)图如下：
+::: warning 🐱 <strong>图像分割</strong>是在图片中对物体分类，并且把它们所对应的位置标示出来。下图就是把人的五官，面部皮肤和头发分割出来，效 (小) 果 (丑) 图如下：
+:::
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnxn5GlJZmsrMV5qKNwMlDPc.jpg)
+<table>
+    <tr>
+        <td><img src=https://cdn.xyxsw.site/boxcnxn5GlJZmsrMV5qKNwMlDPc.jpg width=175></td>
+        <td><img src=https://cdn.xyxsw.site/boxcnokdWGegr2XCi1vfg0ZZiWg.png width=200></td>
+        <td><img src=https://cdn.xyxsw.site/boxcn2o9ilOZg6jI6ssTYWhoeme.png width=200></td>
+    </tr>
+</table>
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnokdWGegr2XCi1vfg0ZZiWg.png)
+::: warning 🐱 <strong>图像生成</strong>相信大家一定不陌生，NovalAI 在 2022 年火的一塌糊涂，我觉得不需要我过多赘述，对它 (Diffusion model) 的改进工作也是层出不穷，这里就放一张由可控姿势网络 (ControlNet) 生成的图片吧：
+:::
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn2o9ilOZg6jI6ssTYWhoeme.png)
+![](https://cdn.xyxsw.site/boxcnUjnRociXua1yKj6dmU1A3c.png)
 
-<strong>图像生成</strong>相信大家一定不陌生，NovalAI 在 2022 年火的一塌糊涂，我觉得不需要我过多赘述，对它(Diffusion model)的改进工作也是层出不穷，这里就放一张由可控姿势网络(ControlNet)生成的图片吧：
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnUjnRociXua1yKj6dmU1A3c.png)
-
-<strong>三维重建</strong>也是很多研究者关注的方向，指的是传入对同一物体不同视角的照片，来生成 3D 建模的任务。这方面比图像处理更加前沿并且难度更大。具体见[4.6.5.4神经辐射场(NeRF)](4.6.5.4%E7%A5%9E%E7%BB%8F%E8%BE%90%E5%B0%84%E5%9C%BA(NeRF).md) 章节。
+::: warning 🐱 <strong>三维重建</strong>也是很多研究者关注的方向，指的是传入对同一物体不同视角的照片，来生成 3D 建模的任务。这方面比图像处理更加前沿并且难度更大。具体见[4.6.5.4 神经辐射场 (NeRF)](4.6.5.4%E7%A5%9E%E7%BB%8F%E8%BE%90%E5%B0%84%E5%9C%BA(NeRF).md) 章节。
+:::
 
 如果对计算机视觉有兴趣，可以通过以下路线进行学习：深度学习快速入门—> 经典网络。本块内容的主要撰写者之一<strong>SRT 社团</strong>多数成员主要从事 CV 方向研究，欢迎与我们交流。
 
-## NLP(自然语言处理)
+### NLP(自然语言处理)
 
-这就更好理解了，让计算机能够像人类一样，理解文本中的“真正含义”。在计算机眼中，文本就是单纯的字符串，NLP 的工作就是把字符转换为计算机可理解的数据。举个例子，ChatGPT(或者 New Bing)都是 NLP 的成果。在过去，NLP 领域被细分为了多个小任务，比如文本情感分析、关键段落提取等。而 ChatGPT 的出现可以说是集几乎所有小任务于大成，接下来 NLP 方向的工作会向 ChatGPT 的方向靠近。
+这就更好理解了，让计算机能够像人类一样，理解文本中的“真正含义”。在计算机眼中，文本就是单纯的字符串，NLP 的工作就是把字符转换为计算机可理解的数据。举个例子，ChatGPT(或者 New Bing) 都是 NLP 的成果。在过去，NLP 领域被细分为了多个小任务，比如文本情感分析、关键段落提取等。而 ChatGPT 的出现可以说是集几乎所有小任务于大成，接下来 NLP 方向的工作会向 ChatGPT 的方向靠近。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnyh6pakAkcxCKq6pLylSdef.png)
+<table>
+    <tr>
+        <td><img src=https://cdn.xyxsw.site/boxcnyh6pakAkcxCKq6pLylSdef.png width=580></td>
+        <td><img src=https://cdn.xyxsw.site/boxcnwWnoEDulgWdqGkY0WeYogc.png width=200></td>
+    </tr>
+</table>
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnwWnoEDulgWdqGkY0WeYogc.png)
-
-## 多模态(跨越模态的处理)
+### 多模态 (跨越模态的处理)
 
 模态，可以简单理解为数据形式，比如图片是一种模态，文本是一种模态，声音是一种模态，等等……
 
@@ -53,13 +60,13 @@
 
 具体的任务比如说<strong>图片问答</strong>，传入一张图片，问 AI 这张图片里面有几只猫猫，它们是什么颜色，它告诉我有一只猫猫，是橙色的：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnrMvM1THshjXXOuh8WXi2zr.jpg)
+![](https://cdn.xyxsw.site/boxcnrMvM1THshjXXOuh8WXi2zr.jpg)
 
-## 对比学习
+### 对比学习
 
-因为传统 AI 训练一般都需要数据集标注，比如说图片分割数据集需要人工在数万张图片上抠出具体位置，才能进行训练，这样的人力成本是巨大的，而且难以得到更多数据。因此，对比学习应运而生，这是一种不需要进行标注或者只需要少量标注的训练方式，具体可见[4.6.8对比学习](4.6.8%E5%AF%B9%E6%AF%94%E5%AD%A6%E4%B9%A0.md) 。
+因为传统 AI 训练一般都需要数据集标注，比如说图片分割数据集需要人工在数万张图片上抠出具体位置，才能进行训练，这样的人力成本是巨大的，而且难以得到更多数据。因此，对比学习应运而生，这是一种不需要进行标注或者只需要少量标注的训练方式，具体可见[4.6.8 对比学习](4.6.8%E5%AF%B9%E6%AF%94%E5%AD%A6%E4%B9%A0.md) 。
 
-## 强化学习
+### 强化学习
 
 强调模型如何依据环境（比如扫地机器人在学习家里的陈设，这时陈设就是环境）的变化而改进，以取得最大的收益（比如游戏得到最高分）。
 
@@ -67,25 +74,26 @@
 
 强化学习主要理论来源于心理学中的动物学习和最优控制的控制理论。说的通俗点，强化学习就是操控智能体与环境交互、去不断试错，在这个过程中进行学习。因此，强化学习被普遍地应用于游戏、资源优化分配、机器人等领域。强化学习本身已经是个老东西了，但是和深度学习结合之后焕发出了第二春——深度强化学习（DRL）。
 
-深度强化学习最初来源是2013年谷歌DeepMind团队发表的《Playing Atari with Deep Reinforcement Learning》一文，正式提出Deep Q-network（DQN）算法。在这篇论文中，DeepMind团队训练智能体Agent玩雅达利游戏，并取得了惊人的成绩。事实上，深度强化学习最为人熟知的成就是AlphaGO Zero,它没有使用任何人类棋谱进行训练，训练了三天的成就就已经超过了人类几千年的经验积累<del>导致柯洁道心破碎</del>。
+深度强化学习最初来源是 2013 年谷歌 DeepMind 团队发表的《Playing Atari with Deep Reinforcement Learning》一文，正式提出 Deep Q-network（DQN）算法。在这篇论文中，DeepMind 团队训练智能体 Agent 玩雅达利游戏，并取得了惊人的成绩。事实上，深度强化学习最为人熟知的成就是 AlphaGO Zero，它没有使用任何人类棋谱进行训练，训练了三天的成就就已经超过了人类几千年的经验积累<del>导致柯洁道心破碎</del>。
 
-# 交叉学科&经典机器学习算法
+## 交叉学科&经典机器学习算法
 
 交叉学科巨大的难度在于你往往需要掌握多个学科以及其相对应的知识。
 
 举个例子：如果你想要做出一个可以识别病人是否得了某种疾病，现在你得到了一批数据，你首先得自己可以标注出或者找到这个数据中，哪些是有问题的，并且可以指明问题在哪，如果你想分出更具体的，比如具体哪里有问题，那你可能甚至需要熟悉他并且把他标注出来。
 
-目前其实全学科都有向着AI走的趋势，例如量化金融，医疗，生物科学（nature的那篇有关氨基酸的重大发现真的很cool)。他们很多都在用非常传统的机器学习算法，甚至有的大公司的算法岗在处理某些数据的时候，可能会先考虑用最简单的决策树试一试
+目前其实全学科都有向着 AI 走的趋势，例如量化金融，医疗，生物科学 (nature 的那篇有关氨基酸的重大发现真的很 cool)。他们很多都在用非常传统的机器学习算法，甚至有的大公司的算法岗在处理某些数据的时候，可能会先考虑用最简单的决策树试一试
 
-当然，在大语言模型出现的趋势下，很多学科的应用会被融合会被简化会被大一统(科研人的崇高理想），但是不得不提的是，传统的机器学习算法和模型仍然希望你能去了解甚至更进一步学习。
+当然，在大语言模型出现的趋势下，很多学科的应用会被融合会被简化会被大一统 (科研人的崇高理想)，但是不得不提的是，传统的机器学习算法和模型仍然希望你能去了解甚至更进一步学习。
 
 除了能让你了解所谓前人的智慧，还可以给你带来更进一步的在数学思维，算法思维上的提高。
 
-# And more?
+## And more?
 
-我们对AI的定义如果仅仅只有这些内容，我认为还是太过于狭隘了，我们可以把知识规划，知识表征等等东西都可以将他划入AI的定义中去，当然这些还期待着你的进一步探索和思考~
+我们对 AI 的定义如果仅仅只有这些内容，我认为还是太过于狭隘了，我们可以把知识规划，知识表征等等东西都可以将他划入 AI 的定义中去，当然这些还期待着你的进一步探索和思考~
 
+## 特别致谢
 
-# 特别致谢
+非常荣幸能在本章中得到 IIPL 智能信息处理实验室 [http://iipl.net.cn](http://iipl.net.cn) 的宝贵贡献，衷心感谢他们的无私支持与帮助！
 
-非常荣幸能在本章中得到 IIPL智能信息处理实验室 http://iipl.net.cn 的宝贵贡献，衷心感谢他们的无私支持与帮助！
+希望加入 IIPL？欢迎移步[SRT 社团介绍](SRT.md)～
diff --git a/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md b/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md
index 77eb764..464c06e 100644
--- a/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md	
+++ b/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md	
@@ -1,6 +1,6 @@
 # 机器学习（AI）快速入门（quick start）
 
-本章内容需要你掌握一定的 python 基础知识。
+::: warning 😇 本章内容需要你掌握一定的 python 基础知识。
 
 如果你想要快速了解机器学习，并且动手尝试去实践他，你可以先阅览本部分内容。
 
@@ -11,8 +11,9 @@
 当然我需要承认一点，为了让大家都可以看懂，我做了很多抽象，具有了很多例子，某些内容不太准确，这是必然的，最为准确的往往是课本上精确到少一个字都不行的概念，这是难以理解的。
 
 本篇内容只适合新手理解使用，所以不免会损失一些精度。
+:::
 
-# 什么是机器学习
+## 什么是机器学习
 
 这个概念其实不需要那么多杂七杂八的概念去解释。
 
@@ -22,17 +23,17 @@
 
 然后你给了他更多信息，比如说国家给出了某些条例，他分析这个条例一出，房价就会降低，他给你了个新的数据。
 
-因此我们得出一个结论:机器学习 ＝ 泛型算法。
+因此我们得出一个结论：机器学习 ＝ 泛型算法。
 
 甚至深度学习，也只是机器学习的一部分，不过使用了更多技巧和方法，增大了计算能力罢了。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnbtaUStj8coQiNTmZzfWqNl.png)
+![](https://cdn.xyxsw.site/boxcnbtaUStj8coQiNTmZzfWqNl.png)
 
-# 两种机器学习算法
+## 两种机器学习算法
 
 你可以把机器学习算法分为两大类：监督式学习（supervised Learning）和非监督式学习（unsupervised Learning）。要区分两者很简单，但也非常重要。
 
-## 监督式学习
+### 监督式学习
 
 你是卖方的，你公司很大，因此你雇了一批新员工来帮忙。
 
@@ -42,15 +43,15 @@
 
 近三个月来，每当你的城市里有人卖了房子，你都记录了下面的细节——卧室数量、房屋大小、地段等等。但最重要的是，你写下了最终的成交价：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnL1MNHqAyDjcxIzjFTOdYtt.png)
+![](https://cdn.xyxsw.site/boxcnL1MNHqAyDjcxIzjFTOdYtt.png)
 
 然后你让新人根据着你的成交价来估计新的数量
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnwcDWIDvLnuvZ1uOb75QKPh.png)
+![](https://cdn.xyxsw.site/boxcnwcDWIDvLnuvZ1uOb75QKPh.png)
 
 这就是监督学习，你有一个参照物可以帮你决策。
 
-## 无监督学习
+### 无监督学习
 
 没有答案怎么办？
 
@@ -66,7 +67,7 @@
 
 这其实就是一种经典的聚类算法
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnSn17EC3YvEnA6GScKNAF3e.png)
+![](https://cdn.xyxsw.site/boxcnSn17EC3YvEnA6GScKNAF3e.png)
 
 可以把特征不一样的数据分开，有非常多的操作，你感兴趣可以选择性的去了解一下。
 
@@ -78,29 +79,27 @@
 
 但是「机器在少量样本数据的基础上找出一个公式来解决特定的问题」不是个好名字。所以最后我们用「机器学习」取而代之。而深度学习，则是机器在数据的基础上通过很深的网络（很多的公式）找一个及解决方案来解决问题。
 
-# 看看 Code
+## 看看 Code
 
 如果你完全不懂机器学习知识，你可能会用一堆 if else 条件判断语句来判断比如说房价
 
 ```python
 def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
-	price = 0  # In my area, the average house costs $200 per sqft
-	price_per_sqft = 200  
-	if neighborhood == "hipsterton":
+  price = 0  # In my area, the average house costs $200 per sqft
+  price_per_sqft = 200  i f neighborhood == "hipsterton":
     # but some areas cost a bit more
-		price_per_sqft = 400
-	elif neighborhood == "skid row":
+    price_per_sqft = 400  elif neighborhood == "skid row":
     # and some areas cost less
-		price_per_sqft = 100  # start with a base price estimate based on how big the place is
-	price = price_per_sqft * sqft  # now adjust our estimate based on the number of bedrooms
-	if num_of_bedrooms == 0:
-	# Studio apartments are cheap
-		price = price - 20000
-	else:
+    price_per_sqft = 100  # start with a base price estimate based on how big the place is
+  price = price_per_sqft * sqft  # now adjust our estimate based on the number of bedrooms
+  if num_of_bedrooms == 0:
+    # Studio apartments are cheap
+    price = price — 20000
+  else:
     # places with more bedrooms are usually
     # more valuable
-		price = price + (num_of_bedrooms * 1000)
-	return price
+    price = price + (num_of_bedrooms * 1000)
+    return price
 ```
 
 假如你像这样瞎忙几个小时，最后也许会得到一些像模像样的东西。但是永远感觉差点东西。
@@ -119,7 +118,7 @@ def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
 
 如果你可以找到这么一个公式：
 
-Y(房价)=W(参数）*X1（卧室数量）+W*X2（面积）+W*X3（地段）
+Y(房价)=W(参数) \* X1(卧室数量) + W \*X2(面积) + W \* X3(地段)
 
 你是不是会舒服很多，可以把他想象成，你要做菜，然后那些参数就是佐料的配比
 
@@ -139,7 +138,7 @@ def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
 
 第二步把每个数值都带入进行运算。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcniDICYiLh7ddcxEVrHxFODe.png)
+![](https://cdn.xyxsw.site/boxcniDICYiLh7ddcxEVrHxFODe.png)
 
 比如说，如果第一套房产实际成交价为 25 万美元，你的函数估价为 17.8 万美元，这一套房产你就差了 7.2 万。
 
@@ -151,7 +150,7 @@ def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
 
 第三步：
 
-通过尝试所有可能的权重值组合，不断重复第二步。哪一个权重组合的代价最接近于 0，你就使用哪个。当你找到了合适的权重值，你就解决了问题!
+通过尝试所有可能的权重值组合，不断重复第二步。哪一个权重组合的代价最接近于 0，你就使用哪个。当你找到了合适的权重值，你就解决了问题！
 
 兴奋的时刻到了！
 
@@ -168,21 +167,21 @@ def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
 
 为了避免这种情况，数学家们找到了很多种[聪明的办法](https://link.zhihu.com/?target=http%3A//en.wikipedia.org/wiki/Gradient_descent)来快速找到优秀的权重值。下面是一种：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnXkjzipUjgJpFYXaEhbEN8e.png)
+![](https://cdn.xyxsw.site/boxcnXkjzipUjgJpFYXaEhbEN8e.png)
 
 这就是被称为 loss 函数的东西。
 
 这是个专业属于，你可以选择性忽略他，我们将它改写一下
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnXbd7bqnqPwF8f1Up8rHq5e.png)
+![](https://cdn.xyxsw.site/boxcnXbd7bqnqPwF8f1Up8rHq5e.png)
 
-<em>θ 表示当前的权重值。 J(θ) 表示「当前权重的代价」。</em>
+<em>θ 表示当前的权重值。J(θ) 表示「当前权重的代价」。</em>
 
 这个等式表示，在当前权重值下，我们估价程序的偏离程度。
 
 如果我们为这个等式中所有卧室数和面积的可能权重值作图的话，我们会得到类似下图的图表：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcniBPPpszGhbOWGpvto38Alf.png)
+![](https://cdn.xyxsw.site/boxcniBPPpszGhbOWGpvto38Alf.png)
 
 因此，我们需要做的只是调整我们的权重，使得我们在图上朝着最低点「走下坡路」。如果我们不断微调权重，一直向最低点移动，那么我们最终不用尝试太多权重就可以到达那里。
 
@@ -194,7 +193,7 @@ def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
 
 当你使用一个机器学习算法库来解决实际问题时，这些都已经为你准备好了。但清楚背后的原理依然是有用的。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn2xlALHL53uUMXSHjloWiOe.jpg)
+![](https://cdn.xyxsw.site/boxcn2xlALHL53uUMXSHjloWiOe.jpg)
 
 枚举法
 
@@ -210,7 +209,7 @@ def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
 
 换言之，尽管基本概念非常简单，要通过机器学习得到有用的结果还是需要一些技巧和经验的。但是，这是每个开发者都能学会的技巧。
 
-# 更为智能的预测
+## 更为智能的预测
 
 我们通过上一次的函数假设已经得到了一些值。
 
@@ -225,25 +224,25 @@ def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
 
 我们换一个好看的形式给他展示
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnhbR6lGSXd6UAEpRvSIYSHg.png)
+![](https://cdn.xyxsw.site/boxcnhbR6lGSXd6UAEpRvSIYSHg.png)
 
 <em>箭头头表示了函数中的权重。</em>
 
-然而，这个算法仅仅能用于处理一些简单的问题，就是那些输入和输出有着线性关系的问题。但如果真实价格和决定因素的关系并不是如此简单，那我们该怎么办？ 比如说，地段对于大户型和小户型的房屋有很大影响，然而对中等户型的房屋并没有太大影响。那我们该怎么在我们的模型中收集这种复杂的信息呢？
+然而，这个算法仅仅能用于处理一些简单的问题，就是那些输入和输出有着线性关系的问题。但如果真实价格和决定因素的关系并不是如此简单，那我们该怎么办？比如说，地段对于大户型和小户型的房屋有很大影响，然而对中等户型的房屋并没有太大影响。那我们该怎么在我们的模型中收集这种复杂的信息呢？
 
 所以为了更加的智能化，我们可以利用不同的权重来多次运行这个算法，收集各种不同情况下的估价。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnpDPWKnB6x4fQmGpyvLQJLf.png)
+![](https://cdn.xyxsw.site/boxcnpDPWKnB6x4fQmGpyvLQJLf.png)
 
 然后我们把四种整合到一起，就得到一个超级答案
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnplbH8Ot0U6cuLHStDmXyze.png)
+![](https://cdn.xyxsw.site/boxcnplbH8Ot0U6cuLHStDmXyze.png)
 
 这样我们相当于得到了更为准确的答案
 
-# 神经网络是什么
+## 神经网络是什么
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnhLjMMdts91f8gcpgSVE8Ed.png)
+![](https://cdn.xyxsw.site/boxcnhLjMMdts91f8gcpgSVE8Ed.png)
 
 我们把四个超级网络的结合图整体画出来，其实这就是个超级简单的神经网络，虽然我们省略了很多的内容，但是他仍然有了一定的拟合能力
 
@@ -272,7 +271,7 @@ class LinearModel(torch.nn.Module):
         y_pred=self.linear(x)
         return y_pred
 '''
-线性模型所必须的前馈传播，即wx+b
+线性模型所必须的前馈传播，即 wx+b
 '''
 
 model=LinearModel()
@@ -299,36 +298,38 @@ y_test=model(x_test)
 print('y_pred=',y_test.data)
 ```
 
-# 由浅入深（不会涉及代码）
+## 由浅入深（不会涉及代码）
 
-# 为什么不教我写代码？
+::: warning 😇 为什么不教我写代码？
 
 因为你可能看这些基础知识感觉很轻松毫无压力，但是倘若附上很多代码，会一瞬间拉高这里的难度，虽然仅仅只是调包。
 
 但是我还是会在上面贴上一点代码，但不会有很详细的讲解，因为很多都是调包，没什么好说的，如果你完全零基础，忽略这部分内容即可
 
+:::
+
 我们尝试做一个神奇的工作，那就是用神经网络来识别一下手写数字，听上去非常不可思议，但是我要提前说的一点是，图像也不过是数据的组合，每一张图片有不同程度的像素值，如果我们把每一个像素值都当成神经网络的输入值，然后经过一个黑盒，让他识别出一个他认为可能的数字，然后进行纠正即可。
 
 机器学习只有在你拥有数据（最好是大量数据）的情况下，才能有效。所以，我们需要有大量的手写「8」来开始我们的尝试。幸运的是，恰好有研究人员建立了 [MNIST 手写数字数据库](https://link.zhihu.com/?target=http%3A//yann.lecun.com/exdb/mnist/)，它能助我们一臂之力。MNIST 提供了 60,000 张手写数字的图片，每张图片分辨率为 18×18。即有这么多的数据。
 
 ```python
 (X_train, y_train), (X_test, y_test) = mnist.load_data()
-#这段是导入minist的方法，但是你看不到，如果你想看到的话需要其他操作
+#这段是导入 minist 的方法，但是你看不到，如果你想看到的话需要其他操作
 ```
 
 我们试着只识别一个数字 8
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnOvoCMEuaMIpKZkfoFLDitf.png)
+![](https://cdn.xyxsw.site/boxcnOvoCMEuaMIpKZkfoFLDitf.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnZQnrltieoJ93DT79pyX45e.png)
+![](https://cdn.xyxsw.site/boxcnZQnrltieoJ93DT79pyX45e.png)
 
 我们把一幅 18×18 像素的图片当成一串含有 324 个数字的数组，就可以把它输入到我们的神经网络里面了：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnZ6bzfOUDQgPAJrKI7Pp3Yc.png)
+![](https://cdn.xyxsw.site/boxcnZ6bzfOUDQgPAJrKI7Pp3Yc.png)
 
 为了更好地操控我们的输入数据，我们把神经网络的输入节点扩大到 324 个：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnha4DXsSfAUIYbCQqAx6QKd.png)
+![](https://cdn.xyxsw.site/boxcnha4DXsSfAUIYbCQqAx6QKd.png)
 
 请注意，我们的神经网络现在有了两个输出（而不仅仅是一个房子的价格）。第一个输出会预测图片是「8」的概率，而第二个则输出不是「8」的概率。概括地说，我们就可以依靠多种不同的输出，利用神经网络把要识别的物品进行分组。
 
@@ -345,17 +346,17 @@ model.add(Activation('relu'))# 激活函数，你可以理解为加上这个东
 
 现在唯一要做的就是用各种「8」和非「8」的图片来训练我们的神经网络了。当我们喂给神经网络一个「8」的时候，我们会告诉它是「8」的概率是 100% ，而不是「8」的概率是 0%，反之亦然。
 
-# 仅此而已吗
+## 仅此而已吗
 
 当数字并不是正好在图片中央的时候，我们的识别器就完全不工作了。一点点的位移我们的识别器就掀桌子不干了
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnShOBEoOhsJLR6L5xyr7INb.png)
+![](https://cdn.xyxsw.site/boxcnShOBEoOhsJLR6L5xyr7INb.png)
 
 这是因为我们的网络只学习到了正中央的「8」。它并不知道那些偏离中心的「8」长什么样子。它仅仅知道中间是「8」的图片规律。
 
 在真实世界中，这种识别器好像并没什么卵用。真实世界的问题永远不会如此轻松简单。所以，我们需要知道，当「8」不在图片正中时，怎么才能让我们的神经网络识别它。
 
-## 暴力方法：更多的数据和更深的网络
+### 暴力方法：更多的数据和更深的网络
 
 他不能识别靠左靠右的数据？我们都给他！给他任何位置的图片！
 
@@ -365,19 +366,19 @@ model.add(Activation('relu'))# 激活函数，你可以理解为加上这个东
 
 当然，你同时也需要更强的拟合能力和更深的网络。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnLwoxR6OC3ZBxqtMcKg4v6b.png)
+![](https://cdn.xyxsw.site/boxcnLwoxR6OC3ZBxqtMcKg4v6b.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnIcHcRF34F6jJgTRvhyAevc.png)
+![](https://cdn.xyxsw.site/boxcnIcHcRF34F6jJgTRvhyAevc.png)
 
 一层一层堆叠起来，这种方法很早就出现了。
 
-## 更好的方法？
+### 更好的方法？
 
 你可以通过卷积神经网络进行进一步的处理
 
 作为人类，你能够直观地感知到图片中存在某种层级（hierarchy）或者是概念结构（conceptual structure）。比如说，你在看
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcndjXp5ayczwemklMk9ZA3ig.jpg)
+![](https://cdn.xyxsw.site/boxcndjXp5ayczwemklMk9ZA3ig.jpg)
 
 你会快速的辨认出一匹马，一个人。
 
@@ -387,25 +388,25 @@ model.add(Activation('relu'))# 激活函数，你可以理解为加上这个东
 
 有人对此做过研究，人的眼睛可能会逐步判断一个物体的信息，比如说你看到一张图片，你会先看颜色，然后看纹理然后再看整体，那么我们需要一种操作来模拟这个过程，我们管这种操作叫卷积操作。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnsm0cJGKqt0AU8Kv3K3rkKg.png)
+![](https://cdn.xyxsw.site/boxcnsm0cJGKqt0AU8Kv3K3rkKg.png)
 
-## 卷积是如何工作的
+### 卷积是如何工作的
 
 之前我们提到过，我们可以把一整张图片当做一串数字输入到神经网络里面。不同的是，这次我们会利用<strong>平移不变性</strong>的概念来把这件事做得更智能。
 
 当然也有最新研究说卷积不具备平移不变性，但是我这里使用这个概念是为了大伙更好的理解，举个例子：你将 8 无论放在左上角还是左下角都改变不了他是 8 的事实
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnHo4tt4wmnC7sUykRPPLKmm.png)
+![](https://cdn.xyxsw.site/boxcnHo4tt4wmnC7sUykRPPLKmm.png)
 
 我们将一张图像分成这么多个小块，然后输入神经网络中的是一个小块。<em>每次判断一张小图块。</em>
 
 然而，有一个非常重要的不同：对于每个小图块，我们会使用同样的神经网络权重。换一句话来说，我们平等对待每一个小图块。如果哪个小图块有任何异常出现，我们就认为这个图块是「异常」
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnCxlvaanbzweMmeCOsp1xKf.png)
+![](https://cdn.xyxsw.site/boxcnCxlvaanbzweMmeCOsp1xKf.png)
 
 换一句话来说，我们从一整张图片开始，最后得到一个稍小一点的数组，里面存储着我们图片中的哪一部分有异常。
 
-## 池化层
+### 池化层
 
 图像可能特别大。比如说 1024*1024 再来个颜色 RGB
 
@@ -413,7 +414,7 @@ model.add(Activation('relu'))# 激活函数，你可以理解为加上这个东
 
 让我们先来看每个 2×2 的方阵数组，并且留下最大的数：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnquKepO4wJ74KfNIy3LtqVg.png)
+![](https://cdn.xyxsw.site/boxcnquKepO4wJ74KfNIy3LtqVg.png)
 
 每一波我们只保留一个数，这样就大大减少了图片的计算量了。
 
@@ -429,13 +430,13 @@ model.add(Activation('relu'))# 激活函数，你可以理解为加上这个东
 
 我们也要感谢显卡，这项技术早就出现了但是一直算不了，有了显卡让这件事成为了可能。
 
-## 作出预测
+### 作出预测
 
 到现在为止，我们已经把一个很大的图片缩减到了一个相对较小的数组。
 
 你猜怎么着？数组就是一串数字而已，所以我们我们可以把这个数组输入到另外一个神经网络里面去。最后的这个神经网络会决定这个图片是否匹配。为了区分它和卷积的不同，我们把它称作「全连接」网络
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnDqrUZwXHzgmLR6yvbYSgsV.png)
+![](https://cdn.xyxsw.site/boxcnDqrUZwXHzgmLR6yvbYSgsV.png)
 
 我们的图片处理管道是一系列的步骤：卷积、最大池化，还有最后的「全连接」网络。
 
@@ -445,10 +446,10 @@ model.add(Activation('relu'))# 激活函数，你可以理解为加上这个东
 
 比如说，第一个卷积的步骤可能就是尝试去识别尖锐的东西，而第二个卷积步骤则是通过找到的尖锐物体来找鸟类的喙，最后一步是通过鸟喙来识别整只鸟，以此类推。
 
-# 结语
+## 结语
 
 这篇文章仅仅只是粗略的讲述了一些机器学习的一些基本操作，如果你要更深一步学习的话你可能还需要更多的探索。
 
-# 参考资料
+## 参考资料
 
 [machine-learning-for-software-engineers/README-zh-CN.md at master · ZuzooVn/machine-learning-for-sof](https://github.com/ZuzooVn/machine-learning-for-software-engineers/blob/master/README-zh-CN.md#%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E6%A6%82%E8%AE%BA)
diff --git a/4.人工智能/4.3.1.1程序示例——maze迷宫解搜索.md b/4.人工智能/4.3.1.1程序示例——maze迷宫解搜索.md
index d3c0838..4c1cc8f 100644
--- a/4.人工智能/4.3.1.1程序示例——maze迷宫解搜索.md
+++ b/4.人工智能/4.3.1.1程序示例——maze迷宫解搜索.md
@@ -1,16 +1,17 @@
 # 程序示例——maze 迷宫解搜索
+
 ::: warning 😋
 阅读程序中涉及搜索算法的部分，然后运行程序，享受机器自动帮你寻找路径的快乐！
 完成习题
 :::
 
 ::: tip 📥
-本节附件下载 <Download url="https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/code/1-Lecture.zip"/>
+本节附件下载 <Download url="https://cdn.xyxsw.site/code/1-Lecture.zip"/>
 :::
 
 /4.人工智能/code/MAZE.zip
 
-# Node
+## Node
 
 ```python
 # 节点类 Node
@@ -21,7 +22,7 @@ class Node:
         self.action = action      # 存储采取的行动
 ```
 
-## 节点复习：
+## 节点复习
 
 - 节点是一种包含以下数据的数据结构：
   - 状态——state
@@ -29,7 +30,7 @@ class Node:
   - 应用于父级状态以获取当前节点的操作——action
   - 从初始状态到该节点的路径成本——path cost
 
-# 堆栈边域——DFS
+## 堆栈边域——DFS
 
 ```python
 class StackFrontier:  # 堆栈边域
@@ -50,11 +51,11 @@ class StackFrontier:  # 堆栈边域
             return node
 ```
 
-## 深度优先搜索复习：
+## 深度优先搜索复习
 
 - 深度优先搜索算法在尝试另一个方向之前耗尽每个方向。在这些情况下，边域作为堆栈数据结构进行管理。这里需要记住的流行语是“后进先出”。在将节点添加到边域后，第一个要删除和考虑的节点是最后一个要添加的节点。这导致了一种搜索算法，该算法在第一个方向上尽可能深入，直到尽头，同时将所有其他方向留到后面。“不撞南墙不回头”
 
-# 队列边域——BFS
+## 队列边域——BFS
 
 ```python
 class QueueFrontier(StackFrontier):  # 队列边域
@@ -67,11 +68,11 @@ class QueueFrontier(StackFrontier):  # 队列边域
             return node
 ```
 
-## 广度优先搜索复习：
+## 广度优先搜索复习
 
 - 广度优先搜索算法将同时遵循多个方向，在每个可能的方向上迈出一步，然后在每个方向上迈出第二步。在这种情况下，边域作为队列数据结构进行管理。这里需要记住的流行语是“先进先出”。在这种情况下，所有新节点都会排成一行，并根据先添加的节点来考虑节点（先到先得！）。这导致搜索算法在任何一个方向上迈出第二步之前，在每个可能的方向上迈出一步。
 
-# 迷宫解——Maze_solution
+## 迷宫解——Maze_solution
 
 ```python
 class Maze:
@@ -111,7 +112,7 @@ class Maze:
     # 打印结果
     def print(self):
         ...
-    # 寻找邻结点，返回元组(动作，坐标(x,y))
+    # 寻找邻结点，返回元组 (动作，坐标 (x,y))
     def neighbors(self, state):
         row, col = state
         candidates = [
@@ -130,8 +131,8 @@ class Maze:
         self.num_explored = 0   # 已搜索的路径长度
         # 将边界初始化为起始位置
         start = Node(state=self.start, parent=None, action=None)
-        frontier = StackFrontier()  # 采用DFS
-        # frontier = QueueFrontier()  # 采用BFS
+        frontier = StackFrontier()  # 采用 DFS
+        # frontier = QueueFrontier()  # 采用 BFS
         frontier.add(start)
         # 初始化一个空的探索集
         self.explored = set()  # 存储已搜索的结点
@@ -166,7 +167,7 @@ class Maze:
         ...
 ```
 
-# Quiz
+## Quiz
 
 1. 在深度优先搜索（DFS）和广度优先搜索（BFS）之间，哪一个会在迷宫中找到更短的路径？
    1. DFS 将始终找到比 BFS 更短的路径
@@ -176,7 +177,7 @@ class Maze:
    5. 两种算法总是能找到相同长度的路径
 2. 下面的问题将问你关于下面迷宫的问题。灰色单元格表示墙壁。在这个迷宫上运行了一个搜索算法，找到了从 A 点到 B 点的黄色突出显示的路径。在这样做的过程中，红色突出显示的细胞是探索的状态，但并没有达到目标。
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/MKtXbfJW3ocWT3xSMK0cwVc4nWf.png)
+    ![](https://cdn.xyxsw.site/MKtXbfJW3ocWT3xSMK0cwVc4nWf.png)
 
     在讲座中讨论的四种搜索算法中——深度优先搜索、广度优先搜索、曼哈顿距离启发式贪婪最佳优先搜索和曼哈顿距离启发式$A^*$
 
@@ -190,13 +191,13 @@ class Maze:
    7. 可能是四种算法中的任何一种
    8. 不可能是四种算法中的任何一种
 3. 为什么有深度限制的极大极小算法有时比没有深度限制的极大极小更可取？
-   1.  深度受限的极大极小算法可以更快地做出决定，因为它探索的状态更少
-   2.  深度受限的极大极小算法将在没有深度限制的情况下实现与极大极小算法相同的输出，但有时会使用较少的内存
-   3.  深度受限的极大极小算法可以通过不探索已知的次优状态来做出更优化的决策
-   4.  深度限制的极小极大值永远不会比没有深度限制的极大极小值更可取
-4.  下面的问题将询问您关于下面的 Minimax 树，其中绿色向上箭头表示 MAX 玩家，红色向下箭头表示 MIN 玩家。每个叶节点都标有其值。
+   1. 深度受限的极大极小算法可以更快地做出决定，因为它探索的状态更少
+   2. 深度受限的极大极小算法将在没有深度限制的情况下实现与极大极小算法相同的输出，但有时会使用较少的内存
+   3. 深度受限的极大极小算法可以通过不探索已知的次优状态来做出更优化的决策
+   4. 深度限制的极小极大值永远不会比没有深度限制的极大极小值更可取
+4. 下面的问题将询问您关于下面的 Minimax 树，其中绿色向上箭头表示 MAX 玩家，红色向下箭头表示 MIN 玩家。每个叶节点都标有其值。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/UVssbyMxCoEQSuxvjh3caWAFnOb.png)
+![](https://cdn.xyxsw.site/UVssbyMxCoEQSuxvjh3caWAFnOb.png)
 
 根节点的值是多少？
 
diff --git a/4.人工智能/4.3.1.2项目：Tic-Tac-Toe井字棋.md b/4.人工智能/4.3.1.2项目：Tic-Tac-Toe井字棋.md
index 422ad9a..8ac9f6d 100644
--- a/4.人工智能/4.3.1.2项目：Tic-Tac-Toe井字棋.md
+++ b/4.人工智能/4.3.1.2项目：Tic-Tac-Toe井字棋.md
@@ -1,22 +1,23 @@
 # 项目：Tic-Tac-Toe 井字棋
 
-我们为你提供了一个简单有趣的项目，帮助你进行知识巩固，请认真阅读文档内容。
+::: warning 😋 我们为你提供了一个简单有趣的项目，帮助你进行知识巩固，请认真阅读文档内容。
 
 如果你卡住了，请记得回来阅读文档，或请求身边人的帮助。
+:::
 
 ::: tip 📥
-本节附件下载 <Download url="https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/code/1-Projects.zip"/>
+本节附件下载 <Download url="https://cdn.xyxsw.site/code/1-Projects.zip"/>
 :::
 
 `pip3 install -r requirements.txt`
 
-# 理解
+## 理解
 
 - 这个项目有两个主要文件：`runner.py` 和 `tictactoe.py`。`tictactoe.py` 包含了玩游戏和做出最佳动作的所有逻辑。`runner.py` 已经为你实现，它包含了运行游戏图形界面的所有代码。一旦你完成了 `tictactoe.py` 中所有必需的功能，你就可以运行 `python runner.py` 来对抗你的人工智能了！
 - 让我们打开 `tictactoe.py` 来了解所提供的内容。首先，我们定义了三个变量：X、O 和 EMPTY，以表示游戏的可能移动。
 - 函数 `initial_state` 返回游戏的启动状态。对于这个问题，我们选择将游戏状态表示为三个列表的列表（表示棋盘的三行），其中每个内部列表包含三个值，即 X、O 或 EMPTY。以下是我们留给你实现的功能！
 
-# 说明
+## 说明
 
 - 实现 `player`, `actions`, `result`, `winner`, `terminal`, `utility`, 以及 `minimax`.
 
@@ -46,7 +47,7 @@
     - 否则，如果游戏仍在进行中，则函数应返回 `False`。
   - `utility` 函数应接受结束棋盘状态作为输入，并输出该棋盘的分数。
 
-    - 如果 X 赢得了比赛，则分数为 1。如果 O 赢得了比赛，则分数为-1。如果比赛以平局结束，则分数为 0。
+    - 如果 X 赢得了比赛，则分数为 1。如果 O 赢得了比赛，则分数为 -1。如果比赛以平局结束，则分数为 0。
     - 你可以假设只有当 `terminal(board)` 为 True 时，才会在棋盘上调用 `utility`。
   - `minimax` 函数应该以一个棋盘作为输入，并返回玩家在该棋盘上移动的最佳移动。
 
@@ -55,7 +56,7 @@
   - 对于所有接受棋盘作为输入的函数，你可以假设它是一个有效的棋盘（即，它是包含三行的列表，每行都有三个值 X、O 或 EMPTY）。你不应该修改所提供的函数声明（每个函数的参数的顺序或数量）。、
   - 一旦所有功能都得到了正确的实现，你就应该能够运行 `python runner.py` 并与你的人工智能进行比赛。而且，由于井字棋是双方最佳比赛的平局，你永远不应该能够击败人工智能（尽管如果你打得不好，它可能会打败你！）
 
-# 提示
+## 提示
 
 - 如果你想在不同的 Python 文件中测试你的函数，你可以用类似于 `from tictactoe import initial_state` 的代码来导入它们。
 - 欢迎在 `tictactoe.py` 中添加其他辅助函数，前提是它们的名称不会与模块中已有的函数或变量名称冲突。
diff --git a/4.人工智能/4.3.1搜索.md b/4.人工智能/4.3.1搜索.md
index de60c51..fc3b276 100644
--- a/4.人工智能/4.3.1搜索.md
+++ b/4.人工智能/4.3.1搜索.md
@@ -1,16 +1,18 @@
 # 搜索
 
-在我们日常生活中，其实有非常多的地方使用了所谓的 AI 算法，只是我们通常没有察觉。
+::: warning 😅 在我们日常生活中，其实有非常多的地方使用了所谓的 AI 算法，只是我们通常没有察觉。
 
 比如美团的外卖程序里面，可以看到外卖员到达你所在的位置的路线，它是如何规划出相关路线的呢？
 
 在我们和电脑下围棋下五子棋的时候，他是如何“思考”的呢？希望你在阅读完本章内容之后，可以有一个最基本的理解。并且，我们还会给你留下一个井字棋的小任务，可以让你的电脑和你下井字棋，是不是很 cool
 
 让我们现在开始吧！
+:::
 
-# 基本定义
+## 基本定义
 
-也许第一次看会觉得云里雾里，没有必要全部记住所有的概念。可以先大致浏览一遍之后，再后续的代码中与概念进行结合，相信你会有更深入的理解
+::: warning 🤔 也许第一次看会觉得云里雾里，没有必要全部记住所有的概念。可以先大致浏览一遍之后，再后续的代码中与概念进行结合，相信你会有更深入的理解
+:::
 
 > 即检索存储在某个[数据结构](https://zh.wikipedia.org/wiki/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84)中的信息，或者在问题域的搜索空间中计算的信息。 --wiki
 
@@ -18,23 +20,23 @@
 
 导航是使用搜索算法的一个典型的搜索，它接收您的当前位置和目的地作为输入，并根据搜索算法返回建议的路径。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Hesobke0ZocH48xGFyocf9Cxntd.png)
+![](https://cdn.xyxsw.site/Hesobke0ZocH48xGFyocf9Cxntd.png)
 
 在计算机科学中，还有许多其他形式的搜索问题，比如谜题或迷宫。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/SYw4bOzqAo65PQxZQLucbZAxnHd.png)
+![](https://cdn.xyxsw.site/SYw4bOzqAo65PQxZQLucbZAxnHd.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/LPgEbVQg2oZBSexmGWwcwfbdnVd.png)
+![](https://cdn.xyxsw.site/LPgEbVQg2oZBSexmGWwcwfbdnVd.png)
 
-# 举个例子
+## 举个例子
 
 要找到一个数字华容道谜题的解决方案，需要使用搜索算法。
 
-- 智能主体(Agent)
+- 智能主体 (Agent)
 
   - 感知其环境并对该环境采取行动的实体。
   - 例如，在导航应用程序中，智能主体将是一辆汽车的代表，它需要决定采取哪些行动才能到达目的地。
-- 状态(State)
+- 状态 (State)
 
   - 智能主体在其环境中的配置。
   - 例如，在一个数字华容道谜题中，一个状态是所有数字排列在棋盘上的任何一种方式。
@@ -42,47 +44,47 @@
 
     - 搜索算法开始的状态。在导航应用程序中，这将是当前位置。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/HCxXbwKFyof6DFx6FZ8c5EHknBh.png)
+![](https://cdn.xyxsw.site/HCxXbwKFyof6DFx6FZ8c5EHknBh.png)
 
-- 动作(Action)
+- 动作 (Action)
 
   - 一个状态可以做出的选择。更确切地说，动作可以定义为一个函数。当接收到状态$s$作为输入时，$Actions(s)$将返回可在状态$s$ 中执行的一组操作作为输出。
   - 例如，在一个数字华容道中，给定状态的操作是您可以在当前配置中滑动方块的方式。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/MpgrbCjtDo1NlLxVyL1cMH6FnAg.png)
+![](https://cdn.xyxsw.site/MpgrbCjtDo1NlLxVyL1cMH6FnAg.png)
 
-- 过渡模型(Transition Model)
+- 过渡模型 (Transition Model)
 
   - 对在任何状态下执行任何适用操作所产生的状态的描述。
   - 更确切地说，过渡模型可以定义为一个函数。
   - 在接收到状态$s$和动作$a$作为输入时，$Results(s，a)$返回在状态$s$中执行动作$a$ 所产生的状态。
   - 例如，给定数字华容道的特定配置（状态$s$），在任何方向上移动正方形（动作$a$）将导致谜题的新配置（新状态）。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/RKV2buJoroCV6SxiMUuct3dbnPU.png)
+![](https://cdn.xyxsw.site/RKV2buJoroCV6SxiMUuct3dbnPU.png)
 
-- 状态空间(State Space)
+- 状态空间 (State Space)
 
   - 通过一系列的操作目标从初始状态可达到的所有状态的集合。
   - 例如，在一个数字华容道谜题中，状态空间由所有$\frac{16!}{2}$种配置，可以从任何初始状态达到。状态空间可以可视化为有向图，其中状态表示为节点，动作表示为节点之间的箭头。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/JdCqb2UI9ooWmdxk258cTIIznab.png)
+![](https://cdn.xyxsw.site/JdCqb2UI9ooWmdxk258cTIIznab.png)
 
-- 目标测试(Goal Test)
+- 目标测试 (Goal Test)
 
   - 确定给定状态是否为目标状态的条件。例如，在导航应用程序中，目标测试将是智能主体的当前位置是否在目的地。如果是，问题解决了。如果不是，我们将继续搜索。
-- 路径成本(Path Cost)
+- 路径成本 (Path Cost)
 
   - 完成给定路径相关的代价。例如，导航应用程序并不是简单地让你达到目标；它这样做的同时最大限度地减少了路径成本，为您找到了达到目标状态的最快方法。
 
-# 解决搜索问题
+## 解决搜索问题
 
-- 解(solution)
+- 解 (solution)
 
   - 从初始状态到目标状态的一系列动作。
-  - 最优解(Optimal Solution)
+  - 最优解 (Optimal Solution)
 
     - 在所有解决方案中路径成本最低的解决方案。
-- 在搜索过程中，数据通常存储在<strong>节点(Node)</strong> 中，节点是一种包含以下数据的数据结构：
+- 在搜索过程中，数据通常存储在<strong>节点 (Node)</strong> 中，节点是一种包含以下数据的数据结构：
 
   - 状态——state
   - 其父节点，通过该父节点生成当前节点——parent node
@@ -96,7 +98,7 @@
 
   一旦选择了节点，通过存储父节点和从父节点到当前节点的动作，就可以追溯从初始状态到该节点的每一步，而这一系列动作就是解决方案。
 
-- 然而，节点只是一个数据结构——它们不搜索，而是保存信息。为了实际搜索，我们使用了边域(frontier)，即“管理”节点的机制。边域首先包含一个初始状态和一组空的已探索项目（探索集），然后重复以下操作，直到找到解决方案：
+- 然而，节点只是一个数据结构——它们不搜索，而是保存信息。为了实际搜索，我们使用了边域 (frontier)，即“管理”节点的机制。边域首先包含一个初始状态和一组空的已探索项目（探索集），然后重复以下操作，直到找到解决方案：
 
   - 重复
 
@@ -112,9 +114,9 @@
       - 展开节点（找到可以从该节点到达的所有新节点），并将生成的节点添加到边域。
       - 将当前节点添加到探索集。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/K53FbGmswoM7JAxqJZxcQEjdnES.png)
+![](https://cdn.xyxsw.site/K53FbGmswoM7JAxqJZxcQEjdnES.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/THhpbemEHoxl80xHeTjc9d35nVh.png)
+![](https://cdn.xyxsw.site/THhpbemEHoxl80xHeTjc9d35nVh.png)
 
 边域从节点 A 初始化开始
 
@@ -122,16 +124,16 @@ a. 取出边域中的节点 A，展开节点 A，将节点 B 添加到边域。
 b. 取出节点 B，展开，添加......
 c. 到达目标节点，停止，返回解决方案
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/XmnObIGaUoF4ssxkgzUc4vTUnmf.png)
+![](https://cdn.xyxsw.site/XmnObIGaUoF4ssxkgzUc4vTUnmf.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Wsntb9rLwogdAKxpJgLchrI8nae.png)
+![](https://cdn.xyxsw.site/Wsntb9rLwogdAKxpJgLchrI8nae.png)
 
 会出现什么问题？节点 A-> 节点 B-> 节点 A->......-> 节点 A。我们需要一个探索集，记录已搜索的节点！
 
-## 不知情搜索(Uninformed Search)
+### 不知情搜索 (Uninformed Search)
 
 - 在之前对边域的描述中，有一件事没有被提及。在上面伪代码的第 1 阶段，应该删除哪个节点？这种选择对解决方案的质量和实现速度有影响。关于应该首先考虑哪些节点的问题，有多种方法，其中两种可以用堆栈（深度优先搜索）和队列（广度优先搜索）的数据结构来表示。
-- 深度优先搜索(Depth-First Search)
+- 深度优先搜索 (Depth-First Search)
 
   - 深度优先搜索算法在尝试另一个方向之前耗尽每个方向。在这些情况下，边域作为堆栈数据结构进行管理。这里需要记住的流行语是“后进先出”。在将节点添加到边域后，第一个要删除和考虑的节点是最后一个要添加的节点。这导致了一种搜索算法，该算法在第一个方向上尽可能深入，直到尽头，同时将所有其他方向留到后面。“不撞南墙不回头”
   - （一个例子：以你正在寻找钥匙的情况为例。在深度优先搜索方法中，如果你选择从裤子里搜索开始，你会先仔细检查每一个口袋，清空每个口袋，仔细检查里面的东西。只有当你完全筋疲力尽时，你才会停止在裤子里搜索，开始在其他地方搜索。）
@@ -143,15 +145,15 @@ c. 到达目标节点，停止，返回解决方案
     - 所找到的解决方案可能不是最优的。
     - 在最坏的情况下，该算法将在找到解决方案之前探索每一条可能的路径，从而在到达解决方案之前花费尽可能长的时间。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/SGVWbCcTlobQwJxSjKvcNyJAnEG.png)
+![](https://cdn.xyxsw.site/SGVWbCcTlobQwJxSjKvcNyJAnEG.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Vv9Sb26QfoMrkqx5apycIYPJnlf.png)
+![](https://cdn.xyxsw.site/Vv9Sb26QfoMrkqx5apycIYPJnlf.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Gjd5bpdpcoIxGtxcUJ0c2OVfnOf.png)
+![](https://cdn.xyxsw.site/Gjd5bpdpcoIxGtxcUJ0c2OVfnOf.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/M2vZbA5hpoT9RExuAGwcBHF1nmh.png)
+![](https://cdn.xyxsw.site/M2vZbA5hpoT9RExuAGwcBHF1nmh.png)
 
-  - 代码实现
+- 代码实现
 
 ```python
 def remove(self):
@@ -163,7 +165,7 @@ def remove(self):
         return node
 ```
 
-- 广度优先搜索(Breadth-First Search)
+- 广度优先搜索 (Breadth-First Search)
 
   - 广度优先搜索算法将同时遵循多个方向，在每个可能的方向上迈出一步，然后在每个方向上迈出第二步。在这种情况下，边域作为队列数据结构进行管理。这里需要记住的流行语是“先进先出”。在这种情况下，所有新节点都会排成一行，并根据先添加的节点来考虑节点（先到先得！）。这导致搜索算法在任何一个方向上迈出第二步之前，在每个可能的方向上迈出一步。
   - （一个例子：假设你正在寻找钥匙。在这种情况下，如果你从裤子开始，你会看你的右口袋。之后，你会在一个抽屉里看一眼，而不是看你的左口袋。然后在桌子上。以此类推，在你能想到的每个地方。只有在你用完所有位置后，你才会回到你的裤子上，在下一个口袋里找。）
@@ -175,15 +177,15 @@ def remove(self):
     - 几乎可以保证该算法的运行时间会比最短时间更长。
     - 在最坏的情况下，这种算法需要尽可能长的时间才能运行。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/S6SRbMUrcoYQCYxZGgJczkdcnBP.png)
+![](https://cdn.xyxsw.site/S6SRbMUrcoYQCYxZGgJczkdcnBP.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Xg7Qbv59IoQB3bxPFO1ceXgRnkf.png)
+![](https://cdn.xyxsw.site/Xg7Qbv59IoQB3bxPFO1ceXgRnkf.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/X34Rb5R7AonUg3xYs7DcQzSfndg.png)
+![](https://cdn.xyxsw.site/X34Rb5R7AonUg3xYs7DcQzSfndg.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/PQeZbJv3Bom6NYxa6lccT084nFn.png)
+![](https://cdn.xyxsw.site/PQeZbJv3Bom6NYxa6lccT084nFn.png)
 
-  - 代码实现
+- 代码实现
 
 ```python
 def remove(self):
@@ -195,78 +197,74 @@ def remove(self):
         return node
 ```
 
-## 知情搜索(Informed Search)
+## 知情搜索 (Informed Search)
 
 - 广度优先和深度优先都是不知情的搜索算法。也就是说，这些算法没有利用他们没有通过自己的探索获得的关于问题的任何知识。然而，大多数情况下，关于这个问题的一些知识实际上是可用的。例如，当人类进入一个路口时，人类可以看到哪条路沿着解决方案的大致方向前进，哪条路没有。人工智能也可以这样做。一种考虑额外知识以试图提高性能的算法被称为知情搜索算法。
-- 贪婪最佳优先搜索(Greedy Best-First Search)
+- 贪婪最佳优先搜索 (Greedy Best-First Search)
 
   - 贪婪最佳优先搜索扩展最接近目标的节点，如启发式函数$h(n)$所确定的。顾名思义，该函数估计下一个节点离目标有多近，但可能会出错。贪婪最佳优先算法的效率取决于启发式函数的好坏。例如，在迷宫中，算法可以使用启发式函数，该函数依赖于可能节点和迷宫末端之间的曼哈顿距离。曼哈顿距离忽略了墙壁，并计算了从一个位置到目标位置需要向上、向下或向两侧走多少步。这是一个简单的估计，可以基于当前位置和目标位置的$(x，y)$坐标导出。
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Pe3WbBuTjomWjfxd5Ryc3OPPnSd.png)
+![](https://cdn.xyxsw.site/Pe3WbBuTjomWjfxd5Ryc3OPPnSd.png)
 
   - 然而，重要的是要强调，与任何启发式算法一样，它可能会出错，并导致算法走上比其他情况下更慢的道路。不知情的搜索算法有可能更快地提供一个更好的解决方案，但它比知情算法更不可能这样。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/HkvdbcEdmo6RtjxOqqic31XFnSh.png)
+![](https://cdn.xyxsw.site/HkvdbcEdmo6RtjxOqqic31XFnSh.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/SU2DbQeN2oxs5ex3K3NcMaJfnch.png)
+![](https://cdn.xyxsw.site/SU2DbQeN2oxs5ex3K3NcMaJfnch.png)
 
 - $A^*$搜索
   
-  - 作为贪婪最佳优先算法的一种发展，$A^*$搜索不仅考虑了从当前位置到目标的估计成本$h(n)$，还考虑了直到当前位置为止累积的成本$g(n)$。通过组合这两个值，该算法可以更准确地确定解决方案的成本并在旅途中优化其选择。该算法跟踪（到目前为止的路径成本+到目标的估计成本,$g(n)+h(n)$），一旦它超过了之前某个选项的估计成本，该算法将放弃当前路径并返回到之前的选项，从而防止自己沿着$h(n)$错误地标记为最佳的却长而低效的路径前进。
+  - 作为贪婪最佳优先算法的一种发展，$A^*$搜索不仅考虑了从当前位置到目标的估计成本$h(n)$，还考虑了直到当前位置为止累积的成本$g(n)$。通过组合这两个值，该算法可以更准确地确定解决方案的成本并在旅途中优化其选择。该算法跟踪（到目前为止的路径成本 + 到目标的估计成本，$g(n)+h(n)$），一旦它超过了之前某个选项的估计成本，该算法将放弃当前路径并返回到之前的选项，从而防止自己沿着$h(n)$错误地标记为最佳的却长而低效的路径前进。
   
   - 然而，由于这种算法也依赖于启发式，所以它依赖它所使用的启发式。在某些情况下，它可能比贪婪的最佳第一搜索甚至不知情的算法效率更低。对于最佳的$A^*$搜索，启发式函数$h(n)$应该：
-    
+
     - 可接受，从未高估真实成本。
-    
-    - 一致性，这意味着从新节点到目标的估计路径成本加上从先前节点转换到该新节点的成本应该大于或等于先前节点到目标的估计路径成本。用方程的形式表示，$h(n)$是一致的，如果对于每个节点n$和后续节点n'$，从n$到$n'$的步长为c$，满足$h(n)≤h(n')+c$。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/BbIiba1pwo3uI7x4k7QcwicznGc.png)
+    - 一致性，这意味着从新节点到目标的估计路径成本加上从先前节点转换到该新节点的成本应该大于或等于先前节点到目标的估计路径成本。用方程的形式表示，$h(n)$是一致的，如果对于每个节点 n$和后续节点 n'$,从 n$到$n'$的步长为 c$,满足$h(n) ≤ h(n') + c$.
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/HhG9bcJP2okKMMxY0FGclP0AnXY.png)
+![](https://cdn.xyxsw.site/BbIiba1pwo3uI7x4k7QcwicznGc.png)
 
-# 对抗性搜索
+![](https://cdn.xyxsw.site/HhG9bcJP2okKMMxY0FGclP0AnXY.png)
+
+## 对抗性搜索
 
 尽管之前我们讨论过需要找到问题答案的算法，但在对抗性搜索中，算法面对的是试图实现相反目标的对手。通常，在游戏中会遇到使用对抗性搜索的人工智能，比如井字游戏。
 
-- 极大极小算法(Minimax)
+- 极大极小算法 (Minimax)
 
   - 作为对抗性搜索中的一种算法，Minimax 将获胜条件表示为$(-1)$表示为一方，$(+1)$表示为另一方。进一步的行动将受到这些条件的驱动，最小化的一方试图获得最低分数，而最大化的一方则试图获得最高分数。
   
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/FYu3bQwCZofBgsxKDJiciTR7nzc.png)
+    ![](https://cdn.xyxsw.site/FYu3bQwCZofBgsxKDJiciTR7nzc.png)
   
--  井字棋 AI 为例
+- 井字棋 AI 为例
   
-    - $s_0$: 初始状态（在我们的情况下，是一个空的3X3棋盘）
-    
-      ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/WstnbmHwYoQauRxUQOCclz8Jngb.png)
+  - $s_0$: 初始状态（在我们的情况下，是一个空的 3X3 棋盘）
+
+      ![](https://cdn.xyxsw.site/WstnbmHwYoQauRxUQOCclz8Jngb.png)
+
+    - $Players(s)$: 一个函数，在给定状态$$s$$的情况下，返回轮到哪个玩家（X 或 O）。
+
+      ![](https://cdn.xyxsw.site/DKzTbJSZMoc1UkxT9KOcIHqvnob.png)
 
-    - $Players(s)$: 一个函数，在给定状态$$s$$的情况下，返回轮到哪个玩家（X或O）。
-    
-      ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/DKzTbJSZMoc1UkxT9KOcIHqvnob.png)
-    
     - $Actions(s)$: 一个函数，在给定状态$$s$$的情况下，返回该状态下的所有合法动作（棋盘上哪些位置是空的）。
-    
-      ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/LuEzbLOaqox7yox5lXzcouWYnKc.png)
-    
-    - $Result(s, a)$: 一个函数，在给定状态$$s$$和操作$$a$$的情况下，返回一个新状态。这是在状态$$s$$上执行动作$$a$$（在游戏中移动）所产生的棋盘。
-    
-      ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/AdOVbwCGhoVcWVx21TMcdhbDnIg.png)
-    
-    - $Terminal(s)$: 一个函数，在给定状态$$s$$的情况下，检查这是否是游戏的最后一步，即是否有人赢了或打成平手。如果游戏已结束，则返回True，否则返回False。
-    
-      ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/EOfJbvoUMogVT8xsrTxcl5ugnrk.png)
-    
-    - $Utility(s)$: 一个函数，在给定终端状态s的情况下，返回状态的效用值：$$-1、0或1$$。
-    
-      
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/UcpAbpWtJoHb5Wx6ycrcG2ZZnIe.png)
+      ![](https://cdn.xyxsw.site/LuEzbLOaqox7yox5lXzcouWYnKc.png)
+
+    - $Result(s, a)$: 一个函数，在给定状态$$s$$和操作$$a$$的情况下，返回一个新状态。这是在状态$$s$$上执行动作$$a$$（在游戏中移动）所产生的棋盘。
+
+      ![](https://cdn.xyxsw.site/AdOVbwCGhoVcWVx21TMcdhbDnIg.png)
+
+    - $Terminal(s)$: 一个函数，在给定状态$$s$$的情况下，检查这是否是游戏的最后一步，即是否有人赢了或打成平手。如果游戏已结束，则返回 True，否则返回 False。
+
+      ![](https://cdn.xyxsw.site/EOfJbvoUMogVT8xsrTxcl5ugnrk.png)
+
+    - $Utility(s)$: 一个函数，在给定终端状态 s 的情况下，返回状态的效用值：$$-1、0 或 1$$。
+
+![](https://cdn.xyxsw.site/UcpAbpWtJoHb5Wx6ycrcG2ZZnIe.png)
 
 - 算法的工作原理：
 
   - 该算法递归地模拟从当前状态开始直到达到终端状态为止可能发生的所有游戏状态。每个终端状态的值为$(-1)$、$0$或$(+1)$。
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/DN3mb0lbno2AHvx2M0JcrTvtnYf.png)
+![](https://cdn.xyxsw.site/DN3mb0lbno2AHvx2M0JcrTvtnYf.png)
 
   - 根据轮到谁的状态，算法可以知道当前玩家在最佳游戏时是否会选择导致状态值更低或更高的动作。
 
@@ -278,7 +276,7 @@ def remove(self):
 
 在得到这些值之后，最大化的玩家会选择最高的一个。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/EjB9bzgZNohQtkxXwXgcVrKwnth.png)
+![](https://cdn.xyxsw.site/EjB9bzgZNohQtkxXwXgcVrKwnth.png)
 
 - 具体算法：
 
@@ -302,17 +300,17 @@ def remove(self):
       - $$v = Min(v, Max-Value(Result(state, action)))$$
     - return $v$
 
-不会理解递归？也许你需要看看这个：[阶段二:递归操作](../3.%E7%BC%96%E7%A8%8B%E6%80%9D%E7%BB%B4%E4%BD%93%E7%B3%BB%E6%9E%84%E5%BB%BA/3.6.4.2%E9%98%B6%E6%AE%B5%E4%BA%8C%EF%BC%9A%E9%80%92%E5%BD%92%E6%93%8D%E4%BD%9C.md)
+不会理解递归？也许你需要看看这个：[阶段二：递归操作](../3.%E7%BC%96%E7%A8%8B%E6%80%9D%E7%BB%B4%E4%BD%93%E7%B3%BB%E6%9E%84%E5%BB%BA/3.6.4.2%E9%98%B6%E6%AE%B5%E4%BA%8C%EF%BC%9A%E9%80%92%E5%BD%92%E6%93%8D%E4%BD%9C.md)
 
-- $\alpha$-$\beta$剪枝(Alpha-Beta Pruning)
+- $\alpha$-$\beta$剪枝 (Alpha-Beta Pruning)
 
-  - 作为一种优化Minimax的方法，Alpha-Beta剪枝跳过了一些明显不利的递归计算。在确定了一个动作的价值后，如果有初步证据表明接下来的动作可以让对手获得比已经确定的动作更好的分数，那么就没有必要进一步调查这个动作，因为它肯定比之前确定的动作不利。
+  - 作为一种优化 Minimax 的方法，Alpha-Beta 剪枝跳过了一些明显不利的递归计算。在确定了一个动作的价值后，如果有初步证据表明接下来的动作可以让对手获得比已经确定的动作更好的分数，那么就没有必要进一步调查这个动作，因为它肯定比之前确定的动作不利。
   
-  - 这一点最容易用一个例子来说明：最大化的玩家知道，在下一步，最小化的玩家将试图获得最低分数。假设最大化玩家有三个可能的动作，第一个动作的值为4。然后玩家开始为下一个动作生成值。要做到这一点，如果当前玩家做出这个动作，玩家会生成最小化者动作的值，并且知道最小化者会选择最低的一个。然而，在完成最小化器所有可能动作的计算之前，玩家会看到其中一个选项的值为3。这意味着没有理由继续探索最小化玩家的其他可能行动。尚未赋值的动作的值无关紧要，无论是10还是（-10）。如果该值为10，则最小化器将选择最低选项3，该选项已经比预先设定的4差。如果尚未估价的行动结果是（-10），那么最小化者将选择（-10）这一选项，这对最大化者来说更加不利。因此，在这一点上为最小化者计算额外的可能动作与最大化者无关，因为最大化玩家已经有了一个明确的更好的选择，其值为4。
+  - 这一点最容易用一个例子来说明：最大化的玩家知道，在下一步，最小化的玩家将试图获得最低分数。假设最大化玩家有三个可能的动作，第一个动作的值为 4。然后玩家开始为下一个动作生成值。要做到这一点，如果当前玩家做出这个动作，玩家会生成最小化者动作的值，并且知道最小化者会选择最低的一个。然而，在完成最小化器所有可能动作的计算之前，玩家会看到其中一个选项的值为 3。这意味着没有理由继续探索最小化玩家的其他可能行动。尚未赋值的动作的值无关紧要，无论是 10 还是（-10）。如果该值为 10，则最小化器将选择最低选项 3，该选项已经比预先设定的 4 差。如果尚未估价的行动结果是（-10），那么最小化者将选择（-10）这一选项，这对最大化者来说更加不利。因此，在这一点上为最小化者计算额外的可能动作与最大化者无关，因为最大化玩家已经有了一个明确的更好的选择，其值为 4。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/LDZab4TeMoByvDxF1Onc8WQenpb.png)
+![](https://cdn.xyxsw.site/LDZab4TeMoByvDxF1Onc8WQenpb.png)
 
-- 深度限制的极大极小算法(Depth-Limited Minimax)
+- 深度限制的极大极小算法 (Depth-Limited Minimax)
 
   - 总共有$255168$个可能的井字棋游戏，以及有$10^{29000}$个可能的国际象棋中游戏。到目前为止，最小最大算法需要生成从某个点到<strong>终端条件</strong>的所有假设游戏状态。虽然计算所有的井字棋游戏状态对现代计算机来说并不是一个挑战，但目前用来计算国际象棋是不可能的。
 
diff --git a/4.人工智能/4.3.2.1程序示例——命题逻辑与模型检测.md b/4.人工智能/4.3.2.1程序示例——命题逻辑与模型检测.md
index db1d8ef..da94041 100644
--- a/4.人工智能/4.3.2.1程序示例——命题逻辑与模型检测.md
+++ b/4.人工智能/4.3.2.1程序示例——命题逻辑与模型检测.md
@@ -1,4 +1,5 @@
 # 程序示例——命题逻辑与模型检测
+
 ::: warning 😋
 阅读程序中涉及命题逻辑的部分，然后“玩一玩”程序！
 
@@ -6,9 +7,10 @@
 :::
 
 ::: tip 📥
-本节附件下载 <Download url="https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/code/2-Lecture.zip"/>
+本节附件下载 <Download url="https://cdn.xyxsw.site/code/2-Lecture.zip"/>
 :::
-# Sentence——父类
+
+## Sentence——父类
 
 ```python
 class Sentence(): # 父类
@@ -21,12 +23,12 @@ class Sentence(): # 父类
     def symbols(self):
         """返回逻辑表达式中所有命题符号的集合。"""
         return set()
-    @classmethod # @classmethod装饰器 使得类方法可以在类上被调用 Sentence.validate(...)
+    @classmethod # @classmethod 装饰器 使得类方法可以在类上被调用 Sentence.validate(...)
     def validate(cls, sentence):
-        """验证操作数是否是Sentence或其子类"""
+        """验证操作数是否是 Sentence 或其子类"""
         if not isinstance(sentence, Sentence):
             raise TypeError("must be a logical sentence")
-    @classmethod # @classmethod装饰器 使得类方法可以在类上被调用 Sentence.parenthesize(...)
+    @classmethod # @classmethod 装饰器 使得类方法可以在类上被调用 Sentence.parenthesize(...)
     def parenthesize(cls, s):
         """如果表达式尚未加圆括号，则加圆括号。"""
         def balanced(s):
@@ -46,7 +48,7 @@ class Sentence(): # 父类
             return f"({s})"
 ```
 
-# Symbol——命题符号类
+## Symbol——命题符号类
 
 ```python
 class Symbol(Sentence):
@@ -71,12 +73,12 @@ class Symbol(Sentence):
         return {self.name}
 ```
 
-# Not——逻辑非类
+## Not——逻辑非类
 
 ```python
 class Not(Sentence):
     def __init__(self, operand):
-        """验证操作数是否是Sentence或其子类"""
+        """验证操作数是否是 Sentence 或其子类"""
         Sentence.validate(operand)
         self.operand = operand
     def __eq__(self, other):
@@ -94,13 +96,13 @@ class Not(Sentence):
         return self.operand.symbols()
 ```
 
-# And——逻辑乘类
+## And——逻辑乘类
 
 ```python
 class And(Sentence):
     def __init__(self, *conjuncts):
         for conjunct in conjuncts:
-        """验证操作数是否是Sentence或其子类"""
+        """验证操作数是否是 Sentence 或其子类"""
             Sentence.validate(conjunct)
         self.conjuncts = list(conjuncts)
     def __eq__(self, other):
@@ -124,13 +126,13 @@ class And(Sentence):
         return set.union(*[conjunct.symbols() for conjunct in self.conjuncts])
 ```
 
-# Or——逻辑和类
+## Or——逻辑和类
 
 ```python
 class Or(Sentence):
     def __init__(self, *disjuncts):
         for disjunct in disjuncts:
-        """验证操作数是否是Sentence或其子类"""
+        """验证操作数是否是 Sentence 或其子类"""
             Sentence.validate(disjunct)
         self.disjuncts = list(disjuncts)
     def __eq__(self, other):
@@ -151,12 +153,12 @@ class Or(Sentence):
         return set.union(*[disjunct.symbols() for disjunct in self.disjuncts])
 ```
 
-# Implication——逻辑蕴含类
+## Implication——逻辑蕴含类
 
 ```python
 class Implication(Sentence):
     def __init__(self, antecedent, consequent):
-        """验证操作数是否是Sentence或其子类"""
+        """验证操作数是否是 Sentence 或其子类"""
         Sentence.validate(antecedent)
         Sentence.validate(consequent)
         """前件"""
@@ -183,12 +185,12 @@ class Implication(Sentence):
         return set.union(self.antecedent.symbols(), self.consequent.symbols())
 ```
 
-# Biconditional——逻辑等值类
+## Biconditional——逻辑等值类
 
 ```python
 class Biconditional(Sentence):
     def __init__(self, left, right):
-        """验证操作数是否是Sentence或其子类"""
+        """验证操作数是否是 Sentence 或其子类"""
         Sentence.validate(left)
         Sentence.validate(right)
         self.left = left
@@ -215,7 +217,7 @@ class Biconditional(Sentence):
         return set.union(self.left.symbols(), self.right.symbols())
 ```
 
-# Model_check()——模型检测算法
+## Model_check()——模型检测算法
 
 ```python
 def model_check(knowledge, query):
@@ -234,7 +236,7 @@ def model_check(knowledge, query):
     def check_all(knowledge, query, symbols, model):
         """检查给定特定模型的知识库是否推理蕴含查询结论。"""
         # 如果模型已经为所有的命题符号赋值
-        if not symbols:  # symbols为空即所有 symbols都在模型中被赋值
+        if not symbols:  # symbols 为空即所有 symbols 都在模型中被赋值
             # 若模型中的知识库为真，则查询结论也必须为真
             if knowledge.evaluate(model):
                 return query.evaluate(model)
@@ -244,10 +246,10 @@ def model_check(knowledge, query):
             # 选择其余未使用的命题符号之一
             remaining = symbols.copy()
             p = remaining.pop()
-            # 创建一个命题符号为true的模型
+            # 创建一个命题符号为 true 的模型
             model_true = model.copy()
             model_true[p] = True
-            # 创建一个命题符号为false的模型
+            # 创建一个命题符号为 false 的模型
             model_false = model.copy()
             model_false[p] = False
             # 确保在两种模型中都进行蕴含推理
@@ -259,7 +261,7 @@ def model_check(knowledge, query):
     return check_all(knowledge, query, symbols, dict())
 ```
 
-# 线索游戏
+## 线索游戏
 
 在游戏中，一个人在某个地点使用工具实施了谋杀。人、工具和地点用卡片表示。每个类别的一张卡片被随机挑选出来，放在一个信封里，由参与者来揭开真相。参与者通过揭开卡片并从这些线索中推断出信封里必须有什么来做到这一点。我们将使用之前的模型检查算法来揭开这个谜团。在我们的模型中，我们将已知与谋杀有关的项目标记为 True，否则标记为 False。
 
@@ -287,7 +289,7 @@ def check_knowledge(knowledge):
         if model_check(knowledge, symbol):
             termcolor.cprint(f"{symbol}: YES", "green")
         elif not model_check(knowledge, Not(symbol)):
-            # 模型检测无法确定知识库可以得出 Not(symbol) 即 symbol是可能的
+            # 模型检测无法确定知识库可以得出 Not(symbol) 即 symbol 是可能的
             print(f"{symbol}: MAYBE")
         else:
             termcolor.cprint(f"{symbol}: No", "red")
@@ -311,21 +313,21 @@ knowledge.add(Not(ballroom))
 check_knowledge(knowledge)
 ```
 
-# Mastermind 游戏
+## Mastermind 游戏
 
 在这个游戏中，玩家一按照一定的顺序排列颜色，然后玩家二必须猜测这个顺序。每一轮，玩家二进行猜测，玩家一返回一个数字，指示玩家二正确选择了多少颜色。让我们用四种颜色模拟一个游戏。假设玩家二猜测以下顺序：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/FZCJbOzr9o4oQPx7SNGcFxTSnRd.png)
+![](https://cdn.xyxsw.site/FZCJbOzr9o4oQPx7SNGcFxTSnRd.png)
 
 玩家一回答“二”。因此，我们知道其中一些两种颜色位于正确的位置，而另两种颜色则位于错误的位置。根据这些信息，玩家二试图切换两种颜色的位置。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Y80wbn96sol7PUxO5fKcOA9Hnbg.png)
+![](https://cdn.xyxsw.site/Y80wbn96sol7PUxO5fKcOA9Hnbg.png)
 
 现在玩家一回答“零”。因此，玩家二知道切换后的颜色最初位于正确的位置，这意味着未被切换的两种颜色位于错误的位置。玩家二切换它们。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/EuXObldHcoaO74xIzZocQQKTn4k.png)
+![](https://cdn.xyxsw.site/EuXObldHcoaO74xIzZocQQKTn4k.png)
 
-在命题逻辑中表示这一点需要我们有(颜色的数量)$^2$个原子命题。所以，在四种颜色的情况下，我们会有命题 red0，red1，red2，red3，blue0…代表颜色和位置。下一步是用命题逻辑表示游戏规则（每个位置只有一种颜色，没有颜色重复），并将它们添加到知识库中。最后一步是将我们所拥有的所有线索添加到知识库中。在我们的案例中，我们会补充说，在第一次猜测中，两个位置是错误的，两个是正确的，而在第二次猜测中没有一个是对的。利用这些知识，模型检查算法可以为我们提供难题的解决方案。
+在命题逻辑中表示这一点需要我们有 (颜色的数量)$^2$个原子命题。所以，在四种颜色的情况下，我们会有命题 red0，red1，red2，red3，blue0…代表颜色和位置。下一步是用命题逻辑表示游戏规则（每个位置只有一种颜色，没有颜色重复），并将它们添加到知识库中。最后一步是将我们所拥有的所有线索添加到知识库中。在我们的案例中，我们会补充说，在第一次猜测中，两个位置是错误的，两个是正确的，而在第二次猜测中没有一个是对的。利用这些知识，模型检查算法可以为我们提供难题的解决方案。
 
 ```python
 from logic import *
@@ -379,9 +381,9 @@ for symbol in symbols:
         print(symbol)
 ```
 
-# Quiz
+## Quiz
 
-1. 下面的问题将问你关于以下逻辑句子的问题。 1.如果 Hermione 在图书馆，那么 Harry 在图书馆。 2.Hermione 在图书馆里。 3.Ron 在图书馆，Ron 不在图书馆。 4.Harry 在图书馆。 5.Harry 不在图书馆，或者 Hermione 在图书馆。 6.Rom 在图书馆，或者 Hermione 在图书馆。
+1. 下面的问题将问你关于以下逻辑句子的问题。1.如果 Hermione 在图书馆，那么 Harry 在图书馆。2.Hermione 在图书馆里。3.Ron 在图书馆，Ron 不在图书馆。4.Harry 在图书馆。5.Harry 不在图书馆，或者 Hermione 在图书馆。6.Rom 在图书馆，或者 Hermione 在图书馆。
 
     以下哪一个逻辑蕴含推理是正确的？
 
@@ -395,21 +397,21 @@ for symbol in symbols:
 2. 除了讲义上讨论的连接词之外，还有其他的逻辑连接词。其中最常见的是“异或”（用符号$\oplus$表示）。表达式$A\oplus B$表示句子“A 或 B，但不是两者都有。”以下哪一个在逻辑上等同于$A\oplus B$？
    1. $(A ∨ B) ∧ ¬ (A ∨ B)$
    2. $(A ∨ B) ∧ (A ∧ B)$
-   3.  $(A ∨ B) ∧ ¬ (A ∧ B)$
-   4.  $(A ∧ B) ∨ ¬ (A ∨ B)$
+   3. $(A ∨ B) ∧ ¬ (A ∧ B)$
+   4. $(A ∧ B) ∨ ¬ (A ∨ B)$
 
-3.  设命题变量$R$为“今天下雨”，变量$C$为“今天多云”，变量$S$ 为“今天晴”。下面哪一个是“如果今天下雨，那么今天多云但不是晴天”这句话的命题逻辑表示？
+3. 设命题变量$R$为“今天下雨”，变量$C$为“今天多云”，变量$S$ 为“今天晴”。下面哪一个是“如果今天下雨，那么今天多云但不是晴天”这句话的命题逻辑表示？
 
-    1.  $(R → C) ∧ ¬S$
-    2.  $R → C → ¬S$
-    3.  $R ∧ C ∧ ¬S$
-    4.  $R → (C ∧ ¬S)$
-    5.  $(C ∨ ¬S) → R$
+    1. $(R → C) ∧ ¬S$
+    2. $R → C → ¬S$
+    3. $R ∧ C ∧ ¬S$
+    4. $R → (C ∧ ¬S)$
+    5. $(C ∨ ¬S) → R$
 
-4.  在一阶逻辑中，考虑以下谓词符号。$Student(x)$表示“x 是学生”的谓词。$Course(x)$代表“x 是课程”的谓词，$Enrolled(x,y)$表示“x 注册了 y”的谓词以下哪一项是“有一门课程是 Harry 和 Hermione 都注册的”这句话的一阶逻辑翻译？
-    1.  $∀x(Course(x)∧Enrolled(Harry, x) ∧ Enrolled(Hermione, x))$
-    2.  $∀x(Enrolled(Harry, x) ∨ Enrolled(Hermione, x))$
-    3.  $∀x(Enrolled(Harry, x) ∧ ∀y Enrolled(Hermione, y))$
-    4.  $∃xEnrolled(Harry, x) ∧ ∃y Enrolled(Hermione, y)$
-    5.  $∃x(Course(x) ∧ Enrolled(Harry, x) ∧ Enrolled(Hermione, x))$
-    6.  $∃x(Enrolled(Harry, x) ∨ Enrolled(Hermione, x))$
+4. 在一阶逻辑中，考虑以下谓词符号。$Student(x)$表示“x 是学生”的谓词。$Course(x)$代表“x 是课程”的谓词，$Enrolled(x,y)$表示“x 注册了 y”的谓词以下哪一项是“有一门课程是 Harry 和 Hermione 都注册的”这句话的一阶逻辑翻译？
+    1. $∀x(Course(x)∧Enrolled(Harry, x) ∧ Enrolled(Hermione, x))$
+    2. $∀x(Enrolled(Harry, x) ∨ Enrolled(Hermione, x))$
+    3. $∀x(Enrolled(Harry, x) ∧ ∀y Enrolled(Hermione, y))$
+    4. $∃xEnrolled(Harry, x) ∧ ∃y Enrolled(Hermione, y)$
+    5. $∃x(Course(x) ∧ Enrolled(Harry, x) ∧ Enrolled(Hermione, x))$
+    6. $∃x(Enrolled(Harry, x) ∨ Enrolled(Hermione, x))$
diff --git a/4.人工智能/4.3.2.2项目：扫雷，骑士与流氓问题.md b/4.人工智能/4.3.2.2项目：扫雷，骑士与流氓问题.md
index 7b0c716..90c4dd5 100644
--- a/4.人工智能/4.3.2.2项目：扫雷，骑士与流氓问题.md
+++ b/4.人工智能/4.3.2.2项目：扫雷，骑士与流氓问题.md
@@ -1,18 +1,19 @@
 # 项目：扫雷，骑士与流氓问题
 
-我们为你提供了两个简单有趣的项目，帮助你进行知识巩固，请认真阅读文档内容。
+::: warning 😋 我们为你提供了两个简单有趣的项目，帮助你进行知识巩固，请认真阅读文档内容。
 
 如果你卡住了，请记得回来阅读文档，或请求身边人的帮助。
+:::
 
 ::: tip 📥
-本节附件下载 <Download url="https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/code/2-Projects.zip"/>
+本节附件下载 <Download url="https://cdn.xyxsw.site/code/2-Projects.zip"/>
 :::
 
 `pip3 install -r requirements.txt`
 
-# 骑士与流氓问题
+## 骑士与流氓问题
 
-## 背景
+### 背景
 
 - 在 1978 年，逻辑学家雷蒙德·斯穆里安（Raymond Smullyan）出版了《这本书叫什么名字？》，这是一本逻辑难题的书。在书中的谜题中，有一类谜题被斯穆里安称为“骑士与流氓”谜题。
 - 在骑士与流氓谜题中，给出了以下信息：每个角色要么是骑士，要么是流氓。骑士总是会说实话：如果骑士陈述了一句话，那么这句话就是真的。相反，流氓总是说谎：如果流氓陈述了一个句子，那么这个句子就是假的。
@@ -21,15 +22,15 @@
 - 从逻辑上讲，我们可以推断，如果 A 是骑士，那么这句话一定是真的。但我们知道这句话不可能是真的，因为 A 不可能既是骑士又是流氓——我们知道每个角色要么是骑士，要么是流氓，不会出现是流氓的骑士或是骑士的流氓。所以，我们可以得出结论，A 一定是流氓。
 - 那个谜题比较简单。随着更多的字符和更多的句子，谜题可以变得更加棘手！你在这个问题中的任务是确定如何使用命题逻辑来表示这些谜题，这样一个运行模型检查算法的人工智能可以为我们解决这些谜题。
 
-## 理解
+### 理解
 
 - 看一下 `logic.py`，你可能还记得讲义的内容。无需了解此文件中的所有内容，但请注意，此文件为不同类型的逻辑连接词定义了多个类。这些类可以相互组合，所以表达式 `And(Not(A), Or(B, C))` 代表逻辑语句：命题 A 是不正确的，同时，命题 B 或者命题 C 是正确的。（这里的“或”是同或，不是异或）
-- 回想一下 `logic.py`，它还包含一个 函数 `model_check` 。`model_check` 输入知识库和查询结论。知识库是一个逻辑命题：如果知道多个逻辑语句，则可以将它们连接在一个表达式中。 递归考虑所有可能的模型，如果知识库推理蕴含查询结论，则返回 `True`，否则返回 `False`。
+- 回想一下 `logic.py`，它还包含一个 函数 `model_check` 。`model_check` 输入知识库和查询结论。知识库是一个逻辑命题：如果知道多个逻辑语句，则可以将它们连接在一个表达式中。递归考虑所有可能的模型，如果知识库推理蕴含查询结论，则返回 `True`，否则返回 `False`。
 - 现在，看看 `puzzle.py`，在顶部，我们定义了六个命题符号。例如，`AKnight` 表示“A 是骑士”的命题，`AKnave` 而表示“A 是流氓”的句子。我们也为字符 B 和 C 定义了类似的命题符号。
 - 接下来是四个不同的知识库 `knowledge0`, `knowledge1`, `knowledge2`, and `knowledge3`，它们将分别包含推断即将到来的谜题 0、1、2 和 3 的解决方案所需的知识。请注意，目前，这些知识库中的每一个都是空的。这就是你进来的地方！
 - 这个 `puzzle.py` 的 `main` 函数在所有谜题上循环，并使用模型检查来计算，给定谜题的知识，无论每个角色是骑士还是无赖，打印出模型检查算法能够得出的任何结论。
 
-## 明确
+### 明确
 
 - 将知识添加到知识库 `knowledge0`, `knowledge1`, `knowledge2`, 和 `knowledge3` 中，以解决以下难题。
 
@@ -62,7 +63,7 @@ C 说：“A 是骑士。”
 - 上述每个谜题中，每个角色要么是骑士，要么是流氓。骑士说的每一句话都是真的，流氓说的每一句话都是假的。
 - 一旦你完成了一个问题的知识库，你应该能够运行 `python puzzle.py` 来查看谜题的解决方案。
 
-## 提示
+### 提示
 
 - 对于每个知识库，你可能想要编码两种不同类型的信息：（1）关于问题本身结构的信息（即骑士与流氓谜题定义中给出的信息），以及（2）关于角色实际说了什么的信息。
 - 考虑一下，如果一个句子是由一个角色说出的，这意味着什么。在什么条件下这句话是真的？在什么条件下这个句子是假的？你如何将其表达为一个合乎逻辑的句子？
@@ -71,36 +72,36 @@ C 说：“A 是骑士。”
   - 例如，对于谜题 0，设置 `knowledge0=AKnave` 将产生正确的输出，因为通过我们自己的推理，我们知道 A 一定是一个无赖。但这样做违背了这个问题的精神：目标是让你的人工智能为你做推理。
 - 您不需要（也不应该）修改 `logic.py` 来完成这个问题。
 
-# 扫雷
+## 扫雷
 
 写一个 AI 来玩扫雷游戏。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/CQmGb6QTjoeyVCx9vjncYF2QnQe.png)
+![](https://cdn.xyxsw.site/CQmGb6QTjoeyVCx9vjncYF2QnQe.png)
 
-## 背景
+### 背景
 
-### 扫雷
+#### 扫雷游戏
 
 - 扫雷器是一款益智游戏，由一个单元格网格组成，其中一些单元格包含隐藏的“地雷”。点击包含地雷的单元格会引爆地雷，导致用户输掉游戏。单击“安全”单元格（即不包含地雷的单元格）会显示一个数字，指示有多少相邻单元格包含地雷，其中相邻单元格是指从给定单元格向左、向右、向上、向下或对角线一个正方形的单元格。
 - 例如，在这个 3x3 扫雷游戏中，三个 1 值表示这些单元格中的每个单元格都有一个相邻的单元格，该单元格是地雷。四个 0 值表示这些单元中的每一个都没有相邻的地雷。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/BcfWbqCNKoXpTHxPQVqczsvcnBd.png)
+![](https://cdn.xyxsw.site/BcfWbqCNKoXpTHxPQVqczsvcnBd.png)
 
 - 给定这些信息，玩家根据逻辑可以得出结论，右下角单元格中一定有地雷，左上角单元格中没有地雷，因为只有在这种情况下，其他单元格上的数字标签才会准确。
 - 游戏的目标是标记（即识别）每个地雷。在游戏的许多实现中，包括本项目中的实现中，玩家可以通过右键单击单元格（或左键双击，具体取决于计算机）来标记地雷。
 
-### 命题逻辑
+#### 命题逻辑
 
 - 你在这个项目中的目标是建立一个可以玩扫雷游戏的人工智能。回想一下，基于知识的智能主体通过考虑他们的知识库来做出决策，并根据这些知识做出推断。
 - 我们可以表示人工智能关于扫雷游戏的知识的一种方法是，使每个单元格成为命题变量，如果单元格包含地雷，则为真，否则为假。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/IROdbJ4zAooiWNxitU9cRovbnne.png)
+![](https://cdn.xyxsw.site/IROdbJ4zAooiWNxitU9cRovbnne.png)
 
 - 我们现在掌握了什么信息？我们现在知道八个相邻的单元格中有一个是地雷。因此，我们可以写一个逻辑表达式，如下所示，表示其中一个相邻的单元格是地雷。
 - `Or(A,B,C,D,E,F,G,H)`
 - 但事实上，我们知道的比这个表达所说的要多。上面的逻辑命题表达了这样一种观点，即这八个变量中至少有一个是真的。但我们可以做一个更有力的陈述：我们知道八个变量中有一个是真的。这给了我们一个命题逻辑命题，如下所示。
 
-```
+```txt
 Or(
     And(A, Not(B), Not(C), Not(D), Not(E), Not(F), Not(G), Not(H)),
     And(Not(A), B, Not(C), Not(D), Not(E), Not(F), Not(G), Not(H)),
@@ -121,19 +122,19 @@ Or(
 
   个可能的模型——太多了，计算机无法在任何合理的时间内计算。对于这个问题，我们需要更好地表达知识。
 
-### 知识表示
+#### 知识表示
 
 - 相反，我们将像下面这样表示人工智能知识的每一句话。
 - `{A, B, C, D, E, F, G, H} = 1`
 - 这种表示法中的每个逻辑命题都有两个部分：一个是网格中与提示数字有关的一组单元格 `cell`，另一个是数字计数 `count`，表示这些单元格中有多少是地雷。上面的逻辑命题说，在单元格 A、B、C、D、E、F、G 和 H 中，正好有 1 个是地雷。
 - 为什么这是一个有用的表示？在某种程度上，它很适合某些类型的推理。考虑下面的游戏。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/UiHObqm4noSOKlxcEtScuwPlnLd.png)
+![](https://cdn.xyxsw.site/UiHObqm4noSOKlxcEtScuwPlnLd.png)
 
 - 利用左下数的知识，我们可以构造命题 `{D，E，G}=0`，意思是在 D、E 和 G 单元中，正好有 0 个是地雷。凭直觉，我们可以从这句话中推断出所有的单元格都必须是安全的。通过推理，每当我们有一个 `count` 为 0 的命题时，我们就知道该命题的所有 `cell` 都必须是安全的。
 - 同样，考虑下面的游戏。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/VSbubz9JYo7H8XxgSbCcmMQHniK.png)
+![](https://cdn.xyxsw.site/VSbubz9JYo7H8XxgSbCcmMQHniK.png)
 
 - 我们的人工智能会构建命题 `{E，F，H}=3`。凭直觉，我们可以推断出所有的 E、F 和 H 都是地雷。更一般地说，任何时候 `cell` 的数量等于 `count`，我们都知道这个命题的所有单元格都必须是地雷。
 - 一般来说，我们只希望我们的命题是关于那些还不知道是安全的还是地雷的 `cell`。这意味着，一旦我们知道一个单元格是否是地雷，我们就可以更新我们的知识库来简化它们，并可能得出新的结论。
@@ -141,23 +142,23 @@ Or(
 - 同样，如果我们的人工智能知道命题 `{A，B，C}＝2`，并且我们被告知 C 是一颗地雷，我们可以从命题中删除 C，并减少计数的值（因为 C 是导致该计数的地雷），从而得到命题 `{A、B}＝1`。这是合乎逻辑的：如果 A、B 和 C 中有两个是地雷，并且我们知道 C 是地雷，那么 A 和 B 中一定有一个是地雷。
 - 如果我们更聪明，我们可以做最后一种推理。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/GsxxbeoPzoOZn4xSUaecVzKNnBc.png)
+![](https://cdn.xyxsw.site/GsxxbeoPzoOZn4xSUaecVzKNnBc.png)
 
 - 考虑一下我们的人工智能根据中间顶部单元格和中间底部单元格会知道的两个命题。从中上角的单元格中，我们得到 `{A，B，C}=1`。从底部中间单元格中，我们得到 `{A，B，C，D，E}=2`。从逻辑上讲，我们可以推断出一个新的知识，即 `{D，E}＝1`。毕竟，如果 A、B、C、D 和 E 中有两个是地雷，而 A、B 和 C 中只有一个是地雷的话，那么 D 和 E 必须是另一个地雷。
 - 更一般地说，任何时候我们有两个命题满足 `set1=count1` 和 `set2=count2`，其中 `set1` 是 `set2` 的子集，那么我们可以构造新的命题 `set2-set1=count2-count1`。考虑上面的例子，以确保你理解为什么这是真的。
 - 因此，使用这种表示知识的方法，我们可以编写一个人工智能智能主体，它可以收集有关扫雷的知识，并希望选择它知道安全的单元格！
 
-## 理解
+### 理解
 
 - 这个项目有两个主要文件：`runner.py` 和 `minesweeper.py`。`minesweeper.py` 包含游戏本身和 AI 玩游戏的所有逻辑。`runner.py` 已经为你实现，它包含了运行游戏图形界面的所有代码。一旦你完成了 `minesweeper.py` 中所有必需的功能，你就可以运行 `python runner.py` 来玩扫雷了（或者让你的 AI 为你玩）！
 - 让我们打开 `minesweeper.py` 来了解提供了什么。这个文件中定义了三个类，`Minesweeper`，负责处理游戏；`Sentence`，表示一个既包含一组 `cell` 又包含一个 `count` 的逻辑命题；以及 `MinesweeperAI`，它处理根据知识做出的推断。
-- `Minesweeper` 类已经完全实现了。请注意，每个单元格都是一对 `(i，j)`，其中 `i` 是行号(范围从 `0` 到 `height-1`)，`j` 是列号(范围从 `0` 到 `width-1`)。
+- `Minesweeper` 类已经完全实现了。请注意，每个单元格都是一对 `(i，j)`，其中 `i` 是行号 (范围从 `0` 到 `height-1`)，`j` 是列号 (范围从 `0` 到 `width-1`)。
 - `Sentence` 类将用于表示背景中描述的形式的逻辑命题。每个命题中都有一组 `cell`，以及 `count` 表示其中有多少单元格是地雷。该类还包含函数 `known_mines` 和 `known_safes`，用于确定命题中的任何单元格是已知的地雷还是已知的安全单元格。它还包含函数 `mark_mine` 和 `mark_safe`，用于响应有关单元格的新信息来更新命题。
 - 最后，`MinesweeperAI` 类将实现一个可以玩扫雷的 AI。AI 类跟踪许多值。`self.moves_made` 包含一组已经点击过的所有单元格，因此人工智能知道不要再选择这些单元格。`self.mines` 包含一组已知为地雷的所有单元格。`self.safes` 包含一组已知安全的所有单元格。而 `self.knowledge` 包含了人工智能知道是真的所有命题的列表。
 - `mark_mine` 函数为 `self.mines` 添加了一个单元格，因此 AI 知道这是一个地雷。它还循环遍历人工智能知识中的所有命题，并通知每个命题该单元格是地雷，这样，如果命题包含有关地雷的信息，它就可以相应地更新自己。`mark_safe` 函数也做同样的事情，只是针对安全单元格。
 - 剩下的函数 `add_knowledge`、`make_safe_move` 和 `make_random_move` 由你完成！
 
-## 明确
+### 明确
 
 - 完成 `minesweeper.py` 中的 `Sentence` 类和 `MinesweeperAI` 类的实现。
 - 在 `Sentence` 类中，完成 `known_mines`、`known_safes`、`mark_mine` 和 `mark_safe` 的实现。
@@ -194,11 +195,11 @@ Or(
   - 此举决不能是已知的地雷行动。
   - 如果无法进行此类移动，则函数应返回 `None`。
 
-## 提示
+### 提示
 
 - 确保你已经彻底阅读了背景部分，以了解知识在这个人工智能中是如何表现的，以及人工智能是如何进行推理的。
-- 如果对面向对象编程感觉不太舒服，你可能会发现<u>python 关于类</u>的文档很有帮助。
-- 你可以在<u>python 关于集合</u>的文档中找到一些常见的集合操作。
+- 如果对面向对象编程感觉不太舒服，你可能会发现[<u>python 关于类</u>](https://docs.python.org/3/tutorial/classes.html)的文档很有帮助。
+- 你可以在[<u>python 关于集合</u>](https://docs.python.org/3/library/stdtypes.html#set)的文档中找到一些常见的集合操作。
 - 在 `Sentence` 类中实现 `known_mines` 和 `known_safes` 时，请考虑：在什么情况下，你确信命题的单元格是安全的？在什么情况下，你确定一个命题的单元格是地雷？
 - `add_knowledge` 做了很多工作，可能是迄今为止你为该项目编写的最长的函数。一步一步地实现此函数的行为可能会有所帮助。
 - 如果愿意，欢迎您向任何类添加新方法，但不应修改任何现有函数的定义或参数。
diff --git a/4.人工智能/4.3.2知识推理.md b/4.人工智能/4.3.2知识推理.md
index 93b3329..780e8a9 100644
--- a/4.人工智能/4.3.2知识推理.md
+++ b/4.人工智能/4.3.2知识推理.md
@@ -1,8 +1,8 @@
 # 知识推理
 
 人类根据现有的知识进行推理并得出结论。表示知识并从中得出结论的概念也被用于人工智能中，在本章中我们将探讨如何实现这种行为。
-::: warning 😱
-# 说好的 AI 呢？怎么感觉越来越偏了？
+
+::: warning <font size=5><strong>说好的 AI 呢？怎么感觉越来越偏了？</strong></font>
 
 如果有这样的疑问的同学，可能存在一定的误区，认为人工智能就是局限在深度学习的算法或者说机器学习的部分算法上，其实这是对这个领域一个巨大的误解。
 
@@ -20,36 +20,37 @@
 
 较为基础的知识各位可以看以下的内容。
 :::
-# 基础知识
 
-- 基于知识的智能主体(Knowledge-Based Agents)
+## 基础知识
+
+- 基于知识的智能主体 (Knowledge-Based Agents)
   - 智能主体通过对内部的知识表征进行操作来推理得出结论。
   - “根据知识推理得出结论”是什么意思？
-  - 让我们开始用哈利波特的例子来回答这个问题。 考虑以下句子：
+  - 让我们开始用哈利波特的例子来回答这个问题。考虑以下句子：
     1. 如果没有下雨，哈利今天会去拜访海格。
     2. 哈利今天拜访了海格或邓布利多，但没有同时拜访他们。
     3. 哈利今天拜访了邓布利多。
   - 基于这三个句子，我们可以回答“今天下雨了吗？”这个问题，尽管没有一个单独的句子告诉我们今天是否下雨，根据推理我们可以得出结论“今天下雨了”。
-- 陈述句(Sentence)
-  - 陈述句是知识表示语言中关于世界的断言。 陈述句是人工智能存储知识并使用它来推断新信息的方式。
+- 陈述句 (Sentence)
+  - 陈述句是知识表示语言中关于世界的断言。陈述句是人工智能存储知识并使用它来推断新信息的方式。
 
-# 命题逻辑(Propositional Logic)
+## 命题逻辑 (Propositional Logic)
 
 命题逻辑基于命题。命题是关于世界的陈述，可以是真也可以是假，正如上面例子中的句子。
 
-- 命题符号(Propositional Symbols)
+- 命题符号 (Propositional Symbols)
   - 命题符号通常是用于表示命题的字母$P、Q、R$
-- 逻辑连接词(Logical Connectives)
+- 逻辑连接词 (Logical Connectives)
   - 逻辑连接词是连接命题符号的逻辑符号，以便以更复杂的方式对世界进行推理。
-  - <strong>Not</strong><strong> </strong><strong>(</strong>$\lnot$<strong>)</strong> 逻辑非: 命题真值的反转。 例如，如果 $P$：“正在下雨”，那么 $¬P$：“没有下雨”。
-    - 真值表用于将所有可能的真值赋值与命题进行比较。 该工具将帮助我们更好地理解与不同逻辑连接词相关联的命题的真值。 例如，下面是我们的第一个真值表：
+  - <strong>Not</strong><strong> </strong><strong>(</strong>$\lnot$<strong>)</strong> 逻辑非：命题真值的反转。例如，如果 $P$：“正在下雨”，那么 $¬P$：“没有下雨”。
+    - 真值表用于将所有可能的真值赋值与命题进行比较。该工具将帮助我们更好地理解与不同逻辑连接词相关联的命题的真值。例如，下面是我们的第一个真值表：
 
     | $P$      | $\lnot P$ |
     | -------- | --------- |
     | false(0) | true(1)   |
     | true(1)  | false(0)  |
 
-- <strong>And(</strong>$\land$<strong>)</strong> 逻辑乘(合取): 连接两个不同的命题。 当这两个命题$P$和$Q$用$∧$连接时，得到的命题$P∧Q$只有在$P$和$Q$都为真的情况下才为真。
+- <strong>And(</strong>$\land$<strong>)</strong> 逻辑乘 (合取): 连接两个不同的命题。当这两个命题$P$和$Q$用$∧$连接时，得到的命题$P∧Q$只有在$P$和$Q$都为真的情况下才为真。
 
   | $P$ | $Q$ | $P\land Q$ |
   | --- | --- | ---------- |
@@ -58,7 +59,7 @@
   | 1   | 0   | 0          |
   | 1   | 1   | 1          |
 
-- <strong>Or(</strong>$\lor$<strong>)</strong> 逻辑和(析取): 只要它的任何一个参数为真，它就为真。 这意味着要使 $P ∨ Q$为真，$P$ 或 $Q$ 中至少有一个必须为真。
+- <strong>Or(</strong>$\lor$<strong>)</strong> 逻辑和 (析取): 只要它的任何一个参数为真，它就为真。这意味着要使 $P ∨ Q$为真，$P$ 或 $Q$ 中至少有一个必须为真。
 
   | $P$ | $Q$ | $P\lor Q$ |
   | --- | --- | --------- |
@@ -67,12 +68,11 @@
   | 1   | 0   | 1         |
   | 1   | 1   | 1         |
 
+  - 值得一提的是，Or 有两种类型：同或 Or 和异或 Or。在异或中，如果$P\lor Q$为真，则$P∧Q$为假。也就是说，一个异或要求它只有一个论点为真，而不要求两者都为真。如果$P、Q$或$P∧Q$中的任何一个为真，则包含或为真。在 Or($\lor$) 的情况下，意图是一个包含的 Or。
 
-  - 值得一提的是，Or有两种类型：同或Or和异或Or。在异或中，如果$P\lor Q$为真，则$P∧Q$为假。也就是说，一个异或要求它只有一个论点为真，而不要求两者都为真。如果$P、Q$或$P∧Q$中的任何一个为真，则包含或为真。在Or($\lor$)的情况下，意图是一个包含的Or。
+- <strong>Implication (→)</strong> 逻辑蕴含：表示“如果$P$，则$Q$的结构。例如，如果$P$：“正在下雨”，$Q$：“我在室内”，则$P→ Q$的意思是“如果下雨，那么我在室内。”在$P$的情况下，意味着$Q$，$P$被称为前件，$Q$ 被称为后件。
 
-- <strong>Implication (→)</strong> 逻辑蕴含: 表示“如果$P$，则$Q$的结构。例如，如果$P$：“正在下雨”，$Q$：“我在室内”，则$P→ Q$的意思是“如果下雨，那么我在室内。”在$P$的情况下，意味着$Q$，$P$被称为前件，$Q$ 被称为后件。
-
-  - 当前件为真时，在后件为真的情况下，整个蕴含逻辑为真（这是有道理的：如果下雨，我在室内，那么“如果下雨，那么我在室内”这句话是真的）。当前件为真时，如果后件为假，则蕴含逻辑为假（如果下雨时我在外面，那么“如果下雨，那么我在室内”这句话是假的）。然而，当前件为假时，无论后件如何，蕴含逻辑总是真的。这有时可能是一个令人困惑的概念。从逻辑上讲，我们不能从蕴含中学到任何东西$(P→ Q)$如果前件($P$)为假。看一下我们的例子，如果没有下雨，这个蕴含逻辑并没有说我是否在室内的问题。我可能是一个室内型的人，即使不下雨也不在外面走，或者我可能是一个室外型的人，不下雨的时候一直在外面。当前件是假的，我们说蕴含逻辑是真的。
+  - 当前件为真时，在后件为真的情况下，整个蕴含逻辑为真（这是有道理的：如果下雨，我在室内，那么“如果下雨，那么我在室内”这句话是真的）。当前件为真时，如果后件为假，则蕴含逻辑为假（如果下雨时我在外面，那么“如果下雨，那么我在室内”这句话是假的）。然而，当前件为假时，无论后件如何，蕴含逻辑总是真的。这有时可能是一个令人困惑的概念。从逻辑上讲，我们不能从蕴含中学到任何东西$(P→ Q)$如果前件 ($P$) 为假。看一下我们的例子，如果没有下雨，这个蕴含逻辑并没有说我是否在室内的问题。我可能是一个室内型的人，即使不下雨也不在外面走，或者我可能是一个室外型的人，不下雨的时候一直在外面。当前件是假的，我们说蕴含逻辑是真的。
 
     | $P$ | $Q$ | $P\to Q$ |
     | --- | --- | -------- |
@@ -90,29 +90,29 @@
   | 1   | 0   | 0                    |
   | 1   | 1   | 1                    |
 
-- 模型(Model)
-  - 模型是对每个命题的真值赋值。 重申一下，命题是关于世界的陈述，可以是真也可以是假。 然而，关于世界的知识体现在这些命题的真值中。 模型是提供有关世界的信息的真值赋值。
-  - 例如，如果 $P$：“正在下雨。” 和 $Q$：“今天是星期二。”，模型可以是以下真值赋值：$\set{P = True, Q = False}$。 此模型表示正在下雨，但不是星期二。 然而，在这种情况下有更多可能的模型（例如，$\set{P = True, Q = True}$，星期二并且下雨）。 事实上，可能模型的数量是命题数量的 2 次方。 在这种情况下，我们有 2 个命题，所以 $2^2=4$ 个可能的模型。
-- 知识库(Knowledge Base (KB))
-  - 知识库是基于知识的智能主题已知的一组陈述句。 这是关于人工智能以命题逻辑语句的形式提供的关于世界的知识，可用于对世界进行额外的推理。
-- 蕴含推理(Entailment ($\vDash$))
+- 模型 (Model)
+  - 模型是对每个命题的真值赋值。重申一下，命题是关于世界的陈述，可以是真也可以是假。然而，关于世界的知识体现在这些命题的真值中。模型是提供有关世界的信息的真值赋值。
+  - 例如，如果 $P$：“正在下雨。”和 $Q$：“今天是星期二。”，模型可以是以下真值赋值：$\set{P = True, Q = False}$。此模型表示正在下雨，但不是星期二。然而，在这种情况下有更多可能的模型（例如，$\set{P = True, Q = True}$，星期二并且下雨）。事实上，可能模型的数量是命题数量的 2 次方。在这种情况下，我们有 2 个命题，所以 $2^2=4$ 个可能的模型。
+- 知识库 (Knowledge Base (KB))
+  - 知识库是基于知识的智能主题已知的一组陈述句。这是关于人工智能以命题逻辑语句的形式提供的关于世界的知识，可用于对世界进行额外的推理。
+- 蕴含推理 (Entailment ($\vDash$))
   - 如果 $α ⊨ β$（$α$蕴含推理出 $β$），那么在任何 $α$为真的世界中，$β$也为真。
-  - 例如，如果 $α$：“今天是一月的星期二”和 $β$：“今天是星期二”，那么我们知道 $α ⊨ β$。 如果确实是一月的星期二，我们也知道这是星期二。 蕴含推理不同于逻辑蕴含。 逻辑蕴涵是两个命题之间的逻辑连接。 另一方面，推理蕴含关系是指如果 $α$中的所有信息都为真，则 $β$中的所有信息都为真。
+  - 例如，如果 $α$：“今天是一月的星期二”和 $β$：“今天是星期二”，那么我们知道 $α ⊨ β$。如果确实是一月的星期二，我们也知道这是星期二。蕴含推理不同于逻辑蕴含。逻辑蕴涵是两个命题之间的逻辑连接。另一方面，推理蕴含关系是指如果 $α$中的所有信息都为真，则 $β$中的所有信息都为真。
 
-# 推理(Inference)
+## 推理 (Inference)
 
 推理是从原有命题推导出新命题的过程。
 
-- 模型检查算法(Model Checking algorithm)
+- 模型检查算法 (Model Checking algorithm)
   - 确定是否$KB ⊨ α$(换句话说，回答问题：“我们能否根据我们的知识库得出结论 $α$为真？”)
     - 枚举所有可能的模型。
     - 如果在 $KB$为真的每个模型中，$α$也为真，则 $KB ⊨ α$。
   - 一个例子
     - $P$: 今天是星期四，$Q$: 今天下雨，$R$: 我将出门跑步$
     - $KB$: 如果今天是星期四并且不下雨，那我将出门跑步；今天是星期四；今天不下雨。$(P\land\lnot Q)\to R,P,\lnot Q$
-    - 查询结论(query): $R$
+    - 查询结论 (query): $R$
 
-      ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/E8YrbXnGtoNHEJxmAttcX4p0nlg.png)
+      ![](https://cdn.xyxsw.site/E8YrbXnGtoNHEJxmAttcX4p0nlg.png)
 
 - 接下来，让我们看看如何将知识和逻辑表示为代码。
 
@@ -126,21 +126,21 @@ knowledge = And(  # 从“和”逻辑连接词开始，因为每个命题都代
 Implication(Not(rain), hagrid),  # ¬(今天下雨) → (哈利拜访了海格)
 Or(hagrid, dumbledore),  # (哈利拜访了海格) ∨ (哈利拜访了邓布利多).
 Not(And(hagrid, dumbledore)),  # ¬(哈利拜访了邓布利多 ∧ 哈利拜访了海格) i.e. 哈利没有同时去拜访海格和邓布利多。
-dumbledore  # 哈利拜访了邓布利多。请注意，虽然之前的命题包含多个带有连接符的符号，但这是一个由一个符号组成的命题。 这意味着我们将在这个 KB 中，Harry 拜访了 Dumbledore 作为事实。
+dumbledore  # 哈利拜访了邓布利多。请注意，虽然之前的命题包含多个带有连接符的符号，但这是一个由一个符号组成的命题。这意味着我们将在这个 KB 中，Harry 拜访了 Dumbledore 作为事实。
 )
 ```
 
 - 要运行模型检查算法，需要以下信息：
 
-  - 知识库(KB)，将用于得出推论
-  - 一个查询结论(query)，或者我们感兴趣的命题是否被$KB$包含
+  - 知识库 (KB)，将用于得出推论
+  - 一个查询结论 (query)，或者我们感兴趣的命题是否被$KB$包含
   - 命题符号，所有使用的符号（或原子命题）的列表（在我们的例子中，这些是 rain、hagrid 和 dumbledore）
   - 模型，将真值和假值分配给命题
 - 模型检查算法如下所示：
 
 ```python
 def check_all(knowledge, query, symbols, model):# 如果模型对每个符号都有一个赋值
-    # (下面的逻辑可能有点混乱：我们从命题符号列表开始。该函数是递归的，每次调用自身时，它都会从命题符号列表中弹出一个命题符号并从中生成模型。 因此，当命题符号列表为空时，我们知道我们已经完成生成模型，其中包含每个可能的命题真值分配。)
+    # (下面的逻辑可能有点混乱：我们从命题符号列表开始。该函数是递归的，每次调用自身时，它都会从命题符号列表中弹出一个命题符号并从中生成模型。因此，当命题符号列表为空时，我们知道我们已经完成生成模型，其中包含每个可能的命题真值分配。)
     if not symbols: 
         # 如果知识库在模型中为真，则查询结论也必须为真
         if knowledge.evaluate(model):
@@ -160,46 +160,46 @@ def check_all(knowledge, query, symbols, model):# 如果模型对每个符号都
         return(check_all(knowledge, query, remaining, model_true) and check_all(knowledge, query, remaining, model_false))
 ```
 
-- 请注意，我们只对$KB$为真的模型感兴趣。 如果$KB$为假，那么我们知道真实的条件并没有出现在这些模型中，使它们与我们的案例无关。
+- 请注意，我们只对$KB$为真的模型感兴趣。如果$KB$为假，那么我们知道真实的条件并没有出现在这些模型中，使它们与我们的案例无关。
 
-> 另一个例子：假设 $P$：Harry 扮演找球手，$Q$：Oliver 扮演守门员，$R$：Gryffindor获胜。 我们的$KB$指定$P$, $Q$, $(P ∧ Q) \to R$。换句话说，我们知道$P$为真，即Harry扮演找球手，$Q$为真，即Oliver扮演守门员，并且如果$P$和$Q$都为真， 那么$R$也为真，这意味着Gryffindor赢得了比赛。 现在想象一个模型，其中Harry扮演击球手而不是找球手(因此，Harry没有扮演找球手，$¬P$)。 嗯，在这种情况下，我们不关心Gryffindor是否赢了(无论$R$是否为真)，因为我们的$KB$中有信息表明Harry扮演的是找球手而不是击球手。 我们只对$P$和$Q$ 为真的模型感兴趣。）
+> 另一个例子：假设 $P$：Harry 扮演找球手，$Q$：Oliver 扮演守门员，$R$：Gryffindor 获胜。我们的$KB$指定$P$, $Q$, $(P ∧ Q) \to R$。换句话说，我们知道$P$为真，即 Harry 扮演找球手，$Q$为真，即 Oliver 扮演守门员，并且如果$P$和$Q$都为真，那么$R$也为真，这意味着 Gryffindor 赢得了比赛。现在想象一个模型，其中 Harry 扮演击球手而不是找球手 (因此，Harry 没有扮演找球手，$¬P$)。嗯，在这种情况下，我们不关心 Gryffindor 是否赢了 (无论$R$是否为真)，因为我们的$KB$中有信息表明 Harry 扮演的是找球手而不是击球手。我们只对$P$和$Q$ 为真的模型感兴趣。）
 
-- 此外，`check_all` 函数的工作方式是递归的。 也就是说，它选择一个命题符号，创建两个模型，其中一个符号为真，另一个为假，然后再次调用自己，现在有两个模型因该命题符号的真值分配不同而不同。 该函数将继续这样做，直到所有符号都已在模型中分配了真值，使 `symbol` 符号为空。 一旦它为空（由 `if not symbols` 行标识），在函数的每个实例中（其中每个实例都包含不同的模型），函数检查$KB$是否为给定的有效模型。 如果$KB$在此模型中为真，函数将检查查询结论是否为真，如前所述。
+- 此外，`check_all` 函数的工作方式是递归的。也就是说，它选择一个命题符号，创建两个模型，其中一个符号为真，另一个为假，然后再次调用自己，现在有两个模型因该命题符号的真值分配不同而不同。该函数将继续这样做，直到所有符号都已在模型中分配了真值，使 `symbol` 符号为空。一旦它为空（由 `if not symbols` 行标识），在函数的每个实例中（其中每个实例都包含不同的模型），函数检查$KB$是否为给定的有效模型。如果$KB$在此模型中为真，函数将检查查询结论是否为真，如前所述。
 
-# 知识工程(Knowledge Engineering)
+## 知识工程 (Knowledge Engineering)
 
 知识工程是弄清楚如何在 AI 中表示命题和逻辑的工程。
 
-## 推理规则(Inference Rules)
+### 推理规则 (Inference Rules)
 
-- 模型检查不是一种有效的算法，因为它必须在给出答案之前考虑每个可能的模型（提醒：如果在$KB$为真的所有模型（真值分配）下，查询结论$R$为真，则$R$ 也为真）。 推理规则允许我们根据现有知识生成新信息，而无需考虑所有可能的模型。
-- 推理规则通常使用将顶部部分（前提）与底部部分（结论）分开的水平条表示。 前提是我们有什么知识，结论是根据这个前提可以产生什么知识。
+- 模型检查不是一种有效的算法，因为它必须在给出答案之前考虑每个可能的模型（提醒：如果在$KB$为真的所有模型（真值分配）下，查询结论$R$为真，则$R$ 也为真）。推理规则允许我们根据现有知识生成新信息，而无需考虑所有可能的模型。
+- 推理规则通常使用将顶部部分（前提）与底部部分（结论）分开的水平条表示。前提是我们有什么知识，结论是根据这个前提可以产生什么知识。
 
-  ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/FjYOb3Qr5ofHdOx7REacdcyqn0c.png)
+  ![](https://cdn.xyxsw.site/FjYOb3Qr5ofHdOx7REacdcyqn0c.png)
 
-- 肯定前件(Modus Ponens)
+- 肯定前件 (Modus Ponens)
 
   - 如果我们知道一个蕴涵及其前件为真，那么后件也为真。
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/HaqObF0xAoX6O8xDX7KctF0jnpf.png)
+    ![](https://cdn.xyxsw.site/HaqObF0xAoX6O8xDX7KctF0jnpf.png)
 
-- 合取消除(And Elimination)
+- 合取消除 (And Elimination)
 
-  - 如果 And 命题为真，则其中的任何一个原子命题也为真。 例如，如果我们知道哈利与罗恩和赫敏是朋友，我们就可以得出结论，哈利与赫敏是朋友。
+  - 如果 And 命题为真，则其中的任何一个原子命题也为真。例如，如果我们知道哈利与罗恩和赫敏是朋友，我们就可以得出结论，哈利与赫敏是朋友。
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/TI5Mb781YocwpqxRsyRcPS8WnAg.png)
+    ![](https://cdn.xyxsw.site/TI5Mb781YocwpqxRsyRcPS8WnAg.png)
 
-- 双重否定消除(Double Negation Elimination)
+- 双重否定消除 (Double Negation Elimination)
 
-  - 被两次否定的命题为真。 例如，考虑命题“哈利没有通过考试是不正确的”。  这两个否定相互抵消，将命题“哈利通过考试”标记为真。
+  - 被两次否定的命题为真。例如，考虑命题“哈利没有通过考试是不正确的”。这两个否定相互抵消，将命题“哈利通过考试”标记为真。
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/NuabbQqZjoBkNixz45AcDZ8Bnrg.png)
+    ![](https://cdn.xyxsw.site/NuabbQqZjoBkNixz45AcDZ8Bnrg.png)
 
-- 蕴含消除(Implication Elimination)
+- 蕴含消除 (Implication Elimination)
 
-  - 蕴涵等价于被否定的前件和后件之间的 Or 关系。 例如，命题“如果正在下雨，哈利在室内”等同于命题“(没有下雨)或(哈利在室内)”。
+  - 蕴涵等价于被否定的前件和后件之间的 Or 关系。例如，命题“如果正在下雨，哈利在室内”等同于命题“(没有下雨) 或 (哈利在室内)”。
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/S31Ub9xcUo9yArxntWscU47pnwh.png)
+    ![](https://cdn.xyxsw.site/S31Ub9xcUo9yArxntWscU47pnwh.png)
 
       | $P$ | $Q$ | $P\to Q$ | $\lnot P\lor Q$ |
       | --- | --- | -------- | --------------- |
@@ -208,31 +208,31 @@ def check_all(knowledge, query, symbols, model):# 如果模型对每个符号都
       | 1   | 0   | 0        | 0               |
       | 1   | 1   | 1        | 1               |
 
-- 等值消除(Biconditional Elimination)
+- 等值消除 (Biconditional Elimination)
 
-  - 等值命题等价于蕴涵及其逆命题的 And 关系。 例如，“当且仅当 Harry 在室内时才下雨”等同于(“如果正在下雨，Harry 在室内”和“如果 Harry 在室内，则正在下雨”)。
+  - 等值命题等价于蕴涵及其逆命题的 And 关系。例如，“当且仅当 Harry 在室内时才下雨”等同于 (“如果正在下雨，Harry 在室内”和“如果 Harry 在室内，则正在下雨”)。
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/EtPMbOXWwopIZsxjUJ0cYvHXn5g.png)
+    ![](https://cdn.xyxsw.site/EtPMbOXWwopIZsxjUJ0cYvHXn5g.png)
 
-- 德摩根律(De Morgan’s Law)
+- 德摩根律 (De Morgan’s Law)
 
-  - 可以将 And 连接词变成 Or 连接词。考虑以下命题：“哈利和罗恩都通过了考试是不正确的。” 由此，可以得出“哈利通过考试不是真的”或者“罗恩不是真的通过考试”的结论。 也就是说，要使前面的 And 命题为真，Or 命题中至少有一个命题必须为真。
+  - 可以将 And 连接词变成 Or 连接词。考虑以下命题：“哈利和罗恩都通过了考试是不正确的。”由此，可以得出“哈利通过考试不是真的”或者“罗恩不是真的通过考试”的结论。也就是说，要使前面的 And 命题为真，Or 命题中至少有一个命题必须为真。
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/GTagbx1jso6l8gx1rQOcPW3inIb.png)
+    ![](https://cdn.xyxsw.site/GTagbx1jso6l8gx1rQOcPW3inIb.png)
 
-  - 同样，可以得出相反的结论。考虑这个命题“哈利或罗恩通过考试是不正确的”。 这可以改写为“哈利没有通过考试”和“罗恩没有通过考试”。
+  - 同样，可以得出相反的结论。考虑这个命题“哈利或罗恩通过考试是不正确的”。这可以改写为“哈利没有通过考试”和“罗恩没有通过考试”。
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/XOeTbb4BooRbKBx4gHwc3A7EnYf.png)
+    ![](https://cdn.xyxsw.site/XOeTbb4BooRbKBx4gHwc3A7EnYf.png)
 
-- 分配律(Distributive Property)
+- 分配律 (Distributive Property)
 
   - 具有两个用 And 或 Or 连接词分组的命题可以分解为由 And 和 Or 组成的更小单元。
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/KBxzbZhUCoX7FBx5ZVFczfPvnoc.png)
+    ![](https://cdn.xyxsw.site/KBxzbZhUCoX7FBx5ZVFczfPvnoc.png)
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/CvPybic63o7jSlxvuzpcFxjQnse.png)
+    ![](https://cdn.xyxsw.site/CvPybic63o7jSlxvuzpcFxjQnse.png)
 
-## 知识和搜索问题
+### 知识和搜索问题
 
 - 推理可以被视为具有以下属性的搜索问题：
 
@@ -243,23 +243,23 @@ def check_all(knowledge, query, symbols, model):# 如果模型对每个符号都
   - 路径成本：证明中的步骤数
 - 这显示了搜索算法的通用性，使我们能够使用推理规则根据现有知识推导出新信息。
 
-# 归结(Resolution)
+## 归结 (Resolution)
 
-- 归结是一个强大的推理规则，它规定如果 Or 命题中的两个原子命题之一为假，则另一个必须为真。 例如，给定命题“Ron 在礼堂”或“Hermione 在图书馆”，除了命题“Ron 不在礼堂”之外，我们还可以得出“Hermione 在图书馆”的结论。 更正式地说，我们可以通过以下方式定义归结：
+- 归结是一个强大的推理规则，它规定如果 Or 命题中的两个原子命题之一为假，则另一个必须为真。例如，给定命题“Ron 在礼堂”或“Hermione 在图书馆”，除了命题“Ron 不在礼堂”之外，我们还可以得出“Hermione 在图书馆”的结论。更正式地说，我们可以通过以下方式定义归结：
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/PBF7bNpPcoTh1bxP4rqcshA5nIg.png)
+    ![](https://cdn.xyxsw.site/PBF7bNpPcoTh1bxP4rqcshA5nIg.png)
 
-    ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/LTKXbs7VPoZxlqxfXfkczFh0nBh.png)
+    ![](https://cdn.xyxsw.site/LTKXbs7VPoZxlqxfXfkczFh0nBh.png)
 
 - 归结依赖于互补文字，两个相同的原子命题，其中一个被否定而另一个不被否定，例如$P$和$¬P$。
-- 归结可以进一步推广。 假设除了“Rom 在礼堂”或“Hermione 在图书馆”的命题外，我们还知道“Rom 不在礼堂”或“Harry 在睡觉”。 我们可以从中推断出“Hermione 在图书馆”或“Harry 在睡觉”。 正式地说：
+- 归结可以进一步推广。假设除了“Rom 在礼堂”或“Hermione 在图书馆”的命题外，我们还知道“Rom 不在礼堂”或“Harry 在睡觉”。我们可以从中推断出“Hermione 在图书馆”或“Harry 在睡觉”。正式地说：
 
-  ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/MebubVSxRonfZ2xnYj9c5TYCnIg.png)
+  ![](https://cdn.xyxsw.site/MebubVSxRonfZ2xnYj9c5TYCnIg.png)
 
-  ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/UZn3b4V8mo1OXxxKDQ0cAjwYnyf.png)
+  ![](https://cdn.xyxsw.site/UZn3b4V8mo1OXxxKDQ0cAjwYnyf.png)
 
-- 互补文字使我们能够通过解析推理生成新句子。 因此，推理算法定位互补文字以生成新知识。
-- 从句(Clause)是多个原子命题的析取式（命题符号或命题符号的否定，例如$P$, $¬P$）。 析取式由Or逻辑连接词 ($P ∨ Q ∨ R$) 相连的命题组成。 另一方面，连接词由And逻辑连接词 ($P ∧ Q ∧ R$) 相连的命题组成。 从句允许我们将任何逻辑语句转换为合取范式 (CNF)，它是从句的合取，例如：$(A ∨ B ∨ C) ∧ (D ∨ ¬E) ∧ (F ∨ G)$。
+- 互补文字使我们能够通过解析推理生成新句子。因此，推理算法定位互补文字以生成新知识。
+- 从句 (Clause) 是多个原子命题的析取式（命题符号或命题符号的否定，例如$P$, $¬P$）。析取式由 Or 逻辑连接词 ($P ∨ Q ∨ R$) 相连的命题组成。另一方面，连接词由 And 逻辑连接词 ($P ∧ Q ∧ R$) 相连的命题组成。从句允许我们将任何逻辑语句转换为合取范式 (CNF)，它是从句的合取，例如：$(A ∨ B ∨ C) ∧ (D ∨ ¬E) ∧ (F ∨ G)$。
 - 命题转换为合取范式的步骤、
 
   - 等值消除
@@ -301,22 +301,22 @@ def check_all(knowledge, query, symbols, model):# 如果模型对每个符号都
     - $(A\lor B)\land\lnot B\vDash A\implies(A ∨ B) ∧ (¬B ∨ C) ∧ (¬C) ∧ (¬A)\land (\lnot B)\land(A)$
     - $(\lnot A\land A)\vDash ()\implies(A ∨ B) ∧ (¬B ∨ C) ∧ (¬C) ∧ (¬A)\land (\lnot B)\land(A)\land ()\implies False$
 
-# 一阶逻辑(First Order Logic)
+## 一阶逻辑 (First Order Logic)
 
 - 一阶逻辑是另一种类型的逻辑，它使我们能够比命题逻辑更简洁地表达更复杂的想法。一阶逻辑使用两种类型的符号：常量符号和谓词符号。常量符号表示对象，而谓词符号类似于接受参数并返回 true 或 false 值的关系或函数。
 - 例如，我们回到霍格沃茨不同的人和家庭作业的逻辑谜题。常量符号是指人或房子，如 Minerva、Pomona、Gryffindor、Hufflepuff 等。谓语符号是一些常量符号的真或虚的属性。例如，我们可以使用句子 `person(Minerva)` 来表达 Minerva 是一个人的想法。同样，我们可以用 `house(Gryffindor)` 这个句子来表达 Gryffindor 是一所房子的想法。所有的逻辑连接词都以与以前相同的方式在一阶逻辑中工作。例如，$\lnot$`House(Minerva)` 表达了 Minerva 不是房子的想法。谓词符号也可以接受两个或多个自变量，并表达它们之间的关系。例如，BelongsTo 表达了两个论点之间的关系，即人和人所属的房子。因此，Minerva 拥有 Gryffindor 的想法可以表达为 `BelongsTo(Minerva，Gryffindor)`。一阶逻辑允许每个人一个符号，每个房子一个符号。这比命题逻辑更简洁，因为命题逻辑中每个人的房屋分配都需要不同的符号。
-- 全称量化(Universal Quantification)
+- 全称量化 (Universal Quantification)
 
   - 量化是一种可以在一阶逻辑中使用的工具，可以在不使用特定常量符号的情况下表示句子。全称量化使用符号$∀$来表示“所有”。例如，$\forall x(BelongsTo(x, Gryffindor) → ¬BelongsTo(x, Hufflepuff))$表达了这样一种观点，即对于每个符号来说，如果这个符号属于 Gryffindor，那么它就不属于 Hufflepuff。
-- 存在量化(Existential Quantification)
+- 存在量化 (Existential Quantification)
 
-  - 存在量化是一个与全称量化平行的概念。然而，虽然全称量化用于创建对所有$x$都成立的句子，但存在量化用于创建至少对一个$x$成立的句子。它使用符号$∃$表示。例如，$∃x(House(x) ∧ BelongsTo(Minerva, x))$ 意味着至少有一个符号既是房子，又是属于 Minerva。换句话说，这表达了Minerva 拥有房子的想法。
+  - 存在量化是一个与全称量化平行的概念。然而，虽然全称量化用于创建对所有$x$都成立的句子，但存在量化用于创建至少对一个$x$成立的句子。它使用符号$∃$表示。例如，$∃x(House(x) ∧ BelongsTo(Minerva, x))$ 意味着至少有一个符号既是房子，又是属于 Minerva。换句话说，这表达了 Minerva 拥有房子的想法。
 - 存在量化和全称量化可以用在同一个句子中。例如，$∀x(Person(x) → (∃y(House(y) ∧ BelongsTo(x, y))))$表达了这样一种观点，即如果$x$是一个人，那么这个人至少拥有一个房子$y$。换句话说，这句话的意思是每个人都拥有一所房子。
 
 还有其他类型的逻辑，它们之间的共同点是，它们都是为了表示信息而存在的。这些是我们用来在人工智能中表示知识的系统。
 
-# 补充材料
+## 补充材料
 
 Introduction to the Theory of Computation, Third International Edition (Michael Sipser)
 
-具体数学：计算机科学基础.第 2 版
+具体数学：计算机科学基础。第 2 版
diff --git a/4.人工智能/4.3.3.1程序示例.md b/4.人工智能/4.3.3.1程序示例.md
index c3b1111..429dc50 100644
--- a/4.人工智能/4.3.3.1程序示例.md
+++ b/4.人工智能/4.3.3.1程序示例.md
@@ -1,13 +1,13 @@
 # 程序示例
+
 ::: tip
 阅读程序，然后“玩一玩”程序！
 
 完成习题
 :::
 
-
 ::: tip 📥
-本节附件下载 <Download url="https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/code/3-Lecture.zip"/>
+本节附件下载 <Download url="https://cdn.xyxsw.site/code/3-Lecture.zip"/>
 :::
 
 本节代码不做额外梳理，[不确定性问题](./4.3.3%E4%B8%8D%E7%A1%AE%E5%AE%9A%E6%80%A7%E9%97%AE%E9%A2%98.md) 中已有解释。
@@ -23,20 +23,18 @@
     6. About 0.327
     7. About 0.5
     8. None of the above
-2.  想象一下，抛出两枚硬币，每枚硬币都有正面和反面，50% 的时间出现正面，50% 的时间出现反面。抛出这两枚硬币后，其中一枚是正面，另一枚是反面的概率是多少？
-    1.  0
-    2.  0.125
-    3.  0.25
-    4.  0.375
-    5.  0.5
-    6.  0.625
-    7.  0.75
-    8.  0.875
-    9.  1
-3.  回答关于贝叶斯网络的问题，问题如下：
-
-  ![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/PUesbhgsFoiucAxWBKYcUUU3nMd.png)
-
+2. 想象一下，抛出两枚硬币，每枚硬币都有正面和反面，50% 的时间出现正面，50% 的时间出现反面。抛出这两枚硬币后，其中一枚是正面，另一枚是反面的概率是多少？
+    1. 0
+    2. 0.125
+    3. 0.25
+    4. 0.375
+    5. 0.5
+    6. 0.625
+    7. 0.75
+    8. 0.875
+    9. 1
+3. 回答关于贝叶斯网络的问题，问题如下：
+  ![](https://cdn.xyxsw.site/PUesbhgsFoiucAxWBKYcUUU3nMd.png)
   以下哪句话是真的？
 
     1. 假设我们知道有轨道维护，那么是否有雨并不影响列车准时到达的概率。
@@ -48,11 +46,11 @@
     1. 0.008
     2. 0.012
     3. 0.024
-    4.  0.028
-    5.  0.02
-    6.  0.06
-    7.  0.12
-    8.  0.2
-    9.  0.429
+    4. 0.028
+    5. 0.02
+    6. 0.06
+    7. 0.12
+    8. 0.2
+    9. 0.429
     10. 0.6
     11. None of the above
diff --git a/4.人工智能/4.3.3.2项目：遗传.md b/4.人工智能/4.3.3.2项目：遗传.md
index 86fb146..df7aa25 100644
--- a/4.人工智能/4.3.3.2项目：遗传.md
+++ b/4.人工智能/4.3.3.2项目：遗传.md
@@ -7,7 +7,7 @@
 :::
 
 ::: tip 📥
-本节附件下载 <Download url="https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/code/3-Projects.zip"/>
+本节附件下载 <Download url="https://cdn.xyxsw.site/code/3-Projects.zip"/>
 :::
 
 ## 背景
@@ -16,7 +16,7 @@
 - 每个孩子都会从他们的父母那里继承一个 GJB2 基因。如果父母有两个变异基因，那么他们会将变异基因传给孩子；如果父母没有变异基因，那么他们不会将变异基因传给孩子；如果父母有一个变异基因，那么该基因传给孩子的概率为 0.5。不过，在基因被传递后，它有一定的概率发生额外的突变：从导致听力障碍的基因版本转变为不导致听力障碍的版本，或者反过来。
 - 我们可以尝试通过对所有相关变量形成一个贝叶斯网络来模拟所有这些关系，就像下面这个网络一样，它考虑了一个由两个父母和一个孩子组成的家庭。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/FNyab3RWQo3EA8xu8T7cyLwhnyh.png)
+![](https://cdn.xyxsw.site/FNyab3RWQo3EA8xu8T7cyLwhnyh.png)
 
 - 家庭中的每个人都有一个 `Gene` 随机变量，代表一个人有多少个特定基因（例如，GJB2 的听力障碍版本）：一个 0、1 或 2 的值。家族中的每个人也有一个 `Trait` 随机变量，它是 `yes` 或 `no`，取决于该人是否表达基于该基因的性状（例如，听力障碍）。从每个人的 `Gene` 变量到他们的 `Trait` 变量之间有一个箭头，以编码一个人的基因影响他们具有特定性状的概率的想法。同时，也有一个箭头从母亲和父亲的 `Gene` 随机变量到他们孩子的 `Gene` 随机变量：孩子的基因取决于他们父母的基因。
 - 你在这个项目中的任务是使用这个模型对人群进行推断。给出人们的信息，他们的父母是谁，以及他们是否具有由特定基因引起的特定可观察特征（如听力损失），你的人工智能将推断出每个人的基因的概率分布，以及任何一个人是否会表现出有关特征的概率分布。
@@ -24,7 +24,7 @@
 ## 理解
 
 - 打开 `data/family0.csv`，看看数据目录中的一个样本数据集（你可以在文本编辑器中打开，或者在 Google Sheets、Excel 或 Apple Numbers 等电子表格应用程序中打开）。注意，第一行定义了这个 CSV 文件的列：`name`, `mother`, `father`, 和 `trait`。下一行表明 Harry 的母亲是 Lily，父亲是 James，而 `Trait` 的空单元格意味着我们不知道 Harry 是否有这种性状。同时，James 在我们的数据集中没有列出父母（如母亲和父亲的空单元格所示），但确实表现出了性状（如 `Trait` 单元格中的 1 所示）。另一方面，Lily 在数据集中也没有列出父母，但没有表现出这种性状（如 `Trait` 单元格中的 0 表示）。
-- 打开 `heredity.py`，首先看一下 `PROBS` 的定义。`PROBS` 是一个包含若干常数的字典，代表各种不同事件的概率。所有这些事件都与一个人拥有多少个特定的突变基因，以及一个人是否基于该基因表现出特定的性状有关。这里的数据松散地基于 GJB2 基因的听力障碍版本和听力障碍性状的概率，但通过改变这些值，你也可以用你的人工智能来推断其他的基因和性状!
+- 打开 `heredity.py`，首先看一下 `PROBS` 的定义。`PROBS` 是一个包含若干常数的字典，代表各种不同事件的概率。所有这些事件都与一个人拥有多少个特定的突变基因，以及一个人是否基于该基因表现出特定的性状有关。这里的数据松散地基于 GJB2 基因的听力障碍版本和听力障碍性状的概率，但通过改变这些值，你也可以用你的人工智能来推断其他的基因和性状！
 - 首先，`PROBS["gene"]` 代表了该基因的无条件概率分布（即如果我们对该人的父母一无所知的概率）。根据分布代码中的数据，在人群中，有 1% 的机会拥有该基因的 2 个副本，3% 的机会拥有该基因的 1 个副本，96% 的机会拥有该基因的零副本。
 - 接下来，`PROBS["trait"]` 表示一个人表现出某种性状（如听力障碍）的条件概率。这实际上是三个不同的概率分布：基因的每个可能值都有一个。因此，`PROBS["trait"][2]` 是一个人在有两个突变基因的情况下具有该特征的概率分布：在这种情况下，他们有 65% 的机会表现出该特征，而有 35% 的机会不表现出该特征。同时，如果一个人有 0 个变异基因，他们有 1% 的机会表现出该性状，99% 的机会不表现出该性状。
 - 最后，`PROBS["mutation"]` 是一个基因从作为相关基因突变为不是该基因的概率，反之亦然。例如，如果一个母亲有两个变异基因，并因此将其中一个传给她的孩子，就有 1% 的机会突变为不再是变异基因。相反，如果一个母亲没有任何变异基因，因此没有把变异基因传给她的孩子，但仍有 1% 的机会突变为变异基因。因此，即使父母双方都没有变异基因，他们的孩子也可能有 1 个甚至 2 个变异基因。
@@ -76,7 +76,7 @@
 ## 一个联合概率例子
 
 - 为了帮助你思考如何计算联合概率，我们在下面附上一个例子。
-- 请考虑以下 `people` 的值:
+- 请考虑以下 `people` 的值：
 
 ```python
 {
@@ -91,7 +91,7 @@
 - 接下来，我们考虑 James。James 有 2 个变异基因，概率为 `0.01`（这是 `PROBS["gene"][2]`）。鉴于他有 2 个变异基因，他确实具有该性状的概率为 `0.65`。因此，他有 2 个变异基因并且他确实具有该性状的概率是 `0.01*0.65=0.0065`。
 - 最后，我们考虑 Harry。Harry 有 1 个变异基因的概率是多少？有两种情况可以发生。要么他从母亲那里得到这个基因，而不是从父亲那里，要么他从父亲那里得到这个基因，而不是从母亲那里。他的母亲 Lily 没有变异基因，所以 Harry 会以 `0.01` 的概率从他母亲那里得到这个基因（这是 `PROBS["mutation"]`），因为从他母亲那里得到这个基因的唯一途径是基因突变；相反，Harry 不会从他母亲那里得到这个基因，概率是 `0.99`。他的父亲 James 有 2 个变异基因，所以 Harry 会以 `0.99` 的概率从他父亲那里得到这个基因（这是 `1-PROBS["mutation"]`），但会以 `0.01` 的概率从他母亲那里得到这个基因（突变的概率）。这两种情况加在一起可以得到 `0.99*0.99+0.01*0.01=0.9802`，即 Harry 有 1 个变异基因的概率。
 - 考虑到 Harry 有 1 个变异基因，他没有该性状的概率是 `0.44`（这是 `PROBS["trait"][1][false]`）。因此，哈利有 1 个变异基因而没有该性状的概率是 `0.9802 * 0.44 = 0.431288`。
-- 因此，整个联合概率是三个人中每个人的所有这些数值相乘的结果: `0.9504 * 0.0065 * 0.431288 = 0.0026643247488`。
+- 因此，整个联合概率是三个人中每个人的所有这些数值相乘的结果：`0.9504 * 0.0065 * 0.431288 = 0.0026643247488`。
 
 ## 提示
 
diff --git a/4.人工智能/4.3.3不确定性问题.md b/4.人工智能/4.3.3不确定性问题.md
index f6ed14a..6966537 100644
--- a/4.人工智能/4.3.3不确定性问题.md
+++ b/4.人工智能/4.3.3不确定性问题.md
@@ -2,7 +2,7 @@
 
 - 上一讲中，我们讨论了人工智能如何表示和推导新知识。然而，在现实中，人工智能往往对世界只有部分了解，这给不确定性留下了空间。尽管如此，我们还是希望我们的人工智能在这些情况下做出尽可能好的决定。例如，在预测天气时，人工智能掌握了今天的天气信息，但无法 100% 准确地预测明天的天气。尽管如此，我们可以做得比偶然更好，今天的讲座是关于我们如何创造人工智能，在有限的信息和不确定性的情况下做出最佳决策。
 
-## 概率(Probability)
+## 概率 (Probability)
 
 - 不确定性可以表示为多个事件以及每一个事件发生的可能性或概率。
 
@@ -12,9 +12,9 @@
 
 ### 概率公理
 
-- $0<P(ω)<1$ ：表示概率的每个值必须在0和1之间。
-  - 0是一个不可能发生的事件，就像掷一个标准骰子并出现7一样。
-  - 1是肯定会发生的事件，比如掷标准骰子，得到的值小于10。
+- $0<P(ω)<1$ ：表示概率的每个值必须在 0 和 1 之间。
+  - 0 是一个不可能发生的事件，就像掷一个标准骰子并出现 7 一样。
+  - 1 是肯定会发生的事件，比如掷标准骰子，得到的值小于 10。
   - 一般来说，值越高，事件发生的可能性就越大。
 - 每一个可能发生的事件的概率加在一起等于 1。
 
@@ -24,19 +24,19 @@ $
 
 - 用标准骰子掷出数字 R 的概率可以表示为 $P(R)$ 。在我们的例子中，$P(R)=1/6$ ，因为有六个可能的世界（从 1 到 6 的任何数字），并且每个世界有相同的可能性发生。现在，考虑掷两个骰子的事件。现在，有 36 个可能的事件，同样有相同的可能性发生。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/GqlRbfW7Yom5a9xKCBHckMBuniF.png)
+![](https://cdn.xyxsw.site/GqlRbfW7Yom5a9xKCBHckMBuniF.png)
 
 - 然而，如果我们试图预测两个骰子的总和，会发生什么？在这种情况下，我们只有 11 个可能的值（总和必须在 2 到 12 之间），而且它们的出现频率并不相同。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Y8EbbcnUsoHHlFxHCrGcIUDNn0f.png)
+![](https://cdn.xyxsw.site/Y8EbbcnUsoHHlFxHCrGcIUDNn0f.png)
 
 - 为了得到事件发生的概率，我们将事件发生的世界数量除以可能发生的世界总数。例如，当掷两个骰子时，有 36 个可能的世界。只有在其中一个世界中，当两个骰子都得到 6 时，我们才能得到 12 的总和。因此，$P(12)＝\frac{1}{36}$，或者，换句话说，掷两个骰子并得到两个和为 12 的数字的概率是$\frac{1}{36}$。$P(7)$是多少？我们数了数，发现和 7 出现在 6 个世界中。因此，$P(7)＝\frac{6}{36}＝\frac{1}{6}$。
 
-### 无条件概率(Unconditional Probability)
+### 无条件概率 (Unconditional Probability)
 
 - 无条件概率是指在没有任何其他证据的情况下对命题发生的概率。到目前为止，我们所问的所有问题都是无条件概率的问题，因为掷骰子的结果并不取决于之前的事件。
 
-## 条件概率(Conditional Probability)
+## 条件概率 (Conditional Probability)
 
 - 条件概率是在给定一些已经揭示的证据的情况下，命题发生的概率。正如引言中所讨论的，人工智能可以利用部分信息对未来进行有根据的猜测。为了使用这些影响事件在未来发生概率的信息，我们需要依赖条件概率。
 - 条件概率用以下符号表示：$P(a|b)$，意思是“如果我们知道事件$b$已经发生，事件$a$发生的概率”，或者更简洁地说，“给定$b$的概率”。现在我们可以问一些问题，比如如果昨天下雨，今天下雨的概率是多少$P(今天下雨 | 昨天下雨)$，或者给定患者的测试结果，患者患有该疾病的概率 $P(疾病 | 测试结果)$ 是多少。
@@ -47,15 +47,15 @@ $P(a\land b)=P(b)P(a|b)$
 
 $P(a\land b)=P(a)P(b|a)$
 
-- 例如，考虑$P(总和为12|在一个骰子上掷出6)$，或者掷两个骰子假设我们已经掷了一个骰子并获得了六，得到十二的概率。为了计算这一点，我们首先将我们的世界限制在第一个骰子的值为六的世界：
+- 例如，考虑$P(总和为 12|在一个骰子上掷出 6)$，或者掷两个骰子假设我们已经掷了一个骰子并获得了六，得到十二的概率。为了计算这一点，我们首先将我们的世界限制在第一个骰子的值为六的世界：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/MkZ6bIPFroAm3lxzLydcsn5QnNg.png)
+![](https://cdn.xyxsw.site/MkZ6bIPFroAm3lxzLydcsn5QnNg.png)
 
 - 现在我们问，在我们将问题限制在（除以$P(6)$，或第一个骰子产生 6 的概率）的世界中，事件 a（和为 12）发生了多少次？
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/XZfhbR6sBorTI9x7hVVchGLUn3b.png)
+![](https://cdn.xyxsw.site/XZfhbR6sBorTI9x7hVVchGLUn3b.png)
 
-## 随机变量(Random Variables)
+## 随机变量 (Random Variables)
 
 - 随机变量是概率论中的一个变量，它有一个可能取值的域。例如，为了表示掷骰子时的可能结果，我们可以定义一个随机变量 Roll，它可以取值$\set{0，1，2，3，4，5，6}$。为了表示航班的状态，我们可以定义一个变量 flight，它采用$\set{准时、延迟、取消}$的值。
 - 通常，我们对每个值发生的概率感兴趣。我们用概率分布来表示这一点。例如：
@@ -69,24 +69,24 @@ $P(Flight=取消)=0.1$
 - 用文字来解释概率分布，这意味着航班准时的可能性为 60%，延误的可能性为 30%，取消的可能性为 10%。注意，如前所述，所有可能结果的概率之和为 1。
 - 概率分布可以更简洁地表示为向量。例如，$P(Flight)=<0.6，0.3，0.1>$。为了便于解释，这些值有一个固定的顺序（在我们的情况下，准时、延迟、取消）。
 
-### 独立性(Independence)
+### 独立性 (Independence)
 
 - 独立性是指一个事件的发生不会影响另一个事件发生的概率。例如，当掷两个骰子时，每个骰子的结果与另一个骰子的结果是独立的。用第一个骰子掷出 4 不会影响我们掷出的第二个骰子的值。这与依赖事件相反，比如早上的云和下午的雨。如果早上多云，下午更有可能下雨，所以这些事件是有依赖性的。
 - 独立性可以用数学定义：事件$a$和$b$是独立的，当且仅当$a$并且$b$的概率等于$a$的概率乘以$b$的概率：$P(a∧b)=P(a)P(b)$。
 
-## 贝叶斯规则(Bayes’ Rule)
+## 贝叶斯规则 (Bayes’Rule)
 
 - 贝叶斯规则在概率论中常用来计算条件概率。换句话说，贝叶斯规则说，给定$b$条件下$a$的概率等于给定$a$的条件下$b$概率，乘以$b$的概率除以$a$ 的概率。
 - $P(b|a)=\frac{P(a|b)P(b)}{P(a)}$
-- 例如，如果早上有云，我们想计算下午下雨的概率，或者$P(雨|云)$。我们从以下信息开始：
+- 例如，如果早上有云，我们想计算下午下雨的概率，或者$P(雨 | 云)$。我们从以下信息开始：
 
-  - 80% 的雨天下午开始于多云的早晨，或$P(云|雨)$。
+  - 80% 的雨天下午开始于多云的早晨，或$P(云 | 雨)$。
   - 40% 的日子早晨多云，或$P(云)$。
   - 10% 的日子有下雨的下午，或$P(雨)$。
 - 应用贝叶斯规则，我们计算$\frac{0.8*0.1}{0.4}=0.2$。也就是说，考虑到早上多云，下午下雨的可能性是 20%。
-- 除了$P(a)$和$P(b)$之外，知道$P(a|b)$还允许我们计算$P(b|a)$。这是有帮助的，因为知道给定未知原因的可见效应的条件概率$P(可见效应|未知原因)$，可以让我们计算给定可见效应的未知原因的概率$P(未知原因|可见效应)$。例如，我们可以通过医学试验来学习$P(医学测试结果|疾病)$，在医学试验中，我们对患有该疾病的人进行测试，并观察测试结果发生的频率。知道了这一点，我们就可以计算出$P(疾病|医学检测结果)$，这是有价值的诊断信息。
+- 除了$P(a)$和$P(b)$之外，知道$P(a|b)$还允许我们计算$P(b|a)$。这是有帮助的，因为知道给定未知原因的可见效应的条件概率$P(可见效应 | 未知原因)$，可以让我们计算给定可见效应的未知原因的概率$P(未知原因 | 可见效应)$。例如，我们可以通过医学试验来学习$P(医学测试结果 | 疾病)$，在医学试验中，我们对患有该疾病的人进行测试，并观察测试结果发生的频率。知道了这一点，我们就可以计算出$P(疾病 | 医学检测结果)$，这是有价值的诊断信息。
 
-## 联合概率(Joint Probability)
+## 联合概率 (Joint Probability)
 
 - 联合概率是指多个事件全部发生的可能性。
 - 让我们考虑下面的例子，关于早上有云，下午有雨的概率。
@@ -107,25 +107,25 @@ $P(Flight=取消)=0.1$
 | C=$\lnot$云 | 0.02 | 0.58         |
 
 - 现在我们可以知道有关这些事件同时发生的信息了。例如，我们知道某一天早上有云，下午有雨的概率是 0.08。早上没有云，下午没有雨的概率是 0.58。
-- 使用联合概率，我们可以推导出条件概率。例如，如果我们感兴趣的是在下午下雨的情况下，早上云层的概率分布。$P(C|雨)=\frac{P(C，雨)}{P(雨)}$旁注：在概率上，逗号和$∧$可以互换使用。因此，$P(C,雨)=P(C\land 雨)$。换句话说，我们将降雨和云层的联合概率除以降雨的概率。
-- 在最后一个方程中，可以将$P(雨)$视为$P(C,雨)$乘以的某个常数$\alpha=\frac{1}{P(雨)}$。因此，我们可以重写$P(C|雨)=\frac{P(C,雨)}{P(雨)}=αP(C,雨)$，或$α<0.08,0.02>=<0.8,0.2>$。考虑到下午有雨，将$α$分解后，我们可以得到 C 的可能值的概率比例。也就是说，如果下午有雨，那么早上有云和早上没有云的概率的比例是$0.08:0.02$。请注意，0.08 和 0.02 的总和不等于 1；然而，由于这是随机变量 C 的概率分布，我们知道它们应该加起来为 1。因此，我们需要通过算$α$来归一化这些值，使得$α0.08+α0.02=1$。最后，我们可以说$P(C|雨)=<0.8,0.2>$。
+- 使用联合概率，我们可以推导出条件概率。例如，如果我们感兴趣的是在下午下雨的情况下，早上云层的概率分布。$P(C|雨)=\frac{P(C，雨)}{P(雨)}$旁注：在概率上，逗号和$∧$可以互换使用。因此，$P(C，雨)=P(C\land 雨)$。换句话说，我们将降雨和云层的联合概率除以降雨的概率。
+- 在最后一个方程中，可以将$P(雨)$视为$P(C，雨)$乘以的某个常数$\alpha=\frac{1}{P(雨)}$。因此，我们可以重写$P(C|雨)=\frac{P(C，雨)}{P(雨)}=αP(C，雨)$，或$α<0.08,0.02>=<0.8,0.2>$。考虑到下午有雨，将$α$分解后，我们可以得到 C 的可能值的概率比例。也就是说，如果下午有雨，那么早上有云和早上没有云的概率的比例是$0.08:0.02$。请注意，0.08 和 0.02 的总和不等于 1；然而，由于这是随机变量 C 的概率分布，我们知道它们应该加起来为 1。因此，我们需要通过算$α$来归一化这些值，使得$α0.08+α0.02=1$。最后，我们可以说$P(C|雨)=<0.8,0.2>$。
 
-## 概率规则(Probability Rules)
+## 概率规则 (Probability Rules)
 
-- 否定(Negation): $P(\lnot a)=1-P(a)$。这源于这样一个事实，即所有可能世界的概率之和为 1，互补事件$\lnot a$和 $a$ 包括所有可能世界。
-- 包含-排除 Inclusion-Exclusion：$P(a\lor b)=P(a)+P(b)-P(a\land b)$。这可以用以下方式解释：$a$或$b$为真的世界等于$a$为真的所有世界，加上$b$为真的所有世界。然而，在这种情况下，有些世界被计算两次（a和$b$都为真的世界）。为了消除这种重叠，我们将$a$和$b$ 都为真的世界减去一次（因为它们被计算了两次）。
+- 否定 (Negation): $P(\lnot a)=1-P(a)$。这源于这样一个事实，即所有可能世界的概率之和为 1，互补事件$\lnot a$和 $a$ 包括所有可能世界。
+- 包含 - 排除 Inclusion-Exclusion：$P(a\lor b)=P(a)+P(b)-P(a\land b)$。这可以用以下方式解释：$a$或$b$为真的世界等于$a$为真的所有世界，加上$b$为真的所有世界。然而，在这种情况下，有些世界被计算两次（a 和$b$都为真的世界）。为了消除这种重叠，我们将$a$和$b$ 都为真的世界减去一次（因为它们被计算了两次）。
 
 > 下面是一个例子，可以说明这一点。假设我 80% 的时间吃冰淇淋，70% 的时间吃饼干。如果我们计算今天我吃冰淇淋或饼干的概率，不减去$P(冰淇淋∧饼干)$，我们错误地得出 0.7+0.8=1.5。这与概率在 0 和 1 之间的公理相矛盾。为了纠正我同时吃冰淇淋和饼干的天数计算两次的错误，我们需要减去$P(冰淇淋∧饼干)$一次。
 
-- 边缘化(Marginalization)：$P(a)=P(a,b)+P(a,\lnot b)$。这里的观点是，$b$和$\lnot b$是独立的概率。也就是说，$b$和$\lnot b$同时发生的概率为0。我们也知道$b$和$\lnot b$的总和为1。因此，当$a$发生时，$b$可以发生也可以不发生。当我们把$a$和$b$发生的概率加上$a$和$\lnot b$的概率时，我们得到的只是$a$ 的概率。
+- 边缘化 (Marginalization)：$P(a)=P(a,b)+P(a,\lnot b)$。这里的观点是，$b$和$\lnot b$是独立的概率。也就是说，$b$和$\lnot b$同时发生的概率为 0。我们也知道$b$和$\lnot b$的总和为 1。因此，当$a$发生时，$b$可以发生也可以不发生。当我们把$a$和$b$发生的概率加上$a$和$\lnot b$的概率时，我们得到的只是$a$ 的概率。
 - 随机变量的边缘化可以用：$P(X=x_i)=\sum_jP(X=x_i,Y=y_j)$表示
-- 方程的左侧表示“随机变量$X$具有$x_i$值的概率” 例如，对于我们前面提到的变量C，两个可能的值是早上有云和早上没有云。等式的正确部分是边缘化的概念。$P(X=x_i)$等于$x_i$以及随机变量$Y$的每一个值的所有联合概率之和。例如，$P(C=云)=P(C=云,R=雨)+P(C=云,R=\lnot 雨)=0.08+0.32=0.4$。
+- 方程的左侧表示“随机变量$X$具有$x_i$值的概率”例如，对于我们前面提到的变量 C，两个可能的值是早上有云和早上没有云。等式的正确部分是边缘化的概念。$P(X=x_i)$等于$x_i$以及随机变量$Y$的每一个值的所有联合概率之和。例如，$P(C=云)=P(C=云，R=雨)+P(C=云，R=\lnot 雨)=0.08+0.32=0.4$。
 
-  - 条件边缘化: $P(a)=P(a|b)P(b)+P(a|\lnot b)P(\lnot b)$。这是一个类似于边缘化的想法。事件$a$发生的概率等于给定$b$的概率乘以$b$的概率，再加上给定$\lnot b$的概率乘以$\lnot b$ 的概率。
+  - 条件边缘化：$P(a)=P(a|b)P(b)+P(a|\lnot b)P(\lnot b)$。这是一个类似于边缘化的想法。事件$a$发生的概率等于给定$b$的概率乘以$b$的概率，再加上给定$\lnot b$的概率乘以$\lnot b$ 的概率。
   - $P(X=x_i)=\sum_jP(X=x_i|Y=y_i)P(Y=y_i)$
   - 在这个公式中，随机变量$X$取$x_i$值概率等于$x_i$以及随机变量$Y$的每个值的联合概率乘以变量$Y$取该值的概率之和。如果我们还记得$P(a|b)=\frac{P(a，b)}{P(b)}$，就可以理解这个公式。如果我们将这个表达式乘以$P(b)$，我们得到$P(a,b)$，从这里开始，我们做的与边缘化相同。
 
-## 贝叶斯网络(Bayesian Networks)
+## 贝叶斯网络 (Bayesian Networks)
 
 - 贝叶斯网络是一种表示随机变量之间相关性的数据结构。贝叶斯网络具有以下属性：
 
@@ -135,7 +135,7 @@ $P(Flight=取消)=0.1$
   - 每个节点 X 具有概率分布$P(X|Parents(X))$。
 - 让我们考虑一个贝叶斯网络的例子，该网络包含影响我们是否按时赴约的随机变量。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/GKc6be6ueopUYZxxQg4cS4AVnmb.png)
+![](https://cdn.xyxsw.site/GKc6be6ueopUYZxxQg4cS4AVnmb.png)
 
 - 让我们从上到下描述这个贝叶斯网络：
 
@@ -145,9 +145,7 @@ $P(Flight=取消)=0.1$
 | ---- | ----- | ----- |
 | 0.7  | 0.2   | 0.1   |
 
-
-- Maintenance对是否有列车轨道维护进行编码，取值为$\set{yes，no}$。Rain是Maintenance的父节点，这意味着Maintenance概率分布受到Rain的影响。
-
+- Maintenance 对是否有列车轨道维护进行编码，取值为$\set{yes，no}$。Rain 是 Maintenance 的父节点，这意味着 Maintenance 概率分布受到 Rain 的影响。
 
 | R     | yes | no  |
 | ----- | --- | --- |
@@ -155,9 +153,7 @@ $P(Flight=取消)=0.1$
 | light | 0.2 | 0.8 |
 | heavy | 0.1 | 0.9 |
 
-
-- Train是一个变量，用于编码列车是准时还是晚点，取值为$\set{on\ time，delayed}$。请注意，列车上被“Maintenance”和“rain”指向。这意味着两者都是Train的父对象，它们的值会影响Train的概率分布。
-
+- Train 是一个变量，用于编码列车是准时还是晚点，取值为$\set{on\ time，delayed}$。请注意，列车上被“Maintenance”和“rain”指向。这意味着两者都是 Train 的父对象，它们的值会影响 Train 的概率分布。
 
 | R      | M   | On time | Delayed |
 | ------ | --- | ------- | ------- |
@@ -168,45 +164,41 @@ $P(Flight=取消)=0.1$
 | heavry | yes | 0.4     | 0.6     |
 | heavy  | no  | 0.5     | 0.5     |
 
-
-- Appointment 是一个随机变量，表示我们是否参加约会，取值为$\set{attend, miss}$。请注意，它唯一的父级是Train。关于贝叶斯网络的这一点值得注意：父子只包括直接关系。的确，Maintenance会影响Train是否准时，而Train是否准时会影响我们是否赴约。然而，最终，直接影响我们赴约机会的是Train是否准时，这就是贝叶斯网络所代表的。例如，如果火车准时到达，可能会有大雨和轨道维护，但这对我们是否赴约没有影响。
-
+- Appointment 是一个随机变量，表示我们是否参加约会，取值为$\set{attend, miss}$。请注意，它唯一的父级是 Train。关于贝叶斯网络的这一点值得注意：父子只包括直接关系。的确，Maintenance 会影响 Train 是否准时，而 Train 是否准时会影响我们是否赴约。然而，最终，直接影响我们赴约机会的是 Train 是否准时，这就是贝叶斯网络所代表的。例如，如果火车准时到达，可能会有大雨和轨道维护，但这对我们是否赴约没有影响。
 
 | T       | attend | miss |
 | ------- | ------ | ---- |
 | on time | 0.9    | 0.1  |
 | delayed | 0.6    | 0.4  |
 
-
 - 例如，如果我们想找出在没有维护和小雨的一天火车晚点时错过约会的概率，或者$P(light,no,delayed,miss)$，我们将计算如下：$P(light)P(no|light)P(delayed|light,no)P(miss|delayed)$。每个单独概率的值可以在上面的概率分布中找到，然后将这些值相乘以产生$P(light,no,delayed,miss)$。
 
-
-### 推理(Inference)
+### 推理 (Inference)
 
 - 在知识推理，我们通过蕴含来看待推理。这意味着我们可以在现有信息的基础上得出新的信息。我们也可以根据概率推断出新的信息。虽然这不能让我们确切地知道新的信息，但它可以让我们计算出一些值的概率分布。推理具有多个属性。
 - Query 查询变量 $X$：我们要计算概率分布的变量。
 - Evidence variables 证据变量$E$: 一个或多个观测到事件$e$ 的变量。例如，我们可能观测到有小雨，这一观测有助于我们计算火车延误的概率。
 - Hidden variables 隐藏变量 $H$: 不是查询结论的变量，也没有被观测到。例如，站在火车站，我们可以观察是否下雨，但我们不知道道路后面的轨道是否有维修。因此，在这种情况下，Maintenance 将是一个隐藏的变量。
-- The goal 目标: 计算$P(X|e)$。例如，根据我们知道有小雨的证据 $e$ 计算 Train 变量(查询)的概率分布。
+- The goal 目标：计算$P(X|e)$。例如，根据我们知道有小雨的证据 $e$ 计算 Train 变量 (查询) 的概率分布。
 - 举一个例子。考虑到有小雨和没有轨道维护的证据，我们想计算 Appointment 变量的概率分布。也就是说，我们知道有小雨，没有轨道维护，我们想弄清楚我们参加约会和错过约会的概率是多少，$P(Appointment|light,no)$。从联合概率部分中，我们知道我们可以将约会随机变量的可能值表示为一个比例，将$P(Appointment|light,no)$重写为$αP(Appointment,light,no)$。如果 Appointment 的父节点仅为 Train 变量，而不是 Rain 或 Maintenance，我们如何计算约会的概率分布？在这里，我们将使用边缘化。$P(Appointment,light,no)$的值等于$α[P(Appointment,light,no,delay)+P(Appointment,light,no,on\ time)]$。
 
 ### 枚举推理
 
 - 枚举推理是在给定观测证据$e$和一些隐藏变量$Y$的情况下，找到变量$X$ 的概率分布的过程。
 - $P(X|e)=\alpha P(X,e)=\alpha \sum_yP(X,e,y)$
-- 在这个方程中，$X$代表查询变量，$e$代表观察到的证据，$y$代表隐藏变量的所有值，$α$归一化结果，使我们最终得到的概率加起来为1。用文字来解释这个方程，即给定$e$的$X$的概率分布等于$X$和$e$的归一化概率分布。为了得到这个分布，我们对$X、e$和$y$的归一化概率求和，其中$y$每次取隐藏变量$Y$ 的不同值。
+- 在这个方程中，$X$代表查询变量，$e$代表观察到的证据，$y$代表隐藏变量的所有值，$α$归一化结果，使我们最终得到的概率加起来为 1。用文字来解释这个方程，即给定$e$的$X$的概率分布等于$X$和$e$的归一化概率分布。为了得到这个分布，我们对$X、e$和$y$的归一化概率求和，其中$y$每次取隐藏变量$Y$ 的不同值。
 - Python 中存在多个库，以简化概率推理过程。我们将查看库 `pomegranate`，看看如何在代码中表示上述数据。
 
 ```python
 from pomegranate import *
 '''创建节点，并为每个节点提供概率分布'''
-# Rain节点没有父节点
+# Rain 节点没有父节点
 rain = Node(DiscreteDistribution({
     "none": 0.7,
     "light": 0.2,
     "heavy": 0.1
 }), name="rain")
-# Track maintenance节点以rain为条件
+# Track maintenance 节点以 rain 为条件
 maintenance = Node(ConditionalProbabilityTable([
     ["none", "yes", 0.4],
     ["none", "no", 0.6],
@@ -215,7 +207,7 @@ maintenance = Node(ConditionalProbabilityTable([
     ["heavy", "yes", 0.1],
     ["heavy", "no", 0.9]
 ], [rain.distribution]), name="maintenance")
-# Train node节点以rain和maintenance为条件
+# Train node 节点以 rain 和 maintenance 为条件
 train = Node(ConditionalProbabilityTable([
     ["none", "yes", "on time", 0.8],
     ["none", "yes", "delayed", 0.2],
@@ -230,7 +222,7 @@ train = Node(ConditionalProbabilityTable([
     ["heavy", "no", "on time", 0.5],
     ["heavy", "no", "delayed", 0.5],
 ], [rain.distribution, maintenance.distribution]), name="train")
-# Appointment节点以列车为条件
+# Appointment 节点以列车为条件
 appointment = Node(ConditionalProbabilityTable([
     ["on time", "attend", 0.9],
     ["on time", "miss", 0.1],
@@ -252,7 +244,7 @@ model.bake()
 # 计算给定观测的概率
 probability = model.probability([["none", "no", "on time", "attend"]])
 print(probability)
-'''我们可以使用该模型为所有变量提供概率分布，给出一些观测到的证据。在以下情况下，我们知道火车晚点了。给定这些信息，我们计算并打印变量Rain、Maintenance和Appointment的概率分布。'''
+'''我们可以使用该模型为所有变量提供概率分布，给出一些观测到的证据。在以下情况下，我们知道火车晚点了。给定这些信息，我们计算并打印变量 Rain、Maintenance 和 Appointment 的概率分布。'''
 # 根据火车晚点的证据计算预测
 predictions = model.predict_proba({
     "train": "delayed"
@@ -271,7 +263,7 @@ for node, prediction in zip(model.states, predictions):
 
 - 上面的代码使用了枚举推理。然而，这种计算概率的方法效率很低，尤其是当模型中有很多变量时。另一种方法是放弃精确推理，转而采用近似推理。这样做，我们在生成的概率中会失去一些精度，但这种不精确性通常可以忽略不计。相反，我们获得了一种可扩展的概率计算方法。
 
-### 采样(Sampling)
+### 采样 (Sampling)
 
 - 采样是一种近似推理技术。在采样中，根据每个变量的概率分布对其值进行采样。
 
@@ -279,28 +271,30 @@ for node, prediction in zip(model.states, predictions):
 
 - 如果我们从对 Rain 变量进行采样开始，则生成的值 none 的概率为 0.7，生成的值 light 的概率为 0.2，而生成的值 heavy 的概率则为 0.1。假设我们的采样值为 none。当我们得到 Maintenance 变量时，我们也会对其进行采样，但只能从 Rain 等于 none 的概率分布中进行采样，因为这是一个已经采样的结果。我们将通过所有节点继续这样做。现在我们有一个样本，多次重复这个过程会生成一个分布。现在，如果我们想回答一个问题，比如什么是$P(Train=on\ time)$，我们可以计算变量 Train 具有准时值的样本数量，并将结果除以样本总数。通过这种方式，我们刚刚生成了$P(Train=on\ {time})$的近似概率。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/CreObGAg4oXB0oxe2hMcQbYZnAc.png)
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Vr96bdSafoV4kBxJ3x2cAU0TnOg.png)
+<table>
+    <tr>
+        <td><img src=https://cdn.xyxsw.site/CreObGAg4oXB0oxe2hMcQbYZnAc.png width=520></td>
+        <td><img src=https://cdn.xyxsw.site/Vr96bdSafoV4kBxJ3x2cAU0TnOg.png width=520></td>
+    </tr>
+</table>
 
 - 我们也可以回答涉及条件概率的问题，例如$P(rain=light|train=on\ {time})$。在这种情况下，我们忽略 Train 值为 delay 的所有样本，然后照常进行。我们计算在$Train=\text{on time}$的样本中有多少样本具有变量$Rain=light$，然后除以$Train=\text{on time}$的样本总数。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/KsELbuMTCoKZkGxU9U5czQpanKg.png)
+<table>
+    <tr>
+        <td><img src=https://cdn.xyxsw.site/KsELbuMTCoKZkGxU9U5czQpanKg.png width=520></td>
+        <td><img src=https://cdn.xyxsw.site/MrP0b2FbXofDsOxgnmncufUynAB.png width=520></td>
+    </tr>
+</table>
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/MrP0b2FbXofDsOxgnmncufUynAB.png)
-
-去除$T= on time$的样本
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Ilj3bPKuwo0l6Dx13rZcVXfenOb.png)
-
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/AptYbb5MZoylvex7LvPcSqivnef.png)
-
-选择$R=light$的样本
+| 去除$T= on time$的样本 | 选择$R=light$的样本 |
+| --------------------- | ------------------ |
+| ![](https://cdn.xyxsw.site/Ilj3bPKuwo0l6Dx13rZcVXfenOb.png) | ![](https://cdn.xyxsw.site/AptYbb5MZoylvex7LvPcSqivnef.png) |
 
 - 在代码中，采样函数可以是 `generate_sample`：
 
 ```python
-'''如果你对pomegrante库不熟悉，没有关系，考虑generate_sample为一个黑盒，或者你可以在python解释器中查看model.states, state.distribution的值以了解model在该库中的实现方式'''
+'''如果你对 pomegrante 库不熟悉，没有关系，考虑 generate_sample 为一个黑盒，或者你可以在 python 解释器中查看 model.states, state.distribution 的值以了解 model 在该库中的实现方式'''
 import pomegranate
 from collections import Counter
 def generate_sample():
@@ -321,17 +315,17 @@ def generate_sample():
     # 返回生成的样本
     return sample
 # 采样
-# 观测到train=delay，计算appointment分布
+# 观测到 train=delay，计算 appointment 分布
 N = 10000
 data = []
-# 重复采样10000次
+# 重复采样 10000 次
 for i in range(N):
     # 根据我们之前定义的函数生成一个样本
     sample = generate_sample()
-    # 如果在该样本中，Train的变量的值为delay，则保存样本。由于我们对给定train=delay的appointment概率分布感兴趣，我们丢弃了train=on time的采样样本。
+    # 如果在该样本中，Train 的变量的值为 delay，则保存样本。由于我们对给定 train=delay 的 appointment 概率分布感兴趣，我们丢弃了 train=on time 的采样样本。
     if sample["train"] == "delayed":
         data.append(sample["appointment"])
-# 计算变量的每个值出现的次数。我们可以稍后通过将结果除以保存的样本总数来进行归一化，以获得变量的近似概率，该概率加起来为1。
+# 计算变量的每个值出现的次数。我们可以稍后通过将结果除以保存的样本总数来进行归一化，以获得变量的近似概率，该概率加起来为 1。
 print(Counter(data))
 ```
 
@@ -341,27 +335,27 @@ print(Counter(data))
 
   - 首先固定证据变量的值。
   - 使用贝叶斯网络中的条件概率对非证据变量进行采样。
-  - 根据其可能性对每个样本进行加权: 所有证据出现的概率。
+  - 根据其可能性对每个样本进行加权：所有证据出现的概率。
 - 例如，如果我们观察到$Train=\text{on time}$，我们将像之前一样开始采样。我们对给定概率分布的 Rain 值进行采样，然后对 Maintenance 进行采样，但当我们到达 Train 时，我们总是按照观测值取值。然后，我们继续进行，并在给定$Train=\text{on time}$的情况下，根据其概率分布对 Appointment 进行采样。既然这个样本存在，我们就根据观察到的变量在给定其采样父变量的情况下的条件概率对其进行加权。也就是说，如果我们采样了 Rain 并得到了 light，然后我们采样了 Maintenance 并得到了 yes，那么我们将用$P(Train=\text{on time}|light,yes)$来加权这个样本。
 
-## 马尔科夫模型(Markov Models)
+## 马尔科夫模型 (Markov Models)
 
 - 到目前为止，我们已经研究了概率问题，给出了我们观察到的一些信息。在这种范式中，时间的维度没有以任何方式表示。然而，许多任务确实依赖于时间维度，例如预测。为了表示时间变量，我们将创建一个新的变量$X$，并根据感兴趣的事件对其进行更改，使$X_t$ 是当前事件，$X_{t+1}$ 是下一个事件，依此类推。为了能够预测未来的事件，我们将使用马尔可夫模型。
 
-### 马尔科夫假设(<strong>The Markov Assumption</strong>)
+### 马尔科夫假设 (<strong>The Markov Assumption</strong>)
 
 - 马尔科夫假设是一个假设，即当前状态只取决于有限的固定数量的先前状态。想想预测天气的任务。在理论上，我们可以使用过去一年的所有数据来预测明天的天气。然而，这是不可行的，一方面是因为这需要计算能力，另一方面是因为可能没有关于基于 365 天前天气的明天天气的条件概率的信息。使用马尔科夫假设，我们限制了我们以前的状态（例如，在预测明天的天气时，我们要考虑多少个以前的日子），从而使这个任务变得可控。这意味着我们可能会得到感兴趣的概率的一个更粗略的近似值，但这往往足以满足我们的需要。此外，我们可以根据最后一个事件的信息来使用马尔可夫模型（例如，根据今天的天气来预测明天的天气）。
 
-### 马尔科夫链(<strong>Markov Chain</strong>)
+### 马尔科夫链 (<strong>Markov Chain</strong>)
 
 - 马尔科夫链是一个随机变量的序列，每个变量的分布都遵循马尔科夫假设。也就是说，链中的每个事件的发生都是基于之前事件的概率。
 - 为了构建马尔可夫链，我们需要一个过渡模型，该模型将根据当前事件的可能值来指定下一个事件的概率分布。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/VBGxbrNgAovuKXxnTKYcm7UinFd.png)
+![](https://cdn.xyxsw.site/VBGxbrNgAovuKXxnTKYcm7UinFd.png)
 
 - 在这个例子中，基于今天是晴天，明天是晴天的概率是 0.8。这是合理的，因为晴天之后更可能是晴天。然而，如果今天是雨天，明天下雨的概率是 0.7，因为雨天更有可能相继出现。使用这个过渡模型，可以对马尔可夫链进行采样。从一天是雨天或晴天开始，然后根据今天的天气，对第二天的晴天或雨天的概率进行采样。然后，根据明天的情况对后天的概率进行采样，以此类推，形成马尔科夫链：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/XBghbKBaVoz0C4xa85rch804ngd.png)
+![](https://cdn.xyxsw.site/XBghbKBaVoz0C4xa85rch804ngd.png)
 
 - 给定这个马尔可夫链，我们现在可以回答诸如“连续四个雨天的概率是多少？”这样的问题。下面是一个如何在代码中实现马尔可夫链的例子：
 
@@ -381,20 +375,20 @@ transitions = ConditionalProbabilityTable([
 ], [start])
 # 创造马尔科夫链
 model = MarkovChain([start, transitions])
-# 采样50次
+# 采样 50 次
 print(model.sample(50))
 ```
 
-## 隐马尔科夫模型(Hidden Markov Models)
+## 隐马尔科夫模型 (Hidden Markov Models)
 
 - 隐马尔科夫模型是一种具有隐藏状态的系统的马尔科夫模型，它产生了一些观察到的事件。这意味着，有时候，人工智能对世界有一些测量，但无法获得世界的精确状态。在这些情况下，世界的状态被称为隐藏状态，而人工智能能够获得的任何数据都是观察结果。下面是一些这方面的例子：
 
   - 对于一个探索未知领域的机器人来说，隐藏状态是它的位置，而观察是机器人的传感器所记录的数据。
   - 在语音识别中，隐藏状态是所讲的话语，而观察是音频波形。
   - 在衡量网站的用户参与度时，隐藏的状态是用户的参与程度，而观察是网站或应用程序的分析。
-- 举个例子。我们的人工智能想要推断天气(隐藏状态)，但它只能接触到一个室内摄像头，记录有多少人带了雨伞。这里是我们的传感器模型(sensor model)，表示了这些概率：
+- 举个例子。我们的人工智能想要推断天气 (隐藏状态)，但它只能接触到一个室内摄像头，记录有多少人带了雨伞。这里是我们的传感器模型 (sensor model)，表示了这些概率：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/E0TtbfgiCoV2dtxbbPHcjPgXnQe.png)
+![](https://cdn.xyxsw.site/E0TtbfgiCoV2dtxbbPHcjPgXnQe.png)
 
 - 在这个模型中，如果是晴天，人们很可能不会带伞到大楼。如果是雨天，那么人们就很有可能带伞到大楼来。通过对人们是否带伞的观察，我们可以合理地预测外面的天气情况。
 
@@ -403,7 +397,7 @@ print(model.sample(50))
 - 假设证据变量只取决于相应的状态。例如，对于我们的模型，我们假设人们是否带雨伞去办公室只取决于天气。这不一定反映了完整的事实，因为，比如说，比较自觉的、不喜欢下雨的人可能即使在阳光明媚的时候也会到处带伞，如果我们知道每个人的个性，会给模型增加更多的数据。然而，传感器马尔科夫假设忽略了这些数据，假设只有隐藏状态会影响观察。
 - 隐马尔科夫模型可以用一个有两层的马尔科夫链来表示。上层，变量$X$，代表隐藏状态。底层，变量$E$，代表证据，即我们所拥有的观察。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/FnyrbYSEWohimaxIYPSchotGnse.png)
+![](https://cdn.xyxsw.site/FnyrbYSEWohimaxIYPSchotGnse.png)
 
 - 基于隐马尔科夫模型，可以实现多种任务：
 
@@ -440,7 +434,7 @@ model = HiddenMarkovModel.from_matrix(
 model.bake()
 ```
 
-- 请注意，我们的模型同时具有传感器模型和过渡模型。对于隐马尔可夫模型，我们需要这两个模型。在下面的代码片段中，我们看到了人们是否带伞到大楼的观察序列，根据这个序列，我们将运行模型，它将生成并打印出最可能的解释(即最可能带来这种观察模式的天气序列):
+- 请注意，我们的模型同时具有传感器模型和过渡模型。对于隐马尔可夫模型，我们需要这两个模型。在下面的代码片段中，我们看到了人们是否带伞到大楼的观察序列，根据这个序列，我们将运行模型，它将生成并打印出最可能的解释 (即最可能带来这种观察模式的天气序列):
 
 ```python
 from model import model
diff --git a/4.人工智能/4.3人工智能导论及机器学习入门.md b/4.人工智能/4.3人工智能导论及机器学习入门.md
index 09e1ce2..27299ac 100644
--- a/4.人工智能/4.3人工智能导论及机器学习入门.md
+++ b/4.人工智能/4.3人工智能导论及机器学习入门.md
@@ -6,7 +6,7 @@
 
 人工智能是一个宏大的愿景，目标是让机器像我们人类一样思考和行动，既包括增强我们人类脑力也包括增强我们体力的研究领域。而学习只是实现人工智能的手段之一，并且，只是增强我们人类脑力的方法之一。所以，人工智能包含机器学习。机器学习又包含了深度学习，他们三者之间的关系见下图。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/AMU7bSgh4o8tEIxk82icvtbDn0c.png)
+![](https://cdn.xyxsw.site/AMU7bSgh4o8tEIxk82icvtbDn0c.png)
 
 # 如何学习本节内容
 
diff --git a/4.人工智能/4.4FAQ：常见问题.md b/4.人工智能/4.4FAQ：常见问题.md
index e0b774b..b0f600f 100644
--- a/4.人工智能/4.4FAQ：常见问题.md
+++ b/4.人工智能/4.4FAQ：常见问题.md
@@ -42,23 +42,19 @@
 
 机器学习包括深度学习
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnBP4QHAJnXrNfOiK8hp6LIc.png)
+![](https://cdn.xyxsw.site/boxcnBP4QHAJnXrNfOiK8hp6LIc.png)
 
 [同时向你推荐这个 Data Analytics，Data Analysis，数据挖掘，数据科学，机器学习，大数据的区别是什么？](https://www.quora.com/What-is-the-difference-between-Data-Analytics-Data-Analysis-Data-Mining-Data-Science-Machine-Learning-and-Big-Data-1)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnxPsUwwhcCC0zBerZ2s88ld.png)
+![](https://cdn.xyxsw.site/boxcnxPsUwwhcCC0zBerZ2s88ld.png)
 
 ## 我没有任何相关概念
 
 尝试阅读以下内容
 
 - [形象的机器学习简介](http://www.r2d3.us/visual-intro-to-machine-learning-part-1/)
-- [一份温柔的机器学习指南](https://blog.monkeylearn.com/a-gentle-guide-to-machine-learning/)
 - [为开发者准备的机器学习简介](http://blog.algorithmia.com/introduction-machine-learning-developers/)
 - [菜鸟的机器学习基础](https://www.analyticsvidhya.com/blog/2015/06/machine-learning-basics/)
 - [你如何向非计算机专业的人来解释机器学习与数据挖掘？](https://www.quora.com/How-do-you-explain-Machine-Learning-and-Data-Mining-to-non-Computer-Science-people)
 - [在罩子下的机器学习，博文简单明了地介绍了机器学习的原理](https://georgemdallas.wordpress.com/2013/06/11/big-data-data-mining-and-machine-learning-under-the-hood/)
 - [机器学习是什么？它是如何工作的呢？](https://www.youtube.com/watch?v=elojMnjn4kk&list=PL5-da3qGB5ICeMbQuqbbCOQWcS6OYBr5A&index=1)
-- [深度学习——一份非技术性的简介](http://www.slideshare.net/AlfredPong1/deep-learning-a-nontechnical-introduction-69385936)
-
-
diff --git a/4.人工智能/4.6.1工欲善其事，必先利其器.md b/4.人工智能/4.6.1工欲善其事，必先利其器.md
index 9da961a..93355c2 100644
--- a/4.人工智能/4.6.1工欲善其事，必先利其器.md
+++ b/4.人工智能/4.6.1工欲善其事，必先利其器.md
@@ -6,7 +6,7 @@
 
 ## 深度学习框架
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnWLzi1LIWLCncrXcTcjAKne.png)
+![](https://cdn.xyxsw.site/boxcnWLzi1LIWLCncrXcTcjAKne.png)
 
 ### 1、深度学习框架是什么
 
@@ -113,9 +113,9 @@ PyTorch 完全基于 Python。
 
 官网如下
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnaF9UWNcr5pt99Zu5Wr0PTg.png)
+![](https://cdn.xyxsw.site/boxcnaF9UWNcr5pt99Zu5Wr0PTg.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnqHCP5KiSF4Vmc6M1cjEXKg.png)
+![](https://cdn.xyxsw.site/boxcnqHCP5KiSF4Vmc6M1cjEXKg.png)
 
 选择 Conda 或者 Pip 安装皆可
 
@@ -127,9 +127,9 @@ PyTorch 完全基于 Python。
 
 如果你使用 conda 安装 pytorch 太慢或者失败，不妨换个下载源试试
 
-在 [cmd](https://so.csdn.net/so/search?q=cmd&spm=1001.2101.3001.7020) 命令行中，输入添加以下命令：
+在 cmd 命令行中，输入添加以下命令：
 
-```
+```bash
 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/msys2/
 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge
 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
@@ -140,7 +140,7 @@ conda config --set show_channel_urls yes
 
 ### TensorFlow
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn5u9u9M6DPRh83ufoSwfuof.png)
+![](https://cdn.xyxsw.site/boxcn5u9u9M6DPRh83ufoSwfuof.png)
 
 #### 教程
 
@@ -167,17 +167,17 @@ cuda 版本需要额外配置，我们将这个任务留给聪明的你！！！
 同时按下键盘的 win+r 键，打开 cmd，键入 `dxdiag` 然后回车
 系统、显卡、声卡以及其他输入设备的信息都在这里了。（给出我的界面）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnXHceTuUl0XzCNJv9RqHN9c.png)
+![](https://cdn.xyxsw.site/boxcnXHceTuUl0XzCNJv9RqHN9c.png)
 
 cuda 版本查看
 
 桌面空白位置摁下右键
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnbxhAei6H4OWjaN0Hp0YICg.png)
+![](https://cdn.xyxsw.site/boxcnbxhAei6H4OWjaN0Hp0YICg.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnp9i1SagOxXd17W9BiP3RNe.png)
+![](https://cdn.xyxsw.site/boxcnp9i1SagOxXd17W9BiP3RNe.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcngaZNZB3XLSJia0rk0DgGbe.png)
+![](https://cdn.xyxsw.site/boxcngaZNZB3XLSJia0rk0DgGbe.png)
 
 #### linux
 
@@ -193,11 +193,11 @@ nvidia-smi
 
 通常大家所指的 cuda 是位于/usr/local 下的 cuda
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcntFGELTpdcVoigy5ldCorAb.png)
+![](https://cdn.xyxsw.site/boxcntFGELTpdcVoigy5ldCorAb.png)
 
 当然可以看到 cuda 是 cuda-11.6 所指向的软链接（类似 windows 的快捷方式），所以我们如果要切换 cuda 版本只需要改变软链接的指向即可。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnTB39MtPKBr9CgufCpSIYuf.png)
+![](https://cdn.xyxsw.site/boxcnTB39MtPKBr9CgufCpSIYuf.png)
 
 cuda driver version 是 cuda 的驱动版本。
 
@@ -205,9 +205,9 @@ cuda runtimer version 是我们实际很多时候我们实际调用的版本。
 
 二者的版本是可以不一致的。如下图所示：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnATNfI2spkNsXbqtIuwwY6c.png)
+![](https://cdn.xyxsw.site/boxcnATNfI2spkNsXbqtIuwwY6c.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnz03UebyZ42JNOXpdUfjMBg.png)
+![](https://cdn.xyxsw.site/boxcnz03UebyZ42JNOXpdUfjMBg.png)
 
 一般来讲 cuda driver 是向下兼容的。所以 cuda driver version >= cuda runtime version 就不会太大问题。
 
@@ -217,13 +217,13 @@ cuda runtimer version 是我们实际很多时候我们实际调用的版本。
 
 以 pytorch 为例，可以看到在安装过程中我们选择的 cuda 版本是 10.2
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcns8yMCuacj0A2BbMU6ZB08b.png)
+![](https://cdn.xyxsw.site/boxcns8yMCuacj0A2BbMU6ZB08b.png)
 
 那么这个 cudatookit10.2 和 nvidia-smi 的 11.7 以及 nvcc -V 的 11.4 三者有什么区别呢？
 
 pytorch 实际只需要 cuda 的链接文件，即.so 文件，这些链接文件就都包含的 cudatookkit 里面。并不需要 cuda 的头文件等其他东西，如下所示
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnXWjMnlXjMg2lA1ApjoUhnh.png)
+![](https://cdn.xyxsw.site/boxcnXWjMnlXjMg2lA1ApjoUhnh.png)
 
 所以我们如果想让使用 pytorch-cuda 版本，我们实际上不需要/usr/local/cuda。只需要在安装驱动的前提下，在 python 里面安装 cudatookit 即可。
 
@@ -233,8 +233,8 @@ pytorch 实际只需要 cuda 的链接文件，即.so 文件，这些链接文
 
 Cudnn 是一些链接文件，你可以理解成是为了给 cuda 计算加速的东西。同样的我们也可以用以下命令查看/usr/local/cuda 的 cudnn：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnPD5DbA3NPimtV0kVoDJGmh.png)
+![](https://cdn.xyxsw.site/boxcnPD5DbA3NPimtV0kVoDJGmh.png)
 
 以及 pytorch 的 cuda 环境的 cudnn
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnZQ2Mc52Us6ku543l7WPEZd.png)
+![](https://cdn.xyxsw.site/boxcnZQ2Mc52Us6ku543l7WPEZd.png)
diff --git a/4.人工智能/4.6.2你可能会需要的术语介绍.md b/4.人工智能/4.6.2你可能会需要的术语介绍.md
index 5e4da52..56057b5 100644
--- a/4.人工智能/4.6.2你可能会需要的术语介绍.md
+++ b/4.人工智能/4.6.2你可能会需要的术语介绍.md
@@ -40,8 +40,8 @@
 
 这是我用照片重建的独角兽<strong>稀疏</strong>点云，红色的不用管，是照相机视角（图不够多，巨糊）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnWx8hYfT6kFug4A1iA3uftg.png)
+![](https://cdn.xyxsw.site/boxcnWx8hYfT6kFug4A1iA3uftg.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnbWfXyklyZwpjwy8uz2XnLh.jpg)
+![](https://cdn.xyxsw.site/boxcnbWfXyklyZwpjwy8uz2XnLh.jpg)
 
 先这些，后续想起来了可能会补充。
diff --git a/4.人工智能/4.6.3深度学习快速入门.md b/4.人工智能/4.6.3深度学习快速入门.md
index a6f6aea..88dc912 100644
--- a/4.人工智能/4.6.3深度学习快速入门.md
+++ b/4.人工智能/4.6.3深度学习快速入门.md
@@ -68,7 +68,7 @@ Crash course 的课程，可以基本了解pytorch的内容，但是当然有很
 
 ### 损失
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnRbeabbEppeHlM39UwqJSJc.png)
+![](https://cdn.xyxsw.site/boxcnRbeabbEppeHlM39UwqJSJc.png)
 
 首先我们需要有一个损失函数$F（x），x=true-predict$
 
@@ -77,13 +77,13 @@ Crash course 的课程，可以基本了解pytorch的内容，但是当然有很
 
 ### 梯度下降
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnMuwaG2okodvywzbxX138Re.png)
+![](https://cdn.xyxsw.site/boxcnMuwaG2okodvywzbxX138Re.png)
 
 假设损失函数为$y=x^2$,梯度下降的目的是快速找到导数为 0 的位置（附近）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn83M9AW6xDm5pBIqmZEC6Kf.png)
+![](https://cdn.xyxsw.site/boxcn83M9AW6xDm5pBIqmZEC6Kf.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcneVFa131Lb9xDMCsIMI9fcc.png)
+![](https://cdn.xyxsw.site/boxcneVFa131Lb9xDMCsIMI9fcc.png)
 
 以此类推，我们最后的 w 在 0 的附近反复横跳，最后最接近目标函数的权重 w 就是 0。
 
@@ -97,7 +97,7 @@ Crash course 的课程，可以基本了解pytorch的内容，但是当然有很
 
 # 关于 MINIST
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnxdyWA6Sj82kNxMlQ1b9hDg.png)
+![](https://cdn.xyxsw.site/boxcnxdyWA6Sj82kNxMlQ1b9hDg.png)
 
 这个数据集可以说是最最经典的数据集了，里面有 0-9 这 10 个数字的手写图片和标注，正确率最高已经到了 99.7%.
 
diff --git a/4.人工智能/4.6.4Pytorch安装.md b/4.人工智能/4.6.4Pytorch安装.md
index b4c2e36..6a5ee3b 100644
--- a/4.人工智能/4.6.4Pytorch安装.md
+++ b/4.人工智能/4.6.4Pytorch安装.md
@@ -4,7 +4,7 @@
 
 进入官网后选择 Install，在下面表格中按照你的配置进行选择：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnxltvaT52E6mu6JIYaKvM1X.png)
+![](https://cdn.xyxsw.site/boxcnxltvaT52E6mu6JIYaKvM1X.png)
 
 其中 Package 部分选择安装的途径，这里主要介绍 Pip 和 Conda 两种途径。
 
@@ -56,8 +56,8 @@ conda config --show channels
 
 同时按下 Win+R,运行 cmd,输入 `dxdiag` 并回车。系统、显卡、声卡以及其他设备信息都会显示。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnepK0nkI8pWAJaO89zQoRgh.png)
+![](https://cdn.xyxsw.site/boxcnepK0nkI8pWAJaO89zQoRgh.png)
 
 cuda 版本查看
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnRoZEZsUdVduFRR9DjegeNh.png)
+![](https://cdn.xyxsw.site/boxcnRoZEZsUdVduFRR9DjegeNh.png)
diff --git a/4.人工智能/4.6.5.1CV领域任务(研究目标).md b/4.人工智能/4.6.5.1CV领域任务(研究目标).md
index 72368c6..49be167 100644
--- a/4.人工智能/4.6.5.1CV领域任务(研究目标).md
+++ b/4.人工智能/4.6.5.1CV领域任务(研究目标).md
@@ -2,7 +2,7 @@
 
 ### CV 领域的大任务
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnTUlm8EI0byGJJQ78IqGWGx.png)
+![](https://cdn.xyxsw.site/boxcnTUlm8EI0byGJJQ78IqGWGx.png)
 
 #### （a）Image classification <strong>图像分类</strong>
 
@@ -18,7 +18,7 @@
 
     - 这张图我们需要标注两个类别 `head（头）、helmet（头盔）`
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnoyxKL4bOeYOOjrh6it0BHd.gif)
+![](https://cdn.xyxsw.site/boxcnoyxKL4bOeYOOjrh6it0BHd.gif)
 
 #### （c）Semantic segmentation <strong>语义分割</strong>
 
@@ -32,13 +32,13 @@
 
 #### （e）Key Point 人体关键点检测
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnT2udZtMmV2kLQsXoPuElNd.png)
+![](https://cdn.xyxsw.site/boxcnT2udZtMmV2kLQsXoPuElNd.png)
 
 通过人体关键节点的组合和追踪来识别人的运动和行为，对于描述人体姿态，预测人体行为至关重要。
 
 #### （f）Scene Text Recognition（STR）场景文字识别
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnB8ZB4bSaHhIhPFHHrxkakb.png)
+![](https://cdn.xyxsw.site/boxcnB8ZB4bSaHhIhPFHHrxkakb.png)
 
 很多照片中都有一些文字信息，这对理解图像有重要的作用。
 
@@ -48,7 +48,7 @@
 
 利用两张图片或者其他信息生成一张新的图片
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnOdmG0c1kkivVdTn5RUMCIc.png)
+![](https://cdn.xyxsw.site/boxcnOdmG0c1kkivVdTn5RUMCIc.png)
 
 利用左边两张小图生成右边的图片
 
@@ -56,6 +56,6 @@
 
 将输入图片分辨率增加
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnDJ5aNv49ySjw96uCCF0dW8.png)
+![](https://cdn.xyxsw.site/boxcnDJ5aNv49ySjw96uCCF0dW8.png)
 
 当然还有一些新兴领域我们没有写入~
diff --git a/4.人工智能/4.6.5.2.1数据读取.md b/4.人工智能/4.6.5.2.1数据读取.md
index 9e0b5c4..63d10ed 100644
--- a/4.人工智能/4.6.5.2.1数据读取.md
+++ b/4.人工智能/4.6.5.2.1数据读取.md
@@ -117,7 +117,7 @@ Torchvision 库中的 torchvision.datasets 包中提供了丰富的图像数据
 
 下表中列出了 torchvision.datasets 包所有支持的数据集。各个数据集的说明与接口，详见链接 [https://pytorch.org/vision/stable/datasets.html](https://pytorch.org/vision/stable/datasets.html)。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnxvqC7FKt1qeCZoI2kVf9yg.png)
+![](https://cdn.xyxsw.site/boxcnxvqC7FKt1qeCZoI2kVf9yg.png)
 
 注意，torchvision.datasets 这个包本身并不包含数据集的文件本身，它的工作方式是先从网络上把数据集下载到用户指定目录，然后再用它的加载器把数据集加载到内存中。最后，把这个加载后的数据集作为对象返回给用户。
 
@@ -129,11 +129,11 @@ MNIST 数据集是一个著名的手写数字数据集，因为上手简单，
 
 MNIST 数据集是 NIST 数据集的一个子集，MNIST 数据集你可以通过[这里](http://yann.lecun.com/exdb/mnist/)下载。它包含了四个部分。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnCP2Sp932nPy8Il5Z5d4Aih.png)
+![](https://cdn.xyxsw.site/boxcnCP2Sp932nPy8Il5Z5d4Aih.png)
 
 MNIST 数据集是 ubyte 格式存储，我们先将“训练集图片”解析成图片格式，来直观地看一看数据集具体是什么样子的。具体怎么解析，我们在后面数据预览再展开。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnjsG31hhjqdxOnoCGFGR6sh.png)
+![](https://cdn.xyxsw.site/boxcnjsG31hhjqdxOnoCGFGR6sh.png)
 
 接下来，我们看一下如何使用 Torchvision 来读取 MNIST 数据集。
 
diff --git a/4.人工智能/4.6.5.3.1AlexNet.md b/4.人工智能/4.6.5.3.1AlexNet.md
index 46968ca..84436b7 100644
--- a/4.人工智能/4.6.5.3.1AlexNet.md
+++ b/4.人工智能/4.6.5.3.1AlexNet.md
@@ -12,21 +12,21 @@ AlexNet 有 6 千万个参数和 650,000 个神经元。
 
 ### <strong>网络框架图</strong>
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcng0jB2dmDD18EwU8nAIFPIc.png)
+![](https://cdn.xyxsw.site/boxcng0jB2dmDD18EwU8nAIFPIc.png)
 
 ### <strong>使用 ReLU 激活函数代替 tanh</strong>
 
 在当时，标准的神经元激活函数是 tanh()函数，这种饱和的非线性函数在梯度下降的时候要比非饱和的非线性函数慢得多，因此，在 AlexNet 中使用 ReLU 函数作为激活函数。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnFlENdpKXUR7l4MhUXFKzfg.png)
+![](https://cdn.xyxsw.site/boxcnFlENdpKXUR7l4MhUXFKzfg.png)
 
 ### <strong>采用 Dropout 防止过拟合</strong>
 
 dropout 方法会遍历网络的每一层，并设置消除神经网络中节点的概率。假设网络中的每一层，每个节点都以抛硬币的方式设置概率，每个节点得以保留和消除的概率都是 0.5，设置完节点概率，我们会消除一些节点，然后删除掉从该节点进出的连线，最后得到一个节点更少，规模更小的网络（如下图所示），然后再用反向传播方法进行训练。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnNXzBUtJWXbUtEZzxugBr6W.png)
+![](https://cdn.xyxsw.site/boxcnNXzBUtJWXbUtEZzxugBr6W.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn7kG0PcXNumIdTFuEdaHl0e.png)
+![](https://cdn.xyxsw.site/boxcn7kG0PcXNumIdTFuEdaHl0e.png)
 
 ### 
 
diff --git a/4.人工智能/4.6.5.3.2FCN.md b/4.人工智能/4.6.5.3.2FCN.md
index f3eec40..de453d7 100644
--- a/4.人工智能/4.6.5.3.2FCN.md
+++ b/4.人工智能/4.6.5.3.2FCN.md
@@ -10,7 +10,7 @@
 
 ### 框架图
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcndYCXYj7rNfhXoSaEPZxpyc.png)
+![](https://cdn.xyxsw.site/boxcndYCXYj7rNfhXoSaEPZxpyc.png)
 
 ### 同 CNN 的对比
 
@@ -26,7 +26,7 @@ FCN 对图像进行像素级的分类，从而解决了语义级别的图像分
 
 这里图像的反卷积使用了这一种反卷积手段使得图像可以变大，FCN 作者使用的方法是这里所说反卷积的一种变体，这样就可以获得相应的像素值，图像可以实现 end to end。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcngqgiogbvy4OYpIzIo6eSXd.png)
+![](https://cdn.xyxsw.site/boxcngqgiogbvy4OYpIzIo6eSXd.png)
 
 ### 视频
 
diff --git a/4.人工智能/4.6.5.3.3ResNet.md b/4.人工智能/4.6.5.3.3ResNet.md
index 9edc309..e8573d6 100644
--- a/4.人工智能/4.6.5.3.3ResNet.md
+++ b/4.人工智能/4.6.5.3.3ResNet.md
@@ -21,11 +21,11 @@
 
 如图所示，随着层数越来越深，预测的效果反而越来越差(error 越大)
 :::
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnBDfBnOPmS0btwNseKvsN6f.png)
+![](https://cdn.xyxsw.site/boxcnBDfBnOPmS0btwNseKvsN6f.png)
 
 ## 网络模型
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnn8a16DYyEPEVuHxvvw7eAf.png)
+![](https://cdn.xyxsw.site/boxcnn8a16DYyEPEVuHxvvw7eAf.png)
 
 ::: warning 😺
 我们可以看到，ResNet 的网络依旧非常深，这是因为研究团队不仅发现了退化现象，还采用出一个可以将网络继续加深的 trick：shortcut，亦即我们所说的 residual。
@@ -35,7 +35,7 @@
 :::
 ### residual 结构
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnhgVaLChu3O2omGJKzFU7uB.png)
+![](https://cdn.xyxsw.site/boxcnhgVaLChu3O2omGJKzFU7uB.png)
 
 ## 网络代码
 
diff --git a/4.人工智能/4.6.5.3.4UNet.md b/4.人工智能/4.6.5.3.4UNet.md
index 2cd4886..08158a6 100644
--- a/4.人工智能/4.6.5.3.4UNet.md
+++ b/4.人工智能/4.6.5.3.4UNet.md
@@ -8,7 +8,7 @@
 
 ## 网络框架
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnoo4bKuLo5qQdQmRP2H75Sb.png)
+![](https://cdn.xyxsw.site/boxcnoo4bKuLo5qQdQmRP2H75Sb.png)
 
 
 ::: warning 😺
diff --git a/4.人工智能/4.6.5.3.6思考题参考.md b/4.人工智能/4.6.5.3.6思考题参考.md
index f36d467..f90eeed 100644
--- a/4.人工智能/4.6.5.3.6思考题参考.md
+++ b/4.人工智能/4.6.5.3.6思考题参考.md
@@ -10,8 +10,6 @@
 
 [CNN 与 MLP 之间的关系，优缺点](https://www.editcode.net/archive/detail/89781)
 
-[MLP(多层感知机)只是 CNN(卷积网络)的一个特例](https://blog.csdn.net/u010165147/article/details/82851717#:~:text=%E6%98%BE%E7%84%B6%E5%8F%AF%E4%BB%A5%E6%8E%A8%E5%AF%BC%E5%87%BA%EF%BC%8C%E5%BD%93%20CNN%E5%8D%B7%E7%A7%AF%E6%A0%B8%E5%A4%A7%E5%B0%8F%E4%B8%8E%E8%BE%93%E5%85%A5%E5%A4%A7%E5%B0%8F%E7%9B%B8%E5%90%8C%20%E6%97%B6%E5%85%B6%E8%AE%A1%E7%AE%97%E8%BF%87%E7%A8%8B%E7%AD%89%E4%BB%B7%E4%BA%8EMLP%EF%BC%8C%E4%B9%9F%E5%B0%B1%E6%98%AF%E8%AF%B4MLP%E7%AD%89%E4%BB%B7%E4%BA%8E,%E5%8D%B7%E7%A7%AF%E6%A0%B8%E5%A4%A7%E5%B0%8F%E4%B8%8E%E6%AF%8F%E5%B1%82%E8%BE%93%E5%85%A5%E5%A4%A7%E5%B0%8F%E7%9B%B8%E5%90%8C%20%E7%9A%84CNN%EF%BC%88%E5%A6%82%E8%BE%93%E5%85%A5%E5%9B%BE%E7%89%87%E4%B8%BA100x100%EF%BC%8C%E5%8D%B7%E7%A7%AF%E6%A0%B8%E5%A4%A7%E5%B0%8F%E4%B8%BA100x100%EF%BC%89%EF%BC%8C%E6%89%80%E4%BB%A5MLP%E6%98%AFCNN%E7%9A%84%E4%B8%80%E4%B8%AA%E7%89%B9%E4%BE%8B%E3%80%82%20%E8%80%8C%E5%8D%B7%E7%A7%AF%E6%A0%B8%E5%A4%A7%E5%B0%8F%E4%B8%8E%E6%AF%8F%E5%B1%82%E8%BE%93%E5%85%A5%E5%A4%A7%E5%B0%8F%E7%9B%B8%E5%90%8C%E4%BC%9A%E7%9B%B4%E6%8E%A5%E4%B8%A2%E5%A4%B1%E9%9D%9E%E5%B8%B8%E5%A4%9A%E7%9A%84%E8%BE%93%E5%85%A5%E7%A9%BA%E9%97%B4%E4%BF%A1%E6%81%AF%EF%BC%8C%E6%89%80%E4%BB%A5MLP%E8%BF%99%E7%A7%8D%E8%BF%90%E8%A1%8C%E6%A8%A1%E5%BC%8F%E4%B8%8D%E9%80%82%E5%90%88%E5%9B%BE%E5%83%8F%E8%BF%99%E7%A7%8D%E7%A9%BA%E9%97%B4%E4%BF%A1%E6%81%AF%E4%B8%B0%E5%AF%8C%E7%9A%84%E6%95%B0%E6%8D%AE%E3%80%82)
-
 ### 1.2
 
 [深度理解感受野](https://blog.csdn.net/weixin_40756000/article/details/117264194)
@@ -53,9 +51,3 @@
 ### 3.2
 
 [ResNet 残差、退化等细节解读](https://blog.csdn.net/a8039974/article/details/122380735)
-
-## 思考 4
-
-### 4.1
-
-[U-Net 和 ResNet：长短跳跃连接的重要性（生物医学图像分割）](https://www.jianshu.com/p/20a47427823c)
diff --git a/4.人工智能/4.6.5.3.7还要学更多？.md b/4.人工智能/4.6.5.3.7还要学更多？.md
index 12b9354..2a893f7 100644
--- a/4.人工智能/4.6.5.3.7还要学更多？.md
+++ b/4.人工智能/4.6.5.3.7还要学更多？.md
@@ -6,11 +6,11 @@
 
 - 你可以先行尝试一下怎么把在 MNIST 上训练的网络真正投入应用，比如识别一张你自己用黑笔写的数字~
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn2juA3J3ycnHoN5SmYAfEfd.jpg)
+![](https://cdn.xyxsw.site/boxcn2juA3J3ycnHoN5SmYAfEfd.jpg)
 
 - 比如你可以尝试训练一个网络来实现人体五官分割（笔者之前就玩过这个）数据集采用 [helen 数据集](https://pages.cs.wisc.edu/~lizhang/projects/face-parsing/)，关于数据集的架构你可以搜一搜，自己设计一个 Dataloader 和 YourModle 来实现前言中的五官分割效果（真的很有乐子 hhh）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnJJlzanhvtE55Q7d0IR1vph.png)
+![](https://cdn.xyxsw.site/boxcnJJlzanhvtE55Q7d0IR1vph.png)
 
 - 当然你也可以尝试一些自己感兴趣的小任务来锻炼工程能力~
 
diff --git a/4.人工智能/4.6.5.4.1NeRF.md b/4.人工智能/4.6.5.4.1NeRF.md
index 15c09fa..01418e2 100644
--- a/4.人工智能/4.6.5.4.1NeRF.md
+++ b/4.人工智能/4.6.5.4.1NeRF.md
@@ -6,11 +6,11 @@ NeRF 想做这样一件事，不需要中间三维重建的过程，仅根据位
 
 在生成建模前，我们需要对被建模物体进行密集的采样，如下图是一个示例的训练集，它含有 100 张图片以及保存了每一张图片相机参数（表示拍摄位置，拍摄角度，焦距的矩阵）的 json 文件。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn6jg09V944MU1sBsstmdaib.png)
+![](https://cdn.xyxsw.site/boxcn6jg09V944MU1sBsstmdaib.png)
 
 你可以看到，这 100 张图片是对一个乐高推土机的多角度拍摄结果。我们需要的是一个可<strong>以获取这个推土机在任意角度下拍摄的图片</strong>的模型。如图所示：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnLEEyuUWOwiJOePhmmsAakd.gif)
+![](https://cdn.xyxsw.site/boxcnLEEyuUWOwiJOePhmmsAakd.gif)
 
 现在来看 NeRF 网络：
 
@@ -40,7 +40,7 @@ NeRF 想做这样一件事，不需要中间三维重建的过程，仅根据位
 - 对应的小方块的 RGB 信息
 - 不透明度
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcni4q9Cp8G7H9HjKMrfImcZe.jpg)
+![](https://cdn.xyxsw.site/boxcni4q9Cp8G7H9HjKMrfImcZe.jpg)
 
 在这里，作者选择了最简单的 MLP，因此，<strong>这是一个输入为 5 维，输出为 4 维向量</strong>($R,G,B,\sigma$)的简单网络,值得注意的是，不透明度与观察角度无关，这里在网络中进行了特殊处理，让这个值与后两维无关。
 
@@ -58,15 +58,15 @@ NeRF 想做这样一件事，不需要中间三维重建的过程，仅根据位
 
 这段要仔细看和推导，第一遍不容易直接懂。顺带一提，我们的<strong>小方块</strong>学名叫<strong>体素</strong>，<del>为了显得我们更专业一点以后就叫它体素罢</del>
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnnwHy3Hlhbu2bOsi6r2BYJe.png)
+![](https://cdn.xyxsw.site/boxcnnwHy3Hlhbu2bOsi6r2BYJe.png)
 
 上面所说的公式具体如下：t 是我们的$\sigma$，$t_f,t_n$分别是离发射点最远的体素和最近的体素。这个公式求得是像素的颜色。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnDWBUOJucS2YdT7MlKBAq8g.png)
+![](https://cdn.xyxsw.site/boxcnDWBUOJucS2YdT7MlKBAq8g.png)
 
 思路总体如上，这里放一张找来的渲染过程示意图（<del>不知道为什么有点包浆</del>）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnfH30VDvbSdzahs5lRuirUd.gif)
+![](https://cdn.xyxsw.site/boxcnfH30VDvbSdzahs5lRuirUd.gif)
 
 # 算法细节部分
 
@@ -86,10 +86,10 @@ NeRF 想做这样一件事，不需要中间三维重建的过程，仅根据位
 
 粗网络就是上述采样方法用的普通网络，而<strong>粗网络输出的不透明度值会被作为一个概率分布函数</strong>，精细网络根据这个概率分布在光线上进行采样，不透明度越大的点，它的邻域被采样的概率越大，也就实现了我们要求的在实体上多采样，空气中少采样。最后精细网络输出作为结果，因此粗网络可以只求不透明度，无视颜色信息。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnwl72wntQgYMFvRPTWY5fPf.png)
+![](https://cdn.xyxsw.site/boxcnwl72wntQgYMFvRPTWY5fPf.png)
 
 ## 位置编码
 
 学过 cv 的大家想必对这个东西耳熟能详了吧~，这里的位置编码是对输入的两个位置和一个方向进行的（体素位置，相机位置和方向），使用的是类似 transformer 的三角函数类编码如下。位置编码存在的意义是放大原本的 5 维输入对网络的影响程度，把原本的 5D 输入变为 90 维向量；并且加入了与其他体素的相对位置信息。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnliAj5mb0Afz0TOMwrwytmh.png)
+![](https://cdn.xyxsw.site/boxcnliAj5mb0Afz0TOMwrwytmh.png)
diff --git a/4.人工智能/4.6.5.4.2NeRF的改进方向.md b/4.人工智能/4.6.5.4.2NeRF的改进方向.md
index e5c93fb..b889f72 100644
--- a/4.人工智能/4.6.5.4.2NeRF的改进方向.md
+++ b/4.人工智能/4.6.5.4.2NeRF的改进方向.md
@@ -12,19 +12,19 @@
 
 <strong>Pixel-nerf</strong><strong> </strong>对输入图像使用卷积进行特征提取再执行 nerf，若有多个输入，对每个视角都执行 CNN，在计算光线时，取每一个已有视角下该坐标的特征，经过 mlp 后算平均。可以在少量视角下重建视图，需要进行预训练才能使用，有一定自动补全能力（有限）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnEiUODOd4FOBxYIZmmihyef.png)
+![](https://cdn.xyxsw.site/boxcnEiUODOd4FOBxYIZmmihyef.png)
 
 ### 2.IBRnet
 
 <strong>IBRnet</strong><strong> </strong>是 pixel-nerf 的改进版，取消了 CNN，并且在 mlp 后接入了 transformer 结构处理体密度（不透明度），对这条光线上所有的采样点进行一个 transformer。同时，在获取某个体素的颜色和密度时，作者用了本视角相邻的两个视角，获取对应体素在这两张图片中的像素，以图片像素颜色，视角，图片特征作为 mlp 的输入。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnwH75jIO9NiVwQaBqDrbe8e.png)
+![](https://cdn.xyxsw.site/boxcnwH75jIO9NiVwQaBqDrbe8e.png)
 
 ### 3.MVSnerf
 
 <strong>MVSnerf</strong><strong> </strong>它用 MVS 的方法构建代价体然后在后面接了一个 nerf，MVS 是使用<strong>多视角立体匹配</strong>构建一个代价体，用 3D 卷积网络进行优化，这里对代价体进行 nerf 采样，可以得到可泛化网络。它需要 15min 的微调才能在新数据上使用。<strong>多视角立体匹配是一种传统算法，通过光线，几何等信息计算图像中小块的相似度，得出两个相机视角之间的位置关系。这个算法也被广泛使用在得到我们自己采样的数据的相机变换矩阵上（我就是这么干的）</strong>
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnbd2YxumunZR9LZG3ANrPrb.png)
+![](https://cdn.xyxsw.site/boxcnbd2YxumunZR9LZG3ANrPrb.png)
 
 此处涉及较多图形学，使用了平面扫描算法，其中有单应性变换这个角度变换算法，推导与讲解如下：
 
@@ -34,7 +34,7 @@
 
 平面扫描就是把 A 视角中的某一像素点（如图中红色区域）的相邻的几个像素提取出来，用单应性变换转换到 B 视角中，这时候用的深度是假设的深度，遍历所有假设的深度，计算通过每一个假设深度经过单应性变换得到的像素小块和 B 视角中对应位置的差值（loss），取最小的 loss 处的深度作为该像素的深度。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn5JmWUh1Gu283biqHq3Op0r.png)
+![](https://cdn.xyxsw.site/boxcn5JmWUh1Gu283biqHq3Op0r.png)
 
 构建代价体：
 
@@ -55,7 +55,7 @@
 
 展开说说：其实这也是神经网络发展的一个方向，以前的深层网络倾向于把所有东西用网络参数表示，这样推理速度就会慢，这里使用哈希表的快速查找能力存储一些数据信息，instant-ngp 就是把要表达的模型数据特征按照不同的精细度存在哈希表中，使用时通过哈希表调用或插值调用。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnXSUge0BqBCecdDJLQr4cRc.png)
+![](https://cdn.xyxsw.site/boxcnXSUge0BqBCecdDJLQr4cRc.png)
 
 # 3.可编辑（指比如人体运动等做修改工作的）
 
@@ -63,7 +63,7 @@
 
 <strong>Human-nerf</strong><strong> </strong>生成可编辑的人体运动视频建模，输入是一段人随便动动的视频。输出的动作可以编辑修改，并且对衣物折叠等有一定优化。使用的模型并非全隐式的，并且对头发和衣物单独使用变换模型。使用了逆线性蒙皮模型提取人物骨骼（可学习的模型），上面那个蓝色的就是姿态矫正模块，这个模块赋予骨骼之间运动关系的权重（因为使用的是插值处理同一运动时不同骨骼的平移旋转矩阵，一块骨骼动会牵动其他骨骼）图中的 Ω 就是权重的集合，它通过 mlp 学习得到。然后得到显式表达的人物骨骼以及传入视频中得到的对应骨骼的 mesh，skeletal motion 就是做游戏人物动作用的编辑器这种，后面残差链接了一个 non-rigid-motion（非刚性动作），这个是专门处理衣物和毛发的，主要通过学习得到，然后粗暴的加起来就能得到模型，再经过传统的 nerf 渲染出图像。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnHRnNXHvwVXrRmM8wnl53p9.png)
+![](https://cdn.xyxsw.site/boxcnHRnNXHvwVXrRmM8wnl53p9.png)
 
 ### 2.Neural Body
 
@@ -75,7 +75,7 @@
 
 EasyMocap 是通过多视角视频生成骨架以及 SMPL 模型的一个工作，演示视频右下。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnYmy1MnyWSPNEWvFWj9mzCf.png)
+![](https://cdn.xyxsw.site/boxcnYmy1MnyWSPNEWvFWj9mzCf.png)
 
 这是 EasyMocap 的演示。
 
@@ -87,7 +87,7 @@ EasyMocap 是通过多视角视频生成骨架以及 SMPL 模型的一个工作
 
 是个预训练模型，<strong>训练的模块就是这个 3D 卷积神经网络</strong>。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnbclBwg3BsubGOrt8vZf0qb.png)
+![](https://cdn.xyxsw.site/boxcnbclBwg3BsubGOrt8vZf0qb.png)
 
 ### 3.wild-nerf
 
@@ -101,11 +101,11 @@ EasyMocap 是通过多视角视频生成骨架以及 SMPL 模型的一个工作
 
 在此网络的单个输出上貌似是不监督的，因为没办法进行人为标注。这点我不是很确定，以后如果发现了会来修改的。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnYeaiioqtFzQlztsTwiEpzg.png)
+![](https://cdn.xyxsw.site/boxcnYeaiioqtFzQlztsTwiEpzg.png)
 
 渲染经过形变的物体时，光线其实是在 t=0 时刻进行渲染的，因为推土机的铲子放下去了，所以<strong>光线是弯曲的</strong>。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcng7xDooDmmpbCJRyLJBucwe.png)
+![](https://cdn.xyxsw.site/boxcng7xDooDmmpbCJRyLJBucwe.png)
 
 # 4.用于辅助传统图像处理
 
@@ -123,23 +123,23 @@ EasyMocap 是通过多视角视频生成骨架以及 SMPL 模型的一个工作
 
 <strong>GRAF</strong><strong> </strong>把 GAN 与 nerf 结合，增加了两个输入，分别是<strong>外观/形状编码 z</strong>和<strong>2D 采样编码 v</strong>，z 用来改变渲染出来东西的特征，比如把生成的车变色或者变牌子，suv 变老爷车之类的。v(s,u)用来改变下图 2 中训练时选择光线的标准。这里训练时不是拿 G 生成的整张图扔进 D 网络，而是根据 v 的参数选择一些光线组成的 batch 扔进 D 进行辨别
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnVyFqHIoA2MGGc4JJo9tObh.png)
+![](https://cdn.xyxsw.site/boxcnVyFqHIoA2MGGc4JJo9tObh.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnvBzqwCn9i8GGBIkMFEs3ne.png)
+![](https://cdn.xyxsw.site/boxcnvBzqwCn9i8GGBIkMFEs3ne.png)
 
 ### 2.GIRAFFE
 
 <strong>GIRAFFE</strong> 是 GRAF 的改进工作，可以把图片中的物品，背景一个个解耦出来单独进行改变或者移动和旋转，也可以增加新的物品或者减少物品，下图中蓝色是不可训练的模块，橙色可训练。以我的理解好像要设置你要解耦多少个(N)物品再训练，网络根据类似 k 近邻法的方法在特征空间上对物品进行分割解耦，然后分为 N 个渲染 mlp 进行训练，训练前加入外观/形状编码 z。最后还是要扔进 D 训练。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnB04hwHA1o64WBvYSyVTDod.png)
+![](https://cdn.xyxsw.site/boxcnB04hwHA1o64WBvYSyVTDod.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnC2bKVHOANjGOePLHk7jfZe.png)
+![](https://cdn.xyxsw.site/boxcnC2bKVHOANjGOePLHk7jfZe.png)
 
 ### 3.OSF
 
 <strong>OSF</strong>Object-Centric Neural Scene Rendering，可以给移动的物体生成合理的阴影和光照效果。加入了新的坐标信息：光源位置，与相机坐标等一起输入。对每个小物件构建一个单独的小 nerf，计算这个小 nerf 的体素时要先经过光源照射处理（训练出来的）然后在每个小物件之间也要计算反射这样的光线影响，最后进行正常的渲染。<del>这篇文章没人写 review，有点冷门，这些都是我自己读完感觉的，不一定对。</del>
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnV7YcKIq5y8TkOGEGzrPc5g.png)
+![](https://cdn.xyxsw.site/boxcnV7YcKIq5y8TkOGEGzrPc5g.png)
 
 ### 4.Hyper-nerf-gan
 
@@ -153,7 +153,7 @@ EasyMocap 是通过多视角视频生成骨架以及 SMPL 模型的一个工作
 
 左边是常规卷积网络生成图像，右边是用 INR 生成图像。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnGCCZ8qXD1Hhc531NxfLzLd.png)
+![](https://cdn.xyxsw.site/boxcnGCCZ8qXD1Hhc531NxfLzLd.png)
 
 这种方法存在两个问题：
 
@@ -165,8 +165,8 @@ EasyMocap 是通过多视角视频生成骨架以及 SMPL 模型的一个工作
 
 FMM 主要是把要学习的矩阵转化为两个低秩矩阵，去先生成他们俩再相乘，减少网络计算量。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn0oHY54dgL2bxmryxjqxC6f.png)
+![](https://cdn.xyxsw.site/boxcn0oHY54dgL2bxmryxjqxC6f.png)
 
 现在开始讲 Hyper-nerf-gan 本身，它看上去其实就是 nerf 接在 gan 上。不过有一些变化，比如输入不再包含视角信息，我<strong>很怀疑它不能很好表达反光效果</strong>。而且抛弃了粗网络细网络的设计，只使用粗网络减少计算量。这里的 generator 完全就是 INR-Gan 的形状，生成权重，然后再经过 nerf 的 mlp 层生成，没啥别的了，就这样吧。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnc9bZ1nqt3Lighlrj9zSrdd.png)
+![](https://cdn.xyxsw.site/boxcnc9bZ1nqt3Lighlrj9zSrdd.png)
diff --git a/4.人工智能/4.6.5.4.3自制数据集的工具COLMAP.md b/4.人工智能/4.6.5.4.3自制数据集的工具COLMAP.md
index 029b38a..bfae611 100644
--- a/4.人工智能/4.6.5.4.3自制数据集的工具COLMAP.md
+++ b/4.人工智能/4.6.5.4.3自制数据集的工具COLMAP.md
@@ -2,7 +2,7 @@
 
 如何使用和怎么下载就不讲了，直接搜就有，它可以把多个拍摄同一物体的图片转换为它们对应视角的相机矩阵和拍摄角度，可以实现自制数据集做 nerf。它的流程（SFM 算法）可以概括如下：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnXzgaIhmUQ7HQtEn52ksWIf.png)
+![](https://cdn.xyxsw.site/boxcnXzgaIhmUQ7HQtEn52ksWIf.png)
 
 这里主要是记录一下它的原理：
 首先是一个经典关键点匹配技术：<strong>SIFT</strong>
@@ -11,53 +11,53 @@
 
 ## DOG 金字塔
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcneERqw4amGHf6f2SX7gcdny.png)
+![](https://cdn.xyxsw.site/boxcneERqw4amGHf6f2SX7gcdny.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnv4dRbGDg9eemcyQFREYs0b.png)
+![](https://cdn.xyxsw.site/boxcnv4dRbGDg9eemcyQFREYs0b.png)
 
 下面是原理方法：
 
 首先是<strong>高斯金字塔</strong>，它是把原图先放大两倍，然后使用高斯滤波（高斯卷积）对图像进行模糊化数次，取出倒数第三层缩小一半继续进行这个过程，也就是说它是由一组一组的小金字塔组成的。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnKJWrCUc5cPOuZg01HqNCsc.png)
+![](https://cdn.xyxsw.site/boxcnKJWrCUc5cPOuZg01HqNCsc.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnd25i5LQ7WjGJEe2xgU3qce.jpg)
+![](https://cdn.xyxsw.site/boxcnd25i5LQ7WjGJEe2xgU3qce.jpg)
 
 然后是基于高斯金字塔的 DOG 金字塔，也叫差分金字塔，它是把相邻的高斯金字塔层做减法得到的，因为经过高斯模糊，物体的轮廓（或者说不变特征）被模糊化，也就是被改变。通过相减可以得到这些被改变的点。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcncKZlnG7F4oEpcrQYqth8kh.jpg)
+![](https://cdn.xyxsw.site/boxcncKZlnG7F4oEpcrQYqth8kh.jpg)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnAEQSDhsLdDsNOQVxqcic5d.jpg)
+![](https://cdn.xyxsw.site/boxcnAEQSDhsLdDsNOQVxqcic5d.jpg)
 
 ## 空间极值点检测
 
 为了找到变化的最大的几个点来作为特征点，我们需要找到变化的极值点，因此需要进行比较，这里是在整个金字塔中进行对比，我们提取某个点周边 3*3*3 的像素点进行比较，找到最大或最小的局部极值点。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnl48ovxbqSeTljgF3rp16ue.png)
+![](https://cdn.xyxsw.site/boxcnl48ovxbqSeTljgF3rp16ue.png)
 
 同时我们也对关键点分配方向，也就是这个点在图片空间中的梯度方向
 
 梯度为：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnbQx8TntyX8iETPixOnKjef.png)
+![](https://cdn.xyxsw.site/boxcnbQx8TntyX8iETPixOnKjef.png)
 
 梯度方向为：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnfw5FrBxPaD4bNFT4GFyXmd.png)
+![](https://cdn.xyxsw.site/boxcnfw5FrBxPaD4bNFT4GFyXmd.png)
 
 我们计算以关键点为中心的邻域内所有点的梯度方向，然后把这些 360 度范围内的方向分配到 36 个每个 10 度的方向中，并构建方向直方图，这里的示例使用了 8 个方向，几个随你其实：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnyuV5HCumJMhyW7Cb3HSxcg.jpg)
+![](https://cdn.xyxsw.site/boxcnyuV5HCumJMhyW7Cb3HSxcg.jpg)
 
 取其中最大的为主方向，若有一个方向超过主方向的 80%，那么把它作为辅方向。
 
 操作可以优化为下图，先把关键点周围的像素分成 4 块，每块求一次上面的操作，以这个 4 个梯度直方图作为关键点的方向描述。也就是一个 2*2*8(方向数量)的矩阵作为这个点的方向特征。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnEvWRhUKcWKAoYKWbN1kAuc.png)
+![](https://cdn.xyxsw.site/boxcnEvWRhUKcWKAoYKWbN1kAuc.png)
 
 实验表明，使用 4*4*8=122 的描述更加可靠。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcniVb6FvrZziID1B1JFmgVzx.jpg)
+![](https://cdn.xyxsw.site/boxcniVb6FvrZziID1B1JFmgVzx.jpg)
 
 特征点的匹配是通过计算两组特征点的 128 维的关键点的欧式距离实现的。欧式距离越小，则相似度越高，当欧式距离小于设定的阈值时，可以判定为匹配成功。
 
diff --git a/4.人工智能/4.6.5.5行人重识别(ReID).md b/4.人工智能/4.6.5.5行人重识别(ReID).md
index c3f0e87..219682d 100644
--- a/4.人工智能/4.6.5.5行人重识别(ReID).md
+++ b/4.人工智能/4.6.5.5行人重识别(ReID).md
@@ -8,10 +8,10 @@
 
 该任务目前在学术上是检索出不同摄像头下的相同行人图片，同时数据集中只有人的全身照，如下图所示。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/ReID1.png)
+![](https://cdn.xyxsw.site/ReID1.png)
 
 但是实际上在实际应用中的时候会和检测结合，简单来说先框出目标后分类，如下图所示。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/ReID2.png)
+![](https://cdn.xyxsw.site/ReID2.png)
 
 这个方向做的比较的奇怪，该模块只做整体性介绍，同时希望学习该模块的你对经典网络有所了解。
diff --git a/4.人工智能/4.6.6.1NLP领域任务（研究目标）.md b/4.人工智能/4.6.6.1NLP领域任务（研究目标）.md
index e729a12..f0516f9 100644
--- a/4.人工智能/4.6.6.1NLP领域任务（研究目标）.md
+++ b/4.人工智能/4.6.6.1NLP领域任务（研究目标）.md
@@ -4,25 +4,25 @@
 
 <strong>分类 (text classification)：</strong> 给一句话或者一段文本，判断一个标签。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/PxE3b05ApofzZ1x8u49cirdUnye.png)
+![](https://cdn.xyxsw.site/PxE3b05ApofzZ1x8u49cirdUnye.png)
 
 图 2：分类 (text classification)
 
 <strong>蕴含 (textual entailment)：</strong> 给一段话，和一个假设，看看前面这段话有没有蕴含后面的假设。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/OuhabfzABoqxQxxS1n1cPLTinKb.png)
+![](https://cdn.xyxsw.site/OuhabfzABoqxQxxS1n1cPLTinKb.png)
 
 图 3：蕴含 (textual entailment)
 
 <strong>相似 (Similarity)：</strong> 判断两段文字是否相似。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/ByeFbxTfToxFlgxh6xmcIKeRnzd.png)
+![](https://cdn.xyxsw.site/ByeFbxTfToxFlgxh6xmcIKeRnzd.png)
 
 图 4：相似 (Similarity)
 
 <strong>多选题 (Multiple Choice)：</strong> 给个问题，从 N 个答案中选出正确答案。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/ZYgybsj5dol1Ifx96Koc6SRpnmc.jpeg)
+![](https://cdn.xyxsw.site/ZYgybsj5dol1Ifx96Koc6SRpnmc.jpeg)
 
 图 5：多选题 (Multiple Choice)
 
diff --git a/4.人工智能/4.6.6.2.2.3推荐系统实例.md b/4.人工智能/4.6.6.2.2.3推荐系统实例.md
index c2fd453..3855193 100644
--- a/4.人工智能/4.6.6.2.2.3推荐系统实例.md
+++ b/4.人工智能/4.6.6.2.2.3推荐系统实例.md
@@ -1,6 +1,6 @@
 # 推荐系统的外围架构
 
-![推荐系统外围架构图](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/推荐系统外围架构图.png)
+![推荐系统外围架构图](https://cdn.xyxsw.site/推荐系统外围架构图.png)
 
 <center>推荐系统外围架构图</center>
 
@@ -22,7 +22,7 @@
 若是将推荐系统的任务细分，可以结合现实实际情况：将最新加入的物品推荐给用户；商业上需要宣传的物品推荐给用户；为用户推荐不同种类的物品。
 **复杂的特征和情况不同的任务**会让推荐系统变得非常复杂，所以推荐系统的架构为了方便考虑，采用多个不同的推荐引擎组成，每个推荐引擎专门负责某一类特征和一种任务，而推荐系统再将推荐引擎的结果按照一定的优先级合并，排序并返回给UI系统。
 
-![推荐系统的架构图](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/推荐系统的架构图.png)
+![推荐系统的架构图](https://cdn.xyxsw.site/推荐系统的架构图.png)
 
 <center>推荐系统的架构</center>
 	如上图所示。
@@ -38,7 +38,7 @@
 
 - 推荐列表筛选、过滤、重排列部分
 
-![推荐引擎的架构](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/推荐引擎的架构.png)
+![推荐引擎的架构](https://cdn.xyxsw.site/推荐引擎的架构.png)
 
 以上为推荐引擎的架构图。
 
diff --git a/4.人工智能/4.6.6.2.2.4利用用户行为数据.md b/4.人工智能/4.6.6.2.2.4利用用户行为数据.md
index d49ef7d..1d92a3e 100644
--- a/4.人工智能/4.6.6.2.2.4利用用户行为数据.md
+++ b/4.人工智能/4.6.6.2.2.4利用用户行为数据.md
@@ -179,7 +179,7 @@ $$Preference(u,i)=r_{ui}=p^T_uq_i=\sum^F_{f=1}{p_{u,k}q_{i,k}}$$
 
 在研究图模型之前，需要用已有的数据生成一个图，设二元组 $(u,i)$ 表示用u对于物品 i 产生过行为。令 $G(V,E)$ 表示用户物品二分图，其中$V=V_U\cup V_I$ 由用户顶点集合和物品顶点集合组成，$E$ 是边的集合。对于数据集中的二元组 $(u,i)$ 图中都会有对应的边 $e(v_u,v_i)\in E$ 如下图所示。
 
-![用户物品二分图模型](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/用户物品二分图模型.png)
+![用户物品二分图模型](https://cdn.xyxsw.site/用户物品二分图模型.png)
 
 ### 基于图的推荐算法
 
diff --git a/4.人工智能/4.6.6.2.3序列化推荐.md b/4.人工智能/4.6.6.2.3序列化推荐.md
index 3c0065f..5cc0a73 100644
--- a/4.人工智能/4.6.6.2.3序列化推荐.md
+++ b/4.人工智能/4.6.6.2.3序列化推荐.md
@@ -10,5 +10,5 @@
 <br/><br/>
 而SRSs则是将用户和商品的交互建模为一个动态的序列并且利用序列的依赖性来活捉当前和最近用户的喜好。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnolggxKhDZDBzIFPIaDFfhc.png)
+![](https://cdn.xyxsw.site/boxcnolggxKhDZDBzIFPIaDFfhc.png)
 
diff --git a/4.人工智能/4.6.6.2推荐系统.md b/4.人工智能/4.6.6.2推荐系统.md
index 6fa4dd1..967e47e 100644
--- a/4.人工智能/4.6.6.2推荐系统.md
+++ b/4.人工智能/4.6.6.2推荐系统.md
@@ -4,7 +4,7 @@
 
 如下图是阿里巴巴著名的“千人千面”推荐系统
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn3bdrD08wpaYhL59ezDukuc.jpg)
+![](https://cdn.xyxsw.site/boxcn3bdrD08wpaYhL59ezDukuc.jpg)
 
 还有短视频应用用户数量的急剧增长，这背后，视频推荐引擎发挥着不可替代的作用
 
diff --git a/4.人工智能/4.6.6.3知识图谱.md b/4.人工智能/4.6.6.3知识图谱.md
index dca6173..ebd27f4 100644
--- a/4.人工智能/4.6.6.3知识图谱.md
+++ b/4.人工智能/4.6.6.3知识图谱.md
@@ -19,7 +19,6 @@
 具体其发展历程参考：
 
 - [https://mp.weixin.qq.com/s/Mcikp99bsVgxAaykctmcAw](https://mp.weixin.qq.com/s/Mcikp99bsVgxAaykctmcAw) 知识图谱的前世今生
-- [https://www.it610.com/article/1277333416756396032.htm](https://www.it610.com/article/1277333416756396032.htm) 知识图谱历史发展
 
 在大致了解知识图谱的历史发展脉络后，我们或许对它有了一个初步的认知——一个由抽象符号构成的知识库，目的是为了让计算机理解人类的语义信息，打个不太恰当的比方，就是个计算机理解人类世界的大脑。
 
diff --git a/4.人工智能/4.6.7.1VIT.md b/4.人工智能/4.6.7.1VIT.md
index ef5c653..1203809 100644
--- a/4.人工智能/4.6.7.1VIT.md
+++ b/4.人工智能/4.6.7.1VIT.md
@@ -18,7 +18,7 @@
 
 ## 模型详解
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn1wqKtwBc6MCJDm7ehvhXac.png)
+![](https://cdn.xyxsw.site/boxcn1wqKtwBc6MCJDm7ehvhXac.png)
 
 ### 模型主题结构
 
@@ -51,9 +51,9 @@
 
 例如
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn1szLG4Y4s0UkY3kkW18Xoc.png)
+![](https://cdn.xyxsw.site/boxcn1szLG4Y4s0UkY3kkW18Xoc.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnv2inISAGi2xOauc3pxKpCb.png)
+![](https://cdn.xyxsw.site/boxcnv2inISAGi2xOauc3pxKpCb.png)
 
 其中该张图片的编码为[0.5，0.6，0.3，....]
 
diff --git a/4.人工智能/4.6.7.2BERT.md b/4.人工智能/4.6.7.2BERT.md
index b28e205..5d3b8e1 100644
--- a/4.人工智能/4.6.7.2BERT.md
+++ b/4.人工智能/4.6.7.2BERT.md
@@ -30,13 +30,13 @@ mlp 的重点和创新并非它的模型结构，而是它的训练方式，前
 
 BERT 模型的输入就是上面三者的和，如图所示：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcngc1a7cWapQA9rSLXYqUvkf.png)
+![](https://cdn.xyxsw.site/boxcngc1a7cWapQA9rSLXYqUvkf.png)
 
 ## 模型结构
 
 简单来说，BERT 是 transformer<strong>编码器</strong>的叠加，<strong>也就是下图左边部分</strong>。这算一个 block。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnPg8594YzCdnX6KZxpEYYod.png)
+![](https://cdn.xyxsw.site/boxcnPg8594YzCdnX6KZxpEYYod.png)
 
 说白了就是一个 多头自注意力=>layer-norm=> 接 feed forward(其实就是 mlp)=>layer-norm，没有什么创新点在这里。因为是一个 backbone 模型，它没有具体的分类头之类的东西。输出就是最后一层 block 的输出。
 
diff --git a/4.人工智能/4.6.7.3MAE.md b/4.人工智能/4.6.7.3MAE.md
index 45f7ac5..3533bf9 100644
--- a/4.人工智能/4.6.7.3MAE.md
+++ b/4.人工智能/4.6.7.3MAE.md
@@ -28,7 +28,7 @@ cv 领域，其实预训练模型早已推广，一般是在 imagenet 上进行
 
 在这里，作者为了加大任务的难度，扩大了被 mask 掉的比例，避免模型只学到双线性插值去修补缺的图像。作者把 75% 的 patch 进行 mask，然后放入模型训练。从下图可以看出，被 mask 的块是不进行编码的，这样也可以降低计算量，减少成本。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnd7HTEFOiJxVQ3jtOpzK4ie.png)
+![](https://cdn.xyxsw.site/boxcnd7HTEFOiJxVQ3jtOpzK4ie.png)
 
 在被保留的块通过编码器后，我们再在原先位置插入只包含位置信息的 mask 块，一起放入解码器。
 
@@ -38,7 +38,7 @@ cv 领域，其实预训练模型早已推广，一般是在 imagenet 上进行
 
 下面是原论文给的训练结果，可以看到效果是很惊人的。（有些图我脑补都补不出来）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnPWO0VWbPvCE537tf6MWu4e.png)
+![](https://cdn.xyxsw.site/boxcnPWO0VWbPvCE537tf6MWu4e.png)
 
 # 相关资料
 
diff --git a/4.人工智能/4.6.8.1前言.md b/4.人工智能/4.6.8.1前言.md
index 697999b..20ddac7 100644
--- a/4.人工智能/4.6.8.1前言.md
+++ b/4.人工智能/4.6.8.1前言.md
@@ -24,7 +24,7 @@
 
 直观来讲，我们把特征的向量进行一下归一化，它们就分布在一个超球面上。简单起见，我们先看 3 维向量
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnJ6HpIJqxJuxiz7Cw5GopSh.png)
+![](https://cdn.xyxsw.site/boxcnJ6HpIJqxJuxiz7Cw5GopSh.png)
 
 我们通过<strong>正样本</strong>（跟拿到的特征<strong>应当相近</strong>的另一个特征）与<strong>负样本</strong>（反之）的对比，使得
 
diff --git a/4.人工智能/4.6.8.2Inst Disc.md b/4.人工智能/4.6.8.2Inst Disc.md
index 3d6e134..88ad2c4 100644
--- a/4.人工智能/4.6.8.2Inst Disc.md	
+++ b/4.人工智能/4.6.8.2Inst Disc.md	
@@ -8,7 +8,7 @@
 
 作者团队认为，让这些猎豹，雪豹的标签相互接近（指互相在判别时都排名靠前）的原因并不是它们有相似的标签，而是它们有相似的图像特征。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnrR3eFvOSKYRH8Ni0dvHYkc.png)
+![](https://cdn.xyxsw.site/boxcnrR3eFvOSKYRH8Ni0dvHYkc.png)
 
 ## 个体判别任务
 
@@ -16,7 +16,7 @@
 
 于是他们<strong>把每一个图片当作一个类别</strong>，去跟其他的图片做对比，具体模型如下
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnPNukes2FlNwUFSKiqIJEbd.png)
+![](https://cdn.xyxsw.site/boxcnPNukes2FlNwUFSKiqIJEbd.png)
 
 先介绍一下模型结构：
 
@@ -48,11 +48,11 @@
 
 A 是起始点，B 是第一次更新后的点，C 是第二次更新后的点
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn5zfD155Joy1eD5CvbZXZnc.png)
+![](https://cdn.xyxsw.site/boxcn5zfD155Joy1eD5CvbZXZnc.png)
 
 而在我们刚刚提到的动量更新里，它的公式可以概括为：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnTLEK31rFmuRo2MOWGRBoYe.png)
+![](https://cdn.xyxsw.site/boxcnTLEK31rFmuRo2MOWGRBoYe.png)
 
 m 表示动量，k 是新的特征，q 是上一个特征，只要设置小的动量就可以使改变放缓。
 
diff --git a/4.人工智能/4.6.8.3定义正负样本的方式.md b/4.人工智能/4.6.8.3定义正负样本的方式.md
index c62f67d..04af727 100644
--- a/4.人工智能/4.6.8.3定义正负样本的方式.md
+++ b/4.人工智能/4.6.8.3定义正负样本的方式.md
@@ -4,7 +4,7 @@
 
 # 1.时序性定义（生成式模型）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnC10uzdj0G0BJPlUZKFIi7C.png)
+![](https://cdn.xyxsw.site/boxcnC10uzdj0G0BJPlUZKFIi7C.png)
 
 这是处理音频的一个例子，<strong>给模型 t 时刻以前的信息，让它抽取特征并对后文进行预测，真正的后文作为正样本，负样本当然是随便选取就好啦。</strong>
 
@@ -24,4 +24,4 @@
 
 （这篇论文我准备开个新坑放着了，因为说实话不算对比学习，算多模态）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnssaOVvp73SVIrzVvZPr1Je.png)
+![](https://cdn.xyxsw.site/boxcnssaOVvp73SVIrzVvZPr1Je.png)
diff --git a/4.人工智能/4.6.8.4MoCo.md b/4.人工智能/4.6.8.4MoCo.md
index 1d633dd..e048089 100644
--- a/4.人工智能/4.6.8.4MoCo.md
+++ b/4.人工智能/4.6.8.4MoCo.md
@@ -24,7 +24,7 @@ NCE 把<strong>所有负样本都视作一样的</strong>，但实际上负样
 
 右边就是 memory bank 啦
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnKMjslIshEA5SFqc8rbmqoe.png)
+![](https://cdn.xyxsw.site/boxcnKMjslIshEA5SFqc8rbmqoe.png)
 
 # MoCo 做出的改进
 
@@ -38,7 +38,7 @@ NCE 把<strong>所有负样本都视作一样的</strong>，但实际上负样
 
 动量编码器是独立于原编码器的一个编码器，它的参数是根据原编码器动量更新的，k 和 q 就是指代全部参数了
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnFLSP9PtQRkgYgcMwM4idog.png)
+![](https://cdn.xyxsw.site/boxcnFLSP9PtQRkgYgcMwM4idog.png)
 
 这样的话就是解码器在缓慢更新，比对特征使用动量更新要更有连续性。
 
@@ -48,7 +48,7 @@ NCE 把<strong>所有负样本都视作一样的</strong>，但实际上负样
 
 [（什么？你看到这了还不会交叉熵？戳这里）](https://zhuanlan.zhihu.com/p/149186719)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnnWI38bkSzeCe5TtVTBCrNh.png)
+![](https://cdn.xyxsw.site/boxcnnWI38bkSzeCe5TtVTBCrNh.png)
 
 q·k 其实就是各个特征（因为那时候用的都是 transformer 了，这里就是 trnasformer 里的 k 和 q）
 
@@ -56,9 +56,9 @@ q·k 其实就是各个特征（因为那时候用的都是 transformer 了，
 
 T 越大，损失函数就越对所有负样本<strong>一视同仁</strong>，退化为二分类的 NCEloss；T 越小，损失函数就<strong>越关注一些难分类的特征</strong>，但有时候会出现两张其实都是猫猫的图片，你硬要让模型说猫猫跟猫猫不一样，这也不太好，这个参数要根据数据集情况适中调整。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnhuabU9XzXmVQfu0ruENs83.png)
+![](https://cdn.xyxsw.site/boxcnhuabU9XzXmVQfu0ruENs83.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnsGpqCNePn2G34GnJqPieBf.png)
+![](https://cdn.xyxsw.site/boxcnsGpqCNePn2G34GnJqPieBf.png)
 
 上面那张是 T 较大的情况，下面是 T 较小的情况（x 轴是各个类别，y 轴是分类得分）
 
diff --git a/4.人工智能/4.6.8.5SimCLR.md b/4.人工智能/4.6.8.5SimCLR.md
index 07c49fa..7721627 100644
--- a/4.人工智能/4.6.8.5SimCLR.md
+++ b/4.人工智能/4.6.8.5SimCLR.md
@@ -6,7 +6,7 @@
 
 x 是输入的图片，它经过两种不同的数据增强得到 xi 和 xj 两个正样本，而同一个 mini-batch 里的所有其他样本都作为负样本。<del>说白了还是个体判别任务</del>
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnq5TYzSltn6CsPM3Bn3xxAb.png)
+![](https://cdn.xyxsw.site/boxcnq5TYzSltn6CsPM3Bn3xxAb.png)
 
 左右的<strong>f 都是编码器</strong>，并且是<strong>完全一致共享权重</strong>的，可以说是同一个。
 
@@ -18,7 +18,7 @@ x 是输入的图片，它经过两种不同的数据增强得到 xi 和 xj 两
 
 下面这个是更加具体的流程图
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnj3FZsRiJbWsKW07b9B8Fkb.png)
+![](https://cdn.xyxsw.site/boxcnj3FZsRiJbWsKW07b9B8Fkb.png)
 
 # 总结
 
diff --git a/4.人工智能/4.6.8.6SwAV.md b/4.人工智能/4.6.8.6SwAV.md
index bbfd152..9d270fe 100644
--- a/4.人工智能/4.6.8.6SwAV.md
+++ b/4.人工智能/4.6.8.6SwAV.md
@@ -20,7 +20,7 @@
 
 下图左边是常规的对比学习（比如 SimCLR）的结构，右图是 SWAV 的结构，不难看出多了一个叫 prototypes 的东西。这个东西其实是聚类中心向量所构成的矩阵。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnGteJZelEtVqBFwwukw7c8g.png)
+![](https://cdn.xyxsw.site/boxcnGteJZelEtVqBFwwukw7c8g.png)
 
 下面的内容可能有些理解上的难度（反正我第一次听讲解的时候就云里雾里的），我会尽可能直白地描述这个过程。
 
@@ -40,7 +40,7 @@
 
 而我们的优化要采用 [K-means](https://zhuanlan.zhihu.com/p/78798251)(不懂可以看这里)的类似做法，先对聚类中心进行优化，再对特征进行优化。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnKe4DzDfdNbhhHowdE4BJEf.png)
+![](https://cdn.xyxsw.site/boxcnKe4DzDfdNbhhHowdE4BJEf.png)
 
 so，why？相信你现在肯定是一脸懵，不过别急，希望我能为你讲懂。
 
diff --git a/4.人工智能/4.6.8.7BYOL.md b/4.人工智能/4.6.8.7BYOL.md
index fd53f56..fbfd220 100644
--- a/4.人工智能/4.6.8.7BYOL.md
+++ b/4.人工智能/4.6.8.7BYOL.md
@@ -18,7 +18,7 @@
 
 <strong>predictor</strong>的模型结构就是跟 z 一样的<strong>mlp 层</strong>。它的任务是<strong>通过紫色的特征去预测粉色的特征</strong>。也就是说它的代理任务换成了<strong>生成式</strong>。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcne7eizRhw5GKRSpF40KcMEh.png)
+![](https://cdn.xyxsw.site/boxcne7eizRhw5GKRSpF40KcMEh.png)
 
 而具体的损失只有预测特征和真实特征的损失，用的是<strong>MSEloss</strong>。
 
@@ -32,7 +32,7 @@
 
 ### 有篇博客在复现 BYOL 时，不小心没加这个 BN 层，导致模型直接摆烂。那么 BN 到底藏着什么呢？
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn8wfpZCjOD2lFsM03N5vatl.png)
+![](https://cdn.xyxsw.site/boxcn8wfpZCjOD2lFsM03N5vatl.png)
 
 我们得先来回顾一下 BN 做了什么。
 
@@ -52,7 +52,7 @@ BN 根据批次的均值和方差进行归一化
 
   这篇论文叫 BYOL works even without batch statistics，即在没有 BN 的时候 BYOL 照样能工作，详细的消融实验结果如下表所示 ：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcncmJWb99mlUUIFTPjGoCqYb.png)
+![](https://cdn.xyxsw.site/boxcncmJWb99mlUUIFTPjGoCqYb.png)
 
 <strong>BN 非常关键</strong>：只要是 `projector`（SimCLR 提出的 mlp）中没有 BN 的地方，SimCLR 性稍微下降；但是 BYOL 全都模型坍塌了。
 
diff --git a/4.人工智能/4.6.8.8SimSiam.md b/4.人工智能/4.6.8.8SimSiam.md
index 98fe5f1..f9480a1 100644
--- a/4.人工智能/4.6.8.8SimSiam.md
+++ b/4.人工智能/4.6.8.8SimSiam.md
@@ -20,7 +20,7 @@ BYOL 之后，大家都发现对比学习是靠许许多多的小 trick 和技
 
 虽然看起来只有左边预测右边，其实右边也有一个 predictor 去预测左边的特征，两边是对称的，左右的优化有先后顺序。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnWk5QzvbsSNlyV4B7SMt5zb.png)
+![](https://cdn.xyxsw.site/boxcnWk5QzvbsSNlyV4B7SMt5zb.png)
 
 结构其实没什么特殊的地方，主要讲讲思想。
 
@@ -44,7 +44,7 @@ BYOL 之后，大家都发现对比学习是靠许许多多的小 trick 和技
 
 这是作者总结的所有”孪生网络“的模型结构，很精炼。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn8OWwnN8ae2vUVttqlu5O8e.png)
+![](https://cdn.xyxsw.site/boxcn8OWwnN8ae2vUVttqlu5O8e.png)
 
 下面是这些网络训练结果的对比，也列出了它们分别有哪些 trick（用的是分类任务）
 
@@ -52,8 +52,8 @@ BYOL 之后，大家都发现对比学习是靠许许多多的小 trick 和技
                                                    负样本         动量编码器      训练轮数 
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn3uizAKNhAxQryOwvHxFSDb.png)
+![](https://cdn.xyxsw.site/boxcn3uizAKNhAxQryOwvHxFSDb.png)
 
 具体结果还是图片比较直观（
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnqdfrOIxim4wBayDDBitHCd.png)
+![](https://cdn.xyxsw.site/boxcnqdfrOIxim4wBayDDBitHCd.png)
diff --git a/4.人工智能/4.6.8.9MoCo v3.md b/4.人工智能/4.6.8.9MoCo v3.md
index f849189..e3e0ecc 100644
--- a/4.人工智能/4.6.8.9MoCo v3.md	
+++ b/4.人工智能/4.6.8.9MoCo v3.md	
@@ -10,7 +10,7 @@ MoCo v3，它缝合了 MoCo 和 SimSiam，以及新的骨干网络 VIT。
 
 可能因为和前面的工作太像了，作者就没有给模型总览图，我们借 MoCo 的总览图来讲
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnhxg4HZw2NExIbYZxQGISze.png)
+![](https://cdn.xyxsw.site/boxcnhxg4HZw2NExIbYZxQGISze.png)
 
 总体架构其实没有太多变化，还是 memory bank 的结构，右边也还是动量编码器，不过加入了 SimCLR 提出的 projection head（就是额外的那层 mlp），并且在对比上用了 SimSiam 的预测头对称学习方式。具体也不展开了，都是老东西缝合在一起。
 
@@ -18,11 +18,11 @@ MoCo v3，它缝合了 MoCo 和 SimSiam，以及新的骨干网络 VIT。
 
 作者在用 VIT 做骨干网络训练的时候，发现如下问题：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnMMhbVk6wc81H8BSoack7Mg.png)
+![](https://cdn.xyxsw.site/boxcnMMhbVk6wc81H8BSoack7Mg.png)
 
 在使用 VIT 训练的时候，batchsize 不算太大时训练很平滑，但是一旦 batchsize 变大，训练的图像就会出现如上图这样的<strong>波动</strong>。于是作者去查看了每一层的梯度，发现问题出在<strong>VIT 的第一层线性变换</strong>上。也就是下图中的粉色那个层，<strong>把图片打成 patch 后展平做的线性变换</strong>。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcniBkiypcv6IQbxr9D6JukOb.png)
+![](https://cdn.xyxsw.site/boxcniBkiypcv6IQbxr9D6JukOb.png)
 
 在这一层中，梯度会出现波峰，而正确率则会突然下跌。
 
diff --git a/4.人工智能/4.6.9.3基本概念介绍.md b/4.人工智能/4.6.9.3基本概念介绍.md
index c4c7761..227f026 100644
--- a/4.人工智能/4.6.9.3基本概念介绍.md
+++ b/4.人工智能/4.6.9.3基本概念介绍.md
@@ -4,13 +4,13 @@
 
 ## 强化学习的基本过程
 前面已经介绍过强化学习的核心过程，在于智能体与环境进行交互，通过给出的奖励反馈作为信号学习的过程。简单地用图片表示如下：
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/4.6.9.3.1.png)
+![](https://cdn.xyxsw.site/4.6.9.3.1.png)
 正是在这个与环境的交互过程中，智能体不断得到反馈，目标就是尽可能地让环境反馈的奖励足够大。
 
 ## 强化学习过程的基本组成内容
 为了便于理解，我们引入任天堂经典游戏——[新超级马里奥兄弟U](https://www.nintendoswitch.com.cn/new_super_mario_bros_u_deluxe/pc/index.html)，作为辅助理解的帮手。作为一个2D横向的闯关游戏，它的状态空间和动作空间无疑是简单的。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/4.6.9.3.2.png)
+![](https://cdn.xyxsw.site/4.6.9.3.2.png)
 
 1.智能体(Agent):它与环境交互，可以观察到环境并且做出决策，然后反馈给环境。在马里奥游戏中，能操控的这个马里奥本体就是智能体。
 
@@ -22,7 +22,7 @@
 
 5.策略(Policy):智能体采取动作的规则，分为**确定性策略**与**随机性策略**。确定性策略代表在相同的状态下，智能体所输出的动作是唯一的。而随机性策略哪怕是在相同的状态下，输出的动作也有可能不一样。这么说有点过于抽象了，那么请思考这个问题：在下面这张图的环境中，如果执行确定性策略会发生什么？(提示：着重关注两个灰色的格子)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/4.6.9.3.3.png)
+![](https://cdn.xyxsw.site/4.6.9.3.3.png)
 
 因此，在强化学习中我们一般使用随机性策略。随机性策略通过引入一定的随机性，使环境能够被更好地探索。同时，如果策略固定——你的对手很容易能预测你的下一步动作并予以反击，这在博弈中是致命的。
 随机性策略$\pi$定义如下：
diff --git a/4.人工智能/4.9如何做研究.md b/4.人工智能/4.9如何做研究.md
index d9a7986..449e7e3 100644
--- a/4.人工智能/4.9如何做研究.md
+++ b/4.人工智能/4.9如何做研究.md
@@ -4,7 +4,7 @@
 
 Author： 任浩帆
 
-Email: yqykrhf@163.commailto:yqykrhf@163.com
+Email: yqykrhf@163.com
 
 术语介绍的补充：Spy
 
diff --git a/4.人工智能/SRT.md b/4.人工智能/SRT.md
index e3f6dce..5b20f2d 100644
--- a/4.人工智能/SRT.md
+++ b/4.人工智能/SRT.md
@@ -2,7 +2,7 @@
 
 SRT 社团，全名 Student Research Trainning，旨在通过真正的科研活动培养本科生的科研能力。SRT 社团依托 [智能信息处理处理实验室](http://iipl.net.cn/index/list_team.aspx)（IIPL），主要研究方向围绕人工智能，具体来说，包括：计算机视觉，多模态，3D 视觉，Slam 等领域。有充足且优质的显卡资源，工位资源，以及学长学姐，老师的指导。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Am3Iwb1ggnyUkB1b9osh.png)
+![](https://cdn.xyxsw.site/Am3Iwb1ggnyUkB1b9osh.png)
 
 社团每年都在全校范围为智能信息处理实验室招收，培养本科生。本科生进入实验室后跟随导师独立或合作进行科研项目，发表论文。我们届时会在自动化以及通信学院进行宣讲招新，新生在经过1-2学期的培养后，能够具备独立科研的能力。在正式进入实验室前，可以暂时使用社团的工位，进入实验室后可以拥有独立工位以及显卡资源。社团的实验室在科技馆五楼，欢迎大家常来 ~
 
@@ -12,4 +12,4 @@ SRT 社团，全名 Student Research Trainning，旨在通过真正的科研活
 
 当然，在学习人工智能模块时遇到任何问题也都可以咨询我们，我们将在能力范围内尽力给各位解答！
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/srt2023newqqgroup.png)
+![](https://cdn.xyxsw.site/srt2023newqqgroup.png)
diff --git a/4.人工智能/ch02/ch2.1/ch2.1.1/itemcf.md b/4.人工智能/ch02/ch2.1/ch2.1.1/itemcf.md
index 92c69d2..5cda620 100644
--- a/4.人工智能/ch02/ch2.1/ch2.1.1/itemcf.md
+++ b/4.人工智能/ch02/ch2.1/ch2.1.1/itemcf.md
@@ -260,10 +260,4 @@ $$
 # 参考资料
 
 * [基于用户的协同过滤来构建推荐系统：https://mp.weixin.qq.com/s/ZtnaQrVIpVOPJpqMdLWOcw](https://mp.weixin.qq.com/s/ZtnaQrVIpVOPJpqMdLWOcw)
-* [协同过滤算法概述：https://chenk.tech/posts/8ad63d9d.html](https://chenk.tech/posts/8ad63d9d.html)
 * B站黑马推荐系统实战课程
-
-
-
-
-
diff --git a/4.人工智能/ch02/ch2.1/ch2.1.1/usercf.md b/4.人工智能/ch02/ch2.1/ch2.1.1/usercf.md
index 72a3c86..68fd0f0 100644
--- a/4.人工智能/ch02/ch2.1/ch2.1.1/usercf.md
+++ b/4.人工智能/ch02/ch2.1/ch2.1.1/usercf.md
@@ -341,5 +341,4 @@ $$
 # 参考资料
 
 * [基于用户的协同过滤来构建推荐系统：https://mp.weixin.qq.com/s/ZtnaQrVIpVOPJpqMdLWOcw](https://mp.weixin.qq.com/s/ZtnaQrVIpVOPJpqMdLWOcw)
-* [协同过滤算法概述：https://chenk.tech/posts/8ad63d9d.html](https://chenk.tech/posts/8ad63d9d.html)
 * B站黑马推荐系统实战课程
diff --git a/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeDNN.md b/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeDNN.md
index 7e7006a..066b34d 100644
--- a/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeDNN.md
+++ b/4.人工智能/ch02/ch2.1/ch2.1.2/YoutubeDNN.md
@@ -85,7 +85,7 @@ $$
 
 Ok，到这里平淡无奇， 前向传播也大致上快说完了， 还差最后一步。 最后这一步，就是做多分类问题，然后求损失，这就是training那边做的事情。 但是在详细说这个之前， 我想先简单回忆下word2vec里面的skip-gram Model， 这个模型，如果回忆起来，这里理解起来就非常的简单了。
 
-这里只需要看一张图即可， 这个来自cs231N公开课PPT， 我之前整理w2v的时候用到的，详细内容可看我[这篇博客](https://zhongqiang.blog.csdn.net/article/details/106948860)， 这里的思想其实也是从w2v那边过来的。
+这里只需要看一张图即可， 这个来自cs231N公开课PPT， 我之前整理w2v的时候用到的，这里的思想其实也是从w2v那边过来的。
 
 <div align=center>
 <img src="https://img-blog.csdnimg.cn/20200624193409649.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1emhvbmdxaWFuZw==,size_1,color_FFFFFF,t_70#pic_center" alt="在这里插入图片描述" style="zoom:70%;" /> 
diff --git a/4.人工智能/ch02/ch2.1/ch2.1.2/word2vec.md b/4.人工智能/ch02/ch2.1/ch2.1.2/word2vec.md
index cbaea10..5ff769b 100644
--- a/4.人工智能/ch02/ch2.1/ch2.1.2/word2vec.md
+++ b/4.人工智能/ch02/ch2.1/ch2.1.2/word2vec.md
@@ -103,7 +103,7 @@ Word2vec包含两个模型，**Skip-gram与CBOW**。下面，我们先讲**Skip-
 我们滑动窗口，再以banking为中心词
 
 
-<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片4.png"在这里插入图片描述"  /> 
+<img src="https://ryluo.oss-cn-chengdu.aliyuncs.com/图片4.png"  /> 
 
 
 那么，如果我们在整个语料库上不断地滑动窗口，我们可以得到所有位置的$P(o|c)$，我们希望在所有位置上**最大化单词o在单词c周围出现了这一事实**，由极大似然法，可得：
diff --git a/4.人工智能/ch02/ch2.2/ch2.2.1.md b/4.人工智能/ch02/ch2.2/ch2.2.1.md
index e43ab26..57cbb5d 100644
--- a/4.人工智能/ch02/ch2.2/ch2.2.1.md
+++ b/4.人工智能/ch02/ch2.2/ch2.2.1.md
@@ -239,7 +239,7 @@ $$
 
 ### 编程实践
 
-下面我们通过kaggle上的一个ctr预测的比赛来看一下GBDT+LR模型部分的编程实践， [数据来源](https://github.com/zhongqiangwu960812/AI-RecommenderSystem/tree/master/GBDT%2BLR/data)
+下面我们通过kaggle上的一个ctr预测的比赛来看一下GBDT+LR模型部分的编程实践， [数据来源](https://github.com/zhongqiangwu960812/AI-RecommenderSystem/tree/master/Rank/GBDT%2BLR/data)
 
 我们回顾一下上面的模型架构， 首先是要训练GBDT模型， GBDT的实现一般可以使用xgboost， 或者lightgbm。训练完了GBDT模型之后， 我们需要预测出每个样本落在了哪棵树上的哪个节点上， 然后通过one-hot就会得到一些新的离散特征， 这和原来的特征进行合并组成新的数据集， 然后作为逻辑回归的输入，最后通过逻辑回归模型得到结果。
 
diff --git a/4.人工智能/ch02/ch2.2/ch2.2.3/DeepFM.md b/4.人工智能/ch02/ch2.2/ch2.2.3/DeepFM.md
index c03efaf..5ee74dd 100644
--- a/4.人工智能/ch02/ch2.2/ch2.2.3/DeepFM.md
+++ b/4.人工智能/ch02/ch2.2/ch2.2.3/DeepFM.md
@@ -151,6 +151,6 @@ def DeepFM(linear_feature_columns, dnn_feature_columns):
 **参考资料**
 - [论文原文](https://arxiv.org/pdf/1703.04247.pdf)
 - [deepctr](https://github.com/shenweichen/DeepCTR)
-- [FM](https://github.com/datawhalechina/team-learning-rs/blob/master/RecommendationSystemFundamentals/04%20FM.md)
+- [FM](https://github.com/datawhalechina/fun-rec/blob/master/docs/ch02/ch2.1/ch2.1.2/FM.md)
 - [推荐系统遇上深度学习(三)--DeepFM模型理论和实践](https://www.jianshu.com/p/6f1c2643d31b)
 - [FM算法公式推导](https://blog.csdn.net/qq_32486393/article/details/103498519)
\ No newline at end of file
diff --git a/5.富有生命的嵌入式/5.1嵌入式是什么？可以吃吗？.md b/5.富有生命的嵌入式/5.1嵌入式是什么？可以吃吗？.md
index 1faca46..7879620 100644
--- a/5.富有生命的嵌入式/5.1嵌入式是什么？可以吃吗？.md
+++ b/5.富有生命的嵌入式/5.1嵌入式是什么？可以吃吗？.md
@@ -8,7 +8,7 @@
 
 这不是因为那些人没有完全入门嵌入式，而是因为在嵌入式的学习过程中你会发现，它的概念会越来越大，逐渐模糊了你的认知，就拿一张某乎上的照片而言：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcny07MPlh99IIS5yxAdL4iDb.png)
+![](https://cdn.xyxsw.site/boxcny07MPlh99IIS5yxAdL4iDb.png)
 
 可见嵌入式的概念之广。
 
@@ -20,7 +20,7 @@
 
 这玩意儿大家估计不陌生，比如你去酒店里，也许会有一个可以坐电梯上下楼层来完成特定任务的机器人（说实话高二在某季酒店第一次见的时候还蛮新鲜）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn99MPmacSrXPkIgQ13FLABc.jpg)
+![](https://cdn.xyxsw.site/boxcn99MPmacSrXPkIgQ13FLABc.jpg)
 
 而它也是一个嵌入式产品（或者说它们）。
 
diff --git a/5.富有生命的嵌入式/5.2New meaning of C.md b/5.富有生命的嵌入式/5.2New meaning of C.md
index 2389768..42117e4 100644
--- a/5.富有生命的嵌入式/5.2New meaning of C.md	
+++ b/5.富有生命的嵌入式/5.2New meaning of C.md	
@@ -83,15 +83,15 @@ ORG 0BH
 
 下面引入一个 STM32F1 系列的 GPIO 部分寄存器图（来源正点原子提供的 F1 参考手册）：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/MyDMbeCKLowC1Mx7Q6Ec9BLPn4g.png)
+![](https://cdn.xyxsw.site/MyDMbeCKLowC1Mx7Q6Ec9BLPn4g.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/LJ1SbFfv6oUIgtx8CstcbWTNnRg.png)
+![](https://cdn.xyxsw.site/LJ1SbFfv6oUIgtx8CstcbWTNnRg.png)
 
 如果我们想做一个简单的实验-驱动一个 LED 灯（假设此 LED 灯以 PB5 为输出驱动口），在对相应的 RCC 时钟等配置之外，最重要的是对相应的 GPIO 口的配置，首先我们查阅其寄存器的物理起始地址：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/CZ3cbiEhsoWDgJxhwXIcpUkAnMg.png)
+![](https://cdn.xyxsw.site/CZ3cbiEhsoWDgJxhwXIcpUkAnMg.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/HTFUbsQCNouQVzx0QYiciQWOnZf.png)
+![](https://cdn.xyxsw.site/HTFUbsQCNouQVzx0QYiciQWOnZf.png)
 
 可见 GPIO 外设通过 APB2 总线进行地址定位与传输数据的，所以我们要控制 PB5 的话首先需要定位到对应的地址：
 
diff --git a/5.富有生命的嵌入式/5.3还玩裸机？上操作系统！.md b/5.富有生命的嵌入式/5.3还玩裸机？上操作系统！.md
index a5ee4b4..3e8d5cf 100644
--- a/5.富有生命的嵌入式/5.3还玩裸机？上操作系统！.md
+++ b/5.富有生命的嵌入式/5.3还玩裸机？上操作系统！.md
@@ -16,13 +16,13 @@ RTOS 中最重要的概念则是“任务”。
 
 我们可以回想一下在 MCU 开发过程中，一般都是在 main 函数里做个 while（1）来完成大部分的处理，将一些相对来说对实时性要求高的函数（如 PID 控制器）扔到定时器中断当中，即应用程序是个无限的循环，是个单任务系统（前后台系统），while（1）作为后台，中断服务函数作为前台。这里采用了“正点原子”的一张图：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnFySF1Cd02I052V0a9glH1c.png)
+![](https://cdn.xyxsw.site/boxcnFySF1Cd02I052V0a9glH1c.png)
 
 而 RTOS 则是一个多任务系统，那么它这么做有什么好处呢？
 
 2>1 嘛（乐），实际上在前后台系统中，你的每项 Task 要轮流排队等着上次 Task 执行结束后再进行自己的程序，大大影响了其系统的实时性要求；而 RTOS 中我们把整个 while（1）区分成了很多小任务，并且在表面上看起来这些任务运行起来像是同时进行，实际上是因为任务所需的时间较少导致它看起来像是并行，但这将会带来新的疑问，到底什么任务先执行呢？RTOS 就为此提供了任务的相关 API 接口，赋予任务相应的执行优先级属性，并通过任务调度器来控制任务的执行顺序。这里同样采用了“正点原子”的一张图：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcntQgR61yRboDpyb1bpI10Xp.png)
+![](https://cdn.xyxsw.site/boxcntQgR61yRboDpyb1bpI10Xp.png)
 
 所以，<strong>其实可以这么说：RTOS 将整个流程变成了很多个 while（1）【每个任务都是个 while（1）】。</strong>
 
@@ -66,7 +66,7 @@ int main（）{
 
 由于硬件技术的飞速发展，针对于机器人软件设计的框架也面临着极大的挑战，而 ROS 的出现无异是所有机器人开发者的福音，因为如果按照以前的制作一个机器人流程来讲，也许你要经历以下步骤：硬件结构搭建、控制处理、相关算法构建等等，但是 ROS 的开源共享模式令其可以在其平台上巧妙利用别人的开源模型完成自己的机器人搭建，<strong>也就是说 Ros 的出现打破了原本各个开发者（或团队）闭门造车的开发现象，使得其可以共享优秀的机器人应用软件，换句话说就是提高了机器人研发的软件复用率。（毕竟哪个团队都不可能同时在建图、导航、视觉等机器人应用方面处于顶尖位置）</strong>
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnRy7E27xggqNshXX3cu4J5Q.png)
+![](https://cdn.xyxsw.site/boxcnRy7E27xggqNshXX3cu4J5Q.png)
 
 由于 ROS 中完成度最高的是 Ubuntu，所以我们建议你以此展开学习，当然你也可以选择 macOS、Debian 等 OS。
 
diff --git a/5.富有生命的嵌入式/5.富有生命的嵌入式.md b/5.富有生命的嵌入式/5.富有生命的嵌入式.md
index 7c88e20..0fd5f17 100644
--- a/5.富有生命的嵌入式/5.富有生命的嵌入式.md
+++ b/5.富有生命的嵌入式/5.富有生命的嵌入式.md
@@ -16,6 +16,6 @@ Author：肖扬
 
 > “点星星之火，燃燎原之势，热血芳华，理想当燃”
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn3t2GyLQqe4RpGdRtakcwBc.png)
+![](https://cdn.xyxsw.site/boxcn3t2GyLQqe4RpGdRtakcwBc.png)
 
 ps：若对此部分讲义有相关疑问或者建议，欢迎 QQ 联系-1213047454
diff --git a/6.计算机安全/6.1.1SQL 注入.md b/6.计算机安全/6.1.1SQL 注入.md
index d89e491..9a8242d 100644
--- a/6.计算机安全/6.1.1SQL 注入.md	
+++ b/6.计算机安全/6.1.1SQL 注入.md	
@@ -34,7 +34,7 @@ def check_pass(username, password):
 
 从 `users` 表中查出 `username` 对应的 `password` 的哈希值，将其与用户传入的密码哈希值进行比对，若相等则意味着用户传入的密码与数据库中储存的密码相吻合，于是返回准许登录
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnHiNBWN86AR4AvSSsUVwSWb.png)
+![](https://cdn.xyxsw.site/boxcnHiNBWN86AR4AvSSsUVwSWb.png)
 
 那么问题来了，在语句
 
@@ -144,7 +144,7 @@ mysql> select group_concat(id,username separator '_') from users;
 
 现在我们传入 `Liki4'` 这个字符串
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn8TrpE02fnPV7dFzkmnHiAe.png)
+![](https://cdn.xyxsw.site/boxcn8TrpE02fnPV7dFzkmnHiAe.png)
 
 很遗憾，报错了，这个查询因为 SQL 语句存在语法错误而无法完成。
 
@@ -154,7 +154,7 @@ mysql> select group_concat(id,username separator '_') from users;
 
 那如果我们传入 `Liki4';#` 这个字符串，那么在拼接后的查询又是什么结果呢
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnbAKreqEeZxOYQuQMtZbd9d.png)
+![](https://cdn.xyxsw.site/boxcnbAKreqEeZxOYQuQMtZbd9d.png)
 
 很显然，`#` 号将原本语句的 `';` 注释掉了
 
@@ -166,7 +166,7 @@ mysql> select group_concat(id,username separator '_') from users;
 
 `raw_sql_danger' UNION SELECT password FROM users WHERE username = 'Liki5';#`
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcniDohuM3F8FbMqz7YSC0Y5g.png)
+![](https://cdn.xyxsw.site/boxcniDohuM3F8FbMqz7YSC0Y5g.png)
 
 <strong>真是惊人的壮举！我完全不认识这个叫 Liki5 的家伙，但我居然知道了他的密码对应的哈希值！</strong>
 
@@ -273,7 +273,7 @@ if __name__ == "__main__":
 
 接下来我们进行一次常规查询
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnpCCmEi6LIKNi0UqEkXfJ8g.png)
+![](https://cdn.xyxsw.site/boxcnpCCmEi6LIKNi0UqEkXfJ8g.png)
 
 可以看到我们成功从数据库中查出了 `username` 和 `password`，并显示在返回中
 
@@ -293,7 +293,7 @@ def query(username):
 ...
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnbaW15gnJc1O9Iv9WXqJxPc.png)
+![](https://cdn.xyxsw.site/boxcnbaW15gnJc1O9Iv9WXqJxPc.png)
 
 可以看到，实际执行的语句为
 
@@ -307,7 +307,7 @@ SELECT * FROM users WHERE username = '123' UNION SELECT 1, 2;#'
 
 构造语句 `123' UNION SELECT DATABASE(), @@version;#`
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnDeDp5yPE7W4KX9ByBl9ovh.png)
+![](https://cdn.xyxsw.site/boxcnDeDp5yPE7W4KX9ByBl9ovh.png)
 
 我们就能看到返回中包含了当前数据库名与当前数据库版本
 
@@ -317,13 +317,13 @@ SELECT * FROM users WHERE username = '123' UNION SELECT 1, 2;#'
 
 > `information_schema` 库是一个 MySQL 内置数据库，储存了数据库中的一些基本信息，比如数据库名，表名，列名等一系列关键数据，SQL 注入中可以查询该库来获取数据库中的敏感信息。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnkwvSnhKBhlHNLOSthgul9d.png)
+![](https://cdn.xyxsw.site/boxcnkwvSnhKBhlHNLOSthgul9d.png)
 
 我们可以发现，当前数据库中还存在一张叫 `secret` 的表，让我们偷看一下里面存的是什么
 
 构造语句 `123' UNION SELECT 1, secret_string FROM secret;#`
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn3kfhJ79ByNML2Z1Q1MwRye.png)
+![](https://cdn.xyxsw.site/boxcn3kfhJ79ByNML2Z1Q1MwRye.png)
 
 好像得到了什么不得了的秘密 :-)
 
@@ -363,7 +363,7 @@ if __name__ == "__main__":
 
 这样一来我们就只能知道自己是否登录成功，并不能看到查询返回的结果了
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcn2seUNESHkLC9PYvDp0vFbe.png)
+![](https://cdn.xyxsw.site/boxcn2seUNESHkLC9PYvDp0vFbe.png)
 
 那也就是说，我们无法直观地查看数据库中的数据了，即便查出了不该查的也看不到了 :-(
 
@@ -396,7 +396,7 @@ else:
 
 > rlike 是 MySQL 中的一个关键字，是 regex 和 like 的结合体
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnJEeAKow3ZhUSvbL4FQXxOh.png)
+![](https://cdn.xyxsw.site/boxcnJEeAKow3ZhUSvbL4FQXxOh.png)
 
 这里实际执行的语句就变成了
 
@@ -404,13 +404,13 @@ else:
 SELECT password FROM users WHERE username = 'Liki4' AND if(@@version rlike '^5',1,0);
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnJ3jImTQcMUOWJclTACj74e.png)
+![](https://cdn.xyxsw.site/boxcnJ3jImTQcMUOWJclTACj74e.png)
 
 ```sql
 SELECT password FROM users WHERE username = 'Liki4' AND if(@@version rlike '^8',1,0);
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnEDPFbKQ6iaM5WhHWUWmI5d.png)
+![](https://cdn.xyxsw.site/boxcnEDPFbKQ6iaM5WhHWUWmI5d.png)
 
 也就是说，当 if 语句中的条件为真时，这个查询才会将 password 查询出来
 
@@ -480,7 +480,7 @@ if __name__ == "__main__":
     exp()
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnXyMaLh26lkNuAPiQVHuaNg.png)
+![](https://cdn.xyxsw.site/boxcnXyMaLh26lkNuAPiQVHuaNg.png)
 
 #### 
 
@@ -523,7 +523,7 @@ if __name__ == "__main__":
 
 如果想要让布尔盲注不可用，我们可以做一个假设，假设我们并不知道账户的密码，也就无法通过登陆验证，这个时候就失去了布尔盲注最大的依赖，也就无法得知 if 表达式的真或假了。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcndxf4WEQQQEXspS7GwNKI6J.png)
+![](https://cdn.xyxsw.site/boxcndxf4WEQQQEXspS7GwNKI6J.png)
 
 但，真的没办法了吗？
 
@@ -600,7 +600,7 @@ if __name__ == "__main__":
     exp()
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnsStdHC5VmBylyx6S7hakEb.png)
+![](https://cdn.xyxsw.site/boxcnsStdHC5VmBylyx6S7hakEb.png)
 
 ### 基于报错的 SQL 注入 (TODO)
 
@@ -640,7 +640,7 @@ if __name__ == "__main__":
     main()
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnl67uDDSIdh3J7y7Jxjk0dc.png)
+![](https://cdn.xyxsw.site/boxcnl67uDDSIdh3J7y7Jxjk0dc.png)
 
 这样一来如果 SQL 语句执行报错的话，错误信息就会被打印出来
 
@@ -671,9 +671,9 @@ MySQL 8.0 doc: [https://dev.mysql.com/doc/refman/8.0/en/](https://dev.mysql.com/
 
 `Liki4';INSERT INTO users VALUES ('Liki3','01848f8e70090495a136698a41c5b37406968c648ab12133e0f256b2364b5bb5');#`
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnrMIc2m6oubxC86CEtw1jMe.png)
+![](https://cdn.xyxsw.site/boxcnrMIc2m6oubxC86CEtw1jMe.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnVRdntvakiTpt7nP8JhKKfc.png)
+![](https://cdn.xyxsw.site/boxcnVRdntvakiTpt7nP8JhKKfc.png)
 
 INSERT 语句也被成功执行了，向数据库中插入了 Liki3 的数据
 
@@ -776,7 +776,7 @@ INSERT 语句也被成功执行了，向数据库中插入了 Liki3 的数据
 在 GB2312、GBK、GB18030、BIG5、Shift_JIS 等编码下来吃掉 ASCII 字符的方法，可以用来绕过 `addslashes()`
 `id=0%df%27%20union%20select%201,2,database();`
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnaRtyUGC0sX3btnFIgpDCob.png)
+![](https://cdn.xyxsw.site/boxcnaRtyUGC0sX3btnFIgpDCob.png)
 
 ### information_schema 被过滤
 
@@ -795,7 +795,7 @@ select table_name from mysql.innodb_index_stats where database_name=<em>database
 select table_name from mysql.innodb_table_stats where database_name=<em>database</em>();
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnbMtjAq8osStjcSbFuIdDSc.png)
+![](https://cdn.xyxsw.site/boxcnbMtjAq8osStjcSbFuIdDSc.png)
 
 ##### MySQL 5.7 的新特性
 
@@ -812,7 +812,7 @@ select table_name from sys.schema_table_statistics_with_buffer where table_schem
 select table_name from sys.x$schema_table_statistics_with_buffer where table_schema=<em>database</em>();
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnV68mdIQmovJwczDsOc53gc.png)
+![](https://cdn.xyxsw.site/boxcnV68mdIQmovJwczDsOc53gc.png)
 
 ### 无列名注入
 
@@ -820,7 +820,7 @@ select table_name from sys.x$schema_table_statistics_with_buffer where table_sch
 
 `select a,b from (select 1 as a, 2 as b union select * from users)x;`
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnI3jJNlLqq4f7WqRKGEWTeh.png)
+![](https://cdn.xyxsw.site/boxcnI3jJNlLqq4f7WqRKGEWTeh.png)
 
 ## 超脱 MySQL 之外 (TODO)
 
diff --git a/6.计算机安全/6.2.1基础工具的使用.md b/6.计算机安全/6.2.1基础工具的使用.md
index 54122fd..3b794ea 100644
--- a/6.计算机安全/6.2.1基础工具的使用.md
+++ b/6.计算机安全/6.2.1基础工具的使用.md
@@ -12,7 +12,7 @@ IDA pro 是收费软件，价格极其昂贵，一套完全版人民币 10W 左
 
 ## 0x00 IDA 简单介绍
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809113855166.png)
+![](https://cdn.xyxsw.site/image-20220809113855166.png)
 
 IDA是一款交互式反汇编和反编译工具，其支持文件类型和文件平台丰富。
 
@@ -20,7 +20,7 @@ IDA是一款交互式反汇编和反编译工具，其支持文件类型和文
 
 ## 0x01 启动界面
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809114834244.png)
+![](https://cdn.xyxsw.site/image-20220809114834244.png)
 
 ```
 NEW：打开IDA同时弹出对话框选择要打开的文件
@@ -30,15 +30,15 @@ Previous，或者下面的列表项：快速打开之前的的文件
 
 这里选择Go键，打开以后，将文件拖入
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809124156697.png)
+![](https://cdn.xyxsw.site/image-20220809124156697.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809124408179.png)
+![](https://cdn.xyxsw.site/image-20220809124408179.png)
 
 这里按我们的默认选项点击OK即可
 
 ## 0x02 关闭界面
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809125554853.png)
+![](https://cdn.xyxsw.site/image-20220809125554853.png)
 
 ```
 第一个选项：就是不打包数据包文件，那么这些数据库文件就会分开这放。
@@ -53,15 +53,15 @@ Previous，或者下面的列表项：快速打开之前的的文件
 
 反汇编代码的图表窗口
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809130857159.png)
+![](https://cdn.xyxsw.site/image-20220809130857159.png)
 
  按**空格键**切换成文本结构的反汇编
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809130940294.png)
+![](https://cdn.xyxsw.site/image-20220809130940294.png)
 
  按**F5**进行反编译跳转至`Pseudocode`(伪代码)界面
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809131038284.png)
+![](https://cdn.xyxsw.site/image-20220809131038284.png)
 
 然后就可以分析代码逻辑了
 
@@ -71,19 +71,19 @@ Previous，或者下面的列表项：快速打开之前的的文件
 
 十六进制窗口(不太常用)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809132027773.png)
+![](https://cdn.xyxsw.site/image-20220809132027773.png)
 
 ## 0x05 主界面-Structures
 
 结构体窗口
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809132130778.png)
+![](https://cdn.xyxsw.site/image-20220809132130778.png)
 
 ## 0x06 主界面-Enums
 
 枚举类型界面
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809132242739.png)
+![](https://cdn.xyxsw.site/image-20220809132242739.png)
 
 ## 0x07 主界面-Imports
 
@@ -91,23 +91,23 @@ Previous，或者下面的列表项：快速打开之前的的文件
 
 可以查看当前模块用了哪些模块的哪些函数
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809132327043.png)
+![](https://cdn.xyxsw.site/image-20220809132327043.png)
 
 ## 0x08 主界面-Exports
 
 导出表
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809151050575.png)
+![](https://cdn.xyxsw.site/image-20220809151050575.png)
 
 ## 0x09 主界面-Strings
 
 按`Shift+F12`转到`String`界面，该操作会搜索程序中的字符串数据并展示
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809153126737.png)
+![](https://cdn.xyxsw.site/image-20220809153126737.png)
 
 按`Ctrl+F`后输入想要检索的字符可以快速搜索字符串
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809153408536.png)
+![](https://cdn.xyxsw.site/image-20220809153408536.png)
 
 ## 0x0a 其他界面-Functions
 
@@ -115,7 +115,7 @@ Previous，或者下面的列表项：快速打开之前的的文件
 
 其中一般来说`main`是程序的主要函数
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809151328885.png)
+![](https://cdn.xyxsw.site/image-20220809151328885.png)
 
 ## 0x0b 其他界面-Output
 
@@ -125,13 +125,13 @@ Previous，或者下面的列表项：快速打开之前的的文件
 
 另外还可以直接在下面输入python语句，方便在ida使用过程中简单的数据处理
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809151536894.png)
+![](https://cdn.xyxsw.site/image-20220809151536894.png)
 
 ## 0x0c 其他界面-导航栏
 
 一个二进制文件包括不同的区块，这里显示程序的不同类型数据，不同的颜色代表二进制文件中不同的块
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809151815243.png)
+![](https://cdn.xyxsw.site/image-20220809151815243.png)
 
 
 
@@ -170,7 +170,7 @@ Previous，或者下面的列表项：快速打开之前的的文件
 
 IDA 提供可与其交互的IDA Python接口，可以使用Python做很多的辅助操作
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809154742462.png)
+![](https://cdn.xyxsw.site/image-20220809154742462.png)
 
 可以参考这篇文章了解常用的接口
 
@@ -184,17 +184,17 @@ IDA 提供可与其交互的IDA Python接口，可以使用Python做很多的辅
 
 可以先在汇编代码或伪代码界面下断点，然后`F9`选择调试器，这里直接选`Local Windows Debugger`
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809160044665.png)
+![](https://cdn.xyxsw.site/image-20220809160044665.png)
 
 之后就可以用F7(单步不跳过执行)/F8(单步跳过执行)/F9(继续执行,遇到断点停止)进行调试
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809163138453.png)
+![](https://cdn.xyxsw.site/image-20220809163138453.png)
 
 ### 调试Linux下的文件
 
 可以先在汇编代码或伪代码界面下断点
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809155352920.png)
+![](https://cdn.xyxsw.site/image-20220809155352920.png)
 
 由于Linux下文件调试比较特殊，需要远程起一个服务器运行服务端，这里可以使用**Vmware**或者**WSL2(Windows subsystem Linux)**进行调试
 
@@ -240,21 +240,21 @@ int main() {
 
 ##### 将程序拖入IDA
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809173439491.png)
+![](https://cdn.xyxsw.site/image-20220809173439491.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809173548998.png)
+![](https://cdn.xyxsw.site/image-20220809173548998.png)
 
 ##### F5分析查看伪代码
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809173627488.png)
+![](https://cdn.xyxsw.site/image-20220809173627488.png)
 
 发现有`change`和`check`的自定义函数
 
 按`n`修改一下变量名
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809174001600.png)
+![](https://cdn.xyxsw.site/image-20220809174001600.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809174015603.png)
+![](https://cdn.xyxsw.site/image-20220809174015603.png)
 
 分别进入里面查看函数逻辑
 
@@ -262,11 +262,11 @@ int main() {
 
 change函数
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809174035800.png)
+![](https://cdn.xyxsw.site/image-20220809174035800.png)
 
 check函数
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809174058831.png)
+![](https://cdn.xyxsw.site/image-20220809174058831.png)
 
 ###### 静态分析逻辑
 
@@ -280,19 +280,19 @@ change函数是对输入字符串的每一个字节进行修改
 
 随意的进行一些输入
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809174913326.png)
+![](https://cdn.xyxsw.site/image-20220809174913326.png)
 
 然后断下来
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809174957987.png)
+![](https://cdn.xyxsw.site/image-20220809174957987.png)
 
 F7进入函数进行单步不跳过调试
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809175413448.png)
+![](https://cdn.xyxsw.site/image-20220809175413448.png)
 
 遇到类似`strlen`等库函数可以F8单步调试跳过
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/image-20220809175459668.png)
+![](https://cdn.xyxsw.site/image-20220809175459668.png)
 
 可以发现输入字符串的每一个字节的Ascii值都减小了1
 
diff --git a/6.计算机安全/6.2.2软件破解、软件加固.md b/6.计算机安全/6.2.2软件破解、软件加固.md
index 7631692..7ec8ecb 100644
--- a/6.计算机安全/6.2.2软件破解、软件加固.md
+++ b/6.计算机安全/6.2.2软件破解、软件加固.md
@@ -41,11 +41,11 @@ ESP 定律的原理在于利用程序中堆栈平衡来快速找到 OEP.
 
 #### 示例
 
-示例程序可以点击此处下载: [2_esp.zip](https://github.com/ctf-wiki/ctf-challenges/blob/master/reverse/unpack/example/2_esp.zip)
+示例程序可以点击此处下载: [2_esp.zip](https://github.com/ctf-wiki/ctf-challenges/blob/master/reverse/unpack/2_esp.zip)
 
 还是上一篇的示例, 入口一句 `pushad`, 我们按下 F8 执行 `pushad` 保存寄存器状态, 我们可以在右边的寄存器窗口里发现 `ESP` 寄存器的值变为了红色, 也即值发生了改变.
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnJdWqlHmhlvB471dIGT4GEh.png)
+![](https://cdn.xyxsw.site/boxcnJdWqlHmhlvB471dIGT4GEh.png)
 
 我们鼠标右击 `ESP` 寄存器的值, 也就是图中的 `0019FF64`, 选择 `HW break[ESP]` 后, 按下 `F9` 运行程序, 程序会在触发断点时断下. 如图来到了 `0040D3B0` 的位置. 这里就是上一篇我们单步跟踪时到达的位置, 剩余的就不再赘述.
 
diff --git a/6.计算机安全/6.2.3漏洞挖掘、漏洞利用.md b/6.计算机安全/6.2.3漏洞挖掘、漏洞利用.md
index e7d0a07..2be07c7 100644
--- a/6.计算机安全/6.2.3漏洞挖掘、漏洞利用.md
+++ b/6.计算机安全/6.2.3漏洞挖掘、漏洞利用.md
@@ -4,7 +4,7 @@
 #### 栈介绍
 栈是一种典型的后进先出 (Last in First Out) 的数据结构，其操作主要有压栈 (push) 与出栈 (pop) 两种操作，如下图所示（维基百科）。两种操作都操作栈顶，当然，它也有栈底。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/stack.png)
+![](https://cdn.xyxsw.site/stack.png)
 
 高级语言在运行时都会被转换为汇编程序，在汇编程序运行过程中，充分利用了栈这一数据结构。每个程序在运行时都有虚拟地址空间，其中某一部分就是该程序对应的栈，用于保存函数调用信息和局部变量。此外，常见的操作也是压栈与出栈。需要注意的是，**程序的栈是从进程地址空间的高地址向低地址增长的**。
 #### 栈溢出基本原理
@@ -21,7 +21,7 @@ int main()
 
 对于如上程序，运行后可以发现`ch`和`a`的地址相差不大(`a`和`ch`的顺序不一定固定为`a`在前`ch`在后)：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/out1.PNG)
+![](https://cdn.xyxsw.site/out1.PNG)
 
 可以发现`ch`和`ch2`刚好差`8`个字节，也就是`ch`的长度。
 `ch`只有`8`个字节，那么如果我们向`ch`中写入超过`8`个字节的数据呢？很显然，会从`ch`处发生溢出，写入到`ch2`的空间中，覆盖`ch2`的内容。
@@ -37,7 +37,7 @@ int main()
 }
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/out2.PNG)
+![](https://cdn.xyxsw.site/out2.PNG)
 
 这就是栈溢出的基本原理。
 
@@ -131,7 +131,7 @@ retn
 
 可以看到其中使用`call`指令来调用`add`函数。那么该指令是如何工作的呢？其实`call`指令相当于`push next_loc;jmp loc`，通过将`call`指令下一行汇编的地址压栈的方式，等到函数调用完再取回，从而从`call`指令的下一行继续执行。由于栈地址从高向低生长，新调用的函数的局部变量生成在返回地址的上方（低地址处），因此如果我们在新函数中使用栈溢出来修改这一返回地址，如果将返回地址修改为某个函数的地址，就可以执行任意函数：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/stack2.png)
+![](https://cdn.xyxsw.site/stack2.png)
 
 > 注意该图中，使用32位的寄存器（EBP、ESP、EIP），实际原理一样的，并且上方为高地址，下方为低地址
 
@@ -139,22 +139,22 @@ retn
 
 32位的程序，我们使用IDA来打开该题目，查看反编译代码，可以发现有非常明显的栈溢出：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/main.png)
+![](https://cdn.xyxsw.site/main.png)
 
 由于第`8`行`gets`函数并没有检查输入的长度和`s`的长度，我们可以轻易地通过栈溢出来控制`main`函数的返回地址。而在程序中，存在另外一个函数`secure`，在该函数中有一个后门`system("/bin/sh")`，如果我们想办法执行该后门，就可以拿到目标机器的`shell`，从而控制目标计算机。
 
 由于我们需要将返回地址在标准输入中输入待测程序，而返回地址拆分成小端序的字节后经常无法手动输入到待测程序中，所以此处我们使用`pwntools`这一`python`包来方便地进行攻击。
 首先查看后门的地址：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/backdoor.png)
+![](https://cdn.xyxsw.site/backdoor.png)
 
 接着计算溢出长度，这里我们使用gdb来调试程序，图中的gdb安装了pwndbg插件，该插件在pwn调试时比较好用：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/gdb.png)
+![](https://cdn.xyxsw.site/gdb.png)
 
 将断点打在`gets`函数前后，可以看到此时`esp`值为`0xffffcd80`，`ebp`值为`0xffffce08`，在 IDA 中我们又可以看到`s`相对于`esp`的偏移为`+1C`，此时我们即可计算`hex(0xffffcd80+0x1c-0xffffce08)=-0x6C`，即`s`相对于`ebp`的偏移为`0x6C`，由于在`main`函数的开头有`push ebp`的操作，所以将`0x6C`再加`4`，即可到达返回地址处：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/s.png)
+![](https://cdn.xyxsw.site/s.png)
 
 ```python
 from pwn import *
@@ -165,7 +165,7 @@ sh.sendline(exp)
 sh.interactive() # 切换为手动交互模式
 ```
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/shell.png)
+![](https://cdn.xyxsw.site/shell.png)
 
 ##### 0x1
 通过上面的学习，我们已经可以知道执行任意函数的办法，但很多情况下，对于攻击者来说，程序中并没有可用的后门函数来达到攻击的目的，因此我们需要一种手段，来让程序执行任意代码（任意汇编代码），这样就可以最高效地进行攻击。ROP（Return Oriented Programming）面向返回编程就是这样的一种技术，在栈溢出的基础上，通过在程序中寻找以retn结尾的小片段（gadgets），来改变某些寄存器、栈变量等的值，再结合Linux下的系统调用，我们就可以执行需要的任意代码。
diff --git a/6.计算机安全/6.2二进制安全.md b/6.计算机安全/6.2二进制安全.md
index ca9458c..ccc2f81 100644
--- a/6.计算机安全/6.2二进制安全.md
+++ b/6.计算机安全/6.2二进制安全.md
@@ -13,7 +13,7 @@ reverse 主要研究软件破解，软件加固，计算机病毒等。
 ## 入门材料
 > HGAME Mini 2022 Reverse Pwn 入门材料
 > Reverse:https://www.notion.so/b92ca2bfaacf4e7c873882dff9dbf649
-> Pwn:https://ek1ng.oss-cn-hangzhou.aliyuncs.com/HGAME%20Mini%202022%20Pwn%E5%85%A5%E9%97%A8%E6%8C%87%E5%8C%97.pdf
+> Pwn:[PWN入门指北](https://ek1ng.oss-cn-hangzhou.aliyuncs.com/HGAME%20Mini%202022%20Pwn%E5%85%A5%E9%97%A8%E6%8C%87%E5%8C%97.pdf)
 
 ## 学习二进制安全需要具备哪些基础？
 
diff --git a/6.计算机安全/6.5ctf学习网站推荐.md b/6.计算机安全/6.5ctf学习网站推荐.md
deleted file mode 100644
index 8e27fe5..0000000
--- a/6.计算机安全/6.5ctf学习网站推荐.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# CTF学习网站推荐
-
-CTF的学习对于初学者而言可能有些手无足措。因为它涵盖了许多的方向:web,reverse,pwn,crypto,misc,IOT等方向。每一个都需要一定的基础
-
-需要一定的基础才能去解决题目，获取flag。
-
-以下是一些给CTF初学者的网站，欢迎补充：
-
-## 学习网站：
-
-学习其实最高效的可能还是通过打比赛，实操，看大牛博客来学习。但是感觉对于新人而言打好基础和入门是最重要的，很多时候入门了，发现感兴趣了，一切就顺利起来了。因此以下就先放一些容易使人入门的网站。
-
-- [Hello CTF](https://ctf.tj.cn/)
-- [简介 - CTF Wiki (ctf-wiki.org)](https://ctf-wiki.org/)
-- [CTFHub](https://www.ctfhub.com/#/index)
-
-## 练习网站：
-
-- [主页 | NSSCTF](https://www.nssctf.cn/index)
-- [BUUCTF在线评测 (buuoj.cn)](https://buuoj.cn/)
-- [攻防世界 (xctf.org.cn)](https://adworld.xctf.org.cn)
-- [Hack The Box: Hacking Training For The Best | Individuals & Companies](https://www.hackthebox.com/)
-- [CryptoHack – A fun, free platform for learning cryptography](https://cryptohack.org/)
-
-## 工具网站：
-
-之后再补充
-
diff --git a/6.计算机安全/6.5学习资料推荐.md b/6.计算机安全/6.5学习资料推荐.md
new file mode 100644
index 0000000..ea875e6
--- /dev/null
+++ b/6.计算机安全/6.5学习资料推荐.md
@@ -0,0 +1,46 @@
+
+> 计算机基础是非常重要的，协会一直推荐打好基础，勿在浮沙筑高台。
+> 
+> 以下是一些CTF领域写的不错的入门文章和平台，也可以根据文章内容进行学习～
+
+## 学习网站：
+
+学习其实最高效的可能还是通过打比赛，实操，看大牛博客来学习。但是感觉对于新人而言打好基础和入门是最重要的，很多时候入门了，发现感兴趣了，一切就顺利起来了。因此以下就先放一些容易使人入门的网站。
+
+- [Hello CTF](https://ctf.tj.cn/)
+- [简介 - CTF Wiki (ctf-wiki.org)](https://ctf-wiki.org/)
+- [CTFHub](https://www.ctfhub.com/#/index)
+
+## 靶场推荐：
+
+- [主页 | NSSCTF](https://www.nssctf.cn/index)
+- [BUUCTF在线评测 (buuoj.cn)](https://buuoj.cn/)
+- [攻防世界 (xctf.org.cn)](https://adworld.xctf.org.cn)
+- [Hack The Box: Hacking Training For The Best | Individuals & Companies](https://www.hackthebox.com/)
+- [CryptoHack – A fun, free platform for learning cryptography](https://cryptohack.org/)
+
+## 博客推荐：
+
+> 由于很多师傅都会在自己的博客发布自己的研究成果，所以这里有一些推荐阅读的博客～
+
+综合类博客：
+
+> 主题比较宽泛，大多是计算机技术相关
+
+- https://www.leavesongs.com/
+- https://github.red/
+- https://lorexxar.cn/
+- https://su18.org/
+
+安全类博客：
+
+> 主要是一些安全研究成果或者CTF竞赛题解，主要都是安全相关内容
+
+- https://4ra1n.github.io/
+- https://y4tacker.github.io/
+- https://y4er.com/
+- https://cjovi.icu/
+- https://crazymanarmy.github.io/
+- https://www.gem-love.com
+- https://blog.huli.tw/
+- https://blog.orange.tw/
\ No newline at end of file
diff --git a/6.计算机安全/6.计算机安全.md b/6.计算机安全/6.计算机安全.md
index c375410..02b6c47 100644
--- a/6.计算机安全/6.计算机安全.md
+++ b/6.计算机安全/6.计算机安全.md
@@ -1,21 +1,74 @@
 # 6.计算机安全
 
-> 本模块由 [Vidar-Team](https://vidar.club)  信息安全协会成员倾情奉献，Vidar-Team 成立于2008年9月，其名 Vidar 来源于北欧神话"诸神黄昏"中幸存于难、带领人类重建了家园的神 Víðarr，是由杭州电子科技大学一群热爱信息安全的小伙伴自发成立的技术型团体 ，作为高校战队活跃于各大ctf赛事。
+> 本模块由 [Vidar-Team](https://vidar.club)  信息安全协会成员倾情奉献。
 > 
-> Vidar-Team 2023 招新 QQ 群: 861507440（仅向校内开放），欢迎对安全感兴趣的小伙伴加入我们！
+> Vidar-Team 成立于2008年9月，其名 Vidar 来源于北欧神话"诸神黄昏"中幸存于难、带领人类重建了家园的神 Víðarr，是由杭州电子科技大学一群热爱信息安全的小伙伴自发成立的技术型团体 ，作为高校战队活跃于各大ctf赛事。
+> 
+> 2023 招新 QQ 群: 861507440（仅向校内开放），欢迎对技术感兴趣的小伙伴加入我们！
 
+**招新方向汇总:**
+
+- Web（网络安全）
+  - 渗透（模拟黑客攻击，找寻漏洞，修补、加固系统）
+  - 开发（网络的搭建和维护，网站开发）
+  - 运维（各类服务器的运行维护，路由佬）
+- Bin（二进制安全）
+  - Pwn（关注软硬件的底层，对操作系统与应用程序本身进行攻击，如大名鼎鼎的永恒之蓝）
+  - Re（逆向工程，研究领域包括游戏安全、病毒分析、软件加密/解密、自动化程序分析及测试等）
+- 综合
+  - Misc 杂项（流量分析，电子取证，大数据统计等，覆盖面比较广）
+  - Crypto 密码学（与加密系统相关，从已加密的信息中破译明文）
+  - 无线安全（RFID，无线遥控，ADS-B，BLE，ZigBee，移动通信，卫星通信）
+  - Iot安全 (从软件和硬件出发，多方向探索物联网设备)
+  - 人工智能安全 (使用人工智能技术赋能安全，模型本身安全问题)
+  - 美工（负责协会相关的设计，如比赛海报与 LOGO，会服、钥匙扣等等各类周边的制作）
+  - 计算机图形学（游戏开发，游戏引擎开发）
+
+**Vidar-Team 是技术类兴趣社团，为技术而生而不是为 CTF 而生**。
+
+## 什么是安全
 
 计算机安全，通俗的讲就是黑客，主要研究计算机领域的攻防技术，主要包括网络安全（Web）和二进制安全（Bin，包含Pwn和Reverse）两大类。现有的 CTF 信息安全竞赛里面还会看到密码学（Crypto）和安全杂项（Misc），以及最近几年新兴的 IoT 安全，人工智能安全等方向。本系列文章会按照CTF的5个方向，Web、Pwn、Reverse、Crypto、Misc来进行介绍。目前引入了HGAME Mini2022我们编写给新生的入门材料，在今年的10月份和寒假，我们也会分别举办HGAME Mini和HGAME这两场CTF，来帮助新生更好的入门安全。
 
-下面是一些CTF领域写的不错的入门文章和平台，也可以根据文章内容进行学习～
+## CTF竞赛形式
 
-### 入门文章
-CTF-Wiki：https://ctf-wiki.org/
-CTF快速入门手册：https://github.com/ProbiusOfficial/CTF-QuickStart
+### 解题赛
 
+你需要做的事情很简单，利用你的安全知识去找出 flag。
 
-### 刷题平台
-攻防世界: https://adworld.xctf.org.cn/challenges/list
-Bugku: https://ctf.bugku.com/
-ctfhub: https://www.ctfhub.com/#/index
-NSSCTF: https://www.ctfer.vip/index
+flag 可能是被加密的，你得想办法破解它；
+
+可能放在对方服务器上，你得把服务器打下来；
+
+甚至可能是出题人设计了一个不可能完成的小游戏，你得写外挂通关他...
+
+虽然要做的事情是一样的，题目是千变万化的，做题手段是不受限制的。所幸的是大家并不是孤军奋战，一个人一般只需要负责一个方向即可。
+
+### 攻防赛
+
+又叫 AWD，是攻防结合的形式，在攻击其他选手的服务器的同时，你需要找出自己的服务器上的漏洞并在其他选手发现之前修复它。
+
+比起解题赛或许做不出题很坐牢，AWD 非常的紧张刺激。
+
+### 适合我吗
+
+首先 CTF 适合绝大多数具有自主学习能力并对其感兴趣的人，他并不挑基础，大部分人都是在大学阶段起步的，不像 ACM，没有 OI 基础在杭电 ACM 真的相当难混。
+
+#### 劝学
+
+- 如果你曾经梦想过成为一名黑客，穿梭于网络世界，揭露隐藏的秘密，那么现在就是实现梦想的时候。
+- 如果你想追求最为纯粹的最为极致的计算机技术，不想被平庸的条条框框所束缚，那么是时候挣脱他们了，在这里不限手段不限方向。
+- 如果你对于普通的软件开发感到厌倦或者不满足，那么现在就是做出转变的时候。
+- 如果你是一个苦于常常无人可以交流的社恐技术宅，那么你能收获最单纯最诚挚的伙伴。
+- 如果你对计算机一无所知，只是觉得计算机不错选了计算机专业，那么作为门槛最低的竞赛之一，其自然可以成为你的选择。
+- 如果你单纯想捞钱，网络安全拥有着高于计算机平均的薪资。
+
+#### 劝退
+
+- 不知道为什么学计算机，不想学计算机，学不下去，不建议。
+- CTF 虽然门槛低，但是学习强度非常高，学习范围非常广，就比如说，经过一年半的学习，成熟的 CTF Web 选手一般能够审计任意主流编程语言的代码，并选择一种深入挖掘。
+- CTF 竞赛强度非常高，一周甚至可能会出现需要同时打 2-3 个竞赛的情况（参加多了结算奖学金的时候就很有意思），坚持不下来的不建议。
+- CTF 非常非常重实践，没有实际复现一个漏洞而纯理论学习和比赛当场学没本质区别。
+- CTF 对自主学习能力要求很高，一是因为确实玩法多，二是由于 CTF 是允许上网查找资料的（一般也必须允许），所以经常会出现比赛过程中当场极速学习的事情。
+
+总结：强度高，回报高，有且只有对技术有持续热情的人才能坚持下来。
diff --git a/7.网络应用开发/7.1.1.1基础部分.md b/7.网络应用开发/7.1.1.1基础部分.md
index deace25..ca6cc8b 100644
--- a/7.网络应用开发/7.1.1.1基础部分.md
+++ b/7.网络应用开发/7.1.1.1基础部分.md
@@ -14,8 +14,6 @@
 
 [MDN Web 入门](https://developer.mozilla.org/zh-CN/docs/Learn/Getting_started_with_the_web)
 
-[ A friendly web development tutorial for complete beginners](https://www.internetingishard.com/html-and-css/)
-
 [前端入门必会的初级调试技巧](https://zhuanlan.zhihu.com/p/145466139)
 
 #### JavaScript
@@ -45,13 +43,13 @@
 
 设计稿如下：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnVR5z4U8YlXZbc8beDNEHXc.jpg)
+![](https://cdn.xyxsw.site/boxcnVR5z4U8YlXZbc8beDNEHXc.jpg)
 
 #### 可能需要用到的图片资源
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnbigxAK5SbxiWuDHr1Ashne.png)
+![](https://cdn.xyxsw.site/boxcnbigxAK5SbxiWuDHr1Ashne.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnrqddPFusKhe0vZuzXJOosg.png)
+![](https://cdn.xyxsw.site/boxcnrqddPFusKhe0vZuzXJOosg.png)
 
 #### 基本要求
 
@@ -93,9 +91,9 @@
 
 ### 🎫TodoList
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnikdFX5WNml7sgtPMOJQiGh.png)
+![](https://cdn.xyxsw.site/boxcnikdFX5WNml7sgtPMOJQiGh.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnFZwQVTUWkfsbNxYfJkgPDg.png)
+![](https://cdn.xyxsw.site/boxcnFZwQVTUWkfsbNxYfJkgPDg.png)
 
 <center>一些参考</center>
 
@@ -121,7 +119,7 @@
 - 实现不同设备屏幕尺寸的自适应
 - 添加任务热力图(可以参考一下 GitHub 个人主页哦 🤔)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcncVQswB7ziUoV4LvEs35DAe.png)
+![](https://cdn.xyxsw.site/boxcncVQswB7ziUoV4LvEs35DAe.png)
 
 #### 可能涉及的知识点
 
diff --git a/7.网络应用开发/7.1.1.2进阶部分.md b/7.网络应用开发/7.1.1.2进阶部分.md
index e4526d3..0f59f52 100644
--- a/7.网络应用开发/7.1.1.2进阶部分.md
+++ b/7.网络应用开发/7.1.1.2进阶部分.md
@@ -10,11 +10,11 @@
 
 如果你曾经用过助手的小程序，你可能会在首页看到这样的天气卡片：
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnTNJhtqw6Km24fKgAnjZtBS.png)
+![](https://cdn.xyxsw.site/boxcnTNJhtqw6Km24fKgAnjZtBS.png)
 
 当然了，平时大家也会用到各种天气 APP
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnUuqMoTjiOH9NSdYx4GCGme.png)
+![](https://cdn.xyxsw.site/boxcnUuqMoTjiOH9NSdYx4GCGme.png)
 
 那么，让我们动手实现一个天气卡片吧~
 
@@ -63,9 +63,9 @@
 
 ## 🎶 音乐播放器
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnRaBolh8i2FkoIJW69a5g3e.png)
+![](https://cdn.xyxsw.site/boxcnRaBolh8i2FkoIJW69a5g3e.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnJ13CDzxp9lwEtGivTuJ4nh.png)
+![](https://cdn.xyxsw.site/boxcnJ13CDzxp9lwEtGivTuJ4nh.png)
 
 相信你平时或多或少都会听音乐，那么你是喜欢用网易云还是 QQ 音乐呢？或者是系统自带的音乐播放器？不过，其实你也可以自己做一个音乐播放器，来满足你对听音乐这件事的所有幻想，听起来是不是很酷呢 😎~那么，来试试看吧！
 
diff --git a/7.网络应用开发/7.1.1.5附录3：跨端开发.md b/7.网络应用开发/7.1.1.5附录3：跨端开发.md
index f5cd32e..96569af 100644
--- a/7.网络应用开发/7.1.1.5附录3：跨端开发.md
+++ b/7.网络应用开发/7.1.1.5附录3：跨端开发.md
@@ -69,7 +69,7 @@
 
 它是基于WebView渲染，通过JS Bridge 把一部分系统能力开放给JS调用。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/235436487dsfhtwuytjyfj.png)
+![](https://cdn.xyxsw.site/235436487dsfhtwuytjyfj.png)
 
 WebView容器的工作原理是基于Web技术来实现界面和功能，通过将原生的接口封装、暴露给JavaScript调用，JavaScript编写的页面可以运行在系统自带的WebView中。这样做的优势是，对于前端开发者比较友好，可以很快地实现页面跨端，同时保留调用**原生的能力**，通过搭建桥接层和原生能力打通。但这种设计，跨端的能力受限于桥接层，当调用之前没有的原生能力时，就需要增加桥。另外，浏览器内核的渲染独立于系统组件，无法保证原生体验，**渲染的效果会差不少**。
 
@@ -80,7 +80,7 @@ WebView容器的工作原理是基于Web技术来实现界面和功能，通过
 
 浏览器提供了一个容器，屏蔽了底层差异，提供了统一的 api（dom api），这样就可以实现同一份代码跑在不同平台的统一的容器里。这个容器叫做浏览器引擎，由 js 引擎、渲染引擎等构成。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/fdegetyjyrj.png)
+![](https://cdn.xyxsw.site/fdegetyjyrj.png)
 
 #### PWA
 尽管PWA的出现不是为了“跨端”，但他们对于“跨端”的天然支持，能够让一套代码运行在PC、移动两端，就再一次产生了跨端设计实施的可能性。
@@ -107,7 +107,7 @@ PWA 是 Google 于 2016 年提出的概念，于 2017 年正式落地，于 2018
 
 
 #### Electron
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/wettrjryju.png)
+![](https://cdn.xyxsw.site/wettrjryju.png)
 
 Electron 是使用 JavaScript，HTML 和 CSS 构建跨平台的桌面应用程序的框架，可构建出兼容 Mac、Windows 和 Linux 三个平台的应用程序。
 
@@ -123,7 +123,7 @@ Electron 的跨端原理并不难理解：它通过集成浏览器内核，使
 #### React Native
 React Native 是一个由 Facebook 于2015年9月发布的一款开源的 JavaScript 框架，它可以让开发者使用 JavaScript 和 React 来开发跨平台的移动应用。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/eryyjyuj.png)
+![](https://cdn.xyxsw.site/eryyjyuj.png)
 
 React Native 的思路是最大化地复用前端的生态和 Native 的生态，和 WebView 容器的最大区别在于 View 的渲染体系。React Native 抛弃了低效的浏览器内核渲染，转而**使用自己的 DSL 生成中间格式**，然后映射到对应的平台，**渲染成平台的组件**。相对 WebView 容器，体验会有一定的提升。不过，渲染时需要 JavaScript 和原生之间通信，在有些场景可能会导致卡顿。另外就是，渲染还是在Native层，要求开发人员对Native有一定的熟悉度。
 
@@ -150,7 +150,7 @@ Flutter与上述Recat Native、WebView容器本质上都是不同的，它没有
 
 微信小程序的渲染层与逻辑层分别由两个线程管理，渲染层的界面使用 webview 进行渲染；逻辑层采用 JSCore运行JavaScript代码。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/rtjyujyu.png)
+![](https://cdn.xyxsw.site/rtjyujyu.png)
 
 
 ## 类前端开发：拿过来吧你
@@ -166,7 +166,7 @@ Flutter与上述Recat Native、WebView容器本质上都是不同的，它没有
 
 JS UI框架采用类HTML和CSS Web编程语言作为页面布局和页面样式的开发语言，页面业务逻辑则支持ECMAScript规范的JavaScript语言。JS UI框架提供的类Web编程范式，可以让开发者避免编写UI状态切换的代码，视图配置信息更加直观。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/3465ytyjyjy.png)
+![](https://cdn.xyxsw.site/3465ytyjyjy.png)
 
 
 ## 跨端不只是跨端：爱你的全世界
@@ -174,9 +174,9 @@ JS UI框架采用类HTML和CSS Web编程语言作为页面布局和页面样式
 ## 什么样的场景可以跨端？
 跨端应用能够真正推进下去，除了有技术保障外，还需要合适的需求场景，使用PC端的功能型产品主要是需要大屏带来的“效率”（办公、个人管理、教育）与“沉浸”（数据、金融、游戏、影视）体验。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/ertehry.png)
+![](https://cdn.xyxsw.site/ertehry.png)
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/ertjyunyunm.png)
+![](https://cdn.xyxsw.site/ertjyunyunm.png)
 
 依赖PC、移动双端进行经营管理的电商场景，也有很多内容适合跨端。
 
@@ -185,25 +185,25 @@ JS UI框架采用类HTML和CSS Web编程语言作为页面布局和页面样式
 
 1. 双端基础组件设计规则对齐（对前端来说是同类组件API、属性对齐以及组件功能形态映射）
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/ewttrhjy.png)
+![](https://cdn.xyxsw.site/ewttrhjy.png)
 
 Select对应Picker
 
 1. 布局响应规则（行列变化，聚合变化等）；
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/20191118PGkkRz.jpg)
+![](https://cdn.xyxsw.site/20191118PGkkRz.jpg)
 
 卡片布局的一种聚合变化
 
 1. 交互形态响应规则（导航、交互模式等）;
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/20191118aoefIO.jpg)
+![](https://cdn.xyxsw.site/20191118aoefIO.jpg)
 
 表单型弹窗对应新页面
 
 1. 不同场景的跨端策略，例如Dashboard页面的跨端应保证用户在首屏快速获取关键信息，下图的Bootstrap模板是一个错误示例，移动端的布局方式浪费首屏空间，降低用户获取关键信息的效率。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/20191118BrYZzg.jpg)
+![](https://cdn.xyxsw.site/20191118BrYZzg.jpg)
 
 Mobile first 不是唯一准则。进行具体场景的跨端设计时，我们会从两端场景出发重新对比分析用户的需求差异，明确体验的增强点与折损点。特别是电商中后台场景中：有些业务中用户的主阵地并不是在移动端，而是PC端，比如用户运营策略的设置；有些是两端分别承载不同的场景需求，比如任务的处理。
 
@@ -217,7 +217,7 @@ Mobile first 不是唯一准则。进行具体场景的跨端设计时，我们
 
 Serverless字面意思是无服务，但并不代表再也不需要服务器了，而是指开发者不需要过多的考虑服务器的问题，计算资源作为服务出现而不是服务器的概念出现。 那么Serverlss，是对全部底层资源和操作的封装，让开发者专注于业务逻辑。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/gfhuewgfuiwe.png)
+![](https://cdn.xyxsw.site/gfhuewgfuiwe.png)
 
 Serverless = Faas (Function as a service) + Baas (Backend as a service)
 
@@ -254,7 +254,7 @@ Serverless 带来的其实是前端研发模式上的颠覆。相对以往纯前
 - 无需在代码内考虑高并发高可靠性，可以专注于业务
 - 通过云函数实例的高并发能力，实现业务高并发
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/fhuieufsiofhei.png)
+![](https://cdn.xyxsw.site/fhuieufsiofhei.png)
 
 #### 自动弹性压缩
 
@@ -281,7 +281,7 @@ uni-app 是一个使用 Vue.js 开发所有前端应用的框架，开发者编
    - 在Android平台，将.uts文件编译为kotlin代码
    - 在iOS平台，将.uts文件编译为swift代码
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/uni-function-diagram.png)
+![](https://cdn.xyxsw.site/uni-function-diagram.png)
 
 1. 区分页面和组件的区别：页面和组件的生命周期
 2. 云函数、云数据库
@@ -298,12 +298,12 @@ uni-app 是一个使用 Vue.js 开发所有前端应用的框架，开发者编
 
 1. Frameless：桌面端不仅仅只有方框矩形，而是想你所想。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/df77f01037fc4ceb8d4aa8f06168fc95~tplv-k3u1fbpfcp-zoom-in-crop-mark_4536_0_0_0.gif)
+![](https://cdn.xyxsw.site/df77f01037fc4ceb8d4aa8f06168fc95~tplv-k3u1fbpfcp-zoom-in-crop-mark_4536_0_0_0.gif)
 
 
 
 ## 参考作业
 尝试使用某种跨端框架和云函数，实现一个查看课表应用，形式不限。推荐使用hdu-lis包拿到数据。
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/Snipaste_2023-04-22_18-57-44.png)
+![](https://cdn.xyxsw.site/Snipaste_2023-04-22_18-57-44.png)
 
diff --git a/7.网络应用开发/7.1.2.1基础部分.md b/7.网络应用开发/7.1.2.1基础部分.md
index e157ba4..637eecc 100644
--- a/7.网络应用开发/7.1.2.1基础部分.md
+++ b/7.网络应用开发/7.1.2.1基础部分.md
@@ -148,10 +148,9 @@ https://www.runoob.com/http/http-intro.html
 
 #### 补充资料：
 
-- [《互联网时代》纪录片](https://www.bilibili.com/video/BV1DU4y147XR/) - 与 HTTP 没什么关系，但给当时的我带来极大的震撼和触动。互联网是人类连接的重要一步，是对人类自由、平等、互通之理念长达半个世纪的深刻贯彻。
-
-<Bilibili bvid='BV1DU4y147XR'/>
+- [《互联网时代》纪录片](https://www.bilibili.com/video/BV1uE411o7UW/) - 与 HTTP 没什么关系，但给当时的我带来极大的震撼和触动。互联网是人类连接的重要一步，是对人类自由、平等、互通之理念长达半个世纪的深刻贯彻。
 
+<Bilibili bvid='BV1uE411o7UW'/>
 
 > 原本稀薄的得以聚合，曾经蜷曲的得以伸展，容易被忽略的得以显现，可能被排斥的获得接纳：孤独的不再孤独，卑微的不再卑微，每一个生命绽放的声音，从来没有像这样韵味深长。
 
diff --git a/7.网络应用开发/7.1WEB开发入门.md b/7.网络应用开发/7.1WEB开发入门.md
index e675321..8c41223 100644
--- a/7.网络应用开发/7.1WEB开发入门.md
+++ b/7.网络应用开发/7.1WEB开发入门.md
@@ -107,7 +107,7 @@ A：理论上可以。但一般不会这么做（除了一些实时的网络聊
 
 登登登，后端登场！
 
-![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnorsQ6py7AU0LsCtn4f5LSd.png)
+![](https://cdn.xyxsw.site/boxcnorsQ6py7AU0LsCtn4f5LSd.png)
 
 解释一下：
 
diff --git a/9.计算机网络/9.1计网速通.md b/9.计算机网络/9.1计网速通.md
new file mode 100644
index 0000000..e1dd721
--- /dev/null
+++ b/9.计算机网络/9.1计网速通.md
@@ -0,0 +1 @@
+# 9.1计网速通
diff --git a/9.计算机网络/9.2计网基础.md b/9.计算机网络/9.2计网基础.md
new file mode 100644
index 0000000..9d9eb05
--- /dev/null
+++ b/9.计算机网络/9.2计网基础.md
@@ -0,0 +1 @@
+# 9.2计网基础
diff --git a/9.计算机网络/9.3路由与交换.md b/9.计算机网络/9.3路由与交换.md
new file mode 100644
index 0000000..18fd6cd
--- /dev/null
+++ b/9.计算机网络/9.3路由与交换.md
@@ -0,0 +1 @@
+# 9.3路由与交换
\ No newline at end of file
diff --git a/9.计算机网络/9.4隧道和代理.md b/9.计算机网络/9.4隧道和代理.md
new file mode 100644
index 0000000..328d48c
--- /dev/null
+++ b/9.计算机网络/9.4隧道和代理.md
@@ -0,0 +1 @@
+# 9.4隧道和代理
\ No newline at end of file
diff --git a/9.计算机网络/9.5路由佬入门指南.md b/9.计算机网络/9.5路由佬入门指南.md
new file mode 100644
index 0000000..e86bb68
--- /dev/null
+++ b/9.计算机网络/9.5路由佬入门指南.md
@@ -0,0 +1 @@
+# 9.5路由佬入门指南
\ No newline at end of file
diff --git a/9.计算机网络/9.计算机网络..md b/9.计算机网络/9.计算机网络..md
deleted file mode 100644
index 4042650..0000000
--- a/9.计算机网络/9.计算机网络..md
+++ /dev/null
@@ -1,6 +0,0 @@
-# 9.计算机网络
-计算机网络的定义：
-
-    利用通信线路和通信设备，将地理位置不同的、功能独立的多台计算机互连起来，以功能完善的网络软件来实现资源共享和信息传递，就构成了计算机网络系统。
-
-而我们学习计算机网络本质上可以理解为学习这个网络系统中的各种网络协议。
\ No newline at end of file
diff --git a/9.计算机网络/9.计算机网络.md b/9.计算机网络/9.计算机网络.md
new file mode 100644
index 0000000..dec12a1
--- /dev/null
+++ b/9.计算机网络/9.计算机网络.md
@@ -0,0 +1,111 @@
+# 9.计算机网络
+
+> 本模块来自 DN11(Decentralized Network 11)成员倾情奉献，DN11 最初在生活区11号楼群中提出，旨在建立一个跨寝室的大内网。经过一年的发展，已经成为了横跨 11号楼，VidarTeam，杭电助手等群体的中型实验性网络。
+
+计算机网络无非一句话，将所有计算机设备连起来。
+
+但，跨越全球的网络是何其的庞大，能够将他们连起来是一项巨大的工程。我可以说：Internet是人类这近50年来最伟大的工程。
+
+本讲义的计算机网络部分共分为5个章节
+
+## 计算机网络速通
+
+虽然名字看起来像是考前抱佛脚的章节，但他速通的并不是计网这一课程，是做简单Web开发所必须具备的计网知识。
+
+在这个章节，我们会讨论到计算机网络的应用层和传输层，重点介绍一些应用层协议。对于传输层，我们只讨论他为Web开发提供了怎样的接口或者说功能。
+
+上面提到“应用层和传输层”，或许你现在还不知道计算机网络的五层结构（也有其他划分，但是该划分利于学习），这也没关系，在本章节，可以暂时也不需要知道。
+
+计算机网络这一课程其实往往并不太会涉及到这一块内容，或许网络开发一类的选修课程会讲解这一部分内容。
+
+## 计算机网络基础
+
+这里是计算机网络课程的重点内容，并且适当地做出一些拓展，使其更贴近于现行互联网，尽量让大家对计算机网络拥有一个完整且合理自洽的知识图谱。
+
+写这篇讲义的我本人非常注重知识的自洽，就比如说计网的整个体系，他确实很庞大也需要这么庞大来解决全球的网络问题。
+
+我认为如果你的知识并不能够自洽，那么在你的脑海中这其实就是异常的，不自然的，需要拐弯子才能想明白的。反之，在你的脑海中自洽的知识你是很容易理清其中逻辑的而且不容易忘，因为此时你会觉得“他就该这样，不然呢？”。
+
+在这个章节我们会从物理层开始自底向上地介绍计算机网络，直到讲解完传输层，自底向上是符合历史逻辑的，得先有下层的支持才会有上层。
+
+## 路由与交换
+
+路由与交换的理论知识，并不涉及实践主要应付考试，但为了追求知识体系完整，会比考试内容稍多，但都是理解性质的。其实大家一般也没这个需求，除非专门做运维或者类似方向的开发，大伙都不需要了解具体怎么搭建网络，不会做过多的原理性讲解了。
+
+如果你确实有在真实世界中搭建网络的需求，请移步路由佬入门指南或者拿好你的设备并考虑加入DN11。
+
+这里主要讨论一下路由器，交换机，各种路由协议和他们工作的位置，还有NAT，最终把这些东西排排好，给大家一个完整的互联网模型（对比真实互联网做了一些简化，但该有的协议类型都会有）
+
+## 隧道和代理
+
+其实到现在一个理想化的互联网全图景已经差不多讲解完了，现在要正式完全脱离计算机网络这一课程的范畴了。
+
+隧道和代理也是计算机网络中重要的一部分，他们工作的比较高的层却提供着更低层次的功能（其实路由协议很多也这样）。
+
+前面讲解到，通过配置路由协议可以进行路由交换完成组网，但这仅仅可用于物理设备，如果两台路由器之间并没有网线的直接连接，那么我们的路由协议根本无法工作。
+
+其实真实互联网上充斥着这样的需求，比如异地组网之类的，隧道便应运而生，我们把原始数据包打包在另一个层次比较高的协议中进行传输，用高层的协议来模拟低层的协议。一条虚假的网线（其实不能和网线等价） —— 隧道便诞生了。
+
+代理部分会讲解正向和反向代理，正向代理其实就是一种“隧道”外加上访问目标主机的网络资源的能力，反向代理更多是Web开发带来的需求，比如常见的nginx反向代理。
+
+## 路由佬入门指南
+
+很多人不理解，不理解也罢。
+
+互联网不是一个很cool的东西吗?
+
+这是一个遍布全球由无数独立个体一个一个连接起来而形成的一张网，这难道不酷吗？
+
+在把网络配通的瞬间，所有的ping包返回了正确的响应，这难道不振奋人心吗？
+
+身在此却能设计出方案，访问到无比遥远的地方的资源，是难道没有意思吗？
+
+有这样的一个群体，我们普遍称呼他们为“路由佬”，他们便是这样一群，沉迷于配网的一群人。
+
+本章节存在的意义和前面的章节不同，并非是教学，而是劝人快去配网，非常重实践，上面讨论的都是简化模型，理想模型，学习模型，再往下就是实验性网络和真实互联网了，这其实已经脱离了该讲义的宗旨了，所以只会概述概述概述。
+## 画个饼先
+
+```mermaid
+    graph LR 
+        计算机网络 --> 计算机网络速通
+        计算机网络 --> 计算机网络基础
+        计算机网络 --> 路由与交换
+        计算机网络 --> 隧道与代理
+        计算机网络 --> 路由佬入门指南
+        计算机网络基础 ---> 物理层
+        计算机网络基础 ---> 链路层
+        计算机网络基础 ---> 网络层
+        计算机网络基础 ---> 传输层
+        计算机网络基础 ---> DNS与应用层概述
+        路由与交换 ---> 路由设备
+        路由与交换 ---> 路由协议
+        路由与交换 ---> NAT
+        路由与交换 ---> 真实互联网概述
+        隧道与代理 ---> GRE
+        隧道与代理 ---> WireGuard
+        隧道与代理 ---> L2TP/IPSec
+        隧道与代理 ---> 正向代理
+        隧道与代理 ---> 反向代理
+        路由佬入门指南 ---> openwrt/ikuai/ros/vyos介绍
+        路由佬入门指南 ---> 主路由,旁路由,单臂路由
+        路由佬入门指南 ---> 双节点异地组网
+        路由佬入门指南 ---> 多节点高可用网络概论
+        路由佬入门指南 ---> 大规模实验性网络概论
+        路由佬入门指南 ---> 走得更深入...
+        链路层 ---> 数据帧/MAC/CRC
+        链路层 ---> PPP
+        链路层 ---> ARP
+        网络层 ---> IP地址
+        网络层 ---> 子网/掩码/CIDR
+        网络层 ---> IPv6概述
+        传输层 ---> 端口
+        传输层 ---> UDP
+        传输层 ---> TCP概述
+        传输层 ---> TCP握手挥手
+        传输层 ---> TCP滑动窗口
+        传输层 ---> TCP拥塞控制
+        路由协议 ---> RIP
+        路由协议 ---> OSPF
+        路由协议 ---> 自治域与BGP概述
+
+```
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7c31dd3..27fcef1 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -158,4 +158,39 @@ Fork 本仓库，然后在你的仓库中进行修改，修改完成后在本仓
     ```
     :::tip
     语法自查 https://mermaid.js.org
+    :::
+
+3. 代码分块
+
+    ```
+        ::: code-group
+
+        ```sh [npm]
+        $ npm install -D vitepress
+        ```
+
+        ```sh [pnpm]
+        $ pnpm add -D vitepress
+        ```
+
+        ```sh [yarn]
+        $ yarn add -D vitepress
+        ```
+
+        :::
+    ```
+    ::: code-group
+
+    ```sh [npm]
+    $ npm install -D vitepress
+    ```
+
+    ```sh [pnpm]
+    $ pnpm add -D vitepress
+    ```
+
+    ```sh [yarn]
+    $ yarn add -D vitepress
+    ```
+
     :::
\ No newline at end of file
diff --git a/README.md b/README.md
index e1a5afc..6d2d40e 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 <div align="center">
-  <img src="https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/hdu-cs-wiki%20full.svg" alt="logo" width="450rem" height="450rem"/>
+  <img src="https://cdn.xyxsw.site/hdu-cs-wiki%20full.svg" alt="logo" width="450rem" height="450rem"/>
 </div>
 <h1 align="center">HDU计算机科学讲义</h1>
 <p align="center">
@@ -51,11 +51,9 @@
 zzm 花费了一年的时间动员了大伙对讲义进行修缮和完备，不得不说这确实不是一个小的工作，不过在2023年3月，在计院领导的支持下，计算机学院科协成立了。我们将在学院的支持下继续完善这个内容，同时也欢迎大伙加入我们，共同参与到讲义的学习与撰写中来！
 
 <div align="center">
-  <img src="https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/hdu-cs-qq.jpg">
+  <img src="https://cdn.xyxsw.site/qrcodes.png">
 </div>
 
-<p align="center">欢迎加群669895692</p>
-
 ## 学习原则
 
 1. 建议保持至少一半时间在实操，一半时间在学理论知识，比例未必正确的，但是强调实操和反馈的重要性，如果你上来就拿一本经典的花书看，只看理论或者上来就整一段开源代码，势必会陷入不同程度的盲目和困苦当中。
diff --git a/blog/index.md b/blog/index.md
new file mode 100644
index 0000000..ffdc0fb
--- /dev/null
+++ b/blog/index.md
@@ -0,0 +1,30 @@
+---
+title: Blogs
+footer: false
+editLink: false
+aside: false
+next: false 
+lastUpdated: false
+sidebar: false
+---
+
+<script setup>
+import { ref } from 'vue'
+import PostList from '../components/PostList.vue'
+import Blogger from '../components/Blogger.vue'
+const goUrl = (url) => {
+  window.open(url, "_blank")
+}
+</script>
+
+# Friends <Badge type="tip" text="join us" @click="goUrl('https://github.com/NX-Official/friends-link-plus/edit/main/input/friends.json')" style="cursor: pointer;"/>
+
+<Suspense><Blogger ></Blogger></Suspense>
+
+---
+
+# Recent Posts <Badge type="warning" text="beta" />
+
+<Suspense><PostList ></PostList></Suspense>
+
+<a href="https://github.com/NX-Official/friends-link-plus/edit/main/input/friends.json" target="_blank" style="font-size: 0.5rem; color: #666;">在GitHub上修改关注列表</a>
diff --git a/components/Blogger.vue b/components/Blogger.vue
new file mode 100644
index 0000000..af9f78a
--- /dev/null
+++ b/components/Blogger.vue
@@ -0,0 +1,51 @@
+<script setup>
+import { computed } from 'vue'
+import VPTeamMembersItem from './BloggerItem.vue'
+const size = 'small'
+const props= {friends:(await (await fetch("https://ghproxy.com/https://raw.githubusercontent.com/NX-Official/friends-link-plus/main/output/friends.json")).json()).friends}
+const members =  props.friends
+const classes = computed(() => [
+  size ?? 'medium',
+  `count-${members.length}`
+])
+</script>
+
+<template>
+  <div class="VPTeamMembers" :class="classes">
+    <div class="container">
+      <div v-for="member in members" :key="member.name" class="item">
+        <VPTeamMembersItem :size="size" :member="member" />
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.VPTeamMembers.small .container {
+  grid-template-columns: repeat(auto-fit, minmax(224px, 1fr));
+}
+
+.VPTeamMembers.small.count-1 .container { max-width: 276px; }
+.VPTeamMembers.small.count-2 .container { max-width: calc(276px * 2 + 24px); }
+.VPTeamMembers.small.count-3 .container { max-width: calc(276px * 3 + 24px * 2); }
+
+.VPTeamMembers.medium .container {
+  grid-template-columns: repeat(auto-fit, minmax(256px, 1fr));
+}
+
+@media (min-width: 375px) {
+  .VPTeamMembers.medium .container {
+    grid-template-columns: repeat(auto-fit, minmax(288px, 1fr));
+  }
+}
+
+.VPTeamMembers.medium.count-1 .container { max-width: 368px; }
+.VPTeamMembers.medium.count-2 .container { max-width: calc(368px * 2 + 24px); }
+
+.container {
+  display: grid;
+  gap: 24px;
+  margin: 0 auto;
+  max-width: 1152px;
+}
+</style>
\ No newline at end of file
diff --git a/components/BloggerItem.vue b/components/BloggerItem.vue
new file mode 100644
index 0000000..25655e3
--- /dev/null
+++ b/components/BloggerItem.vue
@@ -0,0 +1,239 @@
+<script setup >
+
+defineProps({
+  size: String,
+  member: Object
+})
+
+const goUrl = (url) => {
+  window.open(url, "_blank")
+}
+
+</script>
+
+<template>
+  <article class="VPTeamMembersItem" :class="[size ?? 'medium']">
+    <div class="profile" @click="goUrl(member.url)">
+      <figure class="avatar">
+        <img class="avatar-img" :src="member.avatar" :alt="member.name">
+      </figure>
+      <div class="data">
+        <div class="author_name">
+          {{ member.name }}
+        </div>
+        <p v-if="member.title || member.org" class="affiliation">
+          <span v-if="member.title" class="title">
+            {{ member.title }}
+          </span>
+          <span v-if="member.title && member.org" class="at">
+            @
+          </span>
+        </p>
+        <p v-if="member.description" class="desc" @click.stop>
+          {{ member.description }}
+        </p>
+        <div v-if="member.url" class="links">
+          <svg v-if="member.rss" @click="goUrl(member.rss)" xmlns="http://www.w3.org/2000/svg" width="16" height="16"
+            viewBox="0 0 16 16">
+            <path fill="currentColor"
+              d="M2 0a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V2a2 2 0 0 0-2-2H2zm1.5 2.5c5.523 0 10 4.477 10 10a1 1 0 1 1-2 0a8 8 0 0 0-8-8a1 1 0 0 1 0-2zm0 4a6 6 0 0 1 6 6a1 1 0 1 1-2 0a4 4 0 0 0-4-4a1 1 0 0 1 0-2zm.5 7a1.5 1.5 0 1 1 0-3a1.5 1.5 0 0 1 0 3z" />
+          </svg>
+        </div>
+      </div>
+    </div>
+  </article>
+</template>
+
+<style scoped>
+.VPTeamMembersItem {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  border-radius: 12px;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+}
+
+.VPTeamMembersItem.small .profile {
+  padding: 12px;
+}
+
+.VPTeamMembersItem.small .data {
+  padding-top: 20px;
+}
+
+.VPTeamMembersItem.small .avatar {
+  width: 64px;
+  height: 64px;
+}
+
+.VPTeamMembersItem.small .name {
+  line-height: 24px;
+  font-size: 16px;
+}
+
+.VPTeamMembersItem.small .affiliation {
+  padding-top: 4px;
+  line-height: 20px;
+  font-size: 14px;
+}
+
+.VPTeamMembersItem.small .desc {
+  padding-top: 12px;
+  line-height: 20px;
+  font-size: 14px;
+}
+
+.VPTeamMembersItem.small .links {
+  margin: 0 -16px -20px;
+  padding: 10px 0 0;
+}
+
+.VPTeamMembersItem.medium .profile {
+  padding: 48px 32px;
+}
+
+.VPTeamMembersItem.medium .data {
+  padding-top: 24px;
+  text-align: center;
+}
+
+.VPTeamMembersItem.medium .avatar {
+  width: 96px;
+  height: 96px;
+}
+
+.VPTeamMembersItem.medium .name {
+  letter-spacing: 0.15px;
+  line-height: 28px;
+  font-size: 20px;
+}
+
+.VPTeamMembersItem.medium .affiliation {
+  padding-top: 4px;
+  font-size: 16px;
+}
+
+.VPTeamMembersItem.medium .desc {
+  padding-top: 16px;
+  max-width: 288px;
+  font-size: 16px;
+}
+
+.VPTeamMembersItem.medium .links {
+  margin: 0 -16px -12px;
+  padding: 16px 12px 0;
+}
+
+.profile {
+  flex-grow: 1;
+  background-color: var(--vp-c-bg-soft);
+  display: flex;
+  align-items: center;
+  justify-content: space-evenly;
+}
+
+.data {
+  text-align: center;
+  /* margin: 0 auto; */
+}
+
+.avatar {
+  position: relative;
+  flex-shrink: 0;
+  /* margin: 0 auto; */
+  border-radius: 50%;
+  box-shadow: var(--vp-shadow-3);
+}
+
+.avatar-img {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  border-radius: 50%;
+  object-fit: cover;
+}
+
+.author_name {
+  margin: 0;
+  font-weight: 600;
+  cursor: pointer;
+}
+
+.affiliation {
+  margin: 0;
+  font-weight: 500;
+  color: var(--vp-c-text-2);
+}
+
+.org.link {
+  color: var(--vp-c-text-2);
+  transition: color 0.25s;
+}
+
+.org.link:hover {
+  color: var(--vp-c-brand);
+}
+
+.desc {
+  margin: 0 auto;
+  word-wrap: break-word;
+  white-space: pre-line;
+  overflow-wrap: break-word;
+  display: -webkit-box;
+  overflow: hidden;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  max-width: 150px;
+}
+
+.desc :deep(a) {
+  font-weight: 500;
+  color: var(--vp-c-brand);
+  text-decoration-style: dotted;
+  transition: color 0.25s;
+}
+
+.links {
+  display: flex;
+  justify-content: center;
+  height: 56px;
+}
+
+.links svg {
+  margin: 0 .5rem;
+}
+
+.links :hover {
+  fill: var(--vp-c-brand-lighter)
+}
+
+.sp-link {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  text-align: center;
+  padding: 16px;
+  font-size: 14px;
+  font-weight: 500;
+  color: var(--vp-c-sponsor);
+  background-color: var(--vp-c-bg-soft);
+  transition: color 0.25s, background-color 0.25s;
+}
+
+.sp .sp-link.link:hover,
+.sp .sp-link.link:focus {
+  outline: none;
+  color: var(--vp-c-white);
+  background-color: var(--vp-c-sponsor);
+}
+
+.sp-icon {
+  margin-right: 8px;
+  width: 16px;
+  height: 16px;
+  fill: currentColor;
+}</style>
\ No newline at end of file
diff --git a/components/Pagination.vue b/components/Pagination.vue
new file mode 100644
index 0000000..3994a14
--- /dev/null
+++ b/components/Pagination.vue
@@ -0,0 +1,149 @@
+<script setup>
+import { computed } from 'vue';
+const props = defineProps(['modelValue', 'pageTotal'])
+const emit = defineEmits(['update:modelValue'])
+const onPrev = () => {
+  if (props.modelValue <= 1) return; // 限制上一页翻页按钮的边界
+  emit('update:modelValue', props.modelValue - 1)
+}
+const onNext = () => {
+  if (props.modelValue >= props.pageTotal) return; // 限制下一页翻页按钮的边界
+  emit('update:modelValue', props.modelValue + 1)
+}
+const setPageNum = (pageNum) => {
+  if (typeof pageNum !== 'number') return; //如果pageNum不是数值类型则返回
+  if (pageNum < 1) return; // 限制上一页翻页按钮的边界
+  if (pageNum > props.pageTotal) return; // 限制下一页翻页按钮的边界
+  emit('update:modelValue', pageNum)
+}
+
+const genPageArray = (current, total, size) => {
+  let arr = []
+  if (total < size + 2) {
+    arr = Array.from({ length: total }, (v, k) => k + 1)
+  } else if (current < size - 2) {
+    arr = Array.from(function* gen(i, l) { while (i < l) yield i++; }(1, size - 2 + 1))
+    arr.push('...')
+    arr.push(total)
+  } else if (total - current < size - 2) {
+    arr.push(1)
+    arr.push('...')
+    arr = arr.concat(Array.from(function* gen(i, l) { while (i < l) yield i++; }(total - size + 2, total + 1)))
+  } else {
+    arr.push(1)
+    arr.push('...')
+    arr = arr.concat(Array.from(function* gen(i, l) { while (i < l) yield i++; }(current - Math.floor((size - 4) / 2), current - Math.floor((size - 4) / 2) + size - 4 + 1)))
+    arr.push('...')
+    arr.push(total)
+  }
+  return arr
+}
+const pageArrayLg = computed(() => {
+  const current = props.modelValue
+  const total = props.pageTotal
+  return genPageArray(current, total, 17)
+})
+const pageArrayMd = computed(() => {
+  const current = props.modelValue
+  const total = props.pageTotal
+  return genPageArray(current, total, 10)
+})
+const pageArraySm = computed(() => {
+  const current = props.modelValue
+  const total = props.pageTotal
+  return genPageArray(current, total, 6)
+})
+</script>
+
+<template>
+  <div>
+    <div class="container" v-if="props.pageTotal > 1">
+      <div class="paper-item" @click="onPrev" style="display: flex;">&lt;</div>
+      <div v-for="(item, index) in pageArrayLg" :key="index" @click="setPageNum(item)" class="paper-item paper-lg"
+        :class="{ 'active': item == props.modelValue }">{{ item }}</div>
+      <div v-for="(item, index) in pageArrayMd" :key="index" @click="setPageNum(item)" class="paper-item paper-md"
+        :class="{ 'active': item == props.modelValue }">{{ item }}</div>
+      <div v-for="(item, index) in pageArraySm" :key="index" @click="setPageNum(item)" class="paper-item paper-sm"
+        :class="{ 'active': item == props.modelValue }">{{ item }}</div>
+      <div class="paper-item" @click="onNext" style="display: flex;">></div>
+    </div>
+  </div>
+</template>
+
+
+
+<style scoped>
+.container {
+  margin: 1rem 0;
+  width: 100%;
+  display: flex;
+  justify-content: center;
+  /* font-weight: 600; */
+}
+
+@media screen and (min-width: 780px) {
+
+  .paper-lg,
+  .paper-sm {
+    display: none;
+  }
+
+  .paper-md {
+    display: flex;
+  }
+}
+
+@media screen and (min-width: 1024px) {
+
+  .paper-md,
+  .paper-sm {
+    display: none;
+  }
+
+  .paper-lg {
+    display: flex;
+  }
+}
+
+@media screen and (max-width: 780px) {
+
+  .paper-lg,
+  .paper-md {
+    display: none;
+  }
+
+  .paper-sm {
+    display: flex;
+  }
+}
+
+.paper-item {
+  height: 2rem;
+  width: 2rem;
+  margin: 0 .5rem;
+  padding: 0rem .25rem;
+  align-items: center;
+  justify-content: center;
+  background-color: #f6f6f7;
+  border-radius: .25rem;
+  cursor: pointer;
+}
+
+.paper-item:hover {
+  background-color: #0099ff0d;
+  --un-text-opacity: 1;
+  color: var(--vp-c-brand-lighter);
+}
+
+.paper-item.active {
+  background-color: #0099ff0d;
+  --un-text-opacity: 1;
+  color: var(--vp-c-brand-lighter);
+}
+
+@media (prefers-color-scheme: dark) {
+
+.paper-item {
+  background-color: #9ca3af0d;
+}
+}</style>
diff --git a/components/Parallax.vue b/components/Parallax.vue
index 9056c31..4f135e3 100644
--- a/components/Parallax.vue
+++ b/components/Parallax.vue
@@ -39,13 +39,13 @@ const containerStyle: CSSProperties = {
 
 const layer0 = computed(() => ({
   ...layerBase,
-  content:'url(https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/hdu-cs-wiki_main.png)',
+  content:'url(https://cdn.xyxsw.site/hdu-cs-wiki_main.png)',
   transform: `translateX(${parallax.tilt * 10}px) translateY(${parallax.roll * 10
     }px) scale(1)`,
 }))
 
 const layer1 = computed(() => ({
-  content:'url(https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/sparkles.gif)',
+  content:'url(https://cdn.xyxsw.site/sparkles.gif)',
   userSelect: 'none',
   "-webkit-user-drag": "none",
   transform: `translateX(${parallax.tilt * 20}px) translateY(${parallax.roll * 20
diff --git a/components/PostItem.vue b/components/PostItem.vue
new file mode 100644
index 0000000..e04c1c5
--- /dev/null
+++ b/components/PostItem.vue
@@ -0,0 +1,222 @@
+<template>
+  <div class="blog-item" @click="openBlog(PostURL)">
+    <div class="title" v-if="inMobile">{{ Title }}</div>
+    <div class="info-container">
+      <div class="info-part">
+        <div class="title" v-if="!inMobile">{{ Title }}</div>
+        <div class="description" v-if="!!Content">
+          {{ Content }}
+        </div>
+        <div class="badge-list" v-if="!inMobile">
+          <a class="split" v-if="Author" :href="withBase(AuthorURL)" @click.stop target="_blank">{{ Author }}</a>
+          <span class="split">{{ showTime }}</span>
+          <span class="split" v-if="tag?.length">{{ tag.join(' · ') }}</span>
+        </div>
+      </div>
+      <div
+        v-if="cover"
+        class="cover-img"
+        :style="`background-image: url(${cover});`"
+      ></div>
+    </div>
+    <div class="badge-list" v-if="inMobile">
+      <a class="split" v-if="Author" :href="withBase(AuthorURL)" @click.stop target="_blank">{{ Author }}</a>
+      <span class="split">{{ showTime }}</span>
+      <span class="split" v-if="tag?.length">{{ tag.join(' · ') }}</span>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { withBase } from 'vitepress'
+import { computed } from 'vue'
+import { useWindowSize } from '@vueuse/core'
+const openBlog = (url) => {
+  window.open(url, '_blank')
+}
+const { width } = useWindowSize()
+const inMobile = computed(() => width.value <= 500)
+function formatDate(d, fmt = 'yyyy-MM-dd hh:mm:ss') {
+  if (!(d instanceof Date)) {
+    d = new Date(d)
+  }
+  const o = {
+    'M+': d.getMonth() + 1, // 月份
+    'd+': d.getDate(), // 日
+    'h+': d.getHours(), // 小时
+    'm+': d.getMinutes(), // 分
+    's+': d.getSeconds(), // 秒
+    'q+': Math.floor((d.getMonth() + 3) / 3), // 季度
+    S: d.getMilliseconds() // 毫秒
+  }
+  if (/(y+)/.test(fmt)) {
+    fmt = fmt.replace(
+      RegExp.$1,
+      `${d.getFullYear()}`.substr(4 - RegExp.$1.length)
+    )
+  }
+  // eslint-disable-next-line no-restricted-syntax
+  for (const k in o) {
+    if (new RegExp(`(${k})`).test(fmt))
+      fmt = fmt.replace(
+        RegExp.$1,
+        RegExp.$1.length === 1 ? o[k] : `00${o[k]}`.substr(`${o[k]}`.length)
+      )
+  }
+  return fmt
+}
+function formatShowDate(date) {
+  const source = date ? +new Date(date) : +new Date()
+  const now = +new Date()
+  const diff = now - source
+  const oneSeconds = 1000
+  const oneMinute = oneSeconds * 60
+  const oneHour = oneMinute * 60
+  const oneDay = oneHour * 24
+  const oneWeek = oneDay * 7
+  if (diff < oneMinute) {
+    return `${Math.floor(diff / oneSeconds)}秒前`
+  }
+  if (diff < oneHour) {
+    return `${Math.floor(diff / oneMinute)}分钟前`
+  }
+  if (diff < oneDay) {
+    return `${Math.floor(diff / oneHour)}小时前`
+  }
+  if (diff < oneWeek) {
+    return `${Math.floor(diff / oneDay)}天前`
+  }
+
+  return formatDate(new Date(date), 'yyyy-MM-dd')
+}
+
+const props = defineProps({
+  Title: String,
+  Date: String,
+  Content: String,
+  tag: {
+    type: Array,
+    required: false,
+  },
+  Author: String,
+  cover: {
+    type: String,
+    required: false,
+  },
+  PostURL: String,
+  AuthorURL: String
+})
+
+const showTime = computed(() => {
+  return formatShowDate(props.Date)
+})
+
+</script>
+
+<style scoped>
+.blog-item .pin {
+  position: absolute;
+  overflow: hidden;
+  width: 30px;
+  height: 30px;
+  top: -4px;
+  left: -4px;
+  opacity: 0.5;
+}
+.blog-item:hover .pin {
+  opacity: 1;
+}
+.blog-item .pin::before {
+  content: '';
+  position: absolute;
+  width: 120%;
+  height: 30px;
+  background-image: linear-gradient(
+    45deg,
+    var(--blog-theme-color),
+    var(--blog-theme-color)
+  );
+  transform: rotate(-45deg) translateY(-20px);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  box-shadow: 0 5px 10px rgba(0, 0, 0, 0.23);
+}
+
+.blog-item {
+  position: relative;
+  border: 1px solid rgba(82, 82, 89, .32);
+  border-radius: .5rem;
+  padding: 1.5rem;
+  width: 100%;
+  overflow: hidden;
+  box-sizing: border-box;
+  transition: all 0.3s;
+  display: flex;
+  flex-direction: column;
+  transition: border-color .25s;
+  cursor: pointer;
+}
+
+
+.blog-item:hover {
+  border: 1px solid #09f;
+}
+
+.info-container {
+  display: flex;
+  align-items: center;
+  justify-content: flex-start;
+}
+
+.info-part {
+  flex: 1;
+}
+.title {
+  font-size: 18px;
+  font-weight: 600;
+  margin-bottom: 8px;
+}
+.description {
+  color: var(--description-font-color);
+  font-size: 14px;
+  margin-bottom: 8px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+}
+.description-html {
+  font-size: 14px;
+}
+.badge-list {
+  font-size: 13px;
+  color: var(--badge-font-color);
+  margin-top: 8px;
+}
+.badge-list .split:not(:last-child)::after {
+  content: '';
+  display: inline-block;
+  width: 1px;
+  height: 8px;
+  margin: 0 10px;
+  background-color: #4e5969;
+}
+.cover-img {
+  width: 120px;
+  height: 80px;
+  margin-left: 24px;
+  border-radius: 2px;
+  background-repeat: no-repeat;
+  background-size: 120px 80px;
+}
+
+@media screen and (max-width: 500px) {
+  .cover-img {
+    width: 100px;
+    height: 60px;
+    background-size: 100px 60px;
+  }
+}
+</style>
\ No newline at end of file
diff --git a/components/PostList.vue b/components/PostList.vue
new file mode 100644
index 0000000..727dbb4
--- /dev/null
+++ b/components/PostList.vue
@@ -0,0 +1,247 @@
+<script setup>
+import { ref, computed } from 'vue';
+import Pagination from './Pagination.vue';
+import PostItem from './PostItem.vue';
+const props= {data:(await (await fetch("https://ghproxy.com/https://raw.githubusercontent.com/NX-Official/friends-link-plus/main/output/friends.json")).json()).posts}
+const pageSize = 10
+// const Date = ref('')
+const pageTotal = ref(Math.ceil(props.data.length / pageSize))
+const pageNum = ref(1)
+// const searchText = ref('')
+// const onsearchText = ref('')
+const pluginLists = computed(() => {
+  let data_ = props.data//.filter(item => item.Date == Date.value)
+  // if (!!onsearchText.value) {
+  //   data_ = data_.filter(item => item.name.indexOf(onsearchText.value) > -1)
+  // }
+  pageTotal.value = Math.ceil(data_.length / pageSize)
+  data_ = data_.slice((pageNum.value - 1) * pageSize, pageNum.value * pageSize)
+  return data_
+})
+// const setDate = (Date_) => {
+//   Date.value = Date_
+//   searchText.value = ""
+//   onSearch()
+// }
+// const onSearch = () => {
+//   onsearchText.value = searchText.value
+//   pageNum.value = 1
+// }
+</script>
+
+<template>
+  <div>
+    <!-- <div class="tab">
+      <div opacity="80" text="sm">
+        类型{{ props.data }}
+      </div>
+      <div class="select-list">
+        <button class="select-button" @click="setDate('plugin')" :class="{ 'active': type == 'plugin' }">
+          插件
+        </button>
+        <button class="select-button" @click="setType('adapter')" :class="{ 'active': type == 'adapter' }">
+          适配器
+        </button>
+        <button class="select-button" @click="setType('example')" :class="{ 'active': type == 'example' }">
+          样例
+        </button>
+      </div>
+    </div> -->
+    <!-- <div class="search-bar">
+      <div class="divider" style="margin-top: 1rem;" />
+      <div class="search" @change="onSearch">
+        <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 32 32" class="icon">
+          <path fill="currentColor"
+            d="m29 27.586l-7.552-7.552a11.018 11.018 0 1 0-1.414 1.414L27.586 29ZM4 13a9 9 0 1 1 9 9a9.01 9.01 0 0 1-9-9Z" />
+        </svg>
+        <input data-v-48d9a5fe="" class="search-input" type="text" role="search" placeholder="Search..."
+          v-model="searchText">
+      </div>
+      <div class="divider" style="margin-bottom: 1rem;" />
+    </div> -->
+    <Pagination :pageTotal="pageTotal" v-model="pageNum" style="width: 100%;padding: 1rem 0;" key="0" />
+    <div class="card-list">
+      <PostItem v-for="(item, index) in pluginLists" :key="index" :Title="item.Title" :Content="item.Content"
+        :Date="item.Date" :Author="item.Author" :tag="item?.tag" :cover="item?.cover" :PostURL="item.PostURL" :AuthorURL="item.AuthorURL"/>
+    </div>
+    <Pagination :pageTotal="pageTotal" v-model="pageNum" style="width: 100%;padding: 1rem 0;" key="1" />
+  </div>
+</template>
+
+
+<style scoped>
+.tab {
+  grid-row-gap: .5rem;
+  row-gap: .5rem;
+  margin-top: 2.5rem;
+  grid-template-columns: 80px auto;
+  display: grid;
+}
+
+.sm {
+  font-size: .875rem;
+  line-height: 1.25rem;
+}
+
+.select-list {
+  grid-gap: .5rem;
+  gap: .5rem;
+  flex-wrap: wrap;
+  display: flex;
+  margin-bottom: .5rem;
+}
+
+.select-button {
+  border-radius: .25rem;
+  background-color: #9ca3af0d;
+  padding: .125rem .5rem;
+  font-size: .875rem;
+  line-height: 1.25rem;
+}
+
+.select-button:hover {
+  cursor: pointer;
+  background-color: #9ca3af1a;
+}
+
+.select-button.active {
+  background-color: #0099ff0d;
+  --un-text-opacity: 1;
+  color: var(--vp-c-brand-lighter);
+}
+
+.divider {
+  background-color: rgba(60, 60, 67, .12);
+  height: 1px;
+}
+
+.search {
+  padding: .5rem;
+  display: flex;
+}
+
+.icon {
+  margin-right: .5rem;
+}
+
+.search-input {
+  width: 100%;
+  margin-top: auto;
+  margin-bottom: auto;
+}
+
+.card-list {
+  display: flex;
+  flex-direction: column;
+  gap: 2rem;
+}
+
+.card {
+  display: block;
+  border: 1px solid rgba(82, 82, 89, .32);
+  border-radius: .5rem;
+  padding: 1.5rem;
+  width: 100%;
+  height: 100%;
+  transition: border-color .25s;
+  cursor: pointer;
+}
+
+.card:hover {
+  border: 1px solid #09f;
+}
+
+.card-head {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.card-title {
+  display: flex;
+  font-size: large;
+  font-weight: bold;
+  align-items: center;
+}
+
+.card-github {
+  cursor: pointer;
+}
+
+.card-github:hover {
+  fill: #09f;
+}
+
+.card-des {
+  color: #3C3C43;
+  opacity: .7;
+  font-size: .875rem;
+  line-height: 1.25rem;
+  margin-top: .3rem;
+}
+
+.card-tags {
+  display: flex;
+  margin-top: .5rem;
+  margin-bottom: .5rem;
+  font-size: .875rem;
+  line-height: 1.25rem;
+}
+
+.card-tag {
+  margin: 0 .5rem;
+  padding: 0 .5rem;
+  background-color: #9ca3af2b;
+}
+
+.card-tags .card-tag:first-child {
+  margin-left: 0;
+  /* background-color: #6e6e6e; */
+}
+
+.card-details {
+  margin: .8rem 0 .5rem 0;
+}
+
+.card-text {
+  margin-left: .5rem;
+  font-size: .95rem;
+  line-height: 1.5rem;
+}
+
+.card-detail {
+  display: flex;
+  align-items: center;
+}
+
+.card-button {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  width: 100%;
+  padding: .4rem 1rem;
+  background-color: #f6f6f7;
+  border-radius: .5rem;
+  cursor: pointer;
+}
+
+.card-button:hover {
+  color: #09f;
+}
+
+.card-button:hover {
+  fill: #09f;
+}
+
+@media (prefers-color-scheme: dark) {
+
+  .card-button {
+    background-color: #9ca3af0d;
+  }
+
+  .card-des {
+    color: #9ca3af;
+  }
+
+}
+</style>
diff --git a/contributors.md b/contributors.md
index 9f0b1bb..cd48d0f 100644
--- a/contributors.md
+++ b/contributors.md
@@ -5,7 +5,7 @@ import { members } from './members.ts'
 </script>
 
 # 贡献者名单
-<Parallax/>
+
 以下为对本项目做出贡献的人员名单，排名不分先后。
 
 <VPTeamMembers size="small" :members="members" />
diff --git a/members.ts b/members.ts
index a1bd4c6..440a631 100644
--- a/members.ts
+++ b/members.ts
@@ -133,4 +133,60 @@ export const members: Member = [
       { icon: 'github', link: 'https://github.com/GoldenSheep402' },
     ]
   },
+  {
+    avatar: 'https://avatars.hdu-cs.wiki/NX-Official',
+    name: 'Nick Xu',
+    title: 'Contributer',
+    links: [
+      { icon: 'github', link: 'https://github.com/NX-Official' },
+    ]
+  },
+  {
+    avatar: 'https://avatars.hdu-cs.wiki/4nsw3r123',
+    name: '4nsw3r',
+    title: 'Contributer',
+    links: [
+      { icon: 'github', link: 'https://github.com/4nsw3r123' },
+    ]
+  },
+  {
+    avatar: 'https://avatars.hdu-cs.wiki/BaiMeow',
+    name: '柏喵Sakura',
+    title: 'Contributer',
+    links: [
+      { icon: 'github', link: 'https://github.com/BaiMeow' },
+    ]
+  },
+  {
+    avatar: 'https://avatars.hdu-cs.wiki/sd0ric4',
+    name: 'lightstarts',
+    title: 'Contributer',
+    links: [
+      { icon: 'github', link: 'https://github.com/sd0ric4' },
+    ]
+  },
+  {
+    avatar: 'https://avatars.hdu-cs.wiki/wenjing233',
+    name: 'wenjing233',
+    title: 'Contributer',
+    links: [
+      { icon: 'github', link: 'https://github.com/wenjing233' },
+    ]
+  },
+  {
+    avatar: 'https://avatars.hdu-cs.wiki/Lacsion',
+    name: 'KAFUU',
+    title: 'Contributer',
+    links: [
+      { icon: 'github', link: 'https://github.com/Lacsion' },
+    ]
+  },
+  {
+    avatar: 'https://avatars.hdu-cs.wiki/Krisnile',
+    name: 'Krisnile',
+    title: 'Contributer',
+    links: [
+      { icon: 'github', link: 'https://github.com/Krisnile' },
+    ]
+  },
 ]
diff --git a/package-lock.json b/package-lock.json
index 40643ff..c998e1b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,16 +9,17 @@
         "@codemirror/lang-sql": "^6.5.2",
         "@jupyterlab/mathjax2": "^3.6.5",
         "@jupyterlab/theme-light-extension": "^4.0.3",
-        "@vueuse/core": "^10.2.1",
+        "@vueuse/core": "^10.3.0",
         "markdown-it": "^13.0.1",
-        "markdown-it-pangu": "^1.0.2"
+        "markdown-it-pangu": "^1.0.2",
+        "sitemap": "^7.1.1"
       },
       "devDependencies": {
         "@mermaid-js/mermaid-mindmap": "^9.3.0",
         "cross-env": "^7.0.3",
         "markdown-it-mathjax3": "^4.3.2",
-        "mermaid": "^10.2.4",
-        "vitepress": "^1.0.0-beta.5",
+        "mermaid": "^10.3.0",
+        "vitepress": "^1.0.0-beta.7",
         "vitepress-plugin-mermaid": "^2.0.13"
       }
     },
@@ -326,397 +327,353 @@
       }
     },
     "node_modules/@esbuild/android-arm": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/android-arm/-/android-arm-0.17.19.tgz",
-      "integrity": "sha512-rIKddzqhmav7MSmoFCmDIb6e2W57geRsM94gV2l38fzhXMwq7hZoClug9USI2pFRGL06f4IOPHHpFNOkWieR8A==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/android-arm/-/android-arm-0.18.16.tgz",
+      "integrity": "sha512-gCHjjQmA8L0soklKbLKA6pgsLk1byULuHe94lkZDzcO3/Ta+bbeewJioEn1Fr7kgy9NWNFy/C+MrBwC6I/WCug==",
       "cpu": [
         "arm"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "android"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/android-arm64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/android-arm64/-/android-arm64-0.17.19.tgz",
-      "integrity": "sha512-KBMWvEZooR7+kzY0BtbTQn0OAYY7CsiydT63pVEaPtVYF0hXbUaOyZog37DKxK7NF3XacBJOpYT4adIJh+avxA==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/android-arm64/-/android-arm64-0.18.16.tgz",
+      "integrity": "sha512-wsCqSPqLz+6Ov+OM4EthU43DyYVVyfn15S4j1bJzylDpc1r1jZFFfJQNfDuT8SlgwuqpmpJXK4uPlHGw6ve7eA==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "android"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/android-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/android-x64/-/android-x64-0.17.19.tgz",
-      "integrity": "sha512-uUTTc4xGNDT7YSArp/zbtmbhO0uEEK9/ETW29Wk1thYUJBz3IVnvgEiEwEa9IeLyvnpKrWK64Utw2bgUmDveww==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/android-x64/-/android-x64-0.18.16.tgz",
+      "integrity": "sha512-ldsTXolyA3eTQ1//4DS+E15xl0H/3DTRJaRL0/0PgkqDsI0fV/FlOtD+h0u/AUJr+eOTlZv4aC9gvfppo3C4sw==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "android"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/darwin-arm64/-/darwin-arm64-0.17.19.tgz",
-      "integrity": "sha512-80wEoCfF/hFKM6WE1FyBHc9SfUblloAWx6FJkFWTWiCoht9Mc0ARGEM47e67W9rI09YoUxJL68WHfDRYEAvOhg==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/darwin-arm64/-/darwin-arm64-0.18.16.tgz",
+      "integrity": "sha512-aBxruWCII+OtluORR/KvisEw0ALuw/qDQWvkoosA+c/ngC/Kwk0lLaZ+B++LLS481/VdydB2u6tYpWxUfnLAIw==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "darwin"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/darwin-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/darwin-x64/-/darwin-x64-0.17.19.tgz",
-      "integrity": "sha512-IJM4JJsLhRYr9xdtLytPLSH9k/oxR3boaUIYiHkAawtwNOXKE8KoU8tMvryogdcT8AU+Bflmh81Xn6Q0vTZbQw==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/darwin-x64/-/darwin-x64-0.18.16.tgz",
+      "integrity": "sha512-6w4Dbue280+rp3LnkgmriS1icOUZDyPuZo/9VsuMUTns7SYEiOaJ7Ca1cbhu9KVObAWfmdjUl4gwy9TIgiO5eA==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "darwin"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/freebsd-arm64/-/freebsd-arm64-0.17.19.tgz",
-      "integrity": "sha512-pBwbc7DufluUeGdjSU5Si+P3SoMF5DQ/F/UmTSb8HXO80ZEAJmrykPyzo1IfNbAoaqw48YRpv8shwd1NoI0jcQ==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.16.tgz",
+      "integrity": "sha512-x35fCebhe9s979DGKbVAwXUOcTmCIE32AIqB9CB1GralMIvxdnMLAw5CnID17ipEw9/3MvDsusj/cspYt2ZLNQ==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "freebsd"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/freebsd-x64/-/freebsd-x64-0.17.19.tgz",
-      "integrity": "sha512-4lu+n8Wk0XlajEhbEffdy2xy53dpR06SlzvhGByyg36qJw6Kpfk7cp45DR/62aPH9mtJRmIyrXAS5UWBrJT6TQ==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-x64/-/freebsd-x64-0.18.16.tgz",
+      "integrity": "sha512-YM98f+PeNXF3GbxIJlUsj+McUWG1irguBHkszCIwfr3BXtXZsXo0vqybjUDFfu9a8Wr7uUD/YSmHib+EeGAFlg==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "freebsd"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/linux-arm": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-arm/-/linux-arm-0.17.19.tgz",
-      "integrity": "sha512-cdmT3KxjlOQ/gZ2cjfrQOtmhG4HJs6hhvm3mWSRDPtZ/lP5oe8FWceS10JaSJC13GBd4eH/haHnqf7hhGNLerA==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm/-/linux-arm-0.18.16.tgz",
+      "integrity": "sha512-b5ABb+5Ha2C9JkeZXV+b+OruR1tJ33ePmv9ZwMeETSEKlmu/WJ45XTTG+l6a2KDsQtJJ66qo/hbSGBtk0XVLHw==",
       "cpu": [
         "arm"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/linux-arm64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-arm64/-/linux-arm64-0.17.19.tgz",
-      "integrity": "sha512-ct1Tg3WGwd3P+oZYqic+YZF4snNl2bsnMKRkb3ozHmnM0dGWuxcPTTntAF6bOP0Sp4x0PjSF+4uHQ1xvxfRKqg==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm64/-/linux-arm64-0.18.16.tgz",
+      "integrity": "sha512-XIqhNUxJiuy+zsR77+H5Z2f7s4YRlriSJKtvx99nJuG5ATuJPjmZ9n0ANgnGlPCpXGSReFpgcJ7O3SMtzIFeiQ==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/linux-ia32": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-ia32/-/linux-ia32-0.17.19.tgz",
-      "integrity": "sha512-w4IRhSy1VbsNxHRQpeGCHEmibqdTUx61Vc38APcsRbuVgK0OPEnQ0YD39Brymn96mOx48Y2laBQGqgZ0j9w6SQ==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-ia32/-/linux-ia32-0.18.16.tgz",
+      "integrity": "sha512-no+pfEpwnRvIyH+txbBAWtjxPU9grslmTBfsmDndj7bnBmr55rOo/PfQmRfz7Qg9isswt1FP5hBbWb23fRWnow==",
       "cpu": [
         "ia32"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-loong64/-/linux-loong64-0.17.19.tgz",
-      "integrity": "sha512-2iAngUbBPMq439a+z//gE+9WBldoMp1s5GWsUSgqHLzLJ9WoZLZhpwWuym0u0u/4XmZ3gpHmzV84PonE+9IIdQ==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-loong64/-/linux-loong64-0.18.16.tgz",
+      "integrity": "sha512-Zbnczs9ZXjmo0oZSS0zbNlJbcwKXa/fcNhYQjahDs4Xg18UumpXG/lwM2lcSvHS3mTrRyCYZvJbmzYc4laRI1g==",
       "cpu": [
         "loong64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-mips64el/-/linux-mips64el-0.17.19.tgz",
-      "integrity": "sha512-LKJltc4LVdMKHsrFe4MGNPp0hqDFA1Wpt3jE1gEyM3nKUvOiO//9PheZZHfYRfYl6AwdTH4aTcXSqBerX0ml4A==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-mips64el/-/linux-mips64el-0.18.16.tgz",
+      "integrity": "sha512-YMF7hih1HVR/hQVa/ot4UVffc5ZlrzEb3k2ip0nZr1w6fnYypll9td2qcoMLvd3o8j3y6EbJM3MyIcXIVzXvQQ==",
       "cpu": [
         "mips64el"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-ppc64/-/linux-ppc64-0.17.19.tgz",
-      "integrity": "sha512-/c/DGybs95WXNS8y3Ti/ytqETiW7EU44MEKuCAcpPto3YjQbyK3IQVKfF6nbghD7EcLUGl0NbiL5Rt5DMhn5tg==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-ppc64/-/linux-ppc64-0.18.16.tgz",
+      "integrity": "sha512-Wkz++LZ29lDwUyTSEnzDaaP5OveOgTU69q9IyIw9WqLRxM4BjTBjz9un4G6TOvehWpf/J3gYVFN96TjGHrbcNQ==",
       "cpu": [
         "ppc64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-riscv64/-/linux-riscv64-0.17.19.tgz",
-      "integrity": "sha512-FC3nUAWhvFoutlhAkgHf8f5HwFWUL6bYdvLc/TTuxKlvLi3+pPzdZiFKSWz/PF30TB1K19SuCxDTI5KcqASJqA==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-riscv64/-/linux-riscv64-0.18.16.tgz",
+      "integrity": "sha512-LFMKZ30tk78/mUv1ygvIP+568bwf4oN6reG/uczXnz6SvFn4e2QUFpUpZY9iSJT6Qpgstrhef/nMykIXZtZWGQ==",
       "cpu": [
         "riscv64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/linux-s390x": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-s390x/-/linux-s390x-0.17.19.tgz",
-      "integrity": "sha512-IbFsFbxMWLuKEbH+7sTkKzL6NJmG2vRyy6K7JJo55w+8xDk7RElYn6xvXtDW8HCfoKBFK69f3pgBJSUSQPr+4Q==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-s390x/-/linux-s390x-0.18.16.tgz",
+      "integrity": "sha512-3ZC0BgyYHYKfZo3AV2/66TD/I9tlSBaW7eWTEIkrQQKfJIifKMMttXl9FrAg+UT0SGYsCRLI35Gwdmm96vlOjg==",
       "cpu": [
         "s390x"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/linux-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-x64/-/linux-x64-0.17.19.tgz",
-      "integrity": "sha512-68ngA9lg2H6zkZcyp22tsVt38mlhWde8l3eJLWkyLrp4HwMUr3c1s/M2t7+kHIhvMjglIBrFpncX1SzMckomGw==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-x64/-/linux-x64-0.18.16.tgz",
+      "integrity": "sha512-xu86B3647DihHJHv/wx3NCz2Dg1gjQ8bbf9cVYZzWKY+gsvxYmn/lnVlqDRazObc3UMwoHpUhNYaZset4X8IPA==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "linux"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/netbsd-x64/-/netbsd-x64-0.17.19.tgz",
-      "integrity": "sha512-CwFq42rXCR8TYIjIfpXCbRX0rp1jo6cPIUPSaWwzbVI4aOfX96OXY8M6KNmtPcg7QjYeDmN+DD0Wp3LaBOLf4Q==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/netbsd-x64/-/netbsd-x64-0.18.16.tgz",
+      "integrity": "sha512-uVAgpimx9Ffw3xowtg/7qQPwHFx94yCje+DoBx+LNm2ePDpQXHrzE+Sb0Si2VBObYz+LcRps15cq+95YM7gkUw==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "netbsd"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/openbsd-x64/-/openbsd-x64-0.17.19.tgz",
-      "integrity": "sha512-cnq5brJYrSZ2CF6c35eCmviIN3k3RczmHz8eYaVlNasVqsNY+JKohZU5MKmaOI+KkllCdzOKKdPs762VCPC20g==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/openbsd-x64/-/openbsd-x64-0.18.16.tgz",
+      "integrity": "sha512-6OjCQM9wf7z8/MBi6BOWaTL2AS/SZudsZtBziXMtNI8r/U41AxS9x7jn0ATOwVy08OotwkPqGRMkpPR2wcTJXA==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "openbsd"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/sunos-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/sunos-x64/-/sunos-x64-0.17.19.tgz",
-      "integrity": "sha512-vCRT7yP3zX+bKWFeP/zdS6SqdWB8OIpaRq/mbXQxTGHnIxspRtigpkUcDMlSCOejlHowLqII7K2JKevwyRP2rg==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/sunos-x64/-/sunos-x64-0.18.16.tgz",
+      "integrity": "sha512-ZoNkruFYJp9d1LbUYCh8awgQDvB9uOMZqlQ+gGEZR7v6C+N6u7vPr86c+Chih8niBR81Q/bHOSKGBK3brJyvkQ==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "sunos"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/win32-arm64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/win32-arm64/-/win32-arm64-0.17.19.tgz",
-      "integrity": "sha512-yYx+8jwowUstVdorcMdNlzklLYhPxjniHWFKgRqH7IFlUEa0Umu3KuYplf1HUZZ422e3NU9F4LGb+4O0Kdcaag==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/win32-arm64/-/win32-arm64-0.18.16.tgz",
+      "integrity": "sha512-+j4anzQ9hrs+iqO+/wa8UE6TVkKua1pXUb0XWFOx0FiAj6R9INJ+WE//1/Xo6FG1vB5EpH3ko+XcgwiDXTxcdw==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "win32"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/win32-ia32": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/win32-ia32/-/win32-ia32-0.17.19.tgz",
-      "integrity": "sha512-eggDKanJszUtCdlVs0RB+h35wNlb5v4TWEkq4vZcmVt5u/HiDZrTXe2bWFQUez3RgNHwx/x4sk5++4NSSicKkw==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/win32-ia32/-/win32-ia32-0.18.16.tgz",
+      "integrity": "sha512-5PFPmq3sSKTp9cT9dzvI67WNfRZGvEVctcZa1KGjDDu4n3H8k59Inbk0du1fz0KrAbKKNpJbdFXQMDUz7BG4rQ==",
       "cpu": [
         "ia32"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "win32"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/@esbuild/win32-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/win32-x64/-/win32-x64-0.17.19.tgz",
-      "integrity": "sha512-lAhycmKnVOuRYNtRtatQR1LPQf2oYCkRGkSFnseDAKPl8lu5SOsK/e1sXe5a0Pc5kHIHe6P2I/ilntNv2xf3cA==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/win32-x64/-/win32-x64-0.18.16.tgz",
+      "integrity": "sha512-sCIVrrtcWN5Ua7jYXNG1xD199IalrbfV2+0k/2Zf2OyV2FtnQnMgdzgpRAbi4AWlKJj1jkX+M+fEGPQj6BQB4w==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "license": "MIT",
       "optional": true,
       "os": [
         "win32"
       ],
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
@@ -1353,6 +1310,27 @@
         "react": "^16.14.0 || >=17"
       }
     },
+    "node_modules/@types/d3-scale": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmmirror.com/@types/d3-scale/-/d3-scale-4.0.3.tgz",
+      "integrity": "sha512-PATBiMCpvHJSMtZAMEhc2WyL+hnzarKzI6wAHYjhsonjWJYGq5BXTzQjv4l8m2jO183/4wZ90rKvSeT7o72xNQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/d3-time": "*"
+      }
+    },
+    "node_modules/@types/d3-scale-chromatic": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/@types/d3-scale-chromatic/-/d3-scale-chromatic-3.0.0.tgz",
+      "integrity": "sha512-dsoJGEIShosKVRBZB0Vo3C8nqSDqVGujJU6tPznsBJxNJNwMF8utmS83nvCBKQYPpjCzaaHcrf66iTRpZosLPw==",
+      "dev": true
+    },
+    "node_modules/@types/d3-time": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/@types/d3-time/-/d3-time-3.0.0.tgz",
+      "integrity": "sha512-sZLCdHvBUcNby1cB6Fd3ZBrABbjz3v1Vm90nysCQ6Vt7vd6e/h9Lt7SiJUoEX0l4Dzc7P5llKyhqSi1ycSf1Hg==",
+      "dev": true
+    },
     "node_modules/@types/debug": {
       "version": "4.1.8",
       "resolved": "https://registry.npmmirror.com/@types/debug/-/debug-4.1.8.tgz",
@@ -1377,6 +1355,11 @@
       "integrity": "sha512-iiUgKzV9AuaEkZqkOLDIvlQiL6ltuZd9tGcW3gwpnX8JbuiuhFlEGmmFXEXkN50Cvq7Os88IY2v0dkDqXYWVgA==",
       "dev": true
     },
+    "node_modules/@types/node": {
+      "version": "17.0.45",
+      "resolved": "https://registry.npmmirror.com/@types/node/-/node-17.0.45.tgz",
+      "integrity": "sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw=="
+    },
     "node_modules/@types/prop-types": {
       "version": "15.7.5",
       "resolved": "https://registry.npmmirror.com/@types/prop-types/-/prop-types-15.7.5.tgz",
@@ -1392,6 +1375,14 @@
         "csstype": "^3.0.2"
       }
     },
+    "node_modules/@types/sax": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmmirror.com/@types/sax/-/sax-1.2.4.tgz",
+      "integrity": "sha512-pSAff4IAxJjfAXUG6tFkO7dsSbTmf8CtUpfhhZ5VhkRpC4628tJhh3+V6H1E+/Gs9piSzYKT5yzHO5M4GG9jkw==",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@types/scheduler": {
       "version": "0.16.3",
       "resolved": "https://registry.npmmirror.com/@types/scheduler/-/scheduler-0.16.3.tgz",
@@ -1541,13 +1532,21 @@
       "license": "MIT"
     },
     "node_modules/@vueuse/core": {
-      "version": "10.2.1",
-      "resolved": "https://registry.npmmirror.com/@vueuse/core/-/core-10.2.1.tgz",
-      "integrity": "sha512-c441bfMbkAwTNwVRHQ0zdYZNETK//P84rC01aP2Uy/aRFCiie9NE/k9KdIXbno0eDYP5NPUuWv0aA/I4Unr/7w==",
+      "version": "10.3.0",
+      "resolved": "https://registry.npmmirror.com/@vueuse/core/-/core-10.3.0.tgz",
+      "integrity": "sha512-BEM5yxcFKb5btFjTSAFjTu5jmwoW66fyV9uJIP4wUXXU8aR5Hl44gndaaXp7dC5HSObmgbnR2RN+Un1p68Mf5Q==",
       "dependencies": {
         "@types/web-bluetooth": "^0.0.17",
-        "@vueuse/metadata": "10.2.1",
-        "@vueuse/shared": "10.2.1",
+        "@vueuse/metadata": "10.3.0",
+        "@vueuse/shared": "10.3.0",
+        "vue-demi": ">=0.14.5"
+      }
+    },
+    "node_modules/@vueuse/core/node_modules/@vueuse/shared": {
+      "version": "10.3.0",
+      "resolved": "https://registry.npmmirror.com/@vueuse/shared/-/shared-10.3.0.tgz",
+      "integrity": "sha512-kGqCTEuFPMK4+fNWy6dUOiYmxGcUbtznMwBZLC1PubidF4VZY05B+Oht7Jh7/6x4VOWGpvu3R37WHi81cKpiqg==",
+      "dependencies": {
         "vue-demi": ">=0.14.5"
       }
     },
@@ -1636,6 +1635,24 @@
         }
       }
     },
+    "node_modules/@vueuse/integrations/node_modules/@vueuse/core": {
+      "version": "10.2.1",
+      "resolved": "https://registry.npmmirror.com/@vueuse/core/-/core-10.2.1.tgz",
+      "integrity": "sha512-c441bfMbkAwTNwVRHQ0zdYZNETK//P84rC01aP2Uy/aRFCiie9NE/k9KdIXbno0eDYP5NPUuWv0aA/I4Unr/7w==",
+      "dev": true,
+      "dependencies": {
+        "@types/web-bluetooth": "^0.0.17",
+        "@vueuse/metadata": "10.2.1",
+        "@vueuse/shared": "10.2.1",
+        "vue-demi": ">=0.14.5"
+      }
+    },
+    "node_modules/@vueuse/integrations/node_modules/@vueuse/metadata": {
+      "version": "10.2.1",
+      "resolved": "https://registry.npmmirror.com/@vueuse/metadata/-/metadata-10.2.1.tgz",
+      "integrity": "sha512-3Gt68mY/i6bQvFqx7cuGBzrCCQu17OBaGWS5JdwISpMsHnMKKjC2FeB5OAfMcCQ0oINfADP3i9A4PPRo0peHdQ==",
+      "dev": true
+    },
     "node_modules/@vueuse/integrations/node_modules/vue-demi": {
       "version": "0.14.5",
       "resolved": "https://registry.npmmirror.com/vue-demi/-/vue-demi-0.14.5.tgz",
@@ -1660,14 +1677,15 @@
       }
     },
     "node_modules/@vueuse/metadata": {
-      "version": "10.2.1",
-      "resolved": "https://registry.npmmirror.com/@vueuse/metadata/-/metadata-10.2.1.tgz",
-      "integrity": "sha512-3Gt68mY/i6bQvFqx7cuGBzrCCQu17OBaGWS5JdwISpMsHnMKKjC2FeB5OAfMcCQ0oINfADP3i9A4PPRo0peHdQ=="
+      "version": "10.3.0",
+      "resolved": "https://registry.npmmirror.com/@vueuse/metadata/-/metadata-10.3.0.tgz",
+      "integrity": "sha512-Ema3YhNOa4swDsV0V7CEY5JXvK19JI/o1szFO1iWxdFg3vhdFtCtSTP26PCvbUpnUtNHBY2wx5y3WDXND5Pvnw=="
     },
     "node_modules/@vueuse/shared": {
       "version": "10.2.1",
       "resolved": "https://registry.npmmirror.com/@vueuse/shared/-/shared-10.2.1.tgz",
       "integrity": "sha512-QWHq2bSuGptkcxx4f4M/fBYC3Y8d3M2UYyLsyzoPgEoVzJURQ0oJeWXu79OiLlBb8gTKkqe4mO85T/sf39mmiw==",
+      "dev": true,
       "dependencies": {
         "vue-demi": ">=0.14.5"
       }
@@ -1676,6 +1694,7 @@
       "version": "0.14.5",
       "resolved": "https://registry.npmmirror.com/vue-demi/-/vue-demi-0.14.5.tgz",
       "integrity": "sha512-o9NUVpl/YlsGJ7t+xuqJKx8EBGf1quRhCiT6D/J0pfwmk9zUwYkC7yrF4SZCe6fETvSM3UNL2edcbYrSyc4QHA==",
+      "dev": true,
       "hasInstallScript": true,
       "bin": {
         "vue-demi-fix": "bin/vue-demi-fix.js",
@@ -1742,6 +1761,11 @@
       "integrity": "sha512-lEm8mt52to2fT8GhciPCGeCXACSz2UwIN4X2e2LJSnZ5uAbn2/dsYdOmUXq0AtWS5cpAupysIneExOgH0Vd2TQ==",
       "dev": true
     },
+    "node_modules/arg": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmmirror.com/arg/-/arg-5.0.2.tgz",
+      "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg=="
+    },
     "node_modules/argparse": {
       "version": "2.0.1",
       "resolved": "https://registry.npmmirror.com/argparse/-/argparse-2.0.1.tgz",
@@ -2246,6 +2270,46 @@
         "node": ">=12"
       }
     },
+    "node_modules/d3-sankey": {
+      "version": "0.12.3",
+      "resolved": "https://registry.npmmirror.com/d3-sankey/-/d3-sankey-0.12.3.tgz",
+      "integrity": "sha512-nQhsBRmM19Ax5xEIPLMY9ZmJ/cDvd1BG3UVvt5h3WRxKg5zGRbvnteTyWAbzeSvlh3tW7ZEmq4VwR5mB3tutmQ==",
+      "dev": true,
+      "dependencies": {
+        "d3-array": "1 - 2",
+        "d3-shape": "^1.2.0"
+      }
+    },
+    "node_modules/d3-sankey/node_modules/d3-array": {
+      "version": "2.12.1",
+      "resolved": "https://registry.npmmirror.com/d3-array/-/d3-array-2.12.1.tgz",
+      "integrity": "sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ==",
+      "dev": true,
+      "dependencies": {
+        "internmap": "^1.0.0"
+      }
+    },
+    "node_modules/d3-sankey/node_modules/d3-path": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmmirror.com/d3-path/-/d3-path-1.0.9.tgz",
+      "integrity": "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg==",
+      "dev": true
+    },
+    "node_modules/d3-sankey/node_modules/d3-shape": {
+      "version": "1.3.7",
+      "resolved": "https://registry.npmmirror.com/d3-shape/-/d3-shape-1.3.7.tgz",
+      "integrity": "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw==",
+      "dev": true,
+      "dependencies": {
+        "d3-path": "1"
+      }
+    },
+    "node_modules/d3-sankey/node_modules/internmap": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/internmap/-/internmap-1.0.1.tgz",
+      "integrity": "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw==",
+      "dev": true
+    },
     "node_modules/d3-scale": {
       "version": "4.0.2",
       "resolved": "https://registry.npmmirror.com/d3-scale/-/d3-scale-4.0.2.tgz",
@@ -2468,9 +2532,9 @@
       }
     },
     "node_modules/dompurify": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmmirror.com/dompurify/-/dompurify-3.0.3.tgz",
-      "integrity": "sha512-axQ9zieHLnAnHh0sfAamKYiqXMJAVwu+LM/alQ7WDagoWessyWvMSFyW65CqF3owufNu8HBcE4cM2Vflu7YWcQ==",
+      "version": "3.0.5",
+      "resolved": "https://registry.npmmirror.com/dompurify/-/dompurify-3.0.5.tgz",
+      "integrity": "sha512-F9e6wPGtY+8KNMRAVfxeCOHU0/NPWMSENNq4pQctuXRqqdEPW7q3CrLbR5Nse044WwacyjHGOMlvNsBe1y6z9A==",
       "dev": true
     },
     "node_modules/domutils": {
@@ -2495,13 +2559,11 @@
       "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A=="
     },
     "node_modules/esbuild": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/esbuild/-/esbuild-0.17.19.tgz",
-      "integrity": "sha512-XQ0jAPFkK/u3LcVRcvVHQcTIqD6E2H1fvZMA5dQPSOWb3suUbWbfbRf94pjc0bNzRYLfIrDRQXr7X+LHIm5oHw==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/esbuild/-/esbuild-0.18.16.tgz",
+      "integrity": "sha512-1xLsOXrDqwdHxyXb/x/SOyg59jpf/SH7YMvU5RNSU7z3TInaASNJWNFJ6iRvLvLETZMasF3d1DdZLg7sgRimRQ==",
       "dev": true,
       "hasInstallScript": true,
-      "license": "MIT",
-      "peer": true,
       "bin": {
         "esbuild": "bin/esbuild"
       },
@@ -2509,28 +2571,28 @@
         "node": ">=12"
       },
       "optionalDependencies": {
-        "@esbuild/android-arm": "0.17.19",
-        "@esbuild/android-arm64": "0.17.19",
-        "@esbuild/android-x64": "0.17.19",
-        "@esbuild/darwin-arm64": "0.17.19",
-        "@esbuild/darwin-x64": "0.17.19",
-        "@esbuild/freebsd-arm64": "0.17.19",
-        "@esbuild/freebsd-x64": "0.17.19",
-        "@esbuild/linux-arm": "0.17.19",
-        "@esbuild/linux-arm64": "0.17.19",
-        "@esbuild/linux-ia32": "0.17.19",
-        "@esbuild/linux-loong64": "0.17.19",
-        "@esbuild/linux-mips64el": "0.17.19",
-        "@esbuild/linux-ppc64": "0.17.19",
-        "@esbuild/linux-riscv64": "0.17.19",
-        "@esbuild/linux-s390x": "0.17.19",
-        "@esbuild/linux-x64": "0.17.19",
-        "@esbuild/netbsd-x64": "0.17.19",
-        "@esbuild/openbsd-x64": "0.17.19",
-        "@esbuild/sunos-x64": "0.17.19",
-        "@esbuild/win32-arm64": "0.17.19",
-        "@esbuild/win32-ia32": "0.17.19",
-        "@esbuild/win32-x64": "0.17.19"
+        "@esbuild/android-arm": "0.18.16",
+        "@esbuild/android-arm64": "0.18.16",
+        "@esbuild/android-x64": "0.18.16",
+        "@esbuild/darwin-arm64": "0.18.16",
+        "@esbuild/darwin-x64": "0.18.16",
+        "@esbuild/freebsd-arm64": "0.18.16",
+        "@esbuild/freebsd-x64": "0.18.16",
+        "@esbuild/linux-arm": "0.18.16",
+        "@esbuild/linux-arm64": "0.18.16",
+        "@esbuild/linux-ia32": "0.18.16",
+        "@esbuild/linux-loong64": "0.18.16",
+        "@esbuild/linux-mips64el": "0.18.16",
+        "@esbuild/linux-ppc64": "0.18.16",
+        "@esbuild/linux-riscv64": "0.18.16",
+        "@esbuild/linux-s390x": "0.18.16",
+        "@esbuild/linux-x64": "0.18.16",
+        "@esbuild/netbsd-x64": "0.18.16",
+        "@esbuild/openbsd-x64": "0.18.16",
+        "@esbuild/sunos-x64": "0.18.16",
+        "@esbuild/win32-arm64": "0.18.16",
+        "@esbuild/win32-ia32": "0.18.16",
+        "@esbuild/win32-x64": "0.18.16"
       }
     },
     "node_modules/escape-goat": {
@@ -2961,19 +3023,22 @@
       "dev": true
     },
     "node_modules/mermaid": {
-      "version": "10.2.4",
-      "resolved": "https://registry.npmmirror.com/mermaid/-/mermaid-10.2.4.tgz",
-      "integrity": "sha512-zHGjEI7lBvWZX+PQYmlhSA2p40OzW6QbGodTCSzDeVpqaTnyAC+2sRGqrpXO+uQk3CnoeClHQPraQUMStdqy2g==",
+      "version": "10.3.0",
+      "resolved": "https://registry.npmmirror.com/mermaid/-/mermaid-10.3.0.tgz",
+      "integrity": "sha512-H5quxuQjwXC8M1WuuzhAp2TdqGg74t5skfDBrNKJ7dt3z8Wprl5S6h9VJsRhoBUTSs1TMtHEdplLhCqXleZZLw==",
       "dev": true,
       "dependencies": {
         "@braintree/sanitize-url": "^6.0.2",
+        "@types/d3-scale": "^4.0.3",
+        "@types/d3-scale-chromatic": "^3.0.0",
         "cytoscape": "^3.23.0",
         "cytoscape-cose-bilkent": "^4.1.0",
         "cytoscape-fcose": "^2.1.0",
         "d3": "^7.4.0",
+        "d3-sankey": "^0.12.3",
         "dagre-d3-es": "7.0.10",
         "dayjs": "^1.11.7",
-        "dompurify": "3.0.3",
+        "dompurify": "3.0.5",
         "elkjs": "^0.8.2",
         "khroma": "^2.0.0",
         "lodash-es": "^4.17.21",
@@ -3370,9 +3435,9 @@
       "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ=="
     },
     "node_modules/postcss": {
-      "version": "8.4.25",
-      "resolved": "https://registry.npmmirror.com/postcss/-/postcss-8.4.25.tgz",
-      "integrity": "sha512-7taJ/8t2av0Z+sQEvNzCkpDynl0tX3uJMCODi6nT3PfASC7dYCWV9aQ+uiCf+KBD4SEFcu+GvJdGdwzQ6OSjCw==",
+      "version": "8.4.27",
+      "resolved": "https://registry.npmmirror.com/postcss/-/postcss-8.4.27.tgz",
+      "integrity": "sha512-gY/ACJtJPSmUFPDCHtX78+01fHa64FaU4zaaWfuh1MhGJISufJAH4cun6k/8fwsHYeK4UQmENQK+tRLCFJE8JQ==",
       "dependencies": {
         "nanoid": "^3.3.6",
         "picocolors": "^1.0.0",
@@ -3516,6 +3581,11 @@
         "postcss": "^8.3.11"
       }
     },
+    "node_modules/sax": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmmirror.com/sax/-/sax-1.2.4.tgz",
+      "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw=="
+    },
     "node_modules/scheduler": {
       "version": "0.23.0",
       "resolved": "https://registry.npmmirror.com/scheduler/-/scheduler-0.23.0.tgz",
@@ -3567,6 +3637,24 @@
         "vscode-textmate": "^8.0.0"
       }
     },
+    "node_modules/sitemap": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmmirror.com/sitemap/-/sitemap-7.1.1.tgz",
+      "integrity": "sha512-mK3aFtjz4VdJN0igpIJrinf3EO8U8mxOPsTBzSsy06UtjZQJ3YY3o3Xa7zSc5nMqcMrRwlChHZ18Kxg0caiPBg==",
+      "dependencies": {
+        "@types/node": "^17.0.5",
+        "@types/sax": "^1.2.1",
+        "arg": "^5.0.0",
+        "sax": "^1.2.4"
+      },
+      "bin": {
+        "sitemap": "dist/cli.js"
+      },
+      "engines": {
+        "node": ">=12.0.0",
+        "npm": ">=5.6.0"
+      }
+    },
     "node_modules/slick": {
       "version": "1.12.2",
       "resolved": "https://registry.npmmirror.com/slick/-/slick-1.12.2.tgz",
@@ -3764,489 +3852,13 @@
       "integrity": "sha512-kRAyotcbNaSYoDnXvb4MHg/0a1egJdLwS6oJ38TJY7aw9n93Fl/3blIXdyYvPOp55CNxywooG/3BcrwNrBpcSg=="
     },
     "node_modules/vite": {
-      "version": "4.3.9",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/vite/-/vite-4.3.9.tgz",
-      "integrity": "sha512-qsTNZjO9NoJNW7KnOrgYwczm0WctJ8m/yqYAMAK9Lxt4SoySUfS5S8ia9K7JHpa3KEeMfyF8LoJ3c5NeBJy6pg==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "esbuild": "^0.17.5",
-        "postcss": "^8.4.23",
-        "rollup": "^3.21.0"
-      },
-      "bin": {
-        "vite": "bin/vite.js"
-      },
-      "engines": {
-        "node": "^14.18.0 || >=16.0.0"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.2"
-      },
-      "peerDependencies": {
-        "@types/node": ">= 14",
-        "less": "*",
-        "sass": "*",
-        "stylus": "*",
-        "sugarss": "*",
-        "terser": "^5.4.0"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        },
-        "less": {
-          "optional": true
-        },
-        "sass": {
-          "optional": true
-        },
-        "stylus": {
-          "optional": true
-        },
-        "sugarss": {
-          "optional": true
-        },
-        "terser": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/vitepress": {
-      "version": "1.0.0-beta.5",
-      "resolved": "https://registry.npmmirror.com/vitepress/-/vitepress-1.0.0-beta.5.tgz",
-      "integrity": "sha512-/RjqqRsSEKkzF6HhK5e5Ij+bZ7ETb9jNCRRgIMm10gJ+ZLC3D1OqkE465lEqCeJUgt2HZ6jmWjDqIBfrJSpv7w==",
+      "version": "4.4.7",
+      "resolved": "https://registry.npmmirror.com/vite/-/vite-4.4.7.tgz",
+      "integrity": "sha512-6pYf9QJ1mHylfVh39HpuSfMPojPSKVxZvnclX1K1FyZ1PXDOcLBibdq5t1qxJSnL63ca8Wf4zts6mD8u8oc9Fw==",
       "dev": true,
       "dependencies": {
-        "@docsearch/css": "^3.5.1",
-        "@docsearch/js": "^3.5.1",
-        "@vitejs/plugin-vue": "^4.2.3",
-        "@vue/devtools-api": "^6.5.0",
-        "@vueuse/core": "^10.2.1",
-        "@vueuse/integrations": "^10.2.1",
-        "body-scroll-lock": "4.0.0-beta.0",
-        "focus-trap": "^7.4.3",
-        "mark.js": "8.11.1",
-        "minisearch": "^6.1.0",
-        "shiki": "^0.14.3",
-        "vite": "4.4.0-beta.3",
-        "vue": "^3.3.4"
-      },
-      "bin": {
-        "vitepress": "bin/vitepress.js"
-      }
-    },
-    "node_modules/vitepress-plugin-mermaid": {
-      "version": "2.0.13",
-      "resolved": "https://registry.npmmirror.com/vitepress-plugin-mermaid/-/vitepress-plugin-mermaid-2.0.13.tgz",
-      "integrity": "sha512-2c0ywXHE7kOK88Ygla9aGgkyF2JbfqfjE36JnoljW/3hQTR9rYBmfTFM5tvs4TUjCUfedUYT4CeyNolCY9t3uw==",
-      "dev": true,
-      "optionalDependencies": {
-        "@mermaid-js/mermaid-mindmap": "^9.3.0"
-      },
-      "peerDependencies": {
-        "mermaid": "10",
-        "vitepress": "^0.21.6 || ^1.0.0 || ^1.0.0-alpha"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/android-arm": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/android-arm/-/android-arm-0.18.12.tgz",
-      "integrity": "sha512-LIxaNIQfkFZbTLb4+cX7dozHlAbAshhFE5PKdro0l+FnCpx1GDJaQ2WMcqm+ToXKMt8p8Uojk/MFRuGyz3V5Sw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/android-arm64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/android-arm64/-/android-arm64-0.18.12.tgz",
-      "integrity": "sha512-BMAlczRqC/LUt2P97E4apTBbkvS9JTJnp2DKFbCwpZ8vBvXVbNdqmvzW/OsdtI/+mGr+apkkpqGM8WecLkPgrA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/android-x64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/android-x64/-/android-x64-0.18.12.tgz",
-      "integrity": "sha512-zU5MyluNsykf5cOJ0LZZZjgAHbhPJ1cWfdH1ZXVMXxVMhEV0VZiZXQdwBBVvmvbF28EizeK7obG9fs+fpmS0eQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/darwin-arm64/-/darwin-arm64-0.18.12.tgz",
-      "integrity": "sha512-zUZMep7YONnp6954QOOwEBwFX9svlKd3ov6PkxKd53LGTHsp/gy7vHaPGhhjBmEpqXEXShi6dddjIkmd+NgMsA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/darwin-x64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/darwin-x64/-/darwin-x64-0.18.12.tgz",
-      "integrity": "sha512-ohqLPc7i67yunArPj1+/FeeJ7AgwAjHqKZ512ADk3WsE3FHU9l+m5aa7NdxXr0HmN1bjDlUslBjWNbFlD9y12Q==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.12.tgz",
-      "integrity": "sha512-GIIHtQXqgeOOqdG16a/A9N28GpkvjJnjYMhOnXVbn3EDJcoItdR58v/pGN31CHjyXDc8uCcRnFWmqaJt24AYJg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/freebsd-x64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-x64/-/freebsd-x64-0.18.12.tgz",
-      "integrity": "sha512-zK0b9a1/0wZY+6FdOS3BpZcPc1kcx2G5yxxfEJtEUzVxI6n/FrC2Phsxj/YblPuBchhBZ/1wwn7AyEBUyNSa6g==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/linux-arm": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm/-/linux-arm-0.18.12.tgz",
-      "integrity": "sha512-y75OijvrBE/1XRrXq1jtrJfG26eHeMoqLJ2dwQNwviwTuTtHGCojsDO6BJNF8gU+3jTn1KzJEMETytwsFSvc+Q==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/linux-arm64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm64/-/linux-arm64-0.18.12.tgz",
-      "integrity": "sha512-JKgG8Q/LL/9sw/iHHxQyVMoQYu3rU3+a5Z87DxC+wAu3engz+EmctIrV+FGOgI6gWG1z1+5nDDbXiRMGQZXqiw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/linux-ia32": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/linux-ia32/-/linux-ia32-0.18.12.tgz",
-      "integrity": "sha512-yoRIAqc0B4lDIAAEFEIu9ttTRFV84iuAl0KNCN6MhKLxNPfzwCBvEMgwco2f71GxmpBcTtn7KdErueZaM2rEvw==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/linux-loong64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/linux-loong64/-/linux-loong64-0.18.12.tgz",
-      "integrity": "sha512-qYgt3dHPVvf/MgbIBpJ4Sup/yb9DAopZ3a2JgMpNKIHUpOdnJ2eHBo/aQdnd8dJ21X/+sS58wxHtA9lEazYtXQ==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/linux-mips64el": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/linux-mips64el/-/linux-mips64el-0.18.12.tgz",
-      "integrity": "sha512-wHphlMLK4ufNOONqukELfVIbnGQJrHJ/mxZMMrP2jYrPgCRZhOtf0kC4yAXBwnfmULimV1qt5UJJOw4Kh13Yfg==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/linux-ppc64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/linux-ppc64/-/linux-ppc64-0.18.12.tgz",
-      "integrity": "sha512-TeN//1Ft20ZZW41+zDSdOI/Os1bEq5dbvBvYkberB7PHABbRcsteeoNVZFlI0YLpGdlBqohEpjrn06kv8heCJg==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/linux-riscv64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/linux-riscv64/-/linux-riscv64-0.18.12.tgz",
-      "integrity": "sha512-AgUebVS4DoAblBgiB2ACQ/8l4eGE5aWBb8ZXtkXHiET9mbj7GuWt3OnsIW/zX+XHJt2RYJZctbQ2S/mDjbp0UA==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/linux-s390x": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/linux-s390x/-/linux-s390x-0.18.12.tgz",
-      "integrity": "sha512-dJ3Rb3Ei2u/ysSXd6pzleGtfDdc2MuzKt8qc6ls8vreP1G3B7HInX3i7gXS4BGeVd24pp0yqyS7bJ5NHaI9ing==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/linux-x64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/linux-x64/-/linux-x64-0.18.12.tgz",
-      "integrity": "sha512-OrNJMGQbPaVyHHcDF8ybNSwu7TDOfX8NGpXCbetwOSP6txOJiWlgQnRymfC9ocR1S0Y5PW0Wb1mV6pUddqmvmQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/netbsd-x64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/netbsd-x64/-/netbsd-x64-0.18.12.tgz",
-      "integrity": "sha512-55FzVCAiwE9FK8wWeCRuvjazNRJ1QqLCYGZVB6E8RuQuTeStSwotpSW4xoRGwp3a1wUsaVCdYcj5LGCASVJmMg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/openbsd-x64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/openbsd-x64/-/openbsd-x64-0.18.12.tgz",
-      "integrity": "sha512-qnluf8rfb6Y5Lw2tirfK2quZOBbVqmwxut7GPCIJsM8lc4AEUj9L8y0YPdLaPK0TECt4IdyBdBD/KRFKorlK3g==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/sunos-x64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/sunos-x64/-/sunos-x64-0.18.12.tgz",
-      "integrity": "sha512-+RkKpVQR7bICjTOPUpkTBTaJ4TFqQBX5Ywyd/HSdDkQGn65VPkTsR/pL4AMvuMWy+wnXgIl4EY6q4mVpJal8Kg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/win32-arm64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/win32-arm64/-/win32-arm64-0.18.12.tgz",
-      "integrity": "sha512-GNHuciv0mFM7ouzsU0+AwY+7eV4Mgo5WnbhfDCQGtpvOtD1vbOiRjPYG6dhmMoFyBjj+pNqQu2X+7DKn0KQ/Gw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/win32-ia32": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/win32-ia32/-/win32-ia32-0.18.12.tgz",
-      "integrity": "sha512-kR8cezhYipbbypGkaqCTWIeu4zID17gamC8YTPXYtcN3E5BhhtTnwKBn9I0PJur/T6UVwIEGYzkffNL0lFvxEw==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/@esbuild/win32-x64": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/@esbuild/win32-x64/-/win32-x64-0.18.12.tgz",
-      "integrity": "sha512-O0UYQVkvfM/jO8a4OwoV0mAKSJw+mjWTAd1MJd/1FCX6uiMdLmMRPK/w6e9OQ0ob2WGxzIm9va/KG0Ja4zIOgg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/vitepress/node_modules/esbuild": {
-      "version": "0.18.12",
-      "resolved": "https://registry.npmmirror.com/esbuild/-/esbuild-0.18.12.tgz",
-      "integrity": "sha512-XuOVLDdtsDslXStStduT41op21Ytmf4/BDS46aa3xPJ7X5h2eMWBF1oAe3QjUH3bDksocNXgzGUZ7XHIBya6Tg==",
-      "dev": true,
-      "hasInstallScript": true,
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "optionalDependencies": {
-        "@esbuild/android-arm": "0.18.12",
-        "@esbuild/android-arm64": "0.18.12",
-        "@esbuild/android-x64": "0.18.12",
-        "@esbuild/darwin-arm64": "0.18.12",
-        "@esbuild/darwin-x64": "0.18.12",
-        "@esbuild/freebsd-arm64": "0.18.12",
-        "@esbuild/freebsd-x64": "0.18.12",
-        "@esbuild/linux-arm": "0.18.12",
-        "@esbuild/linux-arm64": "0.18.12",
-        "@esbuild/linux-ia32": "0.18.12",
-        "@esbuild/linux-loong64": "0.18.12",
-        "@esbuild/linux-mips64el": "0.18.12",
-        "@esbuild/linux-ppc64": "0.18.12",
-        "@esbuild/linux-riscv64": "0.18.12",
-        "@esbuild/linux-s390x": "0.18.12",
-        "@esbuild/linux-x64": "0.18.12",
-        "@esbuild/netbsd-x64": "0.18.12",
-        "@esbuild/openbsd-x64": "0.18.12",
-        "@esbuild/sunos-x64": "0.18.12",
-        "@esbuild/win32-arm64": "0.18.12",
-        "@esbuild/win32-ia32": "0.18.12",
-        "@esbuild/win32-x64": "0.18.12"
-      }
-    },
-    "node_modules/vitepress/node_modules/vite": {
-      "version": "4.4.0-beta.3",
-      "resolved": "https://registry.npmmirror.com/vite/-/vite-4.4.0-beta.3.tgz",
-      "integrity": "sha512-IC/thYTvArOFRJ4qvvudnu4KKZOVc+gduS3I9OfC5SbP/Rf4kkP7z6Of2QpKeOSVqwIK24khW6VOUmVD/0yzSQ==",
-      "dev": true,
-      "dependencies": {
-        "esbuild": "^0.18.6",
-        "postcss": "^8.4.24",
+        "esbuild": "^0.18.10",
+        "postcss": "^8.4.26",
         "rollup": "^3.25.2"
       },
       "bin": {
@@ -4291,6 +3903,43 @@
         }
       }
     },
+    "node_modules/vitepress": {
+      "version": "1.0.0-beta.7",
+      "resolved": "https://registry.npmmirror.com/vitepress/-/vitepress-1.0.0-beta.7.tgz",
+      "integrity": "sha512-P9Rw+FXatKIU4fVdtKxqwHl6fby8E/8zE3FIfep6meNgN4BxbWqoKJ6yfuuQQR9IrpQqwnyaBh4LSabyll6tWg==",
+      "dev": true,
+      "dependencies": {
+        "@docsearch/css": "^3.5.1",
+        "@docsearch/js": "^3.5.1",
+        "@vitejs/plugin-vue": "^4.2.3",
+        "@vue/devtools-api": "^6.5.0",
+        "@vueuse/core": "^10.2.1",
+        "@vueuse/integrations": "^10.2.1",
+        "body-scroll-lock": "4.0.0-beta.0",
+        "focus-trap": "^7.5.2",
+        "mark.js": "8.11.1",
+        "minisearch": "^6.1.0",
+        "shiki": "^0.14.3",
+        "vite": "^4.4.7",
+        "vue": "^3.3.4"
+      },
+      "bin": {
+        "vitepress": "bin/vitepress.js"
+      }
+    },
+    "node_modules/vitepress-plugin-mermaid": {
+      "version": "2.0.13",
+      "resolved": "https://registry.npmmirror.com/vitepress-plugin-mermaid/-/vitepress-plugin-mermaid-2.0.13.tgz",
+      "integrity": "sha512-2c0ywXHE7kOK88Ygla9aGgkyF2JbfqfjE36JnoljW/3hQTR9rYBmfTFM5tvs4TUjCUfedUYT4CeyNolCY9t3uw==",
+      "dev": true,
+      "optionalDependencies": {
+        "@mermaid-js/mermaid-mindmap": "^9.3.0"
+      },
+      "peerDependencies": {
+        "mermaid": "10",
+        "vitepress": "^0.21.6 || ^1.0.0 || ^1.0.0-alpha"
+      }
+    },
     "node_modules/vscode-oniguruma": {
       "version": "1.7.0",
       "resolved": "https://registry.npmmirror.com/vscode-oniguruma/-/vscode-oniguruma-1.7.0.tgz",
@@ -4721,180 +4370,158 @@
       }
     },
     "@esbuild/android-arm": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/android-arm/-/android-arm-0.17.19.tgz",
-      "integrity": "sha512-rIKddzqhmav7MSmoFCmDIb6e2W57geRsM94gV2l38fzhXMwq7hZoClug9USI2pFRGL06f4IOPHHpFNOkWieR8A==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/android-arm/-/android-arm-0.18.16.tgz",
+      "integrity": "sha512-gCHjjQmA8L0soklKbLKA6pgsLk1byULuHe94lkZDzcO3/Ta+bbeewJioEn1Fr7kgy9NWNFy/C+MrBwC6I/WCug==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/android-arm64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/android-arm64/-/android-arm64-0.17.19.tgz",
-      "integrity": "sha512-KBMWvEZooR7+kzY0BtbTQn0OAYY7CsiydT63pVEaPtVYF0hXbUaOyZog37DKxK7NF3XacBJOpYT4adIJh+avxA==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/android-arm64/-/android-arm64-0.18.16.tgz",
+      "integrity": "sha512-wsCqSPqLz+6Ov+OM4EthU43DyYVVyfn15S4j1bJzylDpc1r1jZFFfJQNfDuT8SlgwuqpmpJXK4uPlHGw6ve7eA==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/android-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/android-x64/-/android-x64-0.17.19.tgz",
-      "integrity": "sha512-uUTTc4xGNDT7YSArp/zbtmbhO0uEEK9/ETW29Wk1thYUJBz3IVnvgEiEwEa9IeLyvnpKrWK64Utw2bgUmDveww==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/android-x64/-/android-x64-0.18.16.tgz",
+      "integrity": "sha512-ldsTXolyA3eTQ1//4DS+E15xl0H/3DTRJaRL0/0PgkqDsI0fV/FlOtD+h0u/AUJr+eOTlZv4aC9gvfppo3C4sw==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/darwin-arm64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/darwin-arm64/-/darwin-arm64-0.17.19.tgz",
-      "integrity": "sha512-80wEoCfF/hFKM6WE1FyBHc9SfUblloAWx6FJkFWTWiCoht9Mc0ARGEM47e67W9rI09YoUxJL68WHfDRYEAvOhg==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/darwin-arm64/-/darwin-arm64-0.18.16.tgz",
+      "integrity": "sha512-aBxruWCII+OtluORR/KvisEw0ALuw/qDQWvkoosA+c/ngC/Kwk0lLaZ+B++LLS481/VdydB2u6tYpWxUfnLAIw==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/darwin-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/darwin-x64/-/darwin-x64-0.17.19.tgz",
-      "integrity": "sha512-IJM4JJsLhRYr9xdtLytPLSH9k/oxR3boaUIYiHkAawtwNOXKE8KoU8tMvryogdcT8AU+Bflmh81Xn6Q0vTZbQw==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/darwin-x64/-/darwin-x64-0.18.16.tgz",
+      "integrity": "sha512-6w4Dbue280+rp3LnkgmriS1icOUZDyPuZo/9VsuMUTns7SYEiOaJ7Ca1cbhu9KVObAWfmdjUl4gwy9TIgiO5eA==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/freebsd-arm64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/freebsd-arm64/-/freebsd-arm64-0.17.19.tgz",
-      "integrity": "sha512-pBwbc7DufluUeGdjSU5Si+P3SoMF5DQ/F/UmTSb8HXO80ZEAJmrykPyzo1IfNbAoaqw48YRpv8shwd1NoI0jcQ==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.16.tgz",
+      "integrity": "sha512-x35fCebhe9s979DGKbVAwXUOcTmCIE32AIqB9CB1GralMIvxdnMLAw5CnID17ipEw9/3MvDsusj/cspYt2ZLNQ==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/freebsd-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/freebsd-x64/-/freebsd-x64-0.17.19.tgz",
-      "integrity": "sha512-4lu+n8Wk0XlajEhbEffdy2xy53dpR06SlzvhGByyg36qJw6Kpfk7cp45DR/62aPH9mtJRmIyrXAS5UWBrJT6TQ==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-x64/-/freebsd-x64-0.18.16.tgz",
+      "integrity": "sha512-YM98f+PeNXF3GbxIJlUsj+McUWG1irguBHkszCIwfr3BXtXZsXo0vqybjUDFfu9a8Wr7uUD/YSmHib+EeGAFlg==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/linux-arm": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-arm/-/linux-arm-0.17.19.tgz",
-      "integrity": "sha512-cdmT3KxjlOQ/gZ2cjfrQOtmhG4HJs6hhvm3mWSRDPtZ/lP5oe8FWceS10JaSJC13GBd4eH/haHnqf7hhGNLerA==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm/-/linux-arm-0.18.16.tgz",
+      "integrity": "sha512-b5ABb+5Ha2C9JkeZXV+b+OruR1tJ33ePmv9ZwMeETSEKlmu/WJ45XTTG+l6a2KDsQtJJ66qo/hbSGBtk0XVLHw==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/linux-arm64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-arm64/-/linux-arm64-0.17.19.tgz",
-      "integrity": "sha512-ct1Tg3WGwd3P+oZYqic+YZF4snNl2bsnMKRkb3ozHmnM0dGWuxcPTTntAF6bOP0Sp4x0PjSF+4uHQ1xvxfRKqg==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm64/-/linux-arm64-0.18.16.tgz",
+      "integrity": "sha512-XIqhNUxJiuy+zsR77+H5Z2f7s4YRlriSJKtvx99nJuG5ATuJPjmZ9n0ANgnGlPCpXGSReFpgcJ7O3SMtzIFeiQ==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/linux-ia32": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-ia32/-/linux-ia32-0.17.19.tgz",
-      "integrity": "sha512-w4IRhSy1VbsNxHRQpeGCHEmibqdTUx61Vc38APcsRbuVgK0OPEnQ0YD39Brymn96mOx48Y2laBQGqgZ0j9w6SQ==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-ia32/-/linux-ia32-0.18.16.tgz",
+      "integrity": "sha512-no+pfEpwnRvIyH+txbBAWtjxPU9grslmTBfsmDndj7bnBmr55rOo/PfQmRfz7Qg9isswt1FP5hBbWb23fRWnow==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/linux-loong64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-loong64/-/linux-loong64-0.17.19.tgz",
-      "integrity": "sha512-2iAngUbBPMq439a+z//gE+9WBldoMp1s5GWsUSgqHLzLJ9WoZLZhpwWuym0u0u/4XmZ3gpHmzV84PonE+9IIdQ==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-loong64/-/linux-loong64-0.18.16.tgz",
+      "integrity": "sha512-Zbnczs9ZXjmo0oZSS0zbNlJbcwKXa/fcNhYQjahDs4Xg18UumpXG/lwM2lcSvHS3mTrRyCYZvJbmzYc4laRI1g==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/linux-mips64el": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-mips64el/-/linux-mips64el-0.17.19.tgz",
-      "integrity": "sha512-LKJltc4LVdMKHsrFe4MGNPp0hqDFA1Wpt3jE1gEyM3nKUvOiO//9PheZZHfYRfYl6AwdTH4aTcXSqBerX0ml4A==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-mips64el/-/linux-mips64el-0.18.16.tgz",
+      "integrity": "sha512-YMF7hih1HVR/hQVa/ot4UVffc5ZlrzEb3k2ip0nZr1w6fnYypll9td2qcoMLvd3o8j3y6EbJM3MyIcXIVzXvQQ==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/linux-ppc64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-ppc64/-/linux-ppc64-0.17.19.tgz",
-      "integrity": "sha512-/c/DGybs95WXNS8y3Ti/ytqETiW7EU44MEKuCAcpPto3YjQbyK3IQVKfF6nbghD7EcLUGl0NbiL5Rt5DMhn5tg==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-ppc64/-/linux-ppc64-0.18.16.tgz",
+      "integrity": "sha512-Wkz++LZ29lDwUyTSEnzDaaP5OveOgTU69q9IyIw9WqLRxM4BjTBjz9un4G6TOvehWpf/J3gYVFN96TjGHrbcNQ==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/linux-riscv64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-riscv64/-/linux-riscv64-0.17.19.tgz",
-      "integrity": "sha512-FC3nUAWhvFoutlhAkgHf8f5HwFWUL6bYdvLc/TTuxKlvLi3+pPzdZiFKSWz/PF30TB1K19SuCxDTI5KcqASJqA==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-riscv64/-/linux-riscv64-0.18.16.tgz",
+      "integrity": "sha512-LFMKZ30tk78/mUv1ygvIP+568bwf4oN6reG/uczXnz6SvFn4e2QUFpUpZY9iSJT6Qpgstrhef/nMykIXZtZWGQ==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/linux-s390x": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-s390x/-/linux-s390x-0.17.19.tgz",
-      "integrity": "sha512-IbFsFbxMWLuKEbH+7sTkKzL6NJmG2vRyy6K7JJo55w+8xDk7RElYn6xvXtDW8HCfoKBFK69f3pgBJSUSQPr+4Q==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-s390x/-/linux-s390x-0.18.16.tgz",
+      "integrity": "sha512-3ZC0BgyYHYKfZo3AV2/66TD/I9tlSBaW7eWTEIkrQQKfJIifKMMttXl9FrAg+UT0SGYsCRLI35Gwdmm96vlOjg==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/linux-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/linux-x64/-/linux-x64-0.17.19.tgz",
-      "integrity": "sha512-68ngA9lg2H6zkZcyp22tsVt38mlhWde8l3eJLWkyLrp4HwMUr3c1s/M2t7+kHIhvMjglIBrFpncX1SzMckomGw==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/linux-x64/-/linux-x64-0.18.16.tgz",
+      "integrity": "sha512-xu86B3647DihHJHv/wx3NCz2Dg1gjQ8bbf9cVYZzWKY+gsvxYmn/lnVlqDRazObc3UMwoHpUhNYaZset4X8IPA==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/netbsd-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/netbsd-x64/-/netbsd-x64-0.17.19.tgz",
-      "integrity": "sha512-CwFq42rXCR8TYIjIfpXCbRX0rp1jo6cPIUPSaWwzbVI4aOfX96OXY8M6KNmtPcg7QjYeDmN+DD0Wp3LaBOLf4Q==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/netbsd-x64/-/netbsd-x64-0.18.16.tgz",
+      "integrity": "sha512-uVAgpimx9Ffw3xowtg/7qQPwHFx94yCje+DoBx+LNm2ePDpQXHrzE+Sb0Si2VBObYz+LcRps15cq+95YM7gkUw==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/openbsd-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/openbsd-x64/-/openbsd-x64-0.17.19.tgz",
-      "integrity": "sha512-cnq5brJYrSZ2CF6c35eCmviIN3k3RczmHz8eYaVlNasVqsNY+JKohZU5MKmaOI+KkllCdzOKKdPs762VCPC20g==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/openbsd-x64/-/openbsd-x64-0.18.16.tgz",
+      "integrity": "sha512-6OjCQM9wf7z8/MBi6BOWaTL2AS/SZudsZtBziXMtNI8r/U41AxS9x7jn0ATOwVy08OotwkPqGRMkpPR2wcTJXA==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/sunos-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/sunos-x64/-/sunos-x64-0.17.19.tgz",
-      "integrity": "sha512-vCRT7yP3zX+bKWFeP/zdS6SqdWB8OIpaRq/mbXQxTGHnIxspRtigpkUcDMlSCOejlHowLqII7K2JKevwyRP2rg==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/sunos-x64/-/sunos-x64-0.18.16.tgz",
+      "integrity": "sha512-ZoNkruFYJp9d1LbUYCh8awgQDvB9uOMZqlQ+gGEZR7v6C+N6u7vPr86c+Chih8niBR81Q/bHOSKGBK3brJyvkQ==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/win32-arm64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/win32-arm64/-/win32-arm64-0.17.19.tgz",
-      "integrity": "sha512-yYx+8jwowUstVdorcMdNlzklLYhPxjniHWFKgRqH7IFlUEa0Umu3KuYplf1HUZZ422e3NU9F4LGb+4O0Kdcaag==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/win32-arm64/-/win32-arm64-0.18.16.tgz",
+      "integrity": "sha512-+j4anzQ9hrs+iqO+/wa8UE6TVkKua1pXUb0XWFOx0FiAj6R9INJ+WE//1/Xo6FG1vB5EpH3ko+XcgwiDXTxcdw==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/win32-ia32": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/win32-ia32/-/win32-ia32-0.17.19.tgz",
-      "integrity": "sha512-eggDKanJszUtCdlVs0RB+h35wNlb5v4TWEkq4vZcmVt5u/HiDZrTXe2bWFQUez3RgNHwx/x4sk5++4NSSicKkw==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/win32-ia32/-/win32-ia32-0.18.16.tgz",
+      "integrity": "sha512-5PFPmq3sSKTp9cT9dzvI67WNfRZGvEVctcZa1KGjDDu4n3H8k59Inbk0du1fz0KrAbKKNpJbdFXQMDUz7BG4rQ==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@esbuild/win32-x64": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/@esbuild/win32-x64/-/win32-x64-0.17.19.tgz",
-      "integrity": "sha512-lAhycmKnVOuRYNtRtatQR1LPQf2oYCkRGkSFnseDAKPl8lu5SOsK/e1sXe5a0Pc5kHIHe6P2I/ilntNv2xf3cA==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/@esbuild/win32-x64/-/win32-x64-0.18.16.tgz",
+      "integrity": "sha512-sCIVrrtcWN5Ua7jYXNG1xD199IalrbfV2+0k/2Zf2OyV2FtnQnMgdzgpRAbi4AWlKJj1jkX+M+fEGPQj6BQB4w==",
       "dev": true,
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "@fortawesome/fontawesome-free": {
       "version": "5.15.4",
@@ -5544,6 +5171,27 @@
         "react-is": "^18.2.0"
       }
     },
+    "@types/d3-scale": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmmirror.com/@types/d3-scale/-/d3-scale-4.0.3.tgz",
+      "integrity": "sha512-PATBiMCpvHJSMtZAMEhc2WyL+hnzarKzI6wAHYjhsonjWJYGq5BXTzQjv4l8m2jO183/4wZ90rKvSeT7o72xNQ==",
+      "dev": true,
+      "requires": {
+        "@types/d3-time": "*"
+      }
+    },
+    "@types/d3-scale-chromatic": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/@types/d3-scale-chromatic/-/d3-scale-chromatic-3.0.0.tgz",
+      "integrity": "sha512-dsoJGEIShosKVRBZB0Vo3C8nqSDqVGujJU6tPznsBJxNJNwMF8utmS83nvCBKQYPpjCzaaHcrf66iTRpZosLPw==",
+      "dev": true
+    },
+    "@types/d3-time": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/@types/d3-time/-/d3-time-3.0.0.tgz",
+      "integrity": "sha512-sZLCdHvBUcNby1cB6Fd3ZBrABbjz3v1Vm90nysCQ6Vt7vd6e/h9Lt7SiJUoEX0l4Dzc7P5llKyhqSi1ycSf1Hg==",
+      "dev": true
+    },
     "@types/debug": {
       "version": "4.1.8",
       "resolved": "https://registry.npmmirror.com/@types/debug/-/debug-4.1.8.tgz",
@@ -5568,6 +5216,11 @@
       "integrity": "sha512-iiUgKzV9AuaEkZqkOLDIvlQiL6ltuZd9tGcW3gwpnX8JbuiuhFlEGmmFXEXkN50Cvq7Os88IY2v0dkDqXYWVgA==",
       "dev": true
     },
+    "@types/node": {
+      "version": "17.0.45",
+      "resolved": "https://registry.npmmirror.com/@types/node/-/node-17.0.45.tgz",
+      "integrity": "sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw=="
+    },
     "@types/prop-types": {
       "version": "15.7.5",
       "resolved": "https://registry.npmmirror.com/@types/prop-types/-/prop-types-15.7.5.tgz",
@@ -5583,6 +5236,14 @@
         "csstype": "^3.0.2"
       }
     },
+    "@types/sax": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmmirror.com/@types/sax/-/sax-1.2.4.tgz",
+      "integrity": "sha512-pSAff4IAxJjfAXUG6tFkO7dsSbTmf8CtUpfhhZ5VhkRpC4628tJhh3+V6H1E+/Gs9piSzYKT5yzHO5M4GG9jkw==",
+      "requires": {
+        "@types/node": "*"
+      }
+    },
     "@types/scheduler": {
       "version": "0.16.3",
       "resolved": "https://registry.npmmirror.com/@types/scheduler/-/scheduler-0.16.3.tgz",
@@ -5712,16 +5373,24 @@
       "integrity": "sha512-7OjdcV8vQ74eiz1TZLzZP4JwqM5fA94K6yntPS5Z25r9HDuGNzaGdgvwKYq6S+MxwF0TFRwe50fIR/MYnakdkQ=="
     },
     "@vueuse/core": {
-      "version": "10.2.1",
-      "resolved": "https://registry.npmmirror.com/@vueuse/core/-/core-10.2.1.tgz",
-      "integrity": "sha512-c441bfMbkAwTNwVRHQ0zdYZNETK//P84rC01aP2Uy/aRFCiie9NE/k9KdIXbno0eDYP5NPUuWv0aA/I4Unr/7w==",
+      "version": "10.3.0",
+      "resolved": "https://registry.npmmirror.com/@vueuse/core/-/core-10.3.0.tgz",
+      "integrity": "sha512-BEM5yxcFKb5btFjTSAFjTu5jmwoW66fyV9uJIP4wUXXU8aR5Hl44gndaaXp7dC5HSObmgbnR2RN+Un1p68Mf5Q==",
       "requires": {
         "@types/web-bluetooth": "^0.0.17",
-        "@vueuse/metadata": "10.2.1",
-        "@vueuse/shared": "10.2.1",
+        "@vueuse/metadata": "10.3.0",
+        "@vueuse/shared": "10.3.0",
         "vue-demi": ">=0.14.5"
       },
       "dependencies": {
+        "@vueuse/shared": {
+          "version": "10.3.0",
+          "resolved": "https://registry.npmmirror.com/@vueuse/shared/-/shared-10.3.0.tgz",
+          "integrity": "sha512-kGqCTEuFPMK4+fNWy6dUOiYmxGcUbtznMwBZLC1PubidF4VZY05B+Oht7Jh7/6x4VOWGpvu3R37WHi81cKpiqg==",
+          "requires": {
+            "vue-demi": ">=0.14.5"
+          }
+        },
         "vue-demi": {
           "version": "0.14.5",
           "resolved": "https://registry.npmmirror.com/vue-demi/-/vue-demi-0.14.5.tgz",
@@ -5741,6 +5410,24 @@
         "vue-demi": ">=0.14.5"
       },
       "dependencies": {
+        "@vueuse/core": {
+          "version": "10.2.1",
+          "resolved": "https://registry.npmmirror.com/@vueuse/core/-/core-10.2.1.tgz",
+          "integrity": "sha512-c441bfMbkAwTNwVRHQ0zdYZNETK//P84rC01aP2Uy/aRFCiie9NE/k9KdIXbno0eDYP5NPUuWv0aA/I4Unr/7w==",
+          "dev": true,
+          "requires": {
+            "@types/web-bluetooth": "^0.0.17",
+            "@vueuse/metadata": "10.2.1",
+            "@vueuse/shared": "10.2.1",
+            "vue-demi": ">=0.14.5"
+          }
+        },
+        "@vueuse/metadata": {
+          "version": "10.2.1",
+          "resolved": "https://registry.npmmirror.com/@vueuse/metadata/-/metadata-10.2.1.tgz",
+          "integrity": "sha512-3Gt68mY/i6bQvFqx7cuGBzrCCQu17OBaGWS5JdwISpMsHnMKKjC2FeB5OAfMcCQ0oINfADP3i9A4PPRo0peHdQ==",
+          "dev": true
+        },
         "vue-demi": {
           "version": "0.14.5",
           "resolved": "https://registry.npmmirror.com/vue-demi/-/vue-demi-0.14.5.tgz",
@@ -5751,14 +5438,15 @@
       }
     },
     "@vueuse/metadata": {
-      "version": "10.2.1",
-      "resolved": "https://registry.npmmirror.com/@vueuse/metadata/-/metadata-10.2.1.tgz",
-      "integrity": "sha512-3Gt68mY/i6bQvFqx7cuGBzrCCQu17OBaGWS5JdwISpMsHnMKKjC2FeB5OAfMcCQ0oINfADP3i9A4PPRo0peHdQ=="
+      "version": "10.3.0",
+      "resolved": "https://registry.npmmirror.com/@vueuse/metadata/-/metadata-10.3.0.tgz",
+      "integrity": "sha512-Ema3YhNOa4swDsV0V7CEY5JXvK19JI/o1szFO1iWxdFg3vhdFtCtSTP26PCvbUpnUtNHBY2wx5y3WDXND5Pvnw=="
     },
     "@vueuse/shared": {
       "version": "10.2.1",
       "resolved": "https://registry.npmmirror.com/@vueuse/shared/-/shared-10.2.1.tgz",
       "integrity": "sha512-QWHq2bSuGptkcxx4f4M/fBYC3Y8d3M2UYyLsyzoPgEoVzJURQ0oJeWXu79OiLlBb8gTKkqe4mO85T/sf39mmiw==",
+      "dev": true,
       "requires": {
         "vue-demi": ">=0.14.5"
       },
@@ -5767,6 +5455,7 @@
           "version": "0.14.5",
           "resolved": "https://registry.npmmirror.com/vue-demi/-/vue-demi-0.14.5.tgz",
           "integrity": "sha512-o9NUVpl/YlsGJ7t+xuqJKx8EBGf1quRhCiT6D/J0pfwmk9zUwYkC7yrF4SZCe6fETvSM3UNL2edcbYrSyc4QHA==",
+          "dev": true,
           "requires": {}
         }
       }
@@ -5816,6 +5505,11 @@
       "integrity": "sha512-lEm8mt52to2fT8GhciPCGeCXACSz2UwIN4X2e2LJSnZ5uAbn2/dsYdOmUXq0AtWS5cpAupysIneExOgH0Vd2TQ==",
       "dev": true
     },
+    "arg": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmmirror.com/arg/-/arg-5.0.2.tgz",
+      "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg=="
+    },
     "argparse": {
       "version": "2.0.1",
       "resolved": "https://registry.npmmirror.com/argparse/-/argparse-2.0.1.tgz",
@@ -6212,6 +5906,48 @@
       "integrity": "sha512-FXMe9GfxTxqd5D6jFsQ+DJ8BJS4E/fT5mqqdjovykEB2oFbTMDVdg1MGFxfQW+FBOGoB++k8swBrgwSHT1cUXQ==",
       "dev": true
     },
+    "d3-sankey": {
+      "version": "0.12.3",
+      "resolved": "https://registry.npmmirror.com/d3-sankey/-/d3-sankey-0.12.3.tgz",
+      "integrity": "sha512-nQhsBRmM19Ax5xEIPLMY9ZmJ/cDvd1BG3UVvt5h3WRxKg5zGRbvnteTyWAbzeSvlh3tW7ZEmq4VwR5mB3tutmQ==",
+      "dev": true,
+      "requires": {
+        "d3-array": "1 - 2",
+        "d3-shape": "^1.2.0"
+      },
+      "dependencies": {
+        "d3-array": {
+          "version": "2.12.1",
+          "resolved": "https://registry.npmmirror.com/d3-array/-/d3-array-2.12.1.tgz",
+          "integrity": "sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ==",
+          "dev": true,
+          "requires": {
+            "internmap": "^1.0.0"
+          }
+        },
+        "d3-path": {
+          "version": "1.0.9",
+          "resolved": "https://registry.npmmirror.com/d3-path/-/d3-path-1.0.9.tgz",
+          "integrity": "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg==",
+          "dev": true
+        },
+        "d3-shape": {
+          "version": "1.3.7",
+          "resolved": "https://registry.npmmirror.com/d3-shape/-/d3-shape-1.3.7.tgz",
+          "integrity": "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw==",
+          "dev": true,
+          "requires": {
+            "d3-path": "1"
+          }
+        },
+        "internmap": {
+          "version": "1.0.1",
+          "resolved": "https://registry.npmmirror.com/internmap/-/internmap-1.0.1.tgz",
+          "integrity": "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw==",
+          "dev": true
+        }
+      }
+    },
     "d3-scale": {
       "version": "4.0.2",
       "resolved": "https://registry.npmmirror.com/d3-scale/-/d3-scale-4.0.2.tgz",
@@ -6384,9 +6120,9 @@
       }
     },
     "dompurify": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmmirror.com/dompurify/-/dompurify-3.0.3.tgz",
-      "integrity": "sha512-axQ9zieHLnAnHh0sfAamKYiqXMJAVwu+LM/alQ7WDagoWessyWvMSFyW65CqF3owufNu8HBcE4cM2Vflu7YWcQ==",
+      "version": "3.0.5",
+      "resolved": "https://registry.npmmirror.com/dompurify/-/dompurify-3.0.5.tgz",
+      "integrity": "sha512-F9e6wPGtY+8KNMRAVfxeCOHU0/NPWMSENNq4pQctuXRqqdEPW7q3CrLbR5Nse044WwacyjHGOMlvNsBe1y6z9A==",
       "dev": true
     },
     "domutils": {
@@ -6411,34 +6147,33 @@
       "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A=="
     },
     "esbuild": {
-      "version": "0.17.19",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/esbuild/-/esbuild-0.17.19.tgz",
-      "integrity": "sha512-XQ0jAPFkK/u3LcVRcvVHQcTIqD6E2H1fvZMA5dQPSOWb3suUbWbfbRf94pjc0bNzRYLfIrDRQXr7X+LHIm5oHw==",
+      "version": "0.18.16",
+      "resolved": "https://registry.npmmirror.com/esbuild/-/esbuild-0.18.16.tgz",
+      "integrity": "sha512-1xLsOXrDqwdHxyXb/x/SOyg59jpf/SH7YMvU5RNSU7z3TInaASNJWNFJ6iRvLvLETZMasF3d1DdZLg7sgRimRQ==",
       "dev": true,
-      "peer": true,
       "requires": {
-        "@esbuild/android-arm": "0.17.19",
-        "@esbuild/android-arm64": "0.17.19",
-        "@esbuild/android-x64": "0.17.19",
-        "@esbuild/darwin-arm64": "0.17.19",
-        "@esbuild/darwin-x64": "0.17.19",
-        "@esbuild/freebsd-arm64": "0.17.19",
-        "@esbuild/freebsd-x64": "0.17.19",
-        "@esbuild/linux-arm": "0.17.19",
-        "@esbuild/linux-arm64": "0.17.19",
-        "@esbuild/linux-ia32": "0.17.19",
-        "@esbuild/linux-loong64": "0.17.19",
-        "@esbuild/linux-mips64el": "0.17.19",
-        "@esbuild/linux-ppc64": "0.17.19",
-        "@esbuild/linux-riscv64": "0.17.19",
-        "@esbuild/linux-s390x": "0.17.19",
-        "@esbuild/linux-x64": "0.17.19",
-        "@esbuild/netbsd-x64": "0.17.19",
-        "@esbuild/openbsd-x64": "0.17.19",
-        "@esbuild/sunos-x64": "0.17.19",
-        "@esbuild/win32-arm64": "0.17.19",
-        "@esbuild/win32-ia32": "0.17.19",
-        "@esbuild/win32-x64": "0.17.19"
+        "@esbuild/android-arm": "0.18.16",
+        "@esbuild/android-arm64": "0.18.16",
+        "@esbuild/android-x64": "0.18.16",
+        "@esbuild/darwin-arm64": "0.18.16",
+        "@esbuild/darwin-x64": "0.18.16",
+        "@esbuild/freebsd-arm64": "0.18.16",
+        "@esbuild/freebsd-x64": "0.18.16",
+        "@esbuild/linux-arm": "0.18.16",
+        "@esbuild/linux-arm64": "0.18.16",
+        "@esbuild/linux-ia32": "0.18.16",
+        "@esbuild/linux-loong64": "0.18.16",
+        "@esbuild/linux-mips64el": "0.18.16",
+        "@esbuild/linux-ppc64": "0.18.16",
+        "@esbuild/linux-riscv64": "0.18.16",
+        "@esbuild/linux-s390x": "0.18.16",
+        "@esbuild/linux-x64": "0.18.16",
+        "@esbuild/netbsd-x64": "0.18.16",
+        "@esbuild/openbsd-x64": "0.18.16",
+        "@esbuild/sunos-x64": "0.18.16",
+        "@esbuild/win32-arm64": "0.18.16",
+        "@esbuild/win32-ia32": "0.18.16",
+        "@esbuild/win32-x64": "0.18.16"
       }
     },
     "escape-goat": {
@@ -6797,19 +6532,22 @@
       "dev": true
     },
     "mermaid": {
-      "version": "10.2.4",
-      "resolved": "https://registry.npmmirror.com/mermaid/-/mermaid-10.2.4.tgz",
-      "integrity": "sha512-zHGjEI7lBvWZX+PQYmlhSA2p40OzW6QbGodTCSzDeVpqaTnyAC+2sRGqrpXO+uQk3CnoeClHQPraQUMStdqy2g==",
+      "version": "10.3.0",
+      "resolved": "https://registry.npmmirror.com/mermaid/-/mermaid-10.3.0.tgz",
+      "integrity": "sha512-H5quxuQjwXC8M1WuuzhAp2TdqGg74t5skfDBrNKJ7dt3z8Wprl5S6h9VJsRhoBUTSs1TMtHEdplLhCqXleZZLw==",
       "dev": true,
       "requires": {
         "@braintree/sanitize-url": "^6.0.2",
+        "@types/d3-scale": "^4.0.3",
+        "@types/d3-scale-chromatic": "^3.0.0",
         "cytoscape": "^3.23.0",
         "cytoscape-cose-bilkent": "^4.1.0",
         "cytoscape-fcose": "^2.1.0",
         "d3": "^7.4.0",
+        "d3-sankey": "^0.12.3",
         "dagre-d3-es": "7.0.10",
         "dayjs": "^1.11.7",
-        "dompurify": "3.0.3",
+        "dompurify": "3.0.5",
         "elkjs": "^0.8.2",
         "khroma": "^2.0.0",
         "lodash-es": "^4.17.21",
@@ -7170,9 +6908,9 @@
       "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ=="
     },
     "postcss": {
-      "version": "8.4.25",
-      "resolved": "https://registry.npmmirror.com/postcss/-/postcss-8.4.25.tgz",
-      "integrity": "sha512-7taJ/8t2av0Z+sQEvNzCkpDynl0tX3uJMCODi6nT3PfASC7dYCWV9aQ+uiCf+KBD4SEFcu+GvJdGdwzQ6OSjCw==",
+      "version": "8.4.27",
+      "resolved": "https://registry.npmmirror.com/postcss/-/postcss-8.4.27.tgz",
+      "integrity": "sha512-gY/ACJtJPSmUFPDCHtX78+01fHa64FaU4zaaWfuh1MhGJISufJAH4cun6k/8fwsHYeK4UQmENQK+tRLCFJE8JQ==",
       "requires": {
         "nanoid": "^3.3.6",
         "picocolors": "^1.0.0",
@@ -7293,6 +7031,11 @@
         "postcss": "^8.3.11"
       }
     },
+    "sax": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmmirror.com/sax/-/sax-1.2.4.tgz",
+      "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw=="
+    },
     "scheduler": {
       "version": "0.23.0",
       "resolved": "https://registry.npmmirror.com/scheduler/-/scheduler-0.23.0.tgz",
@@ -7335,6 +7078,17 @@
         "vscode-textmate": "^8.0.0"
       }
     },
+    "sitemap": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmmirror.com/sitemap/-/sitemap-7.1.1.tgz",
+      "integrity": "sha512-mK3aFtjz4VdJN0igpIJrinf3EO8U8mxOPsTBzSsy06UtjZQJ3YY3o3Xa7zSc5nMqcMrRwlChHZ18Kxg0caiPBg==",
+      "requires": {
+        "@types/node": "^17.0.5",
+        "@types/sax": "^1.2.1",
+        "arg": "^5.0.0",
+        "sax": "^1.2.4"
+      }
+    },
     "slick": {
       "version": "1.12.2",
       "resolved": "https://registry.npmmirror.com/slick/-/slick-1.12.2.tgz",
@@ -7509,22 +7263,21 @@
       "integrity": "sha512-kRAyotcbNaSYoDnXvb4MHg/0a1egJdLwS6oJ38TJY7aw9n93Fl/3blIXdyYvPOp55CNxywooG/3BcrwNrBpcSg=="
     },
     "vite": {
-      "version": "4.3.9",
-      "resolved": "https://repo.huaweicloud.com/repository/npm/vite/-/vite-4.3.9.tgz",
-      "integrity": "sha512-qsTNZjO9NoJNW7KnOrgYwczm0WctJ8m/yqYAMAK9Lxt4SoySUfS5S8ia9K7JHpa3KEeMfyF8LoJ3c5NeBJy6pg==",
+      "version": "4.4.7",
+      "resolved": "https://registry.npmmirror.com/vite/-/vite-4.4.7.tgz",
+      "integrity": "sha512-6pYf9QJ1mHylfVh39HpuSfMPojPSKVxZvnclX1K1FyZ1PXDOcLBibdq5t1qxJSnL63ca8Wf4zts6mD8u8oc9Fw==",
       "dev": true,
-      "peer": true,
       "requires": {
-        "esbuild": "^0.17.5",
+        "esbuild": "^0.18.10",
         "fsevents": "~2.3.2",
-        "postcss": "^8.4.23",
-        "rollup": "^3.21.0"
+        "postcss": "^8.4.26",
+        "rollup": "^3.25.2"
       }
     },
     "vitepress": {
-      "version": "1.0.0-beta.5",
-      "resolved": "https://registry.npmmirror.com/vitepress/-/vitepress-1.0.0-beta.5.tgz",
-      "integrity": "sha512-/RjqqRsSEKkzF6HhK5e5Ij+bZ7ETb9jNCRRgIMm10gJ+ZLC3D1OqkE465lEqCeJUgt2HZ6jmWjDqIBfrJSpv7w==",
+      "version": "1.0.0-beta.7",
+      "resolved": "https://registry.npmmirror.com/vitepress/-/vitepress-1.0.0-beta.7.tgz",
+      "integrity": "sha512-P9Rw+FXatKIU4fVdtKxqwHl6fby8E/8zE3FIfep6meNgN4BxbWqoKJ6yfuuQQR9IrpQqwnyaBh4LSabyll6tWg==",
       "dev": true,
       "requires": {
         "@docsearch/css": "^3.5.1",
@@ -7534,210 +7287,12 @@
         "@vueuse/core": "^10.2.1",
         "@vueuse/integrations": "^10.2.1",
         "body-scroll-lock": "4.0.0-beta.0",
-        "focus-trap": "^7.4.3",
+        "focus-trap": "^7.5.2",
         "mark.js": "8.11.1",
         "minisearch": "^6.1.0",
         "shiki": "^0.14.3",
-        "vite": "4.4.0-beta.3",
+        "vite": "^4.4.7",
         "vue": "^3.3.4"
-      },
-      "dependencies": {
-        "@esbuild/android-arm": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/android-arm/-/android-arm-0.18.12.tgz",
-          "integrity": "sha512-LIxaNIQfkFZbTLb4+cX7dozHlAbAshhFE5PKdro0l+FnCpx1GDJaQ2WMcqm+ToXKMt8p8Uojk/MFRuGyz3V5Sw==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/android-arm64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/android-arm64/-/android-arm64-0.18.12.tgz",
-          "integrity": "sha512-BMAlczRqC/LUt2P97E4apTBbkvS9JTJnp2DKFbCwpZ8vBvXVbNdqmvzW/OsdtI/+mGr+apkkpqGM8WecLkPgrA==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/android-x64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/android-x64/-/android-x64-0.18.12.tgz",
-          "integrity": "sha512-zU5MyluNsykf5cOJ0LZZZjgAHbhPJ1cWfdH1ZXVMXxVMhEV0VZiZXQdwBBVvmvbF28EizeK7obG9fs+fpmS0eQ==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/darwin-arm64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/darwin-arm64/-/darwin-arm64-0.18.12.tgz",
-          "integrity": "sha512-zUZMep7YONnp6954QOOwEBwFX9svlKd3ov6PkxKd53LGTHsp/gy7vHaPGhhjBmEpqXEXShi6dddjIkmd+NgMsA==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/darwin-x64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/darwin-x64/-/darwin-x64-0.18.12.tgz",
-          "integrity": "sha512-ohqLPc7i67yunArPj1+/FeeJ7AgwAjHqKZ512ADk3WsE3FHU9l+m5aa7NdxXr0HmN1bjDlUslBjWNbFlD9y12Q==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/freebsd-arm64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.12.tgz",
-          "integrity": "sha512-GIIHtQXqgeOOqdG16a/A9N28GpkvjJnjYMhOnXVbn3EDJcoItdR58v/pGN31CHjyXDc8uCcRnFWmqaJt24AYJg==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/freebsd-x64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-x64/-/freebsd-x64-0.18.12.tgz",
-          "integrity": "sha512-zK0b9a1/0wZY+6FdOS3BpZcPc1kcx2G5yxxfEJtEUzVxI6n/FrC2Phsxj/YblPuBchhBZ/1wwn7AyEBUyNSa6g==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/linux-arm": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm/-/linux-arm-0.18.12.tgz",
-          "integrity": "sha512-y75OijvrBE/1XRrXq1jtrJfG26eHeMoqLJ2dwQNwviwTuTtHGCojsDO6BJNF8gU+3jTn1KzJEMETytwsFSvc+Q==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/linux-arm64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm64/-/linux-arm64-0.18.12.tgz",
-          "integrity": "sha512-JKgG8Q/LL/9sw/iHHxQyVMoQYu3rU3+a5Z87DxC+wAu3engz+EmctIrV+FGOgI6gWG1z1+5nDDbXiRMGQZXqiw==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/linux-ia32": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/linux-ia32/-/linux-ia32-0.18.12.tgz",
-          "integrity": "sha512-yoRIAqc0B4lDIAAEFEIu9ttTRFV84iuAl0KNCN6MhKLxNPfzwCBvEMgwco2f71GxmpBcTtn7KdErueZaM2rEvw==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/linux-loong64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/linux-loong64/-/linux-loong64-0.18.12.tgz",
-          "integrity": "sha512-qYgt3dHPVvf/MgbIBpJ4Sup/yb9DAopZ3a2JgMpNKIHUpOdnJ2eHBo/aQdnd8dJ21X/+sS58wxHtA9lEazYtXQ==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/linux-mips64el": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/linux-mips64el/-/linux-mips64el-0.18.12.tgz",
-          "integrity": "sha512-wHphlMLK4ufNOONqukELfVIbnGQJrHJ/mxZMMrP2jYrPgCRZhOtf0kC4yAXBwnfmULimV1qt5UJJOw4Kh13Yfg==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/linux-ppc64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/linux-ppc64/-/linux-ppc64-0.18.12.tgz",
-          "integrity": "sha512-TeN//1Ft20ZZW41+zDSdOI/Os1bEq5dbvBvYkberB7PHABbRcsteeoNVZFlI0YLpGdlBqohEpjrn06kv8heCJg==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/linux-riscv64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/linux-riscv64/-/linux-riscv64-0.18.12.tgz",
-          "integrity": "sha512-AgUebVS4DoAblBgiB2ACQ/8l4eGE5aWBb8ZXtkXHiET9mbj7GuWt3OnsIW/zX+XHJt2RYJZctbQ2S/mDjbp0UA==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/linux-s390x": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/linux-s390x/-/linux-s390x-0.18.12.tgz",
-          "integrity": "sha512-dJ3Rb3Ei2u/ysSXd6pzleGtfDdc2MuzKt8qc6ls8vreP1G3B7HInX3i7gXS4BGeVd24pp0yqyS7bJ5NHaI9ing==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/linux-x64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/linux-x64/-/linux-x64-0.18.12.tgz",
-          "integrity": "sha512-OrNJMGQbPaVyHHcDF8ybNSwu7TDOfX8NGpXCbetwOSP6txOJiWlgQnRymfC9ocR1S0Y5PW0Wb1mV6pUddqmvmQ==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/netbsd-x64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/netbsd-x64/-/netbsd-x64-0.18.12.tgz",
-          "integrity": "sha512-55FzVCAiwE9FK8wWeCRuvjazNRJ1QqLCYGZVB6E8RuQuTeStSwotpSW4xoRGwp3a1wUsaVCdYcj5LGCASVJmMg==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/openbsd-x64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/openbsd-x64/-/openbsd-x64-0.18.12.tgz",
-          "integrity": "sha512-qnluf8rfb6Y5Lw2tirfK2quZOBbVqmwxut7GPCIJsM8lc4AEUj9L8y0YPdLaPK0TECt4IdyBdBD/KRFKorlK3g==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/sunos-x64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/sunos-x64/-/sunos-x64-0.18.12.tgz",
-          "integrity": "sha512-+RkKpVQR7bICjTOPUpkTBTaJ4TFqQBX5Ywyd/HSdDkQGn65VPkTsR/pL4AMvuMWy+wnXgIl4EY6q4mVpJal8Kg==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/win32-arm64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/win32-arm64/-/win32-arm64-0.18.12.tgz",
-          "integrity": "sha512-GNHuciv0mFM7ouzsU0+AwY+7eV4Mgo5WnbhfDCQGtpvOtD1vbOiRjPYG6dhmMoFyBjj+pNqQu2X+7DKn0KQ/Gw==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/win32-ia32": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/win32-ia32/-/win32-ia32-0.18.12.tgz",
-          "integrity": "sha512-kR8cezhYipbbypGkaqCTWIeu4zID17gamC8YTPXYtcN3E5BhhtTnwKBn9I0PJur/T6UVwIEGYzkffNL0lFvxEw==",
-          "dev": true,
-          "optional": true
-        },
-        "@esbuild/win32-x64": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/@esbuild/win32-x64/-/win32-x64-0.18.12.tgz",
-          "integrity": "sha512-O0UYQVkvfM/jO8a4OwoV0mAKSJw+mjWTAd1MJd/1FCX6uiMdLmMRPK/w6e9OQ0ob2WGxzIm9va/KG0Ja4zIOgg==",
-          "dev": true,
-          "optional": true
-        },
-        "esbuild": {
-          "version": "0.18.12",
-          "resolved": "https://registry.npmmirror.com/esbuild/-/esbuild-0.18.12.tgz",
-          "integrity": "sha512-XuOVLDdtsDslXStStduT41op21Ytmf4/BDS46aa3xPJ7X5h2eMWBF1oAe3QjUH3bDksocNXgzGUZ7XHIBya6Tg==",
-          "dev": true,
-          "requires": {
-            "@esbuild/android-arm": "0.18.12",
-            "@esbuild/android-arm64": "0.18.12",
-            "@esbuild/android-x64": "0.18.12",
-            "@esbuild/darwin-arm64": "0.18.12",
-            "@esbuild/darwin-x64": "0.18.12",
-            "@esbuild/freebsd-arm64": "0.18.12",
-            "@esbuild/freebsd-x64": "0.18.12",
-            "@esbuild/linux-arm": "0.18.12",
-            "@esbuild/linux-arm64": "0.18.12",
-            "@esbuild/linux-ia32": "0.18.12",
-            "@esbuild/linux-loong64": "0.18.12",
-            "@esbuild/linux-mips64el": "0.18.12",
-            "@esbuild/linux-ppc64": "0.18.12",
-            "@esbuild/linux-riscv64": "0.18.12",
-            "@esbuild/linux-s390x": "0.18.12",
-            "@esbuild/linux-x64": "0.18.12",
-            "@esbuild/netbsd-x64": "0.18.12",
-            "@esbuild/openbsd-x64": "0.18.12",
-            "@esbuild/sunos-x64": "0.18.12",
-            "@esbuild/win32-arm64": "0.18.12",
-            "@esbuild/win32-ia32": "0.18.12",
-            "@esbuild/win32-x64": "0.18.12"
-          }
-        },
-        "vite": {
-          "version": "4.4.0-beta.3",
-          "resolved": "https://registry.npmmirror.com/vite/-/vite-4.4.0-beta.3.tgz",
-          "integrity": "sha512-IC/thYTvArOFRJ4qvvudnu4KKZOVc+gduS3I9OfC5SbP/Rf4kkP7z6Of2QpKeOSVqwIK24khW6VOUmVD/0yzSQ==",
-          "dev": true,
-          "requires": {
-            "esbuild": "^0.18.6",
-            "fsevents": "~2.3.2",
-            "postcss": "^8.4.24",
-            "rollup": "^3.25.2"
-          }
-        }
       }
     },
     "vitepress-plugin-mermaid": {
diff --git a/package.json b/package.json
index c996506..ce45cf7 100644
--- a/package.json
+++ b/package.json
@@ -9,16 +9,17 @@
     "@codemirror/lang-sql": "^6.5.2",
     "@jupyterlab/mathjax2": "^3.6.5",
     "@jupyterlab/theme-light-extension": "^4.0.3",
-    "@vueuse/core": "^10.2.1",
+    "@vueuse/core": "^10.3.0",
     "markdown-it": "^13.0.1",
-    "markdown-it-pangu": "^1.0.2"
+    "markdown-it-pangu": "^1.0.2",
+    "sitemap": "^7.1.1"
   },
   "devDependencies": {
     "@mermaid-js/mermaid-mindmap": "^9.3.0",
     "cross-env": "^7.0.3",
     "markdown-it-mathjax3": "^4.3.2",
-    "mermaid": "^10.2.4",
-    "vitepress": "^1.0.0-beta.5",
+    "mermaid": "^10.3.0",
+    "vitepress": "^1.0.0-beta.7",
     "vitepress-plugin-mermaid": "^2.0.13"
   }
 }
diff --git a/public/qrcodes.png b/public/qrcodes.png
new file mode 100644
index 0000000..c936fa4
Binary files /dev/null and b/public/qrcodes.png differ
diff --git a/wiki史.md b/wiki史.md
index bacff61..f36c150 100644
--- a/wiki史.md
+++ b/wiki史.md
@@ -32,7 +32,7 @@
 
 在那一轮培训的过程中，晓宇来改作业，我来组织大伙开会和讲一些内容，我们看着很多原本电脑都不会用的同学有机会能接触到世界相较而言很前沿的任务，心里还是很有成就感的。
 
-![最早的SRT社团培训](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/The%20earliest%20SRT%20community%20training.jpg)
+![最早的SRT社团培训](https://cdn.xyxsw.site/The%20earliest%20SRT%20community%20training.jpg)
 
 （图一：最早的SRT社团培训）
 
@@ -60,20 +60,20 @@
 
 于是我当时的计划是，先尽自己所能，将自己在学习过程中踩得坑，走的错误道路都记录下来，然后借鉴南京大学和上海交大的思想，先写一些有指导意义的软文，然后把自己学的 AI 和编程的内容写下来，并且吸取一些国外优质的课程内容。争取做一些更新手友好的内容。写了两个月，将 AI 和编程部分自己的入门经验写出来了，估计输出了数万字。
 
-![早期Wiki](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/afaaac5d-b99e-4a84-b0ef-862cad4dc1d0.jpg)
+![早期Wiki](https://cdn.xyxsw.site/afaaac5d-b99e-4a84-b0ef-862cad4dc1d0.jpg)
 （早期Wiki）
 
 不过问题很快暴露出来，我作为一个个体是渺小且无力的，而计算机科学的世界是宏伟且庞大的，凭借我一个人，我这辈子写完是没戏了。不过没关系，我在冥冥之中仿佛与战国时期翻手为云，覆手为雨的纵横学家有了心灵感应，是时候发动人民群众的力量了！
 
 在新生到来前的那个暑假，我先后联系了杭电技术最强的几个技术团体的同学，一起参与到 Wiki 的完善工作去，尽可能补齐计算机技术的方方面面，甚至我们找到了杭电最受欢迎的老师之一韩健夫老师为我们写了一篇文章。随着 22 届新生的到来，Wiki 已经初具雏形了，我们依靠新生的反馈，循序渐进地修改内容，并且鼓励新生可以根据自己的学习心得对 Wiki 进行修正。
 
-![超大规模的22届](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/dcf8ab68-4de4-4af2-898d-bd930f829f9f.jpg)
+![超大规模的22届](https://cdn.xyxsw.site/dcf8ab68-4de4-4af2-898d-bd930f829f9f.jpg)
 
 （图三：超大规模的22届）
 
 在这个时候，我觉得也许仅仅靠校内的视角，是远远不够的，我们需要一些更为先进的生产力的帮助！这个时候我想到了之前看到过的 Datawhale 的教程，于是我去联系了他们的开源项目负责人和创始人，甚至去了他们在杭州的总部。
 
-![datawhale杭州](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/dc84aef9-a21e-49e2-92f2-63fe1c3671de.jpg)
+![datawhale杭州](https://cdn.xyxsw.site/dc84aef9-a21e-49e2-92f2-63fe1c3671de.jpg)
 
 在与他们的沟通过之后备受振奋，有种酒逢知己千杯少的快乐，感觉 Datawhale 这样的社区就是一群我这样的聚集在了一起。我们的理念和思考完全相同，并且他们传递给了我一种力量，一种可以让理想真正落地的力量，一种靠人与人之间互相关怀，互相帮助，通过信任和感情把大伙联系起来。
 
diff --git a/简介.md b/简介.md
index f49d246..2145990 100644
--- a/简介.md
+++ b/简介.md
@@ -31,13 +31,11 @@
 想必在这里，你或多或少都能得到自己的答案！
 
 <div align="center">
-    <img src="https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/hdu-cs-qq.jpg"/>
+    <img src="https://cdn.xyxsw.site/qrcodes.png"/>
 </div>
 
 欢迎加群与学长交流！我们也可以针对你的喜好为你定制一个方案！
 
-**群号：669895692**
-
 ::: tip 🤔
 
 ### 为什么我要花大量的时间与折磨受这样的训练？