1.for 循环语句

C# for 循环「步长/起点/终点」专项强化练习题（5道，附答案，适合初学者

这5道练习题专门针对 for 循环的三大核心细节：「循环起点」（初始化表达式）、「循环终点」（条件表达式）、「循环步长」（增量/减量表达式），从简单到复杂递进，帮助初学者熟练掌握 for 语法的灵活运用，避免出现「步长错误」「终点边界判断失误」「起点初始化不当」等常见问题。

练习题1：固定步长2，输出1到20的奇数（基础步长强化）

题目要求

使用 for 循环，设置步长为2，直接输出1到20之间的所有奇数，每个数字占一行（禁止使用 if 条件筛选，必须通过步长实现）。

解题思路

循环起点：int i = 1（奇数的起始值，从1开始）。
循环终点：i <= 20（不超过20，包含20以内的最大奇数19）。
循环步长：i += 2（等价于 i = i + 2，每次递增2，直接跳过偶数，得到奇数）。
核心：利用步长直接控制遍历结果，无需额外条件判断，体现步长的核心作用。

参考代码（答案）

using System;

namespace ForStepExercise1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("1到20之间的所有奇数（步长2）：");
            // 起点：1，终点：<=20，步长：+2
            for (int i = 1; i <= 20; i += 2)
            {
                Console.WriteLine(i);
            }

            Console.ReadKey();
        }
    }
}

运行结果

1到20之间的所有奇数（步长2）：
1
3
5
7
9
11
13
15
17
19

练习题2：步长3，反向输出30到3的倍数（反向循环+自定义步长）

题目要求

使用 for 循环，设置步长为-3（反向步长），输出30到3之间所有能被3整除的数字，每个数字用空格分隔（禁止使用 if 条件筛选，通过起点、终点、步长直接实现）。

解题思路

循环起点：int i = 30（反向循环，从最大的3的倍数开始）。
循环终点：i >= 3（反向循环的终止条件，不小于3，包含3）。
循环步长：i -= 3（等价于 i = i - 3，每次递减3，直接得到3的倍数）。
核心：掌握反向循环的「起点>终点」+「负步长」的搭配，避免出现「循环一次都不执行」的问题。

参考代码（答案）

using System;

namespace ForStepExercise2
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("30到3之间的3的倍数（步长-3）：");
            // 起点：30，终点：>=3，步长：-3
            for (int i = 30; i >= 3; i -= 3)
            {
                Console.Write($"{i} ");
            }

            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

运行结果

30到3之间的3的倍数（步长-3）：30 27 24 21 18 15 12 9 6 3

练习题3：自定义起点和步长，计算累加和（起点+步长综合）

题目要求

使用 for 循环，设置循环起点为5，循环终点为50，步长为5。
计算该范围内所有数字的累加和（即 5 + 10 + 15 + ... + 50）。
输出结果，示例：「5到50之间，步长5的累加和为：XXX」。

解题思路

循环起点：int i = 5（按照题目要求初始化）。
循环终点：i <= 50（不超过50，包含50这个终止值）。
循环步长：i += 5（每次递增5，遍历所有符合要求的数字）。
定义累加变量 sum = 0，循环体内每次将 i 加到 sum 中，最终输出结果。
核心：掌握「非1步长」的累加逻辑，明确终点边界是否包含终止值。

参考代码（答案）

using System;

namespace ForStepExercise3
{
    class Program
    {
        static void Main(string[] args)
        {
            int sum = 0;
            Console.WriteLine("计算5到50之间，步长5的累加和：");

            // 起点：5，终点：<=50，步长：+5
            for (int i = 5; i <= 50; i += 5)
            {
                sum += i;
                // 可选：输出遍历过程，帮助理解
                Console.Write($"{i} + ");
            }

            // 格式化输出结果，去除最后一个"+"
            Console.WriteLine($"\b\b= {sum}");
            Console.WriteLine($"最终累加和为：{sum}");
            Console.ReadKey();
        }
    }
}

