Initial commit: C++ courseware

2.Course/1.深入浅出程序设计竞赛（基础篇）/1.语言入门/第4章 循环结构程序设计/1.while 循环/1. while 循环/讲义资料/while 循环 讲义.md

@@ -0,0 +1,299 @@
+# C++  `while` 循环 讲义
+
+## 1. 课程引言
+
+### 1.1 问题引入
+
+**任务**：让计算机在屏幕上换行输出 1、2、3、4、5。
+很简单，我们利用**顺序结构**很快就能写出这样的代码：
+
+```cpp
+int main() {
+    cout << 1 << endl;
+    cout << 2 << endl;
+    /* ... 略 ... */
+    cout << 5 << endl;
+    return 0;
+}
+```
+
+“So easy!” 很多同学可能会这么想。但是，请看下一个任务：
+
+**升级版任务**：让计算机换行输出 1 到 100 之间的每一个整数。
+这时候，如果继续使用顺序结构，我们需要把 `cout` 语句复制粘贴 100 遍。如果要求是输出 1 到 10000 呢？这种简单、重复、有规律的工作，人类来做既枯燥又易错。
+
+**核心观点：计算机非常适合且极其擅长做大规模重复的事情！** 为了“解放”我们，我们需要一种新的程序结构——**循环结构**。
+
+---
+
+## 2. 核心思想：什么是 while 循环？
+
+循环，顾名思义，就是让一段代码能够“转着圈”地反复执行。`while` 循环是其中最基础、最直观的一种。
+
+### 2.1 生活中的 while 逻辑
+
+大家对这句话一定不陌生，妈妈在你写作业前说：
+
+**“只要（while）你还没完成所有作业（循环条件），你就必须一直写（循环体）。”**
+
+这句话包含了 `while` 循环的核心要素：
+
+* **循环条件**：还没完成所有作业。
+* **循环体（重复的动作）**：一直写作业。
+
+你每写完一门作业，都会检查一次条件（作业写完了吗？）。如果没有，继续写；直到条件不再成立（作业写完了），循环结束，你可以出去玩了。
+
+### 2.2 if 与 while 的区别
+
+* **`if` 语句（分支）**：像一个岔路口，判断一次条件，满足就做，做完就接着往下走。
+* **`while` 语句（循环）**：在执行完“做某事”之后，会**返回到原点再次判断条件**，形成一个圈。只要条件为真，这个圈就会一直转下去。
+
+### 2.3 while 循环的执行流程(重点)
+
+```cpp
+while (条件表达式) {
+    // 循环体：重复执行的代码
+}
+```
+
+1. **第一步（判断）**：计算 `条件表达式` 的值。
+2. **第二步（决策）**：若为 `true`（真），进入大括号执行代码；若为 `false`（假），直接跳过整个 `while` 结构。
+3. **第三步（执行）**：从上到下执行循环体内的所有语句。
+4. **第四步（返回）**：执行完毕后，**自动返回第一步**，重新判断条件。
+
+---
+
+## 3. 代码实战：编写 while 循环的模板
+
+如何编写一个正确的 `while` 循环：
+
+* **第一步：初始化循环控制变量。** 在循环开始前，设立一个“标记变量”（如计数器）。
+* **第二步：设置循环继续的条件。** 写下让循环“继续下去”的规则。
+* **第三步：更新控制变量。** 在循环体内部改变“标记变量”的值，使其朝着“不满足条件”的方向发展。
+
+### 3.1 解决 输出 1 到 100 的任务
+
+```cpp
+int main() {
+    // 初始化：创建一个循环控制变量 i，让它从 1 开始
+    int i = 1;
+
+    // 条件：只要 i 小于或等于 100，就继续循环
+    while (i <= 100) {
+        // 循环体
+        cout << i << endl; // 重复的任务：打印当前数字
+
+        // 更新：让 i 的值加 1，为下一轮判断做准备
+        i++; 
+    }
+    return 0;
+}
+```
+
+---
+
+## 4. 案例剖析
+
+### 案例一：乘地铁回家
+
+**场景**：小六乘坐地铁回家，世纪大道站上车，梦站下车。他想知道途经了多少站。
+**逻辑梳理**：
+
+* **初始化**：上车，计数器设为 0。
+* **条件**：`while (还没有到梦站)`
+* **循环体**：再坐一站路；计数器 +1。
+* **结束**：下车，输出计数器。
+
+**代码思路**：
+
+```cpp
+上车;
+计数器设置为0;
+while( 没有到梦站 ){
+    再做一站路;
+    计数器+1;
+}
+下车;
+输出计数器;
+```
+
+### 案例二：一尺之棰（数学计算 - 书本 P51 例 4-4）
+
+**题目**：《庄子》曰：“一尺之棰，日取其半，万世不竭”。输入木棍初始长度 $a$，每天锯掉一半（向下取整），求第几天木棍长度会变为 1？
+**分析**：这题很适合 `while` 循环，因为我们**不知道具体要循环多少次**，我们只知道**循环结束的条件**。
+
+```cpp
+int a; 
+cin >> a;
+int day = 1; // 第一步：初始化天数
+
+while (a > 1) {  // 第二步：循环条件，只要长度还大于1就继续砍
+    a = a / 2;   // 第三步：更新变量1（木棍变短）
+    day++;       // 第三步：更新变量2（天数增加）
+}
+
+cout << day << endl; // 循环结束后输出结果
+```
+
+**如果缺了 `a = a / 2;`，木棍永远那么长，永远砍不完；如果缺了 `day++;`，时间就静止了天数永远都是1。**
+
+### **案例三：累加**
+
+#### **3.1 题目描述**
+
+编写一个程序，让用户输入一个正整数 `n`，然后计算 `s = 1 + 2 + 3 + … + n` 的值，并输出最终结果 `s`。
+
+**输入/输出样例：**
+
+*   如果用户输入 `3`，程序应该计算 `1 + 2 + 3`，最终输出 `6`。
+*   如果用户输入 `5`，程序应该计算 `1 + 2 + 3 + 4 + 5`，最终输出 `15`。
+*   如果用户输入 `100`，程序应该计算 `1 + 2 + ... + 100`，最终输出 `5050`。
+
+#### **3.2 思路分析**
+
+这个问题我们无法用一行代码直接得出答案。我们先想一想，如果不用程序，我们的大脑是如何计算 `1 + 2 + 3 + 4 + 5` 的？
+
+过程很可能是这样的：
+1.  先算 `1 + 2`，在脑中记下结果 `3`。
+2.  再用刚才记下的 `3`，去加上 `3`，得到 `6`，并用这个新结果 `6` 更新我们脑中的记忆。
+3.  接着，用记下的 `6`，去加上 `4`，得到 `10`，再次更新记忆。
+4.  最后，用记下的 `10`，去加上 `5`，得到最终答案 `15`。
+
+在这个过程中关键的一点是：我们的大脑里始终**“记着”**一个**“当前的和”**。这个“当前的和”在计算过程中是不断变化的、滚雪球式增长的。
+
+程序也需要这样一个能“记事儿”的角色。在编程中，我们给它起了一个非常形象的名字——**累加器** 。
+
+#### **3.3 累加器的运作流程**
+
+基于上面的分析，我们可以把核心思路拆解成以下几个步骤：
+
+1.  **准备一个“累加器”**：我们需要一个整型变量，专门用来存放累加的和。我们叫它 `sum`。在计算开始前，这个“和”是空的，所以 `sum` 的初始值必须是 **0**。
+2.  **准备一个“计数器”**：我们需要另一个变量，依次代表我们要加的数：1, 2, 3, ..., n。这个我们很熟悉了，就是循环控制变量，我们叫它 `i`。它应该从 `1` 开始。
+3.  **建立循环**：我们需要一个 `while` 循环，来驱动计数器 `i` 从 `1` 稳定地增长到 `n`。循环的条件自然就是 `i <= n`。
+4.  **执行累加动作**：在循环的每一次中，我们都执行最核心的累加动作：`sum = sum + i;`。这行代码的含义是：取出 `sum` 的当前值，和 `i` 的当前值相加，得到的**新和**再存回给 `sum` 变量自己，完成一次自我更新。
+5.  **更新计数器**：在累加动作之后，要让 `i` 的值加1 (`i++;`)，这样下次循环才能累加下一个数。
+
+这个过程就像滚雪球，`sum` 是那个雪球，`i` 是每一捧新雪。循环一次，雪球就裹上一层新雪，变得更大。当 `i` 遍历完所有数，雪球的最终大小就是我们所求的总和。
+
+#### **3.4 代码实现与解读**
+
+```cpp
+int main() {
+    // 让用户输入目标数字 n
+    int n;
+    cin >> n;
+
+    // 初始化
+    int sum = 0; // 累加器 sum 初始值为 0
+    int i = 1;   // 计数器 i 从第一个要加的数 1 开始
+    
+    // 循环条件：只要 i 还没有超过 n，就继续累加
+    while (i <= n) {
+        // 将当前的数 i 累加到 sum 中
+        sum = sum + i;  // 也可以简写为: sum += i;
+        // 让 i 增加 1，准备加下一个数
+        i++;
+    }
+
+    // 循环结束后，sum 中存放的就是 1 到 n 的最终累加结果
+    cout << sum << endl;
+    return 0;
+}
+```
+
+**代码解读：**
+
+*   `int sum = 0;`：如果 `sum` 没有被初始化，它的值将是随机的，最终结果自然也是错误的。而`0` 是加法运算的起点。
+*   `while (i <= n)`：循环的边界条件是 `i <= n`，确保从 `1` 到 `n`（包括 `n` 本身）的每一个数都被加进了 `sum` 中。
+*   `sum = sum + i;`：它读取 `sum` 的旧值，进行计算，然后用新值覆盖旧值。
+*   `cout << sum << ...;`：这行代码位于 `while` 循环的**外部**。因为我们只关心最终的那个总和，而不是中间过程的每一个“当前和”。如果你把这行代码错误地放进了循环体内部，会发生什么呢？可以动手试一试，区别一下“循环内外”到底有什么不同。
+
+---
+
+## 5. 深化理解
+
+### 5.1 死循环
+
+如果我们在输出 1 到 100 的代码中漏掉了 `i++;` 会怎样？
+
+```cpp
+int i = 1;
+while (i <= 100) {
+    cout << "救命！" << endl;
+}
+```
+
+**运行结果**：`i` 的值永远是 1，`1 <= 100` 永远成立。屏幕会被“救命！”一直刷屏，程序永不停止。
+**所以务必确保循环体内部有代码能让循环条件最终变为 `false`！**
+
+### 5.2 C++ 中的“真”与“假”
+
+在 C++ 中，**0 为假（`false`），其他所有非 0 数都为真（`true`）**。
+
+* `if (0)` 或 `while (0)`：条件为假，里面的代码**绝对不会**执行。
+* `while (1)` 或 `while (999)`：条件永远为真，这是一个标准的无限循环（死循环）写法，通常需要配合内部的 `break` 语句来跳出（后续课程学习）。
+
+### 5.3 如何实现循环 $n$ 次？
+
+我们要输出 $n$ 个 `*`，有许多种写法（例如从 $n$ 递减到 1），但最通用、最标准的“约定”是：**从 0 开始，循环 $n$ 次**。
+
+```cpp
+int n;
+cin >> n;
+
+int i = 0;          // 从 0 开始
+while (i < n) {     // 条件为小于 n (注意不是小于等于)
+    cout << "*" << endl;
+    i++;
+}
+```
+
+**为什么推荐这种写法？**
+
+1. **与数组契合**：C++ 中的数组索引是从 0 开始的，习惯 `0` 到 `n-1` 的模式，未来学习数组时可以进行衔接。
+2. **逻辑清晰**：`[0, n)` 是一个左闭右开的区间（从 `0~n-1` ），区间内元素的个数正好是 $n$，不多也不少。
+
+---
+
+## 6. 遍历 + 筛选 模式
+
+掌握了基础循环，我们来看一个解决大量编程问题的核心基础框架：**遍历与筛选**。
+
+**任务**：输入区间起点 $n1$ 和终点 $n2$，打印出这个区间内的**所有偶数**。
+
+用一个生活中的例子想象一下，你现在推着购物车在超市的货架通道里走。你的任务是：**“在第 1 排到第 10 排货架之间，把所有打半价的商品挑出来。”**
+
+在这个场景中：
+
+* **货架通道的范围（第 1 排到第 10 排）**：这就是我们的**区间**（$n1$ 到 $n2$）。
+* **你顺着通道一排排走过，目光扫过每一件商品**：这个动作就叫做【遍历】。不管买不买，你都必须逐一“看”过去，不能漏掉。在代码中，这就是 `while (i <= n2)` 和不断向前看的 `i++`，而你当前正在看的这个物品，就相当于是循环变量 `i`。
+* **你拿起一件商品，看一眼标签上的价格**：这个动作叫做【筛选】。如果是半价，放进购物车（执行操作）；如果不是半价，放回原处（什么都不做）。在代码中，这就是 `if` 判断。
+
+```cpp
+int n1, n2; 
+cin >> n1 >> n2;
+
+int i = n1; // 初始化循环变量 i，因为 n1 是起点，故初始化为 n1 让循环变量从起点开始
+
+while (i <= n2) { // 步骤1：【遍历】只要循环变量 i 没越过终点，就挨个检查
+    
+    if (i % 2 == 0) { // 步骤2：【筛选】判断当前数字是否为偶数
+        cout << i << endl; // 满足条件才处理（输出）
+    }
+    
+    i++; // 步骤3：更新，无论是不是偶数，都要前进到下一个数字
+}
+```
+
+为什么说它是“解决大量编程问题的核心基础框架”？因为掌握了这个模式，你只需要修改 `if` 里面的**鉴定条件**，就能解决成百上千种不同的问题，而外层的 `while` 遍历框架**完全不需要改动**！
+
+如果把刚才代码里的 `if` 条件换一下，我们可以实现：
+
+* **找奇数**：`if (i % 2 != 0)` （除以 2 余数不为 0）
+* **找 5 的倍数**：`if (i % 5 == 0)`
+* **找个位数是 7 的数字**：`if (i % 10 == 7)` （任何正整数对 10 取余，结果就是它的个位数）
+
+### 遍历 + 筛选 模式思路步骤：
+
+1. **遍历**：使用 `while` 循环，借助自增循环变量 `i`，挨个访问想要查找区间内的每一个元素。
+2. **筛选**：在循环体内部，嵌套一个 `if` 条件语句，提取出我们感兴趣的数据（如偶数、素数、最大值等）。

