moyin/fzu-product
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Merge branch

Browse Source
This commit is contained in:
E1PsyCongroo
2023-07-31 21:04:50 +08:00
parent 23aa3a4249 82913b9dc8
commit 5fe92e1559
193 changed files with 4631 additions and 3403 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.github/workflows/cos.yaml vendored
View File

@@ -7,6 +7,7 @@ on:
jobs:
build:
if: github.repository == 'camera-2018/hdu-cs-wiki'
runs-on: ubuntu-latest
steps:

12
.github/workflows/link-pr.yaml vendored
View File

@@ -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}}

24
.github/workflows/link-schedule.yaml vendored
View File

@@ -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

7
.lycheeignore
View File

@@ -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

183
.vitepress/components/CustomSwitchAppearance.vue Normal file
View File

@@ -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>

40
.vitepress/config.js
View File

@@ -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)
)
}
]
}
}
})

2
.vitepress/nav.js
View File

@@ -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:

30
.vitepress/sidebar.js
View File

@@ -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() {
]
}
]
}
}
export function chapter9() {
return [
{ text: '返回上一层', link: '/简介' },
{
text: '9.计算机网络',
collapsed: false,
items: [
{ text: '9.计算机网络', link: '/9.计算机网络/9.计算机网络' },
]
}
]
}

BIN
.vitepress/theme/font/NotoSansMono-Regular.ttf Normal file
View File

Binary file not shown.

BIN
.vitepress/theme/font/NotoSansSC-Bold.otf Normal file
View File

Binary file not shown.

BIN
.vitepress/theme/font/NotoSansSC-Regular.otf Normal file
View File

Binary file not shown.

20
.vitepress/theme/style.css
View File

@@ -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

41
1.杭电生存指南/1.12程序员如何活久一点.md
View File

@@ -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)
:::

21
1.杭电生存指南/1.13选课原则与抢课技巧.md → 1.杭电生存指南/1.12选课原则与抢课技巧.md
View File

@@ -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分钟系统会未响应甚至将你踢出登录，还会让你浏览器爆掉显示 *欧呦，崩溃啦* 之类的字样，一切听天由命。
:::
## 具体技巧
#### 系统开放前
通常系统开放前可以查询开课情况，那么可以根据开课情况自己提前规划安排想上的课程。
#### 系统开放时
##### 第一轮选课、第二轮选课开放系统时
提前在粘贴板中剪切/复制第一手要抢的课程，并且在选课平台开放时间前几秒，不停点击刷新，直至选课平台显示的内容不为非选课时间而是可以搜索，粘贴课程名并且点击抢课即可第一手抢到最想抢的课程，再依次抢接下来准备上的课。若课表上已经被系统默认选的课占了想要选的课的位置，那么就需要先退课再选课。
##### 假期以及开学前三周
这时候会有同学因为不想选某门课程或者通过将课卡在其他人号上想在假期“转移”到自己号上，选课系统中的课程余量就会时不时出现波动，此时可以上去系统看看说不定能捡漏哦。签课以及扩学分在开学前三周进行，请关注学校通知并且通过签课选上自己没能选上的课程。

51
1.杭电生存指南/1.2竞赛指北.md
View File

@@ -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)

4
1.杭电生存指南/1.4小心项目陷阱.md
View File

@@ -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)
所以说，还是那句话，小心甄别。

4
1.杭电生存指南/1.7杭电出国自救指南.md
View File

@@ -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 分的难度。有很多资料在不同的角度，我们很难参考，所以我不经会想问？那我们呢，我们考多少多少分能够去什么学校，我们想要直博应该怎么准备，所以我打算完成这份出国留学的手册，能够为学弟学妹们铺路，同样希望后面也能够有学弟学妹做完善和补充。

BIN
1.杭电生存指南/static/prize.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 876 KiB

BIN
1.杭电生存指南/static/src.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 335 KiB

BIN
1.杭电生存指南/static/计算机科学联合会群聊二维码.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 24 KiB

2
2.高效学习/2.1.2浮躁的心理状态.md
View File