运行结果

计算5到50之间，步长5的累加和：
5 + 10 + 15 + 20 + 25 + 30 + 35 + 40 + 45 + 50 + 
最终累加和为：275

练习题4：边界值强化，输出10到20之间步长4的数字（终点边界判断）

题目要求

使用 for 循环，设置起点为10，步长为4，终点分别测试两种情况，观察运行结果，理解循环终点的边界判断：

情况1：循环终点 i <= 20，输出所有符合条件的数字。
情况2：循环终点 i < 20，输出所有符合条件的数字。
对比两种情况的差异，总结「<」和「<=」在终点判断中的区别。

解题思路

核心：同一组「起点+步长」，不同的终点条件，会导致遍历结果不同。
情况1：起点10，步长4，终点<=20：遍历 10 → 14 → 18 → 22（22>20，终止），最终输出 10、14、18。
情况2：起点10，步长4，终点<20：遍历 10 → 14 → 18 → 22（22>=20，终止），最终输出 10、14、18（此处特殊，因18+4=22直接超过20，若步长为3，结果会不同，可拓展）。
延伸：若步长为3，情况1输出 10、13、16、19，情况2输出 10、13、16，更直观体现边界差异。

参考代码（答案）

using System;

namespace ForStepExercise4
{
    class Program
    {
        static void Main(string[] args)
        {
            // 情况1：循环终点 i <= 20
            Console.Write("情况1（终点 i <= 20）：");
            for (int i = 10; i <= 20; i += 4)
            {
                Console.Write($"{i} ");
            }

            // 情况2：循环终点 i < 20
            Console.WriteLine();
            Console.Write("情况2（终点 i < 20）：");
            for (int i = 10; i < 20; i += 4)
            {
                Console.Write($"{i} ");
            }

            // 拓展：步长3，更直观体现边界差异
            Console.WriteLine();
            Console.Write("拓展（步长3，终点 i <= 20）：");
            for (int i = 10; i <= 20; i += 3)
            {
                Console.Write($"{i} ");
            }

            Console.WriteLine();
            Console.Write("拓展（步长3，终点 i < 20）：");
            for (int i = 10; i < 20; i += 3)
            {
                Console.Write($"{i} ");
            }

            Console.ReadKey();
        }
    }
}

运行结果

情况1（终点 i <= 20）：10 14 18 
情况2（终点 i < 20）：10 14 18 
拓展（步长3，终点 i <= 20）：10 13 16 19 
拓展（步长3，终点 i < 20）：10 13 16 

总结（给学生）

循环终点的 <= 包含终止值本身，< 不包含终止值。
最终是否能输出终止值，还需看「起点+步长」是否能刚好到达终止值。

练习题5：灵活步长，输出2的n次方（1到10次方）（步长+起点+终点综合应用）

题目要求

使用 for 循环，实现以下需求：

循环起点：int i = 0（对应2的0次方）。
循环终点：i <= 10（对应2的10次方）。
循环步长：i += 1（每次递增1，遍历0到10的所有整数）。
循环体内计算并输出 2^i 的结果，格式示例：「2^0 = 1」「2^1 = 2」...「2^10 = 1024」。
核心：利用 for 循环的「起点0」「终点10」「步长1」，实现幂次的遍历计算。

解题思路

循环起点：int i = 0（幂次从0开始，符合2的n次方的数学定义）。
循环终点：i <= 10（幂次到10结束，包含2的10次方）。
循环步长：i += 1（每次幂次加1，遍历所有需要计算的幂次）。
利用 Math.Pow(2, i) 计算2的i次方（返回 double 类型，需按需转换）。
核心：灵活设置起点（非1开始），掌握 for 循环在数学计算中的应用，理解起点、终点、步长的灵活搭配。

参考代码（答案）

using System;

