18.3 do-while和while循环练习题集

“小朋友们，为了帮助你们更好地掌握do-while和while循环，让我们来做一些练习题，”我说，”这些题目会测试你们对循环结构的理解和应用能力。”

选择题

第1题：下面C++代码执行后输出是（ ）。

int sum = 0;
int i = 1;
do {
    sum += i;
    i++;
} while(i <= 5);
cout << sum;

A. 10 B. 15 C. 20 D. 25

答案：B

解析： 这个循环计算1+2+3+4+5的和。do-while循环先执行循环体，再判断条件，所以会执行5次循环，计算出1到5的和，即15。

第2题：下面C++代码执行后输出的是（ ）。

int count = 0;
int i = 10;
while(i > 0) {
    i -= 2;
    count++;
}
cout << count;

A. 5 B. 6 C. 10 D. 4

答案：A

解析： 这个循环从i=10开始，每次减2，直到i<=0。i的变化过程为：10→8→6→4→2→0，共执行5次循环，所以count=5。

第3题：下面C++代码执行后，result的值是（ ）。

int result = 0;
int n = 123;
while(n > 0) {
    result = result * 10 + n % 10;
    n /= 10;
}

A. 123 B. 321 C. 0 D. 3

答案：B

解析： 这个循环实现了整数的反转。n=123时，运算过程如下：

• 第一次循环：result = 0*10 + 123%10 = 3，n = 123/10 = 12
• 第二次循环：result = 3*10 + 12%10 = 32，n = 12/10 = 1
• 第三次循环：result = 32*10 + 1%10 = 321，n = 1/10 = 0 循环结束，result = 321。

第4题：下面C++代码执行后输出的是（ ）。

int i = 5;
do {
    cout << i << " ";
    i--;
} while(i > 0);

A. 5 4 3 2 1 B. 5 4 3 2 1 0 C. 4 3 2 1 0 D. 4 3 2 1

答案：A

解析： 这个循环从i=5开始，每次输出i并将i减1，直到i<=0。在循环条件判断前，先执行循环体，所以会先输出当前的i值。i的值变化为：5→4→3→2→1→0，但当i=0时，条件i>0不满足，循环结束。因此输出为”5 4 3 2 1″。

第5题：下面C++代码执行后输出的是（ ）。

int sum = 0;
int i = 0;
while(++i <= 5) {
    sum += i;
}
cout << sum;

A. 10 B. 15 C. 20 D. 25

答案：B

解析： 这个循环使用++i作为条件，意味着i先增加1再与5比较。i的变化过程为：0→1→2→3→4→5→6，循环执行时i的值分别为1,2,3,4,5，当i=6时条件不满足，循环结束。因此sum = 1+2+3+4+5 = 15。

第6题：下面C++代码执行后输出的是（ ）。

int i = 0;
int sum = 0;
do {
    i++;
    if(i % 2 == 0)
        continue;
    sum += i;
} while(i < 10);
cout << sum;

A. 25 B. 30 C. 55 D. 15

答案：A

解析： 这个循环从i=0开始，每次将i加1，然后判断i是否为偶数，如果是则跳过此次迭代的剩余部分。如果i是奇数，则将i加到sum上。循环执行10次，i的值依次为1,2,3,…,10，其中奇数是1,3,5,7,9，所以sum = 1+3+5+7+9 = 25。

第7题：下面C++代码执行后，count的值是（ ）。

int count = 0;
int i = 1;
while(i <= 100) {
    if(i % 5 == 0 && i % 7 != 0)
        count++;
    i++;
}

A. 14 B. 20 C. 16 D. 15

答案：B

解析： 这个循环统计1到100中能被5整除但不能被7整除的数的个数。这些数是5的倍数但不是7的倍数，即5,10,15,…,95,100中排除35,70。共有20个5的倍数，其中2个是7的倍数(35和70)，所以符合条件的数有20-2=18个。

第8题：下面C++代码执行后，sum的值是（ ）。

int x = 10, sum = 0;
while(x > 0) {
    sum += x--;
}

A. 55 B. 45 C. 65 D. 54

答案：A