2.Course/1.深入浅出程序设计竞赛（基础篇）/1.语言入门/第4章 循环结构程序设计/1.while 循环/1. while 循环/课后作业/1. while 循环 课后作业(一) 答案.md

@@ -0,0 +1,35 @@
+### C++ while 循环 课后作业(一) - **答案**
+
+#### **一、 填空题**
+
+1.  循环
+2.  循环条件，循环体
+3.  条件表达式，循环体
+4.  初始化循环控制变量，继续，更新控制变量
+5.  死循环
+
+#### **二、 单项选择题**
+
+1.  C    2. B    3. B    4. B    5. B    6. D    7. B    8. C    9. C    10. B
+
+**选择题解析:**
+4.  当 `a` 为 8：
+    第一次循环：`a > 1` (8>1) 成立，`a` 变为 `8/2=4`。
+    第二次循环：`a > 1` (4>1) 成立，`a` 变为 `4/2=2`。
+    第三次循环：`a > 1` (2>1) 成立，`a` 变为 `2/2=1`。
+    此时 `a` 为 1，`a > 1` 不再成立，循环结束。共执行了 3 次。
+6.  循环开始前 `i` 的值为 `10`，循环条件 `i < 10` (10 < 10) 直接为假，所以循环体一次都不会执行。
+8.  选项 C 中，`i` 的值恒为 `1`，循环条件 `i <= 5` 永远成立，但循环体内没有改变 `i` 的值的语句，导致死循环。
+
+#### **三、 判断题**
+
+1.  × (如果条件初始即为假，一次也不执行)
+2.  √
+3.  √ (在 `i` 是循环条件变量的前提下)
+4.  √
+5.  √
+6.  × (如果删除，`day` 将永远是初始值 1)
+7.  √
+8.  × (`while(0)` 条件为假，循环体一次都不会执行)
+9.  × (变量名可自定义，但 `i` 是常用惯例)
+10. × (判断发生在执行之前)