namespace ForStepExercise5
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("2的0次方到10次方的结果：");
            // 起点：0，终点：<=10，步长：+1
            for (int i = 0; i <= 10; i += 1)
            {
                // Math.Pow(底数, 指数)：计算幂次，返回double类型
                double result = Math.Pow(2, i);
                Console.WriteLine($"2^{i} = {result}");
            }

            Console.ReadKey();
        }
    }
}

运行结果

2的0次方到10次方的结果：
2^0 = 1
2^1 = 2
2^2 = 4
2^3 = 8
2^4 = 16
2^5 = 32
2^6 = 64
2^7 = 128
2^8 = 256
2^9 = 512
2^10 = 1024

五、教学补充建议（给老师）

重点强调：
- 步长可以是任意整数（正/负/非1），正步长对应「正向循环」起点小于终点，负步长对应「反向循环」起点大于终点。
- 循环终点的条件（</<=/>/>=）直接决定是否包含终止值，初学者容易在此出错，建议多做边界测试。
- for 循环的三要素可以灵活调整，但必须保证「循环能正常终止」，避免因步长和终点不匹配导致死循环（如：起点1，终点10，步长-1）。
易错点提醒：
- 反向循环时，误将步长设为正数（如：for (int i = 10; i >= 1; i++)），导致循环一次都不执行。
- 步长为非1时，误判终点边界（如：步长2，想输出到20，却设为 i < 20，导致遗漏20）。
- 忘记步长表达式（如：for (int i = 1; i <= 10;)），导致死循环。
拓展练习：让学生自行修改步长（如步长5、步长-4）、起点（如起点0、起点100）、终点（如终点50、终点0），观察运行结果，加深理解。

C# 循环结构语句练习题（适合初学者，附完整答案）作为老师，我为初学者设计了5道 for 循环题、5道 while 循环题、3道 do-while 循环题，题目从简单到复杂递进，覆盖循环核心知识点（循环条件、循环变量、循环体执行逻辑），所有题目均附带解题思路和可直接运行的参考代码，方便课堂讲解和学生课后练习。

一、for 循环语句练习题（5道经典，附答案）

for 循环适合已知循环次数的场景，重点考察「循环初始化、循环条件、循环增量/减量」的三要素，以及循环体的逻辑实现。

练习题1：输出 1 到 10 的整数（基础入门）

题目要求

使用 for 循环，从控制台依次输出 1 到 10 的整数，每个数字占一行。

解题思路

循环初始化：int i = 1（从1开始）。
循环条件：i <= 10（到10结束，包含10）。
循环增量：i++（每次加1，逐步逼近终止条件）。
循环体：输出当前循环变量 i。

参考代码（答案）

using System;

namespace ForExercise1
{
    class Program
    {
        static void Main(string[] args)
        {
            // for 循环三要素：初始化、条件、增量
            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine(i);
            }

            Console.ReadKey();
        }
    }
}

运行结果

练习题2：计算 1 到 100 的累加和（进阶求和）

题目要求

使用 for 循环，计算 1 + 2 + 3 + ... + 100 的结果，并输出最终累加和。

解题思路

定义一个累加变量 sum，初始值为 0（用于存储累加结果）。
for 循环遍历 1 到 100，每次将循环变量 i 加到 sum 中。
循环结束后，输出 sum 的值。

参考代码（答案）

using System;

namespace ForExercise2
{
    class Program
    {
        static void Main(string[] args)
        {
            int sum = 0; // 累加和变量，初始化为0

            for (int i = 1; i <= 100; i++)
            {
                sum += i; // 等价于 sum = sum + i，逐步累加
            }

            Console.WriteLine($"1到100的累加和为：{sum}");
            Console.ReadKey();
        }
    }
}

运行结果

1到100的累加和为：5050

练习题3：输出 10 到 1 的倒序整数（反向循环）

题目要求

使用 for 循环，从控制台依次输出 10 到 1 的整数，每个数字用空格分隔，最终换行。

解题思路

循环初始化：int i = 10（从10开始，反向循环）。
循环条件：i >= 1（到1结束，包含1）。
循环减量：i--（每次减1，逐步逼近终止条件）。
循环体：使用 Console.Write()（不带换行）输出，添加空格分隔。