解析： 这个循环计算10+9+8+7+6+5+4+3+2+1的和。x–表示先使用x的值，然后将x减1。所以sum = 10+9+8+7+6+5+4+3+2+1 = 55。

第9题：下面C++代码执行后输出的是（ ）。

int i = 0, j = 0;
do {
    i++;
    j += i;
} while(i < 5);
cout << j;

A. 10 B. 15 C. 6 D. 5

答案：B

解析： 这个循环从i=0开始，每次将i加1并加到j上，直到i>=5。i的变化过程为：0→1→2→3→4→5，循环执行时j的计算过程为：

• j = 0 + 1 = 1
• j = 1 + 2 = 3
• j = 3 + 3 = 6
• j = 6 + 4 = 10
• j = 10 + 5 = 15 所以j = 15。

第10题：下面C++代码执行后输出的是（ ）。

int i = 10;
while(i >= 0) {
    if(i % 3 == 0)
        break;
    i--;
}
cout << i;

A. 0 B. 3 C. 9 D. 10

答案：C

解析： 这个循环从i=10开始递减，当i能被3整除时退出循环。i的变化过程为：10→9→停止，因为9能被3整除(9%3=0)，触发break语句退出循环。所以输出i=9。

判断题

第1题：do-while循环的循环体至少执行一次。（ ）

答案：正确

解析： do-while循环的特点是先执行循环体，再判断条件。这意味着无论条件是否满足，循环体至少会执行一次。

第2题：在while循环中使用break语句可以立即终止循环。（ ）

答案：正确

解析： break语句可以用来立即终止循环，无论循环条件是否满足。当程序执行到break语句时，循环立即结束，程序继续执行循环后的语句。

第3题：continue语句会终止整个循环。（ ）

答案：错误

解析： continue语句不会终止整个循环，它只会跳过当前迭代的剩余部分，直接进入下一次迭代。与break不同，continue并不退出循环。

第4题：while(1)表示一个无限循环。（ ）

答案：正确

解析： while(1)创建了一个无限循环，因为条件1始终为真。这种循环通常需要通过break语句或return语句从内部退出，否则会一直执行下去。

第5题：do-while循环和while循环可以相互转换。（ ）

答案：正确

解析： 虽然do-while循环至少执行一次，而while循环可能一次也不执行，但通过适当的条件设置和代码调整，这两种循环结构是可以相互转换的。

第6题：在while循环中，如果条件一开始就不满足，循环体一次也不会执行。（ ）

答案：正确

解析： while循环在执行循环体之前先判断条件。如果条件一开始就不满足，则直接跳过循环体，循环一次也不会执行。

第7题：在do-while循环中，循环条件需要在每次迭代结束时检查。（ ）

答案：正确

解析： do-while循环的特点是先执行循环体，然后再检查循环条件。这意味着条件是在每次迭代结束时检查的，而不是在开始时。

第8题：while(0)循环一次也不会执行。（ ）

答案：正确

解析： while(0)中的条件为假，因此循环体一次也不会执行。while循环会先检查条件，只有条件为真时才执行循环体。

第9题：在do-while循环中使用continue语句会跳过当前迭代并立即检查循环条件。（ ）

答案：正确

解析： 在do-while循环中，continue语句会跳过当前迭代的剩余部分，并立即跳转到循环底部的条件检查。这与while循环中的continue行为类似。

第10题：循环可以没有退出条件。（ ）

答案：正确

解析： 循环可以没有明确的退出条件，例如while(1)或do-while(1)，这种情况下创建了无限循环。但在实际编程中，通常会通过break语句或其他方式提供退出机制，否则程序将永远循环下去。

编程题

编程题1：计算阶乘

题目描述：输入一个正整数n，计算n的阶乘(n!)。n!的定义为n×(n-1)×(n-2)×…×2×1。

样例输入：

5

样例输出：

120

参考代码：

#include <iostream>
using namespace std;

int main() {
    int n;
    long long factorial = 1;  // 使用long long避免整数溢出
    
    cin >> n;
    
    int i = 1;
    while(i <= n) {
        factorial *= i;  // 累乘
        i++;
    }
    
    cout << factorial;
    
    return 0;
}