@@ -32,4 +32,4 @@
如果实在不行，来找 ZZM 聊聊吧。
![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnPDWiNgkgppK1XWq5cRQ71b.jpg)
![](https://cdn.xyxsw.site/boxcnPDWiNgkgppK1XWq5cRQ71b.jpg)

2
2.高效学习/2.1.3错误的提问姿态.md
View File

@@ -28,7 +28,7 @@
问题还是没有解决，现在我该怎么做？
![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnhuhE7qBLHyJKaesHGC033b.png)
![](https://cdn.xyxsw.site/boxcnhuhE7qBLHyJKaesHGC033b.png)
欢迎大家阅读

2
2.高效学习/2.1.4书籍的盲目崇拜.md
View File

@@ -6,7 +6,7 @@
"我们要学 C 语言，我买一本大黑书看看!"
![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnqsCWmUTDr5UDLYca9YkhHh.png)
![](https://cdn.xyxsw.site/boxcnqsCWmUTDr5UDLYca9YkhHh.png)
诚然，上面的各种书写的非常好，但是我们需要思考的是，阅读这些真的能达到我们想要的目标吗？？？

2
2.高效学习/2.1.5错误的学习配比.md
View File

@@ -18,4 +18,4 @@
在你完成这份讲义的时候，希望你可以有选择的阅览一部分，然后带着问题去看某些课，效率也会高很多。
![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcnSq1JzWhVrFs3MePPzp5Txg.jpg)
![](https://cdn.xyxsw.site/boxcnSq1JzWhVrFs3MePPzp5Txg.jpg)

2
2.高效学习/2.1高效的前提：摆脱高中思维.md
View File

@@ -14,7 +14,7 @@
**并且，全部依赖他人给你指明方向的人生已经结束了！**
![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/boxcne9EK3xz8LHOXfM8w9ih5Ig.png)
![](https://cdn.xyxsw.site/boxcne9EK3xz8LHOXfM8w9ih5Ig.png)
你无法依赖大学里的老师还是家里的父母来为你指明所谓的方向，你的人生只属于你自己，你的道路也只能由你自己来思考。

4
2.高效学习/2.2优雅的使用工具.md
View File

@@ -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): 笔记终结者，非常强大，（设计理念被钉钉，飞书，我来非常抄袭）。在线就可以使用。

2
2.高效学习/2.5以理工科的方式阅读英语.md
View File

@@ -2,7 +2,7 @@
作为一名理工科学生，也许英语并不是你的强势，但往往学习又难以避开英语。
![](https://pic-hdu-cs-wiki-1307923872.cos.ap-shanghai.myqcloud.com/G6zAbGrTKoBLsfxhmvHcUBVynpc.png)
![](https://cdn.xyxsw.site/G6zAbGrTKoBLsfxhmvHcUBVynpc.png)
下面提供一些英语阅读的方法：

2
2.高效学习/2.高效学习.md
View File

@@ -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)
来细看看本章节的内容吧！

6
3.编程思维体系构建/3.0 编程入门之道.md
View File

@@ -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/)

12
3.编程思维体系构建/3.1该使用哪个编辑器？？？.md
View File

@@ -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 化需要额外配置)

18
3.编程思维体系构建/3.2.1为什么要选择ACM——谈谈我与ACM.md
View File

@@ -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 吧，大一的空闲时间真的很多，去探索新事物，不试试怎么知道自己行不行。

60
3.编程思维体系构建/3.2.2手把手教你学算法——如何使用OJ（Online Judge）.md
View File

@@ -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 学习，我应该在什么时间节点或训练阶段，出于什么训练目的选择哪个网站，笔者留到下一个篇章继续介绍。

2
3.编程思维体系构建/3.2.3ACM 竞赛从入门到入坟.md
View File

@@ -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 曲线一定是波动上升的。

14
3.编程思维体系构建/3.2算法杂谈.md
View File

@@ -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。

12
3.编程思维体系构建/3.3如何选择编程语言.md
View File

@@ -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)
当然还有各种形形色色的编程语言等着同学们去探索。

36
3.编程思维体系构建/3.4.1FAQ：常见问题.md
View File

@@ -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 聊聊吧

104
3.编程思维体系构建/3.4.2用什么写 C 语言.md
View File

@@ -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 了你还来问我？一边玩去

5
3.编程思维体系构建/3.4.3解决编程问题的普适性过程.md
View File

@@ -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
一旦在代码中发现了问题，就需要修复它，这个过程称为调试。许多新手程序员（甚至一些经验丰富的程序员）以临时方式调试，试图更改代码中的某些内容，并希望它能解决他们的问题。这样的方法很少有效，常常会导致很多挫折。

4
3.编程思维体系构建/3.4.4C语言前置概念学习.md
View File

@@ -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>

70
3.编程思维体系构建/3.4.5.1C语言自测标准——链表.md
View File

@@ -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 不等于头结点，则循环未结束。

12
3.编程思维体系构建/3.4.5阶段一：编程属性.md
View File

@@ -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，了解完成任务所需的前置知识
进阶：评价一个程序，大体分为以下四个层次。

2
3.编程思维体系构建/3.4.6.1.开始冒险.md
View File

@@ -23,7 +23,7 @@ Bye!
尽管可能微不足道，但该程序确实展示 <em>了</em>任何文本冒险中最重要的方面：描述性文本。一个好的故事是制作一款好的冒险游戏的要素之一。
# 为什么要用英文？
## 为什么要用英文？
因为中文的编码模式可能会带来奇怪的影响。

38
3.编程思维体系构建/3.4.6.10.增添属性.md
View File

@@ -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 来查看银币，但程序并不知道鹰是什么意思 (显然这样子是不行的)。
输出样例

31
3.编程思维体系构建/3.4.6.11.设置条件.md
View File

@@ -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 来实现？
:::
输出样例

33
3.编程思维体系构建/3.4.6.12.开启关闭.md
View File

@@ -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>

38
3.编程思维体系构建/3.4.6.13.编写解析器.md
View File

@@ -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 游戏来说限制实在太大了！

20
3.编程思维体系构建/3.4.6.14.丰富命令.md
View File

@@ -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>

43
3.编程思维体系构建/3.4.6.15.赋予明暗.md
View File

@@ -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.

59
3.编程思维体系构建/3.4.6.2.探索未知.md
View File

@@ -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 是干什么的

37
3.编程思维体系构建/3.4.6.3.指明地点.md
View File

@@ -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>

35
3.编程思维体系构建/3.4.6.4.创建对象.md
View File

@@ -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>

47
3.编程思维体系构建/3.4.6.5.捡起物品.md
View File

@@ -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>）。

30
3.编程思维体系构建/3.4.6.6.绘制地图.md
View File

@@ -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 🤔 思考题：
你能否绘制一张更精细的地图，并将其变成对象列表（位置和通道）
```
注：不用当成任务，自行实验即可
```
注：不用当成任务，自行实验即可
:::
输出样例

38
3.编程思维体系构建/3.4.6.7.增大距离.md
View File

@@ -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>端进行改进。在下一章中，我们将使用距离来提高对用户输入的名词的识别。

30
3.编程思维体系构建/3.4.6.8.移动方向.md
View File

@@ -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 🤔 猜猜看该怎么办？
:::

13
3.编程思维体系构建/3.4.6.9.练习：生成代码.md
View File

@@ -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来实现这段伪代码？
::: warning 🤔 思考题：你能否自己用 C 来实现这段伪代码？
:::

22
3.编程思维体系构建/3.4.6阶段二：文字冒险（cool）.md
View File

@@ -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 法则的重要性。

48
3.编程思维体系构建/3.4.7.1.1调试理论.md
View File

@@ -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 了，因为这取决于测试的覆盖度。要设计出一套全覆盖的测试并不是一件简单的事情，越是复杂的系统，全覆盖的测试就越难设计。但是，如何提高测试的覆盖度，是学术界一直以来都在关注的问题。

50
3.编程思维体系构建/3.4.7.1GDB初探索（编程可阅览）.md
View File

@@ -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)

12
3.编程思维体系构建/3.4.7.2C的历史问题：undefined behavior.md
View File

@@ -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>

16
3.编程思维体系构建/3.4.7.3C编译器干了什么.md
View File

@@ -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)