参考代码（答案）

using System;

namespace ForExercise3
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("10到1的倒序输出：");
            for (int i = 10; i >= 1; i--)
            {
                Console.Write($"{i} "); // 不带换行，空格分隔
            }

            Console.WriteLine(); // 循环结束后换行，优化格式
            Console.ReadKey();
        }
    }
}

运行结果

10到1的倒序输出：10 9 8 7 6 5 4 3 2 1

练习题4：输出 1 到 100 之间的所有偶数（条件筛选）

题目要求

使用 for 循环，筛选并输出 1 到 100 之间的所有偶数，每行输出 5 个偶数。

解题思路

for 循环遍历 1 到 100，循环变量 i 每次加1。
循环体内用 if 判断：i % 2 == 0（能被2整除即为偶数）。
定义一个计数器 count，统计已输出的偶数个数，每输出 5 个就换行。

参考代码（答案）

using System;

namespace ForExercise4
{
    class Program
    {
        static void Main(string[] args)
        {
            int count = 0; // 偶数计数器，用于控制每行输出个数
            Console.WriteLine("1到100之间的所有偶数（每行5个）：");

            for (int i = 1; i <= 100; i++)
            {
                // 判断是否为偶数
                if (i % 2 == 0)
                {
                    Console.Write($"{i}\t"); // 制表符分隔，格式更整齐
                    count++; // 计数器加1

                    // 每输出5个偶数，换行
                    if (count % 5 == 0)
                    {
                        Console.WriteLine();
                    }
                }
            }

            Console.ReadKey();
        }
    }
}

运行结果（节选）

1到100之间的所有偶数（每行5个）：
2       4       6       8       10
12      14      16      18      20
...
92      94      96      98      100

练习题5：计算 n 的阶乘（综合应用，n 由用户输入）

题目要求

让用户输入一个正整数 n（1 ≤ n ≤ 20）。
使用 for 循环计算 n 的阶乘（n! = 1 × 2 × 3 × ... × n）。
输出结果，示例：「5的阶乘是：120」。

解题思路

定义阶乘变量 factorial，初始值为 1（乘法累加，初始值不能为0）。
接收用户输入的正整数 n，先校验输入有效性。
for 循环遍历 1 到 n，每次将循环变量 i 乘到 factorial 中。
循环结束后，输出阶乘结果（使用 long 类型存储，避免整数溢出）。

参考代码（答案）

using System;

namespace ForExercise5
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("请输入一个正整数（1≤n≤20）：");
            int n = int.Parse(Console.ReadLine());

            // 校验输入有效性
            if (n < 1 || n > 20)
            {
                Console.WriteLine("输入无效，请输入1到20之间的正整数！");
                Console.ReadKey();
                return;
            }

            long factorial = 1; // 阶乘变量，用long类型避免溢出

            for (int i = 1; i <= n; i++)
            {
                factorial *= i; // 等价于 factorial = factorial * i
            }

            Console.WriteLine($"{n}的阶乘是：{factorial}");
            Console.ReadKey();
        }
    }
}

运行结果

请输入一个正整数（1≤n≤20）：5
5的阶乘是：120

二、while 循环语句练习题（5道经典，附答案）

while 循环适合未知循环次数，仅知道「循环终止条件」的场景，重点考察「循环条件的设置」和「循环体内的变量更新」（避免死循环）。

练习题1：输出 1 到 10 的整数（基础入门，对应 for 题1）

题目要求

使用 while 循环，从控制台依次输出 1 到 10 的整数，每个数字占一行。

解题思路

定义循环变量 i，初始值为 1（在循环外初始化）。
循环条件：while (i <= 10)（满足条件才执行循环体）。
循环体：先输出 i，再更新循环变量 i++（避免死循环）。

参考代码（答案）

using System;