2.Course/1.深入浅出程序设计竞赛（基础篇）/1.语言入门/第4章 循环结构程序设计/1.while 循环/1. while 循环/课后作业/1. while 循环 课后作业(一).md

@@ -0,0 +1,95 @@
+### C++ while 循环 课后作业(一)
+
+姓名: \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
+
+#### **一、 填空题**
+
+1.  当我们需要计算机做大量、重复、有规律的工作时，应该使用 \_\_\_\_\_\_\_\_\_\_ 结构。
+2.  `while` 循环的两个核心要素是 \_\_\_\_\_\_\_\_\_\_ 和 \_\_\_\_\_\_\_\_\_\_。
+3.  `while` 循环的语法结构是 `while` (\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_) {\_\_\_\_\_\_\_\_\_\_\_\_}。
+4.  编写一个正确的 `while` 循环，通常需要三个步骤(填写 **更新循环控制变量、初始化循环控制变量、继续** )：
+    - 循环开始前，______\_\_\_\_\_\_\_\_\_\_______。
+    - 在  `while()` 中设置让循环 _________\_\_\_\_\_\_\_\_\_\____ 的条件表达式。
+    - 在循环体内部 ______\_\_\_\_\_\_\_\_\_\_______，使其最终能让循环条件变为假。
+5.  如果 `while` 循环的条件判断语句一直为真，程序将会陷入 ______\_\_\_\_\_\_\_\_\_\______。
+
+#### **二、 单项选择题**
+
+(     ) 1. 下面哪段描述最适合用 `while` 循环来表达？
+    A. 如果今天下雨，我就带伞出门
+    B. 当我的闹钟响起，我就起床
+    C. 只要我的游戏币还大于0，我就要一直玩游戏
+    D. 我的年龄是18岁
+
+(     ) 2. `if` 语句和 `while` 语句最主要的区别在于？
+    A. `if` 能做判断，`while` 不能
+    B. `while` 语句结束后，可能会回头重新判断条件，而 `if` 不会
+    C. `if` 的执行效率比 `while` 高
+    D. `while` 必须有大括号 `{}`，`if` 可以没有
+
+(     ) 3. 观察下面的代码，它一共会输出多少个 `*`？
+```cpp
+int i = 1;
+while (i <= 5) {
+    cout << "*" << endl;
+    i++;
+}
+```
+
+​	A. 4 个    B. 5 个    C. 6 个    D. 无限个
+
+(     ) 4. 对于 “一尺之棰，日取其半” 的问题，如果木棍初始长度 `a` 为 `8`，`day` 初始为 `1`，下面代码的循环体会被执行几次？
+```cpp
+while (a > 1) {
+    a = a / 2;
+    day++;
+}
+```
+
+​	A. 2 次    B. 3 次    C. 4 次    D. 8 次
+
+(     ) 5. 在 `while (条件表达式)` 结构中，`条件表达式` 的作用是？
+    A. 声明一个新变量
+    B. 决定循环是否继续执行
+    C. 定义循环需要执行的具体操作
+    D. 表示循环体执行结束
+
+(     ) 6. 考虑代码 `int i = 10; while(i < 10) { cout << "Hello" << endl; }`，屏幕上会输出什么？
+    A. 输出 1 个 "Hello"
+    B. 输出 9 个 "Hello"
+    C. 输出无限个 "Hello"
+    D. 什么也不输出
+
+(     ) 7. 要让 `while` 循环最终能停下来，最关键的操作是？
+    A. 在循环前初始化变量
+    B. 在循环体内有让循环条件最终变为 `false` 的操作
+    C. 在循环体里有输出语句
+    D. 把循环条件写得足够简单
+
+(     ) 8. 以下哪个 `while` 循环会导致死循环？
+    A. `int i=0; while(i<5){ i++; }`
+    B. `int i=5; while(i>0){ i--; }`
+    C. `int i=1; while(i<=5){ cout << i; }`
+    D. `int i=5; while(i>5){ i++; }`
+
+(     ) 9. 在 `while` 循环的执行流程中，第一步是？
+    A. 执行循环体内的代码
+    B. 更新循环控制变量
+    C. 计算条件表达式的值
+    D. 返回程序开头
+
+(     ) 10. 对于讲义中“乘地铁回家”的案例，我们需要把“再坐一站路”这个动作放在 `while` 循环里，体现了循环的什么特点？
+    A. 必须有初始值	B. 重复执行的动作	C. 循环必须有出口	D. 循环的判断条件
+
+#### **三、 判断题 (对的打“√”，错的打“×”)**
+
+(     ) 1. `while` 循环的循环体代码至少会被执行一次。
+(     ) 2. `while (i <= 100)` 和 `while (100 >= i)` 这两个循环条件在逻辑上是等价的。
+(     ) 3. 如果缺少类似于 `i++` 这样的用来更新循环变量的语句，`while` 循环肯定会变成死循环。
+(     ) 4. `if` 语句是选择一个分支执行，而 `while` 语句是只要条件满足就一直重复执行。
+(     ) 5. 计算机非常擅长处理简单、重复、有规律的工作。
+(     ) 6. 在“一尺之棰”问题中，`day++` 这个语句即使被删除，程序也能计算出正确的天数。
+(     ) 7. `while` 循环的大括号 `{}` 内的所有语句，在一次循环中都会从上到下被执行。
+(     ) 8. `while(1)` 和 `while(0)` 都会导致死循环。
+(     ) 9. 循环控制变量只能使用 `i` 这个名字。
+(     ) 10. `while` 循环结构中，循环条件的判断发生在循环体执行之后。