22
3.编程思维体系构建/3.4.7.4Inline Assembly与链接加载.md
View File

@@ -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 就可以查看动态链接库

2
3.编程思维体系构建/3.4C语言.md
View File

@@ -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>

137
3.编程思维体系构建/3.5git与github.md
View File

@@ -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)

20
3.编程思维体系构建/3.6.1从CS61A看编程语言学习.md
View File

@@ -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 的难度梯度设计，就是兼具了趣味性和间接性的，并且全面优于互联网上的非常多的教程，比硬啃要给我们更多的正反馈（当然，改变思维和学习方式是很重要的。
#

30
3.编程思维体系构建/3.6.2环境配置.md
View File

@@ -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 中找到环境的配置方法，遇到难以下载的特殊版本包时可以考虑下载它的源码手动编译，具体流程不展开了，可以自行搜索

22
3.编程思维体系构建/3.6.3安装python.md
View File

@@ -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/)：可能很多同学已经用上了，我在这里不做更多解释

42
3.编程思维体系构建/3.6.4.0阶段零：Python解释器.md
View File

@@ -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 这门编程语言的神奇之处了
在这里留一个思考题

5
3.编程思维体系构建/3.6.4.1阶段一：熟悉语句.md
View File

@@ -1,10 +1,11 @@
# 阶段一：熟悉语句
在进行本章之前，请你谨记一个原则：基本所有的功能都被人提前实现好了
::: warning 🐱 在进行本章之前，请你谨记一个原则：基本所有的功能都被人提前实现好了
你需要关心的仅仅是逻辑该如何设立
在做本章任务前，请熟悉 python 的函数，循环和判断语句即可
:::
P1：请仅使用一行语句求出三个数的最小平方和
@@ -30,7 +31,7 @@ def two_of_three(x, y, z):
return _____
```
提示：可以使用 max()函数哦
提示：可以使用 `min()` 函数哦
P2：下降阶乘

12
3.编程思维体系构建/3.6.4.2阶段二：递归操作.md
View File

@@ -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):

96
3.编程思维体系构建/3.6.4.3阶段三：数据抽象.md
View File

@@ -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]
```
首先你试试求出两个地方的距离。