namespace WhileExercise1
{
    class Program
    {
        static void Main(string[] args)
        {
            int i = 1; // 循环变量，在循环外初始化

            // while 循环：先判断条件，再执行循环体
            while (i <= 10)
            {
                Console.WriteLine(i);
                i++; // 必须更新循环变量，否则会进入死循环
            }

            Console.ReadKey();
        }
    }
}

运行结果

练习题2：计算 1 到 100 的累加和（进阶求和，对应 for 题2）

题目要求

使用 while 循环，计算 1 + 2 + 3 + ... + 100 的结果，并输出最终累加和。

解题思路

定义累加变量 sum（初始值 0）和循环变量 i（初始值 1）。
循环条件：while (i <= 100)，满足则执行累加。
循环体：先将 i 加到 sum 中，再更新 i++。
循环结束后，输出累加和。

参考代码（答案）

using System;

namespace WhileExercise2
{
    class Program
    {
        static void Main(string[] args)
        {
            int sum = 0; // 累加和变量
            int i = 1; // 循环变量

            while (i <= 100)
            {
                sum += i;
                i++; // 更新循环变量
            }

            Console.WriteLine($"1到100的累加和为：{sum}");
            Console.ReadKey();
        }
    }
}

运行结果

1到100的累加和为：5050

练习题3：猜数字游戏（未知循环次数，核心应用）

题目要求

程序预设一个数字（如 66），让用户从控制台输入数字猜一猜。
使用 while 循环，直到用户猜对为止，每次猜错给出提示：「猜小了！」或「猜大了！」。
猜对后输出：「恭喜你，猜对了！」，结束循环。

解题思路

定义预设数字 target = 66，并接收用户输入的猜测数字。
循环条件：while (guess != target)（只要没猜对，就继续循环）。
循环体内：用 if 判断猜测结果，给出提示，然后重新接收用户输入。
由于循环次数未知（用户可能猜1次，也可能猜10次），适合用 while 循环。

参考代码（答案）

using System;

namespace WhileExercise3
{
    class Program
    {
        static void Main(string[] args)
        {
            int target = 66; // 预设目标数字
            int guess = 0; // 用户猜测的数字

            Console.WriteLine("=== 猜数字游戏 ===");
            Console.WriteLine("请猜一个1-100之间的整数：");

            // 循环条件：没猜对就继续循环
            while (guess != target)
            {
                guess = int.Parse(Console.ReadLine());

                if (guess < target)
                {
                    Console.WriteLine("猜小了！请再试一次：");
                }
                else if (guess > target)
                {
                    Console.WriteLine("猜大了！请再试一次：");
                }
                else
                {
                    Console.WriteLine("恭喜你，猜对了！");
                }
            }

            Console.ReadKey();
        }
    }
}

运行结果（示例）

=== 猜数字游戏 ===
请猜一个1-100之间的整数：
50
猜小了！请再试一次：
70
猜大了！请再试一次：
66
恭喜你，猜对了！

练习题4：计算用户输入数字的累加和（直到输入 0 结束）

题目要求

让用户反复输入整数，将所有输入的数字累加求和。
当用户输入 0 时，结束循环，输出最终累加和。
提示：「请输入一个整数（输入0结束）：」。

解题思路

定义累加变量 sum = 0 和输入变量 num。
循环条件：while (num != 0)，但首次输入需要在循环外初始化。
循环体内：先将输入的 num 加到 sum 中，再接收下一个输入。
输入 0 时，循环条件不满足，结束循环并输出结果。

参考代码（答案）

using System;

namespace WhileExercise4
{
    class Program
    {
        static void Main(string[] args)
        {
            int sum = 0;
            int num = 0;

            Console.WriteLine("=== 数字累加器（输入0结束）===");
            Console.Write("请输入一个整数（输入0结束）：");
            num = int.Parse(Console.ReadLine());

            // 只要输入的数字不是0，就继续累加
            while (num != 0)
            {
                sum += num;

                // 接收下一个输入
                Console.Write("请输入一个整数（输入0结束）：");
                num = int.Parse(Console.ReadLine());
            }

            Console.WriteLine($"所有输入数字的累加和为：{sum}");
            Console.ReadKey();
        }
    }
}