2.Course/1.深入浅出程序设计竞赛（基础篇）/1.语言入门/第4章 循环结构程序设计/1.while 循环/1. while 循环/课后作业/2. while 循环 课后作业(二) 答案.md

@@ -0,0 +1,33 @@
+### C++ while 循环 课后作业(二) - **答案**
+
+#### **一、 填空题**
+
+1.  累加器，0
+2.  `sum += i;`
+3.  0，非 0
+4.  遍历与筛选
+5.  `i < n`
+
+#### **二、 单项选择题**
+
+1.  C    2. C    3. D    4. C    5. B    6. B    7. C    8. C    9. D    10. B
+
+**选择题解析:**
+1.  `sum` 的变化过程: `0+1=1` -> `1+2=3` -> `3+3=6` -> `6+4=10`。
+2.  `cout` 在循环体内，每次 `sum` 的值更新后都会立即被输出。
+6.  计算 `2 + 4 + 6 + 8 + 10`，结果是 `30`。
+8.  `count` 变化过程：`10` -> `9` -> `8` -> `7` -> `6` -> `5`。当 `count` 为 `5` 时，`5 > 5` 为假，循环停止。
+9.  当 `i` 是一个奇数时（例如 `i=1`），`if` 条件不满足，循环体内的 `i++` 无法被执行，`i` 的值永远停留在 `1`，导致死循环。
+
+#### **三、 判断题**
+
+1.  √
+2.  √ (未初始化的变量值是随机的，结果自然是无意义的)
+3.  × (应该用逻辑与 `&&`，`||` 是或者的意思)
+4.  √
+5.  √
+6.  √
+7.  × (`while`尤其适用于不知道具体次数，只知道结束条件的场景)
+8.  × (两者在功能和现代编译器的优化下没有性能差异)
+9.  × (是为了逻辑正确性，避免使用一个随机的初始值进行计算)
+10. √ 

