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

Merge pull request #81 from FallenYing/master

Browse Source 
chore
This commit is contained in:
camera-2018
2023-07-26 17:04:47 +08:00
committed by GitHub
parent a7efcb78a9 2a52254dc7
commit 1d07fce234
21 changed files with 165 additions and 803 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.vitepress/sidebar.js
View File

@@ -225,7 +225,7 @@ export function chapter3() {
{ text: '3.6.4.6结语', link: '/3.编程思维体系构建/3.6.4.6结语' },
]
},
{text: '3.6.5关于CS61A',link: '/3.编程思维体系构建/3.6.5关于CS61A'}
{text: '3.6.5CS61A食用指南',link: '/3.编程思维体系构建/3.6.5CS61A食用指南'}
]
},
{ text: '3.X 聊聊设计模式和程序设计', link: '/3.编程思维体系构建/3.X 聊聊设计模式和程序设计' },

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

16
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,15 +72,15 @@ 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), [JetBrains](https://www.jetbrains.com/zh-cn/clion/)[ Clion](https://www.jetbrains.com/zh-cn/clion/), Visual Studio Code(编辑器 IDE 化需要额外配置）
C: Visual Studio(宇宙第一 IDE), [JetBrains](https://www.jetbrains.com/zh-cn/clion/)[Clion](https://www.jetbrains.com/zh-cn/clion/), Visual Studio Code(编辑器 IDE 化需要额外配置）
Python: [JetBrains](https://www.jetbrains.com/zh-cn/pycharm/)[ ](https://www.jetbrains.com/zh-cn/pycharm/)[P](https://www.jetbrains.com/zh-cn/pycharm/)[ycharm](https://www.jetbrains.com/zh-cn/pycharm/)
Python: [JetBrains](https://www.jetbrains.com/zh-cn/pycharm/)[](https://www.jetbrains.com/zh-cn/pycharm/)[P](https://www.jetbrains.com/zh-cn/pycharm/)[ycharm](https://www.jetbrains.com/zh-cn/pycharm/)
Vim 在附加篇章里有额外介绍

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

@@ -2,7 +2,7 @@
author:wenjing
先验条件：保证你可以在每天进行练习和学习此方面内容即使是假期也不能超过三天以上休息,如果你想验证一下这件事当然也可以，注意心态的保持很重要
先验条件：保证你可以在每天进行练习和学习此方面内容即使是假期也不能超过三天以上休息，如果你想验证一下这件事当然也可以，注意心态的保持很重要
## 将时间花在 ACM 上值得吗？

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

@@ -127,7 +127,7 @@ Div.1、Div.2、Div.3、Div.4 数字越小难度越大。
首先我们可以看见赛时某道题的通过人数，随比赛时间流逝 100% 仿真变化。而且也可以与当时的“虚拟选手”同步竞争，例如笔者这里就复制之前写过的代码荣登榜三（乐）
对于大多数比赛，采用 ICPC 赛制，解决某题得到的分数由该题当前的分数减去(不成功的提交次数)*50，这里某道题的分数是由比赛开始时的分数随时间线性减少得到的。
对于大多数比赛，采用 ICPC 赛制，解决某题得到的分数由该题当前的分数减去 (不成功的提交次数)*50，这里某道题的分数是由比赛开始时的分数随时间线性减少得到的。
也就是做题越快，错误次数越少，分数和排名就越高，这点大体是与 ACM 赛制相同的。

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。

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

@@ -1,18 +1,18 @@
# 3.3 如何选择编程语言
# 编程语言的工具属性
## 编程语言的工具属性
在回答这个问题之前，需要各位同学明确的一点是，编程并不是一个独立的学科，像数学那样做题是学不好的。
编程语言的选择更像是锤子与扳手之间的选择，更大程度上看的是你需要解决什么样的问题。当你需要砸钉子的时候，使用螺丝刀总归是不顺手的，因此了解不同语言的特性，针对任务进行选择是非常有必要的。
# 编程语言特性
## 编程语言特性
首先附上一张经典老图
![](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++ 程序可看成以下三部分组成。

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

@@ -1,24 +1,24 @@
# FAQ：常见问题
# 我完全没基础觉得好难呜呜
## 我完全没基础觉得好难呜呜
教育除了知识的记忆之外, 更本质的是能力的训练, 即所谓的 training. 而但凡 training 就必须克服一定的难度, 否则你就是在做重复劳动, 能力也不会有改变. 如果遇到难度就选择退缩, 或者让别人来替你克服本该由你自己克服的难度, 等于是自动放弃了获得 training 的机会
教育除了知识的记忆之外，更本质的是能力的训练，即所谓的 training. 而但凡 training 就必须克服一定的难度，否则你就是在做重复劳动，能力也不会有改变。如果遇到难度就选择退缩，或者让别人来替你克服本该由你自己克服的难度，等于是自动放弃了获得 training 的机会
# 我觉得无从下手
## 我觉得无从下手
尝试借鉴他人的代码也未尝不可，但是要保证每一行都看懂哦
![](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,7 +65,7 @@ NJU-ICS-PA 南京大学计算机系统基础
有且仅有大学有这样好的资源帮助你了
# <strong>坚持了好久还是搞不定, 我想放弃了</strong>
## <strong>坚持了好久还是搞不定，我想放弃了</strong>
![](https://cdn.xyxsw.site/boxcnuNXrb5zOppCZAlGQ19wuDk.jpg)

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

@@ -4,11 +4,11 @@
## 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) 看不懂的话直接无脑装
@@ -22,7 +22,7 @@ Visual Studio （以下简称 VS ）是 Windows 下最完美的 C/C++ 等语言
社区版和专业版等的区别：社区版免费，功能上几乎无差别
### VS安装
### VS 安装
选择 C++ 桌面开发，其他不用选，有需要了再说。另外，Python 开发不好使，不要像我一样选 Python 开发。
@@ -78,7 +78,7 @@ C 语言是编译型语言，因此说“运行”代码其实并不是十分合
![](https://cdn.xyxsw.site/boxcnfrxYjk5CCjMfY0mLK1B1Ze.png)
需要你在项目-xxx 属性（xxx 是你的项目名）-C/C++-代码生成-安全检查里将安全检查禁用
需要你在项目-xxx 属性（xxx 是你的项目名）-C/C++-代码生成 - 安全检查里将安全检查禁用
![](https://cdn.xyxsw.site/boxcniHhCIUQY0oB3ALlxqgciLd.png)
@@ -90,7 +90,7 @@ IDE 相比于代码编辑器，最强大的一点莫过于成熟的调试系统
### <strong>深色主题</strong>
需要深色主题请在工具-主题里更改为深色
需要深色主题请在工具 - 主题里更改为深色
### Tips
@@ -114,16 +114,12 @@ IDE 相比于代码编辑器，最强大的一点莫过于成熟的调试系统
## 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安装
### vscode 安装
#### 安装软件本体
@@ -139,11 +135,11 @@ Visual Studio Code（以下简称 vscode） 和 Visual Studio 都是微软开发
vscode 的项目和 VS 不同，vscode 的项目比较松散，并没有 VS 那样是一套非常完善的项目系统。
首先需要一个空文件夹，并在 vscode 里打开这个文件夹。然后点击文件-新建文本文件，并选择语言为 C 语言。此时如果你是第一次创建 C 语言文件，那么右下角会弹出提示，提示你安装 C/C++ 插件，安装即可。
首先需要一个空文件夹，并在 vscode 里打开这个文件夹。然后点击文件 - 新建文本文件，并选择语言为 C 语言。此时如果你是第一次创建 C 语言文件，那么右下角会弹出提示，提示你安装 C/C++ 插件，安装即可。
### 编写代码并运行
编写完代码后，保存文件，并点击运行-启动调试
编写完代码后，保存文件，并点击运行 - 启动调试
![](https://cdn.xyxsw.site/boxcnim98FJybpkGl8sfqxP9v9b.png)
@@ -163,12 +159,9 @@ CLion 是 jetbrains 家族的 C 语言 IDE
用法和 Windows 的差不多，但由于 Mac OS 自带 clang 编译器，所以无需额外安装编译器。
> 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 的差不多。
@@ -200,4 +193,3 @@ next 后选择项目保存的位置，之后即可到达以下界面：
## Linux
### 你都用 Linux 了你还来问我？一边玩去

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

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

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

@@ -18,7 +18,7 @@
7.Web：[LinuxC 一站式编程](https://akaedu.github.io/book/)（难度大，枯燥硬核，收获多，基于 linux）
### 学习建议：可以选择其一或多种学习。
## 学习建议：可以选择其一或多种学习
- 对于缺乏计算机基础（这里的基础指的是计算机的日常使用）的同学，（1、2）是不错的选择，但在学完后要选择 4、5、6 进行补充巩固提高。
- 对于有一定计算机基础的同学，直接上手 4、5、6 都是很不错的选择。

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

@@ -42,13 +42,13 @@ typedef struct Node* Link;
图 4 所示的链表并不完整，一个完整的链表应该由以下几部分构成：
头指针:是指向链表中一个结点所在存储位置的指针。如果链表中有头结点，则头指针指向头结点；若链表中没有头结点，则头指针指向链表中第一个数据结点（也叫首元结点）。
头指针：是指向链表中一个结点所在存储位置的指针。如果链表中有头结点，则头指针指向头结点；若链表中没有头结点，则头指针指向链表中第一个数据结点（也叫首元结点）。
链表有头指针，当我们需要使用链表中的数据时，我们可以使用遍历查找等方法，从头指针指向的结点开始，依次搜索，直到找到需要的数据；反之，若没有头指针，则链表中的数据根本无法使用，也就失去了存储数据的意义。
结点：链表中的节点又细分为头结点、首元结点和其它结点：
头结点:位于链表的表头，即链表中第一个结点，其一般不存储任何数据，特殊情况可存储表示链表信息（表的长度等）的数据。
头结点：位于链表的表头，即链表中第一个结点，其一般不存储任何数据，特殊情况可存储表示链表信息（表的长度等）的数据。
头结点的存在，其本身没有任何作用，就是一个空结点，但是在对链表的某些操作中，链表有无头结点，可以直接影响编程实现的难易程度。
@@ -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;
@@ -111,7 +111,7 @@ while (Judgement)
```c
Link p;
Link r = (*head); //临时中间结构指针，在尾插法中始终指向最后一个结点
while (Judgement) //for同理
while (Judgement) //for 同理
{
p = (Link)malloc(sizeof(Node));
p->elem = element;
@@ -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;
}
```
@@ -178,17 +178,17 @@ int GetElem(Link *L, int i; int *e)
![](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++;
@@ -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)
@@ -258,7 +258,7 @@ temp->next=temp->next->next;
实现代码如下：
```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; //返回结点所存数据
@@ -287,7 +287,7 @@ int ListDelete(Link *L, int i, int* e)
实现代码如下：
```c
/*删除L中的第i个数据元素，并用e返回其值，L的长度减一
/*删除 L 中的第 i 个数据元素，并用 e 返回其值，L 的长度减一
（可以用头结点存储链表长度）*/
int ListDelete(Link *L, int i, int* e)
{

16
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 学习
- 你可以通过使用 git `git clone https://github.com/E1PsyCongroo/HDU_C_Assignments.git` 获取任务
- 或者访问 [https://github.com/E1PsyCongroo/HDU_C_Assignments](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>任何文本冒险中最重要的方面：描述性文本。一个好的故事是制作一款好的冒险游戏的要素之一。
# 为什么要用英文？
## 为什么要用英文？
因为中文的编码模式可能会带来奇怪的影响。

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

@@ -2,25 +2,25 @@
::: tip 提醒
# <strong> 驾驭项目, 而不是被项目驾驭</strong>
## <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 就找大神帮你调试，你失去的机会和能力会比你想象的多得多
:::
文字冒险游戏的基本交互很简单
@@ -41,7 +41,7 @@
2. 函数<em>parseAndExecute</em>。
3. 函数<em>main</em>，负责重复调用其他两个函数。
# main.c
## main.c
```c
#include <stdbool.h>
@@ -55,7 +55,7 @@ static bool getInput(void)
printf("\n--> ");
//你可以将他改成你喜欢的内容
return fgets(input, sizeof input, stdin) != NULL;
//fgets用于收集键盘的输入
//fgets 用于收集键盘的输入
}
int main()
@@ -71,7 +71,7 @@ int main()
思考题：static 是什么意思？我为什么要用他？
# <strong>parsexec.h</strong>
## <strong>parsexec.h</strong>
```c
extern bool parseAndExecute(char *input);
@@ -85,7 +85,7 @@ extern bool parseAndExecute(char *input);
在这里用指针是为了传参的时候可以传字符串哦
# <strong>parsexec.c</strong>
## <strong>parsexec.c</strong>
```c
#include <stdbool.h>
@@ -97,11 +97,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,14 +116,14 @@ 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>将导致主循环结束。

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

@@ -2,11 +2,11 @@
某种极其糟糕的编程习惯
# Copy-paste
## Copy-paste
我们很多同学在编程的过程中，可能会写出一大堆重复性很强的代码，在最近看的 pa 中，举了这样一个例子，你不需要看懂只需要感受到就可：
```
```c
if (strcmp(s, "$0") == 0)
return cpu.gpr[0]._64;
else if (strcmp(s, "ra") == 0)
@@ -90,13 +90,13 @@ bx = torch.cat((xs[0], bs[0], xs[1], bs[1], xs[2], bs[2], xs[3], bs[3], xs[4], b
更可怕的是，这种编码模式可能会导致意想不到的 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 +112,13 @@ struct location {
};
```
思考题：我们为什么要用结构体来保存位置？
::: warning 🤔思考题：
我们为什么要用结构体来保存位置？
```
这样子做有什么好处？
```
这样子做有什么好处？
const 又是什么？
const 又是什么？
:::
接下来，我们定义一个位置数组。目前，我们保持它非常简单：只有两个位置。
@@ -135,9 +135,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 +174,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>

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

@@ -100,7 +100,7 @@ for (obj = objs; obj < objs + 5; obj++)
但是，对象通常具有同样有效的其他特征：
- <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 +122,7 @@ player->location->description
是时候把它们放在一起了。我们从对象数组的全新模块开始
# Object.h
## Object.h
```c
typedef struct object {
@@ -143,7 +143,7 @@ extern OBJECT objs[];
#define endOfObjs (objs + 6)
```
# Object.c
## Object.c
```c
#include <stdio.h>
@@ -163,15 +163,15 @@ OBJECT objs[] = {
以下模块将帮助我们找到与指定名词匹配的对象。
# noun.h
## noun.h
```c
extern OBJECT *getVisible(const char *intention, const char *noun);
```
# 指针？函数？希望你已经掌握这是什么了
## 指针？函数？希望你已经掌握这是什么了
# noun.c
## noun.c
```c
#include <stdbool.h>
@@ -229,13 +229,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 +251,7 @@ int listObjectsAtLocation(OBJECT *location)
//排除玩家在玩家的位置这种蠢东西
{
if (count++ == 0)
//我们需要保证找到一个东西之前他不会打印you see
//我们需要保证找到一个东西之前他不会打印 you see
{
printf("You see:\n");
}
@@ -265,14 +265,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>

33
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; |
@@ -35,7 +30,7 @@
如果你可以在不参考下面内容的情况下就写出基本内容会有很大收获的
# <strong>parsexec.c</strong>
## <strong>parsexec.c</strong>
```c
#include <stdbool.h>
@@ -48,7 +43,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 +89,7 @@ bool parseAndExecute(char *input)
新命令由以下模块实现。
# <strong>inventory.h</strong>
## <strong>inventory.h</strong>
```c
extern void executeGet(const char *noun);
@@ -104,7 +99,7 @@ extern void executeGive(const char *noun);
extern void executeInventory(void);
```
# <strong>inventory.c</strong>
## <strong>inventory.c</strong>
```c
#include <stdio.h>
@@ -171,13 +166,13 @@ void executeInventory(void)
从本质上讲，<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>
@@ -231,14 +226,14 @@ void moveObject(OBJECT *obj, OBJECT *to)
命令“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 +313,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>

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://cdn.xyxsw.site/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://cdn.xyxsw.site/CWDhbW6gzogyMFxtd6kcnPBunv2.png)
这是完全相同的文件夹在终端中的外观：
![](https://cdn.xyxsw.site/HZNMbzGZOoQGAhxQ29gcM5V4nNd.png)
请注意，在这两种情况下，黄色框都显示了 PATH，紫色椭圆显示了“labs”文件夹的内容。
#### 终端与 Python 解释器
让我们停下来思考一下终端和 Python 解释器之间的区别。
![](https://cdn.xyxsw.site/HgTfbMhCGodZbzxBNh9crH3cnCe.png)
1. 哪个是终端？
2. 哪个是 Python 解释器？
3. 哪个是我的代码编辑器？
4. 你怎么知道？
A 和 D 都是我的终端。在这里您可以运行 bash 命令，例如 `cd` 和 `ls`。D 是 VS Code 内置的终端。
B 是 Python 解释器。你可以从 >>> 提示中看出这意味着你已经启动了一个 Python 解释器。您还可以判断，因为启动它的命令是可见的：`python3`。该 `python3` 命令启动 Python 解释器。如果您在 Python 解释器中键入 bash 命令，您可能会遇到语法错误！这是一个例子：
![](https://cdn.xyxsw.site/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://cdn.xyxsw.site/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://cdn.xyxsw.site/FkOybDwtnoQeRyxejlwcjhQ2nch.png)
三引号中的行 `"""` 称为<strong>文档字符串（Docstring）</strong>，它描述了函数应该做什么。在 61A 中编写代码时，您应该始终阅读文档字符串！
开头的行 `>>>` 称为<strong>文档测试模块（Doctest）</strong>。回想一下，当使用 Python 解释器时，您在旁边编写 Python 表达式 `>>>`，输出打印在该行下方。文档测试模块通过显示实际的 Python 代码来解释函数的作用。它回答了这个问题：“如果我们输入这段 Python 代码，预期的输出应该是什么？”
在这里，我们圈出了文档字符串和文档测试，以便于查看：
![](https://cdn.xyxsw.site/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
```

26
3.编程思维体系构建/3.6.5.1CS61A食用指南 → 3.编程思维体系构建/3.6.5CS61A食用指南.md
View File

@@ -1,5 +1,27 @@
# 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 上的课后作业只是用来检测你是否掌握了一些最基础的语法，这样的题目是很难培养学生的编程思想的。
@@ -97,10 +119,10 @@ cs61a 绝对是一个挑战，但是我们都希望你学习并且成功，所
## 在学习过程中，你可以能会遇到的问题和解决方法
1. 在 CS61A 的学习过程中，你可能会找不到 61A 的每一个 lab、hw、disc、proj 的答案，这是因为 61A 说不断更新并进行授课的，所以每过一个季度 61A 是会进行换季的，所以为了避免这个问题，请尽早将 61A 主页的每一个答案保存下来。如果你已经遇到了这种问题，那么向已经学习了这门课的学长学姐求助是个不错的选择。
1. 在 CS61A 的学习过程中，你可能会找不到 61A 的每一个 lab、hw、disc、proj 的答案，这是因为 61A 是不断更新并进行授课的，所以每过一个季度 61A 是会进行换季的，所以为了避免这个问题，请尽早将 61A 主页的每一个答案保存下来。如果你已经遇到了这种问题，那么向已经学习了这门课的学长学姐求助是个不错的选择。
2. 如果出现以下情况，这说明你的并没有在测试对象的目录进行测试，最简单解决办法就是在你对应位置的目录进行鼠标右键点击“在终端中打开”进行输入测试。
![图片丢失](static/02.png)
![图片丢失](static/ok02.png)
1. 如果输入了命令后回车没有任何反应，请试试将测试代码的 python3 变为 python 或者 py 进行操作，如果还没有解决请仔细阅读 61A hw 部分的 Using ok，链接一般位于 HW 01 的开头。

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

@@ -1,21 +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：当然存在“错误”的代码的概率很小，你发现它们的概率就更小了
pppps：不只是在 sol 文件中，youtube 上的视频中的代码也可能会出现一些小问题