运行结果（示例）

=== 数字累加器（输入0结束）===
请输入一个整数（输入0结束）：10
请输入一个整数（输入0结束）：20
请输入一个整数（输入0结束）：30
请输入一个整数（输入0结束）：0
所有输入数字的累加和为：60

练习题5：输出 1 到 100 之间的所有奇数（条件筛选，对应 for 题4）

题目要求

使用 while 循环，筛选并输出 1 到 100 之间的所有奇数，每行输出 5 个奇数。

解题思路

定义循环变量 i = 1，奇数计数器 count = 0。
循环条件：while (i <= 100)，遍历 1 到 100。
循环体内：用 if 判断 i % 2 != 0（不能被2整除即为奇数）。
每输出 5 个奇数换行，同时更新循环变量 i++。

参考代码（答案）

using System;

namespace WhileExercise5
{
    class Program
    {
        static void Main(string[] args)
        {
            int i = 1; // 循环变量
            int count = 0; // 奇数计数器
            Console.WriteLine("1到100之间的所有奇数（每行5个）：");

            while (i <= 100)
            {
                // 判断是否为奇数
                if (i % 2 != 0)
                {
                    Console.Write($"{i}\t");
                    count++;

                    // 每5个奇数换行
                    if (count % 5 == 0)
                    {
                        Console.WriteLine();
                    }
                }

                i++; // 更新循环变量，避免死循环
            }

            Console.ReadKey();
        }
    }
}

运行结果（节选）

1到100之间的所有奇数（每行5个）：
1       3       5       7       9
11      13      15      17      19
...
91      93      95      97      99

三、do-while 循环语句练习题（3道经典，附答案）

do-while 循环的特点是「先执行，后判断」，至少会执行一次循环体，适合「无论条件是否满足，都需要先执行一次逻辑」的场景，重点考察与 while 循环的区别。

练习题1：输出 1 到 10 的整数（基础入门，对比 while）

题目要求

使用 do-while 循环，从控制台依次输出 1 到 10 的整数，每个数字占一行。

解题思路

定义循环变量 i = 1（在循环外初始化）。
先执行 do 后的循环体：输出 i，更新 i++。
再判断 while (i <= 10) 条件，满足则继续循环，不满足则结束。
即使循环条件一开始不满足，循环体也会执行一次。

参考代码（答案）

using System;

namespace DoWhileExercise1
{
    class Program
    {
        static void Main(string[] args)
        {
            int i = 1; // 循环变量

            // do-while 循环：先执行循环体，再判断条件
            do
            {
                Console.WriteLine(i);
                i++; // 更新循环变量
            } while (i <= 10);

            Console.ReadKey();
        }
    }
}

运行结果

练习题2：用户登录验证（至少执行一次，核心应用）

题目要求

预设用户名（如 admin）和密码（如 123456）。
使用 do-while 循环，让用户输入用户名和密码，验证是否正确。
若验证失败，提示「用户名或密码错误，请重新输入！」，继续循环。
若验证成功，提示「登录成功！」，结束循环。
要求：无论是否正确，至少让用户输入一次用户名和密码。

解题思路

预设正确的用户名和密码，定义两个字符串变量存储用户输入。
采用 do-while 循环：先执行「输入用户名和密码」的逻辑（至少执行一次）。
再判断「输入是否正确」，不正确则继续循环，正确则结束。
该场景适合 do-while，因为用户必须先输入一次，才能进行验证。

参考代码（答案）

using System;