2.Course/1.深入浅出程序设计竞赛（基础篇）/1.语言入门/第4章 循环结构程序设计/1.while 循环/1. while 循环/课后作业/2. while 循环 课后作业(二).md

@@ -0,0 +1,99 @@
+### C++ while 循环 课后作业(二)
+
+姓名: \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
+
+#### **一、 填空题**
+
+1.  在编程中，我们用来存放滚雪球式增长的和的变量，通常被称为 \_\_\_\_\_\_\_\_\_\_\_\_\_，它的初始值在进行加法运算时通常设为 \_\_\_\_\_\_\_\_\_\_。
+2.  `sum = sum + i;` 这行累加代码可以简写为 \_\_\_\_\_\_\_\_\_\_\_\_\_\_。
+3.  在 C++ 中，数值 \_\_\_\_\_\_\_ 被视为“假”（false），而所有 \_\_\_\_\_\_\_ 的数值都被视为“真”（true）。
+4.  使用 `while` 循环挨个访问某个区间内的每一个元素，并在循环内部用 `if` 语句挑出符合特定条件的元素，这种编程模式被称为\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_。
+5.  想要实现“循环n次”的效果，那么当循环控制变量 `i` 从 `0` 开始时，`while()`中的循环条件则应该写为\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_。
+
+#### **二、 单项选择题**
+
+(     ) 1. 分析以下代码，最终输出的结果是什么？
+```cpp
+int sum = 0, i = 1;
+while (i <= 4) {
+    sum = sum + i;
+    i++;
+}
+cout << sum << endl;
+```
+​	A. 4	B. 5	C. 10	D. 15
+
+(     ) 2. 如果将上一题中的 `cout << sum << endl;` 语句放到 `while` 循环体的内部，程序的输出会变成？
+    A. 只输出 10	B. 什么都不输出	C. 依次换行输出 1, 3, 6, 10	 D. 程序会报错
+
+(     ) 3. 要打印出 1 到 100 之间所有“个位数是7”的数字，循环体内部的 `if` 判断条件应该写成？
+    A. `if (i == 7)`	B. `if (i % 7 == 0)`	C. `if (i / 10 == 7)`	D. `if (i % 10 == 7)`
+
+(     ) 4. 运行 `int n=5; int i=0; while(i<n){ cout << "*"; i++; }` 这段代码，会输出多少个 `*`？
+	A. 0 个	B. 4 个	C. 5 个	D. 6 个
+
+(     ) 5. 关于 `while(-1)` 这个循环条件，下列说法正确的是？
+    A. 条件为假，循环一次都不会执行
+    B. 条件为真，会形成死循环
+    C. 程序会因为负数而出错
+    D. 循环只会执行一次
+
+(     ) 6. 以下代码执行后最终 `sum` 的值是？
+```cpp
+int sum = 0;
+int i = 1;
+while (i <= 10) {
+    if (i % 2 == 0) { sum = sum + i; }
+    i++;
+}
+```
+​	A. 55    B. 30    C. 25    D. 20
+
+(     ) 7. 在“遍历+筛选”模式中，`if` 语句扮演的角色是？
+    A. 确保循环能够停止		B. 驱动循环变量从起点到达终点
+    C. 定义筛选规则，挑出所需要的数据	D. 初始化累加器
+
+(     ) 8. 观察下面的代码，当循环结束后 `count` 的值是多少？
+```cpp
+int count = 10;
+while (count > 5) { count--; }
+```
+​	A. 10    B. 6    C. 5    D. 4
+
+(     ) 9. 考虑以下代码，它的问题是什么？
+```cpp
+int i = 1;
+while (i <= 100) {
+    if (i % 2 == 0) {
+        cout << i << endl;
+        i++;
+    }
+}
+```
+​	A. 这是一个死循环	 	   B. 它会漏掉一些偶数	
+​	C. 它只能打印出奇数		D. 它在遇到奇数时会陷入死循环
+
+(     ) 10. 要计算 1 到 100 以内所有 3 的倍数之和，下面代码片段的 `???` 处应填写？
+```cpp
+int sum = 0;
+int i = 1;
+while (i <= 100) {
+    if (???) {  sum += i;  }
+    i++;
+}
+```
+​	A. `i / 3 == 0`	B. `i % 3 == 0`
+​	C. `i % 3 != 0`	D. `i * 3 == 0`
+
+#### **三、 判断题 (对的打“√”，错的打“×”)**
+
+(     ) 1. `while(x)` 和 `while(x != 0)` 这两个循环条件是等价的。
+(     ) 2. 在累加求和的程序中，如果累加器变量 `sum` 没有被初始化为 0，程序最终的计算结果一定是错误的。
+(     ) 3. 要筛选出 1 到 100 之间能同时被 2 和 3 整除的数，`if` 条件应写为 `if (i % 2 == 0 || i % 3 == 0)`。
+(     ) 4. 执行代码 `int i = 0; while(i < 5) { cout << i; i++; }` 会在屏幕上打印出 `01234`。
+(     ) 5. `while(1)` 会创建一个无限循环，是因为 C++ 认为 `1` 是一个“真”值。
+(     ) 6. 在“遍历+筛选”模式中，`i++` 必须放在 `if` 语句的外面（但在循环体内），这样才能保证无论当前数字是否被选中，都能继续检查下一个数字。
+(     ) 7. `while` 循环只适用于我们提前知道循环次数的场景。
+(     ) 8. `sum += i;` 的执行效率比 `sum = sum + i;` 更高。
+(     ) 9. 初始化累加器 `sum` 为 0 的主要目的是为了让代码能够通过编译。
+(     ) 10. `i = 0; while(i < n)` 和 `i = 1; while(i <= n)` 都能实现循环 n 次的效果。