思考：

1. 这个实验计算n的阶乘，需要从1到n连续相乘
2. 使用while循环逐个乘以1到n的每个数
3. 使用long long类型避免结果溢出，因为阶乘增长非常快
4. 也可以使用do-while循环实现，尤其是当n>=1时

编程题2：求数字的位数

题目描述：输入一个正整数n，求n的位数。例如，n=12345有5位。

样例输入：

12345

样例输出：

5

参考代码：

#include <iostream>
using namespace std;

int main() {
    int n;
    int count = 0;
    
    cin >> n;
    
    do {
        n /= 10;  // 去掉最低位
        count++;  // 计数加1
    } while(n > 0);
    
    cout << count;
    
    return 0;
}

思考：

1. 这个实验计算一个整数的位数
2. 使用do-while循环确保至少计算一次，适用于所有正整数
3. 每次将n除以10，相当于去掉最低位，同时计数加1
4. 当n变为0时，表示所有位数都已经处理完毕

编程题3：计算最大公约数

题目描述：输入两个正整数a和b，计算它们的最大公约数。

样例输入：

12 18

样例输出：

6

参考代码：

#include <iostream>
using namespace std;

int main() {
    int a, b;
    
    cin >> a >> b;
    
    // 确保a >= b
    if(a < b) {
        int temp = a;
        a = b;
        b = temp;
    }
    
    // 使用辗转相除法(欧几里得算法)
    while(b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    
    cout << a;  // 此时a中存储的是最大公约数
    
    return 0;
}

思考：

1. 这个实验使用辗转相除法(欧几里得算法)计算最大公约数
2. 首先确保a>=b，便于后续计算
3. 使用while循环不断更新a和b，直到b变为0
4. 算法的思想是：如果b能整除a，则b是最大公约数；否则，a和b的最大公约数等于b和a%b的最大公约数
5. 这是一个经典的数论算法，在密码学和其他领域有广泛应用

编程题4：翻转整数

题目描述：输入一个整数n，将n翻转后输出。例如，输入12345，输出54321。

样例输入：

12345

样例输出：

54321

参考代码：

#include <iostream>
using namespace std;

int main() {
    int n;
    int reversed = 0;
    
    cin >> n;
    
    while(n > 0) {
        int digit = n % 10;            // 获取最后一位
        reversed = reversed * 10 + digit;  // 将这一位加到翻转数的末尾
        n /= 10;                       // 去掉最后一位
    }
    
    cout << reversed;
    
    return 0;
}

思考：

1. 这个实验实现了整数的翻转
2. 使用while循环，每次从原数中提取最后一位，然后加到翻转数的末尾
3. 通过n%10获取最后一位，n/=10去掉最后一位
4. 翻转数的构建过程：每次将当前结果乘以10(向左移一位)，然后加上新的最低位
5. 这种数位处理方法在很多数字处理问题中都有应用

编程题5：判断素数

题目描述：输入一个正整数n，判断它是否是素数(除了1和它本身外，没有其他约数的数)。

样例输入：

17

样例输出：

Yes

参考代码：

#include <iostream>
using namespace std;

int main() {
    int n;
    bool isPrime = true;
    
    cin >> n;
    
    // 1不是素数
    if(n <= 1) {
        isPrime = false;
    } else {
        int i = 2;
        while(i * i <= n) {  // 只需检查到sqrt(n)
            if(n % i == 0) {
                isPrime = false;
                break;  // 找到一个因数就可以确定不是素数
            }
            i++;
        }
    }
    
    if(isPrime)
        cout << "Yes";
    else
        cout << "No";
    
    return 0;
}

思考：

1. 这个实验判断一个数是否是素数
2. 使用while循环从2检查到sqrt(n)，如果n能被任何数整除，则不是素数
3. 优化点：只需检查到sqrt(n)，因为若n有大于sqrt(n)的因数，必有小于sqrt(n)的对应因数
4. 使用break语句在找到第一个因数时立即退出循环，提高效率
5. 特殊情况处理：1不是素数，需要单独判断