namespace DoWhileExercise2
{
    class Program
    {
        static void Main(string[] args)
        {
            // 预设正确的用户名和密码
            string correctUser = "admin";
            string correctPwd = "123456";

            string inputUser = "";
            string inputPwd = "";

            Console.WriteLine("=== 用户登录 ===");

            // do-while 循环：先输入，再验证
            do
            {
                Console.Write("请输入用户名：");
                inputUser = Console.ReadLine();

                Console.Write("请输入密码：");
                inputPwd = Console.ReadLine();

                // 验证是否正确
                if (inputUser != correctUser || inputPwd != correctPwd)
                {
                    Console.WriteLine("用户名或密码错误，请重新输入！\n");
                }

            } while (inputUser != correctUser || inputPwd != correctPwd);

            Console.WriteLine("登录成功！");
            Console.ReadKey();
        }
    }
}

运行结果（示例）

=== 用户登录 ===
请输入用户名：test
请输入密码：123
用户名或密码错误，请重新输入！

请输入用户名：admin
请输入密码：123456
登录成功！

练习题3：计算用户输入的正数之和（直到输入负数结束）

题目要求

使用 do-while 循环，让用户反复输入数字。
只累加正数，当用户输入负数时，结束循环。
输出最终的正数累加和，提示：「输入负数结束程序」。
要求：至少让用户输入一次数字。

解题思路

定义累加变量 sum = 0，输入变量 num = 0。
do-while 循环：先执行「输入数字」和「累加正数」的逻辑。
再判断 while (num >= 0)（输入非负数则继续循环，负数则结束）。
即使用户第一次就输入负数，也会执行一次输入逻辑，符合题目要求。

参考代码（答案）

using System;

namespace DoWhileExercise3
{
    class Program
    {
        static void Main(string[] args)
        {
            int sum = 0;
            int num = 0;

            Console.WriteLine("=== 正数累加器（输入负数结束）===");

            // do-while 循环：先输入，再判断
            do
            {
                Console.Write("请输入一个数字（输入负数结束）：");
                num = int.Parse(Console.ReadLine());

                // 只累加正数
                if (num > 0)
                {
                    sum += num;
                }

            } while (num >= 0); // 输入非负数，继续循环

            Console.WriteLine($"所有输入正数的累加和为：{sum}");
            Console.ReadKey();
        }
    }
}

运行结果（示例）

=== 正数累加器（输入负数结束）===
请输入一个数字（输入负数结束）：10
请输入一个数字（输入负数结束）：20
请输入一个数字（输入负数结束）：-5
所有输入正数的累加和为：30

四、教学补充建议（给老师）

做题顺序：先 for 循环 → 再 while 循环 → 最后 do-while 循环，循序渐进，重点对比三者的区别。
核心易错点：
- for 循环：忘记循环增量/减量，或三要素格式错误。
- while 循环：忘记更新循环变量，导致死循环。
- do-while 循环：混淆与 while 循环的执行顺序，忽略「至少执行一次」的特性。
重点强调：
- 已知循环次数 → 优先用 for 循环。
- 未知循环次数，仅知终止条件 → 优先用 while 循环。
- 必须先执行一次循环体，再判断条件 → 用 do-while 循环。
拓展优化：可让学生添加 TryParse() 安全转换输入，避免程序因无效输入崩溃，提升代码健壮性。

练习题1：固定步长2，输出1到20的奇数（基础步长强化）​

题目要求​

解题思路​

参考代码（答案）​

运行结果​

练习题2：步长3，反向输出30到3的倍数（反向循环+自定义步长）​

题目要求​

解题思路​

参考代码（答案）​

运行结果​

练习题3：自定义起点和步长，计算累加和（起点+步长综合）​

题目要求​

解题思路​

参考代码（答案）​

运行结果​

练习题4：边界值强化，输出10到20之间步长4的数字（终点边界判断）​

题目要求​

解题思路​

参考代码（答案）​

运行结果​

总结（给学生）​

练习题5：灵活步长，输出2的n次方（1到10次方）（步长+起点+终点综合应用）​

题目要求​

解题思路​

参考代码（答案）​

运行结果​

五、教学补充建议（给老师）​

一、for 循环语句练习题（5道经典，附答案）​