2.Course/1.深入浅出程序设计竞赛（基础篇）/1.语言入门/第4章 循环结构程序设计/1.while 循环/1. while 循环/课后作业/3. do-while 循环 课后作业 答案.md

@@ -0,0 +1,31 @@
+### C++ do-while 循环 课后作业 - **答案**
+
+#### **一、 填空题**
+
+1.  执行，判断
+2.  1 (或一)
+3.  分号 (`;`)
+4.  `do-while`
+5.  种子，头文件
+
+#### **二、 单项选择题**
+
+1.  C    2. B    3. C    4. C    5. B    6. B    7. C    8. B    9. D    10. D
+
+**选择题解析:**
+2.  `i` 初始值为10。先执行循环体，输出1个"Hello"，然后`i`变为11。此时判断条件`i < 10` (11 < 10) 为假，循环结束。
+6.  `n` 初始值为5。先执行循环体，输出 "5 "，然后`n`变为4。此时判断条件`n > 5` (4 > 5) 为假，循环结束。
+7.  `srand` 只需要在程序开始时调用一次，为整个随机数序列播下种子。如果放在循环内部，可能会因为 `time(0)` 在一秒内返回值相同而导致短时间内生成的随机数都一样。
+
+#### **三、 判断题**
+
+1.  √
+2.  × (当 `while` 循环条件初始为假，一次都不执行，`do-while` 无法模拟这种情况)
+3.  × (范围是 `[0, 99]`)
+4.  √
+5.  √
+6.  ×
+7.  √
+8.  √
+9.  √
+10. √