17
3.编程思维体系构建/3.6.4.4阶段四：高阶函数.md
View File

@@ -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):

19
3.编程思维体系构建/3.6.4.5阶段五：迭代生成.md
View File

@@ -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):

10
3.编程思维体系构建/3.6.4.6结语.md
View File

@@ -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)

2
3.编程思维体系构建/3.6.4Python for fun.md
View File

@@ -1,6 +1,6 @@
# Python for fun
值得一提的是,Python 是面向对象的编程语言，与你之前书写的 C 语言（面向过程）有非常多的不同。
值得一提的是，Python 是面向对象的编程语言，与你之前书写的 C 语言（面向过程）有非常多的不同。
我们为什么要选择要使用 Python 来首先讲解面向对象这个概念？

420
3.编程思维体系构建/3.6.5.1CS61A Sec1.md Normal file
View File

@@ -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`函数的使用只是为了让我们看到计算的中间结果。
## 课后作业
一个好的课程怎么能少得了精心准备的课后作业呢？🤗

625
3.编程思维体系构建/3.6.5.1lab00：让我们开始吧.md
View File

@@ -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
```

129
3.编程思维体系构建/3.6.5CS61A食用指南.md Normal file
View File

@@ -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 的开头。
英文学习的痛苦比不上接触国外优秀课程带来的快乐，请保持初心，砥砺前进，祝愿同学们都能有一个有趣的学习体验 🥰

19
3.编程思维体系构建/3.6.5关于CS61A.md
View File

@@ -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：当然存在“错误”的代码的概率很小，你发现它们的概率就更小了

4
3.编程思维体系构建/3.X 聊聊设计模式和程序设计.md
View File

@@ -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)
这部分的学习不能操之过急。个人的建议是：

31
3.编程思维体系构建/3.Y 附加模块：Linux.md
View File

@@ -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 与命令行之间对比的文章，尝试开始阅读英文文章

31
3.编程思维体系构建/3.Y.0计算机教育中缺失的一课.md Normal file
View File

@@ -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)

51
3.编程思维体系构建/3.Y.1VMware的安装与安装Ubuntu22.04系统.md
View File

@@ -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)
打开命令行

7
3.编程思维体系构建/3.Y.2WSL的安装.md
View File

@@ -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)

120
3.编程思维体系构建/3.Y.3Linux初探索.md
View File

@@ -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` 等), 很容易与用户自己编写的程序重名，不搜索当前目录消除了命令访问的歧义。

24
3.编程思维体系构建/3.Y.4Vim初探索.md
View File

@@ -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)

9
3.编程思维体系构建/3.Y.5linux小任务.md
View File

@@ -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()
}
```

23
3.编程思维体系构建/3.编程思维体系构建.md
View File

@@ -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》

BIN
3.编程思维体系构建/static/call_expression.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 11 KiB

BIN
3.编程思维体系构建/static/expression_tree.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 53 KiB

BIN
3.编程思维体系构建/static/function_abs.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.3 KiB

BIN
3.编程思维体系构建/static/function_print.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 13 KiB

BIN
3.编程思维体系构建/static/ok01.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 84 KiB

BIN
3.编程思维体系构建/static/ok02.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 12 KiB

28
4.人工智能/4.11从 AI 到 智能系统 —— 从 LLMs 到 Agents.md
View File

@@ -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 构建记忆金字塔

261
4.人工智能/4.12LLMAgent之结构化输出.md Normal file
View File

@@ -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>

2
4.人工智能/4.12本章节内容的局限性.md → 4.人工智能/4.13本章节内容的局限性.md
View File

@@ -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)

76
4.人工智能/4.1前言.md
View File

@@ -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)～

129
4.人工智能/4.2机器学习（AI）快速入门（quick start）.md
View File

@@ -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)

39
4.人工智能/4.3.1.1程序示例——maze迷宫解搜索.md
View File

@@ -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)
根节点的值是多少？

Some files were not shown because too many files have changed in this diff Show More