练习题1：输出 1 到 10 的整数（基础入门）​

题目要求​

解题思路​

参考代码（答案）​

运行结果​

练习题2：计算 1 到 100 的累加和（进阶求和）​

题目要求​

解题思路​

参考代码（答案）​

运行结果​

练习题3：输出 10 到 1 的倒序整数（反向循环）​

题目要求​

解题思路​

参考代码（答案）​

运行结果​

练习题4：输出 1 到 100 之间的所有偶数（条件筛选）​

题目要求​

解题思路​

参考代码（答案）​

运行结果（节选）​

练习题5：计算 n 的阶乘（综合应用，n 由用户输入）​

题目要求​

解题思路​

参考代码（答案）​

运行结果​

二、while 循环语句练习题（5道经典，附答案）​

练习题1：输出 1 到 10 的整数（基础入门，对应 for 题1）​

题目要求​

解题思路​

参考代码（答案）​

运行结果​

练习题2：计算 1 到 100 的累加和（进阶求和，对应 for 题2）​

题目要求​

解题思路​

参考代码（答案）​

运行结果​

练习题3：猜数字游戏（未知循环次数，核心应用）​

题目要求​

解题思路​

参考代码（答案）​

运行结果（示例）​

练习题4：计算用户输入数字的累加和（直到输入 0 结束）​

题目要求​

解题思路​

参考代码（答案）​

运行结果（示例）​

练习题5：输出 1 到 100 之间的所有奇数（条件筛选，对应 for 题4）​

题目要求​

解题思路​

参考代码（答案）​

运行结果（节选）​

三、do-while 循环语句练习题（3道经典，附答案）​

练习题1：固定步长2，输出1到20的奇数（基础步长强化）

题目要求

解题思路

参考代码（答案）

运行结果

练习题2：步长3，反向输出30到3的倍数（反向循环+自定义步长）

题目要求

解题思路

参考代码（答案）

运行结果

练习题3：自定义起点和步长，计算累加和（起点+步长综合）

题目要求

解题思路

参考代码（答案）

运行结果

练习题4：边界值强化，输出10到20之间步长4的数字（终点边界判断）

题目要求

解题思路

参考代码（答案）

运行结果

总结（给学生）

练习题5：灵活步长，输出2的n次方（1到10次方）（步长+起点+终点综合应用）

题目要求

解题思路

参考代码（答案）

运行结果

五、教学补充建议（给老师）

一、for 循环语句练习题（5道经典，附答案）

练习题1：输出 1 到 10 的整数（基础入门）

题目要求

解题思路

参考代码（答案）

运行结果

练习题2：计算 1 到 100 的累加和（进阶求和）

题目要求

解题思路

参考代码（答案）

运行结果

练习题3：输出 10 到 1 的倒序整数（反向循环）

题目要求

解题思路

参考代码（答案）

运行结果

练习题4：输出 1 到 100 之间的所有偶数（条件筛选）

题目要求

解题思路

参考代码（答案）

运行结果（节选）

练习题5：计算 n 的阶乘（综合应用，n 由用户输入）

题目要求

解题思路

参考代码（答案）

运行结果

二、while 循环语句练习题（5道经典，附答案）

练习题1：输出 1 到 10 的整数（基础入门，对应 for 题1）

题目要求

解题思路

参考代码（答案）

运行结果

练习题2：计算 1 到 100 的累加和（进阶求和，对应 for 题2）

题目要求

解题思路

参考代码（答案）

运行结果

练习题3：猜数字游戏（未知循环次数，核心应用）

题目要求

解题思路

参考代码（答案）

运行结果（示例）

练习题4：计算用户输入数字的累加和（直到输入 0 结束）

题目要求

解题思路

参考代码（答案）

运行结果（示例）

练习题5：输出 1 到 100 之间的所有奇数（条件筛选，对应 for 题4）

题目要求

解题思路

参考代码（答案）

运行结果（节选）

三、do-while 循环语句练习题（3道经典，附答案）