目录
16. 循环：数列求和（1+1/4+1/7+1/10...+1/(3*n-2) ）
17. 循环：数列求和（1 ＋ 1/2 ＋ 1/3 ＋ …… ＋ 1/n）
01. 循环：最大数
【题目】写一个程序，可以输入一批正数，输入 0 时结束循环，并且输出最大的正数。
【样例】
- 输入：39 28 5 63 18 27 0
- 输出：63
【测试】
- 输入：153 26 963 28 75 90 156 0
- 输出：963
输入为 39 28 5 63 18 27 0，表示输入一批正数，输入 0 时结束循环。
- 最大的正数为 63
所以输出为：63
输入为 153 26 963 28 75 90 156 0，表示输入一批正数，输入 0 时结束循环。
- 最大的正数为 963
所以输出为：963
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int i, max = 0; // 声明变量 i 和 max ，并初始化 max 为 0
cin >> i; // 从用户输入获取一个整数，存储到变量 i 中
while (i != 0) // 当 i 不等于 0 时执行循环
{
if (i > max) // 如果 i 大于 max
max = i; // 将 i 的值赋给 max
cin >> i; // 从用户输入获取下一个整数，存储到变量 i 中
}
cout << max << endl; // 输出 max 的值，并换行
return 0; // 返回值 0，表示程序正常结束
}
02. 循环：奇偶数（计算：平方和、立方和）
【题目】求 N （ <=100 ）个数中奇数的平方和与偶数的立方和。
- 注意：输入格式为，第一个数为 N ，后面接着 N 个数，输出的平方和与立方和以空格隔开。
【样例】
- 输入：3 5 8 9
- 输出：106 512
【测试】
- 输入：5 5 8 9 10 0
- 输出：106 1512
输入为 3 5 8 9，表示 N 为 3，后面的三个数分别为 5、8、9。
- 奇数的平方和 = 5^2 + 9^2 = 25 + 81 = 106
- 偶数的立方和 = 8^3 = 512
所以输出为：106 512
输入为 5 5 8 9 10 0，表示 N 为 5，后面的五个数分别为 5、8、9、10、0
- 奇数的平方和 = 5^2 + 9^2 = 25 + 81 = 106
- 偶数的立方和 = 8^3 + 10^3 = 512 + 1000 = 1512
所以输出为：106 1512
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int i, N, n, a = 0, b = 0; // 声明变量 i、N、n、a 和 b 为整数，并初始化 a 和 b 为 0
cin >> N; // 从用户输入获取一个整数，存储到变量 N 中
for (i = 1; i <= N; i++) // 循环遍历 i 从 1 到 N
{
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
if (n % 2 == 0) // 判断 n 是否为偶数
a += n * n * n; // 如果是偶数，计算 n 的立方并累加到 a 中
else
b += n * n; // 如果是奇数，计算 n 的平方并累加到 b 中
}
cout << b << " " << a << endl; // 输出 b 和 a 的值，并换行
return 0; // 返回值 0，表示程序正常结束
}
03. 循环：素数（是否素数）
【题目】输入正数 n ，判断 n 是否为素数；若为素数则输出 1 ，否则输出 0 。
- 提示：素数是指只可以被 1 和其本身整除的正数（ 1 除外）
【样例 ①】
- 输入：10
- 输出：0
【样例 ②】
- 输入：7
- 输出：1
【测试】
- 输入：9
- 输出：0
素数是只能被 1 和其本身整除的正整数，除了 1。
- 因为 10 可以被 2 和 5 整除，不符合素数的定义。
所以，输入 10 时，输出为 0，表示 10 不是素数。
素数是只能被 1 和其本身整除的正整数，除了 1。
- 因为 7 只能被 1 和 7 整除，符合素数的定义。
所以，输入 7 时，输出为 1，表示 7 是素数。
素数是只能被 1 和其本身整除的正整数，除了 1。
- 因为 9 可以被 3 整除，不符合素数的定义。
所以，输入 9 时，输出为 0，表示 9 不是素数。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, i, d; // 声明变量 n, i, d
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
for (i = 2; i < n; i++) // 从 2 到 n-1 遍历
{
d = n % i; // 计算 n 除以 i 的余数
if (n % i == 0) // 如果 n 能被 i 整除
break; // 结束循环
}
if (n == i) // 如果 n 等于 i，即没有找到能整除 n 的数
cout << "1" << endl; // 输出 1，并换行
else
cout << "0" << endl; // 输出 0，并换行
return 0; // 返回值 0，表示程序正常结束
}
04. 循环：素数（区间内素数及个数）
【题目】输入一个正整数 n ，输出 [2,n] 之间所有的素数及素数个数。
【样例】
- 输入：10
- 输出：
2 3 5 7
4
输入 10 时，在 [2, 10] 之间的素数有：2、3、5、7，共有 4 个素数。
// 示例代码一
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, i, j, s; // 声明变量 n、i、j 和 s 为整数
s = 0; // 初始化变量 s 为 0
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
for (i = 2; i <= n; i++) // 循环遍历 i 从 2 到 n
{
for (j = 2; j < i; j++) // 循环遍历 j 从 2 到 i
{
if (i % j == 0) // 如果 i 能被 j 整除
{
break; // 跳出内部循环
}
}
if (j == i) // 如果内部循环完整执行到末尾（即 j 等于 i），表示 i 是质数
{
s++; // 将 s 的值增加 1
cout << i << " "; // 输出 i 的值后面加一个空格
}
}
cout << endl << s; // 输出换行符和 s 的值
return 0; // 返回值 0，表示程序正常结束
}
// 示例代码二
#include <iostream> // 包含输入输出流库
using namespace std;
// 判断一个数是否为素数
bool isPrime(int num) {
if (num < 2) { // 小于 2 的数不是素数
return false;
}
for (int i = 2; i * i <= num; ++i) { // 从 2 遍历到 sqrt(num)，判断能否整除
if (num % i == 0) { // 如果能被 i 整除，则不是素数
return false;
}
}
return true; // 否则是素数
}
int main() {
int n;
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
int count = 0; // 统计素数的个数
for (int i = 2; i <= n; ++i) { // 从 2 遍历到 n
if (isPrime(i)) { // 判断 i 是否为素数
cout << i << " "; // 输出素数 i
count++; // 素数个数加 1
}
}
cout << endl << count << endl; // 输出素数个数，并换行
return 0; // 返回 0，表示程序正常结束
}
05. 循环：最大公约数
【题目】键盘输入两个正整数 m ， n ，求出他们的最大公约数。
【样例】
- 输入：20 15
- 输出：5
【测试】
- 输入：32 80
- 输出：16
输入两个正整数 m 和 n，求它们的最大公约数。首先，我们需要确定 m 和 n 中的较大数和较小数。在这个例子中，20 显然是较大的数，15 是较小的数。
然后，我们使用辗转相除法来求最大公约数。我们用较大数除以较小数，得到余数。如果余数为 0，则较小数即为最大公约数。如果余数不为 0，则将较小数作为新的较大数，将余数作为新的较小数，继续进行相除运算，直到余数为 0。
- 20 除以 15，余数为 5。
- 15 除以 5，余数为 0。
因此，最大公约数为 5。
所以，输入 20 15 时，输出的最大公约数为 5。
输入两个正整数 m 和 n，求它们的最大公约数。在这个例子中，32 是较大的数，80 是较小的数。
使用辗转相除法，我们用较大数除以较小数，并求得余数。
- 32 除以 80，余数为 32。
- 80 除以 32，余数为 16。
- 32 除以 16，余数为 0。
因此，最大公约数为 16。
所以，输入 32 80 时，输出的最大公约数为 16。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int m, n, i; // 声明变量 m、n 和 i 为整数
cin >> m >> n; // 从用户输入获取两个整数，分别存储到变量 m 和 n 中
for (i = m; i >= 1; i--) // 从 m 开始递减，遍历 i 从 m 到 1
{
if (m % i == 0 && n % i == 0) // 如果 m 和 n 都可以整除 i（即 i 是它们的公约数）
break; // 跳出循环，终止查找
}
cout << i << endl; // 输出 i 的值，并换行
return 0; // 返回值 0，表示程序正常结束
}
06. 循环：因数（统计个数）
【题目】给定一个正整数 n ，求它的因数个数。
- 如 6 的因数为 1 、 2 、 3 、 6 ，则因数个数为 4 。
【样例】
- 输入：12
- 输出：6
【测试】
- 输入：30
- 输出：8
给定一个正整数 n，求它的因数个数。在这个例子中，n = 12。
我们来找出所有的因数。只需要从 1 到 n，判断每个数是否是 n 的因数。如果一个数 k 能够整除 n，即 n % k == 0，那么 k 是 n 的一个因数。
对于 n = 12：
1 是 12 的因数
2 是 12 的因数
3 是 12 的因数
4 不是 12 的因数
5 不是 12 的因数
6 是 12 的因数
7 不是 12 的因数
8 不是 12 的因数
9 不是 12 的因数
10 不是 12 的因数
11 不是 12 的因数
12 是 12 的因数
因此，12 的因数为 1、2、3、4、6、12，所以因数个数为 6。
给定一个正整数 n，求它的因数个数。在这个例子中，n = 30。
我们来找出所有的因数。只需要从 1 到 n，判断每个数是否是 n 的因数。如果一个数 k 能够整除 n，即 n % k == 0，那么 k 是 n 的一个因数。
对于 n = 30：
1 是 30 的因数
2 是 30 的因数
3 是 30 的因数
4 不是 30 的因数
5 是 30 的因数
6 不是 30 的因数
7 不是 30 的因数
8 不是 30 的因数
9 不是 30 的因数
10 是 30 的因数
11 不是 30 的因数
12 不是 30 的因数
13 不是 30 的因数
14 不是 30 的因数
15 是 30 的因数
16 不是 30 的因数
17 不是 30 的因数
18 不是 30 的因数
19 不是 30 的因数
20 是 30 的因数
21 不是 30 的因数
22 不是 30 的因数
23 不是 30 的因数
24 不是 30 的因数
25 不是 30 的因数
26 不是 30 的因数
27 不是 30 的因数
28 不是 30 的因数
29 不是 30 的因数
30 是 30 的因数因此，30 的因数为 1 2 3 5 6 10 15 30，所以因数个数为 8。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, i, count = 0; // 声明变量 n、i 和 count，并初始化 count 为 0
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
for (i = 1; i <= n; i++) // 循环遍历 i 从 1 到 n
{
if (n % i == 0) // 如果 n 可以整除 i（即 i 是 n 的因数）
count++; // 增加 count 的值
}
cout << count << endl; // 输出 count 的值，并换行
return 0; // 返回值 0，表示程序正常结束
}
07. 循环：完数
【题目】输入一个正整数 n ，输出 [1,n] 之间的所有完数。
- 完数的定义：除自身外的因子之和等于它本身。
- 例如： 6=1+2+3 ，因此 6 是完数。
【样例】
- 输入：1000
- 输出：6 28 496
给定输入 1000，我们需要在区间 [1, 1000] 中找出所有的完数。
- 给定输入 1000 时，输出的结果是 [6, 28, 496]
这三个数分别是完数，因为它们的除自身外的因子之和等于它本身：
- 6 = 1 + 2 + 3
- 28 = 1 + 2 + 4 + 7 + 14
- 496 = 1 + 2 + 4 + 8 + 16 + 31 + 62 + 124 + 248
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, i, j, s; // 声明变量 n、i、j 和 s 为整数
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
for (i = 1; i <= n; i++) // 循环遍历 i 从 1 到 n
{
s = 0; // 初始化变量 s 为 0
for (j = 1; j < i; j++) // 循环遍历 j 从 1 到 i 的前一个数
{
if (i % j == 0) // 如果 i 能被 j 整除
{
s += j; // 将 j 的值累加到 s 中
}
}
if (s == i) // 如果 s 等于 i，表示 i 是完全数
{
cout << s << " "; // 输出 s 的值后面加一个空格
}
}
return 0; // 返回值 0，表示程序正常结束
}
08. 循环：幂函数
【题目】输入一个正整数 repeat (0<repeat<10) ，做 repeat 次下列运算：读入 1 个正实数 x 和 1 个正整数 n(n<=50) ，计算并输出 x 的 n 次幂。
【样例】
- 输入：3 2 5 3 4 5 3
- 输出：32 81 125
根据题目描述，我们需要进行 repeat 次下列运算：读入一个正实数 x 和一个正整数 n（n<=50），计算并输出 x 的 n 次幂。
根据给定的输入：
- 第一次运算：计算 2 的 5 次幂，结果为 2 的 5 次幂等于 32
- 第二次运算：计算 3 的 4 次幂，结果为 3 的 4 次幂等于 81
- 第三次运算：计算 5 的 3 次幂，结果为 5 的 3 次幂等于 125
因此，给定输入时，输出的结果为：32 81 125。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int repeat, i, x, n, j, k; // 声明变量 repeat、i、x、n、j 和 k 为整数
cin >> repeat; // 从用户输入获取一个整数，存储到变量 repeat 中
for (i = 1; i <= repeat; i++) // 循环遍历 i 从 1 到 repeat
{
cin >> x >> n; // 从用户输入获取两个整数，存储到变量 x 和 n 中
k = 1; // 初始化变量 k 为 1
for (j = 1; j <= n; j++) // 循环遍历 j 从 1 到 n
{
k = k * x; // 将 x 的值乘以 k，并将结果赋值给 k
}
cout << k << " "; // 输出 k 的值后面加一个空格
}
return 0; // 返回值 0，表示程序正常结束
}
09. 循环：水仙花数
【题目】打印出所有的 " 水仙花数 " ，所谓 " 水仙花数 " 是指一个三位数，其各位数字立方和等于该数本身。
- 例如： 153 是一个 " 水仙花数 " ，因为 153=1 的三次方＋ 5 的三次方＋ 3 的三次方。
【样例】
- 输入：无
- 输出：153 370 371 407
这四个三位数满足立方和等于该数本身的条件：
- 153：1 的三次方 + 5 的三次方 + 3 的三次方 = 1 + 125 + 27 = 153
- 370：3 的三次方 + 7 的三次方 + 0 的三次方 = 27 + 343 + 0 = 370
- 371：3 的三次方 + 7 的三次方 + 1 的三次方 = 27 + 343 + 1 = 371
- 407：4 的三次方 + 0 的三次方 + 7 的三次方 = 64 + 0 + 343 = 407
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, i, j, k; // 声明变量 n、i、j 和 k
for (n = 100; n < 1000; n++) // 循环遍历 n 从 100 到 999
{
i = n / 100; // 计算百位数
j = n / 10 % 10; // 计算十位数
k = n % 10; // 计算个位数
if (i * i * i + j * j * j + k * k * k == n) // 判断是否满足条件
cout << n << " "; // 输出满足条件的数，并加上空格
}
return 0; // 返回值 0，表示程序正常结束
}
10. 循环：数根
【题目】对于一个正整数 n ，我们将它的各个位相加得到一个新的数字，如果这个数字是一位数，我们称之为 n 的数根，否则重复处理直到它成为一个一位数，这个一位数也算是 n 的数根。
- 例如：考虑 24 ， 2+4=6 ， 6 就是 24 的数根。
- 考虑 39 ， 3+9=12 ， 1+2=3 ， 3 就是 39 的数根。
- 请编写程序，计算 n 的数根。
【样例】
- 输入：189
- 输出：9
【测试】
- 输入：8943
- 输出：6
- 对于输入的正整数 189，我们将各个位相加得到 1+8+9=18。由于 18 不是一位数，我们继续将各个位相加得到 1+8=9。最终结果为 9，因此数根为 9。
- 因此，当输入为 189 时，输出结果是 9。
- 对于输入的正整数 8943，我们将各个位相加得到 8+9+4+3=24。由于 24 不是一位数，我们继续将各个位相加得到 2+4=6。最终结果为 6，因此数根为 6。
- 因此，当输入为 8943 时，输出结果是 6。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, s = 0, t; // 声明变量 n、s 和 t 为整数，并初始化 s 为 0
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
t = n; // 将变量 t 初始化为 n 的值
while (t >= 10) // 循环条件：t 大于等于 10
{
s = 0; // 将 s 重置为 0
while (t) // 循环条件：t 不为 0
{
s += t % 10; // 取 t 的个位数字，并累加到 s 中
t = t / 10; // 将 t 除以 10，去除个位数字
}
t = s; // 将 t 更新为 s 的值
}
cout << s << endl; // 输出 s 的值，并换行
return 0; // 返回值 0，表示程序正常结束
}
11. 循环：特殊数值
【题目】已知四位数 3025 有一个特殊性质 : 它的前两位数字 30 和后两位数字 25 的和是 55，而 55 的平方刚好等于该数 (55*55=3025)，试编一程序打印所有具有这种性质的四位数。
【样例】
- 输入：无
- 输出：2025 3025 9801
这三个四位数满足以下条件：
- 2025：前两位数字 20 和后两位数字 25 的和为 55，55 的平方等于该数 2025
- 3025：前两位数字 30 和后两位数字 25 的和为 55，55 的平方等于该数 3025
- 9801：前两位数字 98 和后两位数字 01 的和为 99，99 的平方等于该数 9801
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int i, a, b; // 声明变量 i、a 和 b
for (i = 1000; i <= 9999; i++) // 循环遍历 i 从 1000 到 9999
{
a = i / 100; // 计算百位数
b = i % 100; // 计算十位数和个位数的组合
if ((a + b) * (a + b) == i) // 判断是否满足条件
cout << i << " "; // 输出满足条件的数，并加上空格
}
return 0; // 返回值 0，表示程序正常结束
}
12. 循环：斐波那契数列
【题目】判断第 n 个斐波那契数列能否被 3 整除，给定斐波那契数列为： F(0)=1, F(1)=1, F(n)=F(n-1)+F(n-2)(n>=2)，编写一个程序，输入 n(>=0) ，如果 F(n) 能被 3 整除则输出一个 “yes” ，否则输出一个 “no” 。
【样例 ①】
- 输入：8
- 输出：no
【样例 ②】
- 输入：7
- 输出：yes
【测试】
- 输入：12
- 输出：no
按照给定的斐波那契数列规则，当 n 大于等于 2 时，第 n 个斐波那契数列的值并不是固定的。因此，不能简单地通过判断第 n 个斐波那契数列的值是否能被 3 整除来确定输出。
如果输入 n = 8，按照规则计算斐波那契数列的前 8 个数值如下：
- F(0) = 1
- F(1) = 1
- F(2) = F(1) + F(0) = 1 + 1 = 2
- F(3) = F(2) + F(1) = 2 + 1 = 3
- F(4) = F(3) + F(2) = 3 + 2 = 5
- F(5) = F(4) + F(3) = 5 + 3 = 8
- F(6) = F(5) + F(4) = 8 + 5 = 13
- F(7) = F(6) + F(5) = 13 + 8 = 21
- F(8) = F(7) + F(6) = 21 + 13 = 34
由此可见，第 8 个斐波那契数列的值为 34，无法被 3 整除。
因此，对于输入 n = 8，程序会输出 “no”。
根据斐波那契数列规则：F(0) = 1, F(1) = 1，F(n) = F(n-1) + F(n-2) (n >= 2)。
如果输入 n = 7，根据这个规则，我们可以计算出前几个斐波那契数列的值如下：
- F(0) = 1
- F(1) = 1
- F(2) = F(1) + F(0) = 1 + 1 = 2
- F(3) = F(2) + F(1) = 2 + 1 = 3
- F(4) = F(3) + F(2) = 3 + 2 = 5
- F(5) = F(4) + F(3) = 5 + 3 = 8
- F(6) = F(5) + F(4) = 8 + 5 = 13
- F(7) = F(6) + F(5) = 13 + 8 = 21
由此可见，当输入 n = 7 时，第 7 个斐波那契数列的值为 21。而 21 可以被 3 整除。
因此，对于输入 n = 7，程序会输出 “yes”。
根据斐波那契数列规则：F(0) = 1, F(1) = 1，F(n) = F(n-1) + F(n-2) (n >= 2)。
如果输入 n = 12，根据这个规则，我们计算出前几个斐波那契数列的值如下：
- F(0) = 1
- F(1) = 1
- F(2) = 1 + 1 = 2
- F(3) = 1 + 2 = 3
- F(4) = 2 + 3 = 5
- F(5) = 3 + 5 = 8
- F(6) = 5 + 8 = 13
- F(7) = 8 + 13 = 21
- F(8) = 13 + 21 = 34
- F(9) = 21 + 34 = 55
- F(10) = 34 + 55 = 89
- F(11) = 55 + 89 = 144
- F(12) = 89 + 144 = 233
由此可见，当 n = 12 时，第 12 个斐波那契数列的值为 233，而 233 不能被 3 整除。
因此，对于输入 n = 12，程序会输出 “no”。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, F0 = 1, F1 = 1, F, i; // 声明变量 n、F0、F1、F 和 i 为整数，并初始化 F0 和 F1 为 1
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
for (i = 2; i <= n; i++) // 循环遍历 i 从 2 到 n
{
F = F0 + F1; // 计算当前斐波那契数列的值
F0 = F1; // 更新 F0 的值为上一个斐波那契数列的值
F1 = F; // 更新 F1 的值为当前斐波那契数列的值
}
if (F % 3 == 0) // 判断最后一个斐波那契数列的值是否可以被 3 整除
cout << "yes" << endl; // 输出 "yes"，并换行
else
cout << "no" << endl; // 输出 "no"，并换行
return 0; // 返回值 0，表示程序正常结束
}
13. 循环：计数（统计数据个数及最大值）
【题目】输入一组整数，以 0 结束，统计数据个数（不含 0 ）及最大值。
【样例】
- 输入：1 2 3 456 4 3 5 0
- 输出：7 456
输入为1 2 3 456 4 3 5 0，表示输入一组整数，以0结束。
- 数据个数（不含0）= 7
- 最大值 = 456
所以输出为：数据个数：7，最大值：456
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int a, max = 0, i = 0; // 声明变量 a、max 和 i 为整数，并初始化 max 和 i 为 0
cin >> a; // 从用户输入获取一个整数，存储到变量 a 中
while (a != 0) // 循环条件：a 不等于 0
{
i++; // 自增变量 i，以统计输入的数字个数
if (a > max) // 如果 a 大于 max
{
max = a; // 将 a 的值赋给 max，更新 max 为最大值
}
cin >> a; // 从用户输入获取下一个整数，存储到变量 a 中
}
cout << i << " " << max; // 输出变量 i 和 max 的值
return 0; // 返回值 0，表示程序正常结束
}
14. 循环：求和
【题目】从键盘输入若干正数，对其求和并输出，遇到负数则终止输入。
【样例 ①】
- 输入：32 33 50 34 65 67 -1
- 输出：281
【样例 ②】
- 输入：13 15 17 30 35 -2
- 输出：110
【测试】
- 输入：31 33 50 34 65 67 -5
- 输出：280
输入为 32 33 50 34 65 67 -1，表示从键盘输入若干正数，遇到负数 -1 则终止输入。
- 正数的求和 = 32 + 33 + 50 + 34 + 65 + 67 = 281
所以输出为：281
输入为 13 15 17 30 35 -2，表示从键盘输入若干正数，遇到负数 -2 则终止输入。
- 正数的求和 = 13 + 15 + 17 + 30 + 35 = 110
所以输出为：110
输入为 31 33 50 34 65 67 -5，表示从键盘输入若干正数，遇到负数 -5 则终止输入。
- 正数的求和 = 31 + 33 + 50 + 34 + 65 + 67 = 280
所以输出为：280
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, a = 0; // 声明变量 n 和 a，并初始化 a 为 0
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
while (n >= 0) // 当 n 大于等于 0 时执行循环
{
a = n + a; // 将 n 累加到变量 a 中
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
}
cout << a << endl; // 输出 a 的值，并换行
return 0; // 返回值 0，表示程序正常结束
}
15. 循环：奇数和
【题目】读入一批正整数 ( 以 0 为结束标志 ) ，求其中的奇数和。
【样例 ①】
- 输入：32 33 50 34 65 67 0
- 输出：165
【样例 ②】
- 输入：13 15 17 30 35 0
- 输出：80
【测试】
- 输入：31 33 50 34 65 67 0
- 输出：196
输入的一批正整数是：32 33 50 34 65 67 0，其中 0 为结束标志。
求其中的奇数和，即将所有奇数相加。
- 奇数和 = 33 + 65 + 67 = 165
所以，输出为 165。
输入的一批正整数是：13 15 17 30 35 0，其中 0 为结束标志。
求其中的奇数和，即将所有奇数相加。
- 奇数和 = 13 + 15 + 17 + 35 = 80
所以，输出为 80。
输入的一批正整数是：31 33 50 34 65 67 0，其中0为结束标志。
求其中的奇数和，即将所有奇数相加。
- 奇数和 = 31 + 33 + 65 + 67 = 196
所以，输出为 196。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, s = 0; // 声明变量 n 和 s，并初始化 s 为 0
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
while (n > 0) // 当 n 大于 0 时执行循环
{
if (n % 2 != 0) // 如果 n 除以 2 的余数不为 0（即 n 是奇数）
s = s + n; // 将 n 累加到变量 s 中
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
}
cout << s << endl; // 输出 s 的值，并换行
return 0; // 返回值 0，表示程序正常结束
}
16. 循环：数列求和（1+1/4+1/7+1/10...+1/(3*n-2) ）
【题目】输入一个正整数 n ，计算前 n 项之和： 1+1/4+1/7+1/10...+1/(3*n-2) 。
【样例】
- 输入：5
- 输出：1.56978
【测试】
- 输入：4
- 输出：1.49286
输入的正整数为：5
计算前 5 项之和：
- (3*n-2) = 3*5 - 2 = 15 - 2 = 13
- 前 5 项之和 = 1 + 1/4 + 1/7 + 1/10 + 1/13 = 1.56978022
- 四舍五入保留 5 位小数为：1.56978
所以，输出为 1.56978。
输入的正整数为：4
计算前 4 项之和：
- (3*n-2) = 3*4 - 2 = 12 - 2 = 10
- 前 4 项之和 = 1 + 1/4 + 1/7 + 1/10 = 1.49285714
- 四舍五入保留 5 位小数为：1.49286
所以，输出为 1.49286。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int i, n; // 声明变量 i 和 n
double s = 0; // 声明变量 s 并初始化为 0
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
for (i = 1; i <= n; i++) // 从 1 到 n 遍历
{
s += 1.0 / (3 * i - 2); // 计算公式中的累加项，并累加到变量 s 中
}
cout << s << endl; // 输出 s 的值，并换行
return 0; // 返回值 0，表示程序正常结束
}
17. 循环：数列求和（1 ＋ 1/2 ＋ 1/3 ＋ …… ＋ 1/n）
【题目】输入 1 个正整数 n(n<=100) ，计算并输出 1 ＋ 1/2 ＋ 1/3 ＋ …… ＋ 1/n 。
【样例】
- 输入：5
- 输出：2.28333
【测试】
- 输入：4
- 输出：2.08333
输入的正整数为：5
计算 1 + 1/2 + 1/3 + 1/4 + 1/5 的和：
- 1 + 1/2 + 1/3 + 1/4 + 1/5 = 2.283333333333333
- 四舍五入保留 5 位小数为：2.28333
所以，输入为 5 时，输出结果为 2.28333。
输入的正整数为：4
计算 1 + 1/2 + 1/3 + 1/4 的和：
- 1 + 1/2 + 1/3 + 1/4 = 2.083333333333333
- 四舍五入保留 5 位小数为：2.08333
所以，输入为 4 时，输出结果为 2.08333。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, i = 1; // 声明变量 n 和 i，并初始化 i 为 1
double s = 0; // 声明变量 s，并初始化 s 为 0
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
while (i <= n) // 当 i 小于等于 n 时执行循环
{
s += 1.0 / i; // 计算公式中的累加项，并累加到变量 s 中
i++; // 递增变量 i
}
cout << s << endl; // 输出 s 的值，并换行
return 0; // 返回值 0，表示程序正常结束
}
18. 循环：数位之和
【题目】输入一个正整数，输出其各个位置上的数字之和。
【样例 ①】
- 输入：1234
- 输出：10
【样例 ②】
- 输入：1278918392
- 输出：50
【测试】
- 输入：40325
- 输出：14
输入的正整数为：1234
- 各位数字之和为 1 + 2 + 3 + 4 = 10
所以，输入为 1234 时，输出结果为 10。
输入的正整数为：1278918392
- 各位数字之和为 1 + 2 + 7 + 8 + 9 + 1 + 8 + 3 + 9 + 2 = 50
所以，输入为 1278918392 时，输出结果为 50。
输入的正整数为：40325
- 各位数字之和为 4 + 0 + 3 + 2 + 5 = 14
所以，输入为 40325 时，输出结果为 14。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, s = 0; // 声明变量 n 和 s，并初始化 s 为 0
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
while (n) // 当 n 非零时执行循环
{
s += n % 10; // 计算 n 的各位数相加，并累加到变量 s 中
n = n / 10; // 将 n 除以 10，去除最末位
}
cout << s << endl; // 输出 s 的值，并换行
return 0; // 返回值 0，表示程序正常结束
}
19. 循环：数位计算（数位偶数之和）
【题目】对于输入的一个数字，请计算它的各个位上的数字为偶数的和。
- 例如： 1234 ，结果为 6=2+4 。
【样例 ①】
- 输入：4321
- 输出：6
【样例 ②】
- 输入：51289
- 输出：10
【测试】
- 输入：54893
- 输出：12
输入的数字为：4321
其中，偶数数字为 2 和 4 ：
- 偶数的和 = 2 + 4 = 6
所以，输入为 4321 时，输出结果为 6。
输入的数字为：51289
其中，偶数数字为 2 和 8 ：
- 偶数的和 = 2 + 8 = 10
所以，输入为 51289 时，输出结果为 10。
输入的数字为：54893
其中，偶数数字为 4 和 8 ：
- 偶数的和 = 4 + 8 = 12
所以，输入为 54893 时，输出结果为 12。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, x, s = 0; // 声明变量 n、x 和 s 为整数，并初始化 s 为 0
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
while (n)
{
x = n % 10; // 取 n 的个位数字
if (x % 2 == 0) // 判断 x 是否为偶数
s += x; // 如果是偶数，累加到 s 中
n = n / 10; // 将 n 除以 10，去除个位数字
}
cout << s << endl; // 输出 s 的值，并换行
return 0; // 返回值 0，表示程序正常结束
}
20. 循环：西瓜卖几天
【题目】n 个西瓜，第一天卖一半多两个，以后每天卖剩下的一半多两个，问几天以后能卖完？
- 说明：当西瓜个数为奇数时，卖一半为一半的整数，如当西瓜个数为 5 时，卖一半为卖 2 个。
【样例 ①】
- 输入（西瓜个数）：10
- 输出（天数）：2
【样例 ②】
- 输入（西瓜个数）：50
- 输出（天数）：4
【测试】
- 输入（西瓜个数）：120
- 输出（天数）：5
输入的西瓜个数为：10
按照题目描述：
- 第一天卖一半多两个，也就是卖掉 5 个，剩下 5 个。
- 以后每天卖剩下的一半多两个，也就是卖掉 3 个，剩下 2 个。
- 最后一天卖掉剩下的 2 个。
总共需要卖出的天数为：1 + 1 = 2 天
所以，输入为 10 时，输出结果为 2 天。
输入的西瓜个数为：50
按照题目描述：
- 第一天卖一半多两个，也就是卖掉 26 个，剩下 24 个。
- 以后每天卖剩下的一半多两个，也就是卖掉 14 个，剩下 10 个。
- 以后每天卖剩下的一半多两个，也就是卖掉 6 个，剩下 4 个。
- 最后一天卖掉剩下的 4 个。
总共需要卖出的天数为：1 + 1 + 1 + 1 = 4 天
所以，输入为 50 时，输出结果为 4 天。
输入的西瓜个数为：120
按照题目描述：
- 第一天卖一半多两个，也就是卖掉 61 个，剩下 59 个。
- 以后每天卖剩下的一半多两个，也就是卖掉 31 个，剩下 28 个。
- 以后每天卖剩下的一半多两个，也就是卖掉 15 个，剩下 13 个。
- 以后每天卖剩下的一半多两个，也就是卖掉 7 个，剩下 6 个。
- 最后一天卖掉剩下的 6 个。
总共需要卖出的天数为：1 + 1 + 1 + 1 + 1 = 5 天
所以，输入为 120 时，输出结果为 5 天。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, d = 0; // 声明变量 n 和 d，并初始化 d 为 0
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
while (n > 0) // 当 n 大于 0 时执行循环
{
d++; // 递增变量 d
n = n / 2 - 2; // 更新 n 的值，每次除以 2 再减 2
}
cout << d << endl; // 输出 d 的值，并换行
return 0; // 返回值 0，表示程序正常结束
} 
21. 循环：成绩（及格判定）
【题目】输入一个正整数 repeat (0<repeat<10) ，做 repeat 次下列运算：
- 输入一个学生的数学成绩，如果它低于 60 ，输出 “Fail” ，否则，输出 “Pass” 。
- 第一个数字是学生总数，后面是各个学生的分数
【样例】
- 输入：5 35 68 49 94 88
- 输出：
Fail
Pass
Fail
Pass
Pass
【测试】
- 输入：9 90 80 60 50 40 30 73 88 59
- 输出：
Pass
Pass
Pass
Fail
Fail
Fail
Pass
Pass
Fail
输入 5 35 68 49 94 88，即表示共有 5 个学生，学生分数分别是：35、68、49、94、88
如果分数低于 60 ，输出 “Fail” ，否则，输出 “Pass” ：
- 35 < 60：Fail
- 68 > 60：Pass
- 49 < 60：Fail
- 94 > 60：Pass
- 88 > 60：Pass
输入 9 90 80 60 50 40 30 73 88 59，即表示共有 9 个学生，学生分数分别是：90、80、60、50、40、30、73、88、59
如果分数低于 60 ，输出 “Fail” ，否则，输出 “Pass” ：
- 90 > 60：Pass
- 80 > 60：Pass
- 60 = 60：Pass
- 50 < 60：Fail
- 40 < 60：Fail
- 30 < 60：Fail
- 73 > 60：Pass
- 88 > 60：Pass
- 59 < 60：Fail
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int repeat, n, i; // 声明变量 repeat, n 和 i
cin >> repeat; // 从用户输入获取一个整数，存储到变量 repeat 中
for (i = 0; i < repeat; i++) // 执行 repeat 次循环
{
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
if (n < 60) // 如果 n 小于 60
cout << "Fail" << endl; // 输出 "Fail"，并换行
else
cout << "Pass" << endl; // 输出 "Pass"，并换行
}
return 0; // 返回值 0，表示程序正常结束
}
22. 循环：成绩（平均分）
【题目】假设有一个班级， n 名同学选修了 C++ 语言程序设计，要求统计该门课的平均成绩。
- 输入格式：第一个数为学生人数 n ，后面接着 n 个成绩，输出平均成绩。
【样例】
- 输入（第一个数为学生人数 n ，后面接着 n 个成绩）：5 80 90 88 96 70
- 输出（平均成绩）：84.8
输入的学生人数为：5
后面接着的 n 个成绩分别为：80、90、88、96、70为了计算平均成绩，我们需要将所有成绩相加，然后除以学生人数。
- 80 + 90 + 88 + 96 + 70 = 424
- 平均成绩 = 424 / 5 = 84.8
所以，输入的成绩的平均值为 84.8。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
int n, i, a, s = 0; // 声明变量 n、i、a 和 s 为整数，并初始化 s 为 0
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
for (i = 1; i <= n; i++) // 循环遍历 i 从 1 到 n
{
cin >> a; // 从用户输入获取一个整数，存储到变量 a 中
s += a; // 将 a 的值累加到 s 中
}
cout << double(s) / n << endl; // 输出 s 除以 n 的结果，并换行
return 0; // 返回值 0，表示程序正常结束
}
23. 循环：征税
【题目】税务部门征收所的税，规定如下：
- 收入在 1000 元以内（含 1000 ），免征；
收入在 1000~3000 元以内（含 3000 ），纳税额为收入的 3% ；
收入超过 3000~5000 元以内（含 5000 ），纳税为收入的 4% ；
当收入超过 5000 元时，纳税为收入的 6% 。
请根据以上关系，输入收入 m ，输出应缴纳的税收 tax 。
【样例】
- 输入（收入 m：第一个整数 n 表示后续有 n 个收入）：4 900 2000 4000 6000
- 输出（应缴纳的税收 tax：每个收入对应的纳税额）：0 60 160 360
输入的收入包括：900、2000、4000、6000
按照税务部门的规定计算纳税额：
- 对于 900 元的收入，处于免征范围，所以纳税额为 0。
- 对于 2000 元的收入，处于 1000~3000 元的范围，纳税额为收入的 3%，所以纳税额为 2000 * 0.03 = 60 元。
- 对于 4000 元的收入，处于 3000~5000 元的范围，纳税额为收入的 4%，所以纳税额为 4000 * 0.04 = 160 元。
- 对于 6000 元的收入，超过 5000 元，纳税额为收入的 6%，所以纳税额为 6000 * 0.06 = 360 元。
所以，输入的收入对应的纳税额分别为：0、60、160、360。
输出结果为：0 60 160 360。
#include <iostream> // 包含输入输出流库
using namespace std;
int main()
{
double m, tax; // 声明变量 m 和 tax 为双精度浮点数
int i, n; // 声明变量 i 和 n 为整数
cin >> n; // 从用户输入获取一个整数，存储到变量 n 中
for (i = 1; i <= n; i++) // 循环遍历 i 从 1 到 n
{
cin >> m; // 从用户输入获取一个双精度浮点数，存储到变量 m 中
if (m <= 1000)
tax = 0; // 如果 m 小于等于 1000，tax 为 0
else if (m <= 3000)
tax = m * 0.03; // 如果 m 小于等于 3000，tax 为 m 乘以 0.03
else if (m <= 5000)
tax = m * 0.04; // 如果 m 小于等于 5000，tax 为 m 乘以 0.04
else
tax = m * 0.06; // 否则，tax 为 m 乘以 0.06
cout << tax << " "; // 输出 tax 的值，并加上空格
}
return 0; // 返回值 0，表示程序正常结束
}