2.Course/1.深入浅出程序设计竞赛（基础篇）/1.语言入门/第4章 循环结构程序设计/1.while 循环/1. while 循环/课后作业/3. do-while 循环 课后作业.md

@@ -0,0 +1,89 @@
+### C++ do-while 循环 课后作业
+
+姓名: \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
+
+#### **一、 填空题**
+
+1.  `do-while` 循环的核心思想是“先 \_\_\_\_\_\_\_\_\_\_\_，后 \_\_\_\_\_\_\_\_\_\_\_”。
+2.  与 `while` 循环不同，`do-while` 循环的循环体代码保证至少会被执行 ______ 次。
+3.  `do-while` 循环的语法结构在末尾的 `while(条件)` 之后必须有一个 ________。
+4.  在猜数字游戏中，因为玩家无论如何都需要先输入一次猜测的数字，所以使用 \_\_\_\_\_\_\_\_\_\_\_ 循环比 `while` 循环更合适。
+5.  在 C++ 中，为了生成每次运行程序时都不同的随机数，我们需要使用 `time(0)` 函数来获取当前的\_\_\_\_\_\_\_\_\_\_\_，并通过`srand()`函数设置随机数 \_\_\_\_\_\_\_\_\_\_\_，为了使用这两个函数工具，需要包含 `<ctime>` 和 `<cstdlib>` 两个头文件。
+
+#### **二、 单项选择题**
+
+(     ) 1. 关于 `do-while` 和 `while` 循环，下列说法正确的是？
+    A. 两者没有任何区别
+    B. `while` 循环的循环体至少执行一次
+    C. `do-while` 循环的循环体至少执行一次
+    D. `do-while` 循环先判断条件再执行
+
+(     ) 2. 观察下面的代码，它会输出多少个 "Hello"？
+```cpp
+int i = 10;
+do {
+    cout << "Hello" << endl;
+    i++;
+} while (i < 10);
+```
+A. 0 个    B. 1 个    C. 10 个    D. 无限个
+
+(     ) 3. 哪个场景最适合使用 `do-while` 循环？
+    A. 遍历一个已知长度的数组
+    B. 计算 1 到 100 的累加和
+    C. 程序启动后，先显示菜单让用户选择，如果选择无效则重新显示
+    D. 从 100 倒数到 1
+
+(     ) 4. 要生成一个 `[1, 50]` 范围内的随机整数，正确的表达式是？
+    A. `rand() % 49`			B. `rand() % 50`
+    C. `rand() % 50 + 1`		D. `rand() % 51`
+
+(     ) 5. 在猜数字游戏中，`do-while` 循环的循环条件通常是？
+    A. `guess == ans`		B. `guess != ans`
+    C. `guess > ans`		  D. `guess < ans`
+
+(     ) 6. 分析以下代码，最终输出结果是什么？
+```cpp
+int n = 5;
+do {
+    cout << n << " ";
+    n--;
+} while (n > 5);
+```
+A. 什么都不输出	B. 5	C. 5 4 3 2 1	D. 导致死循环
+
+(     ) 7. 关于 `srand(time(0));` 这行代码，下列描述错误的是？
+	A. 它的作用是初始化随机数种子	B. `time(0)` 提供一个不断变化的值
+	C. 它应该被放在 `do-while` 循环的内部，以保证每次循环都足够随机
+	D. 它能确保程序每次运行时，生成的随机数序列都不同
+
+(     ) 8. `do-while` 循环的条件判断发生在哪个时间点？
+    A. 每次循环体执行之前
+    B. 每次循环体执行之后
+    C. 仅在整个循环开始前判断一次
+    D. 仅在循环体执行到一半时
+
+(     ) 9. 以下哪个 `do-while` 的语法是正确的？
+    A. `do while(x<5) { ... }`
+    B. `do { ... } while x<5;`
+    C. `do { ... } while(x<5)`
+    D. `do { ... } while(x<5);`
+
+(     ) 10. 如果有一个程序需要反复验证用户输入的密码，直到输入正确为止，最合适的循环结构是？
+    A. `if-else` 结构
+    B. `while` 循环，并在循环外先获取一次输入
+    C. `do-while` 循环
+    D. 选项 B 和 C 都可以，但 C 更简洁优雅
+
+#### **三、 判断题 (对的打“√”，错的打“×”)**
+
+(     ) 1. `do-while` 循环的循环条件即使初始就为 `false`，循环体也依然会执行一次。
+(     ) 2. 在任何情况下，一个 `while` 循环都可以被等价地改写为 `do-while` 循环。
+(     ) 3. `rand() % 100` 生成的随机数范围是 `[0, 100]`，即包含0和100。
+(     ) 4. 在 `do { ... } while(条件表达式);` 结构中，在执行完循环体后，`条件表达式` 变为 `false` 时循环终止。
+(     ) 5. 因为 `do-while` 循环体至少执行一次，所以它永远不会导致“一次都不执行”的情况。
+(     ) 6. `srand(time(0));` 这行代码的作用是生成一个随机数。
+(     ) 7. `do-while` 循环适合于需要先获取用户输入再进行判断的逻辑。
+(     ) 8. 如果忘记了 `do-while` 语句末尾的分号，程序将无法通过编译。
+(     ) 9. 在一个 `do-while` 循环体内，必须有能够影响到循环条件的语句，否则可能导致死循环。
+(     ) 10. `while(guess != ans)` 和 `while(!(guess == ans))` 这两个循环条件是完全等价的。