东方 - 循环（1）- 循环输出

天秀信息学奥赛

已于 2024-04-04 17:14:07 修改

阅读量604

点赞数 24

分类专栏：东方 - C++基础知识文章标签： c++

于 2024-03-29 18:28:10 首次发布

本文链接：https://blog.csdn.net/m0_46192147/article/details/137149008

版权

东方 - C++基础知识专栏收录该内容

8 篇文章 1 订阅

订阅专栏

解析部分：

循环输出

1881. 循环输出1~100之间的每个数

问题描述

循环输出1到100之间的每个整数，每行输出一个数。

解题思路

初始化循环计数器：从1开始。
设置循环条件：循环计数器不超过100。
输出每个整数：在循环体中输出当前计数器的值。
更新计数器：每次循环结束后计数器增加1。

代码实现

#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 100; i++) { // 从1循环到100
        cout << i << endl; // 输出当前数并换行
    }
    return 0; // 程序结束
}

代码解析

使用for循环结构，初始化循环变量i为1，并设置循环条件为i <= 100，确保能够输出从1到100的每个整数。
在循环体内，使用cout输出变量i的值，并通过endl实现每输出一个数后换行。
循环体执行完毕后，i自增1，继续判断并执行循环直到i大于100，循环结束。
整个程序通过for循环结构实现了1到100的数的顺序输出，并且每输出一个数就换行。

1882. 循环输出100~1之间的每个数

问题描述

循环输出100到1之间的每个整数，输出时每行输出一个数。

解题思路

初始化循环计数器：从100开始。
设置循环条件：循环计数器不小于1。
输出每个整数：在循环体中输出当前计数器的值。
更新计数器：每次循环结束后计数器减少1。

代码实现

#include <iostream>
using namespace std;

int main() {
    for (int i = 100; i >= 1; i--) { // 从100循环到1
        cout << i << endl; // 输出当前数并换行
    }
    return 0; // 程序结束
}

代码解析

使用for循环结构，初始化循环变量i为100，并设置循环条件为i >= 1，确保能够输出从100到1的每个整数。
在循环体内，使用cout输出变量i的值，并通过endl实现每输出一个数后换行。
循环体执行完毕后，i自减1，继续判断并执行循环直到i小于1，循环结束。
整个程序通过for循环结构实现了100到1的数的倒序输出，并且每输出一个数就换行。

1696. 请输出1~n之间所有的整数

问题描述

从键盘读入一个整数 ( n )，循环输出1到( n )之间所有的整数，每行输出一个数。

解题思路

读入整数：从键盘获取一个整数，表示要输出的数字范围上限。
循环输出：从1开始循环到( n )，在循环体中输出当前的整数，并且每输出一个数字后换行。

代码实现

#include <iostream>
using namespace std;

int main() {
    int n;  // 定义一个整数变量n
    cin >> n;  // 从键盘读入n的值

    for (int i = 1; i <= n; i++) {  // 循环从1到n
        cout << i << endl;  // 输出当前的数并换行
    }

    return 0;  // 程序结束
}

代码解析

int n;定义一个整数变量n用于存储输入的上限。
cin >> n;从键盘读入一个整数，存储到变量n中。
使用for循环，初始化循环变量i为1，设置循环条件i <= n，确保输出从1到n的所有整数。
在循环体内，使用cout输出变量i的值，并通过endl实现每输出一个数后换行。
循环体执行完毕后，i自增1，继续判断并执行循环直到i大于n，循环结束。
整个程序通过for循环结构实现了从1到n的数的顺序输出，并且每输出一个数就换行。

1697. 请输出n~1之间所有的整数

问题描述

从键盘读入一个整数 ( n )，请循环输出 ( n )到1之间所有的整数，每行输出一个数。

解题思路

读入整数：从键盘获取一个整数，表示要输出的数字范围上限。
循环输出：从( n )开始循环到1，递减输出每一个整数，并且每输出一个数字后换行。

代码实现

#include <iostream>
using namespace std;

int main() {
    int n;  // 定义一个整数变量n
    cin >> n;  // 从键盘读入n的值

    for (int i = n; i >= 1; i--) {  // 循环从n到1
        cout << i << endl;  // 输出当前的数并换行
    }

    return 0;  // 程序结束
}

代码解析

int n;定义一个整数变量n用于存储输入的上限。
cin >> n;从键盘读入一个整数，存储到变量n中。
使用for循环，初始化循环变量i为n，设置循环条件i >= 1，确保输出从n到1的所有整数。
在循环体内，使用cout输出变量i的值，并通过endl实现每输出一个数后换行。
循环体执行完毕后，i递减1，继续判断并执行循环直到i小于1，循环结束。
整个程序通过for循环结构实现了从n到1的数的倒序输出，并且每输出一个数就换行。

1698. 请输出带有特殊尾数的数

问题描述

从键盘读入一个整数 ( n )，要求输出 ( 1 )到( n )之间所有个位为 ( 1 )、( 3 )、( 5 )、( 7 )的整数，每行输出一个数。

解题思路

读入整数：首先从键盘获取一个整数，作为范围的上限。
循环判断并输出：对于 ( 1 )到( n )之间的每一个数，判断其个位数是否为 ( 1 )、( 3 )、( 5 )、( 7 )，如果是，则输出这个数。

代码实现

#include <iostream>
using namespace std;

int main() {
    int n;  // 定义整数n
    cin >> n;  // 从键盘读入n的值

    for (int i = 1; i <= n; i++) {  // 从1遍历到n
        int lastDigit = i % 10;  // 计算个位数
        if (lastDigit == 1 || lastDigit == 3 || lastDigit == 5 || lastDigit == 7) {  // 判断个位数是否为1、3、5、7
            cout << i << endl;  // 输出符合条件的数并换行
        }
    }

    return 0;  // 程序结束
}

代码解析

int n;定义整数变量n用于存储输入的数。
cin >> n;从键盘读入一个整数，存储到变量n中。
使用for循环，初始化循环变量i为1，条件为i <= n，确保从1到n的遍历。
在循环体内，计算变量i的个位数，如果这个个位数是1、3、5、7中的一个，则输出i。
使用cout输出满足条件的数，并使用endl实现换行。
循环直到i > n时结束，此时所有符合条件的数已经输出。

1699. 输出是2的倍数，但非3的倍数的数

问题描述

输入一个整数 ( n )，输出 ( 1 )至( n ) 中所有是 ( 2 ) 的倍数，但非 ( 3 ) 的倍数的整数，每行一个数。

解题思路

输入处理：首先获取一个整数，这个整数作为范围的上限。
条件判断与输出：遍历从 ( 1 ) 到 ( n ) 的所有整数，判断每个数是否符合是 ( 2 ) 的倍数但非 ( 3 ) 的倍数的条件。如果符合，则输出该数。

代码实现

#include <iostream>
using namespace std;

int main() {
    int n;  // 定义整数n
    cin >> n;  // 读入整数n

    for (int i = 1; i <= n; i++) {  // 从1遍历到n
        if (i % 2 == 0 && i % 3 != 0) {  // 判断是否是2的倍数但非3的倍数
            cout << i << endl;  // 输出符合条件的数并换行
        }
    }

    return 0;  // 程序结束
}

代码解析

int n; 定义一个整数n用来存储用户输入的数值。
cin >> n; 从键盘读入用户输入的整数。
for (int i = 1; i <= n; i++) { 使用for循环从1到n遍历。
if (i % 2 == 0 && i % 3 != 0) { 在循环内部使用if语句判断当前数i是否符合是2的倍数但非3的倍数的条件。
cout << i << endl; 如果条件成立，则输出该数并换行。
循环继续直到i大于n时结束。这样可以保证输出所有在1到n范围内符合条件的数。

1700. 请输出所有的2位数中，含有数字2的整数

问题描述

需要找出并输出所有两位数中，含有数字2的整数，从小到大每行输出一个。

解题思路

范围确定：两位数范围从10到99。
数字检测：检查每个数的十位和个位上是否含有数字2。
输出：满足条件的数按顺序输出。

代码实现

使用简单的循环和条件判断来实现这个逻辑。

#include <iostream>
using namespace std;

int main() {
    for (int i = 10; i < 100; i++) {  // 遍历所有两位数
        int tens = i / 10;  // 计算十位数字
        int units = i % 10;  // 计算个位数字
        if (tens == 2 || units == 2) {  // 如果十位或个位上有数字2
            cout << i << endl;  // 输出该数
        }
    }

    return 0;  // 程序结束
}

代码解析

循环for (int i = 10; i < 100; i++)：从10开始到99结束，覆盖了所有两位数。
int tens = i / 10; 和 int units = i % 10;：分别计算当前数字的十位和个位数。
if (tens == 2 || units == 2)：判断当前数字的十位或个位是否为2。
cout << i << endl;：如果符合条件，即含有数字2，则输出这个数并换行。

这样就能够按要求输出所有两位数中含有数字2的整数。

1701. 请输出所有的3位对称数

问题描述

需要找出并输出所有三位对称数，这些数正过来和倒过来读都一样。

解题思路

范围确定：三位数范围从100到999。
对称判断：三位数的百位和个位数字相同。
输出：满足条件的数按顺序输出。

代码实现

使用循环遍历所有三位数，并判断对称条件。

#include <iostream>
using namespace std;

int main() {
    for (int i = 100; i < 1000; i++) {  // 遍历所有三位数
        int hundreds = i / 100;  // 计算百位数字
        int units = i % 10;  // 计算个位数字
        if (hundreds == units) {  // 如果百位和个位相同，则为对称数
            cout << i << endl;  // 输出该数
        }
    }

    return 0;  // 程序结束
}

代码解析

循环for (int i = 100; i < 1000; i++)：从100开始到999结束，覆盖了所有三位数。
int hundreds = i / 100;：计算当前数字的百位数。
int units = i % 10;：计算当前数字的个位数。
if (hundreds == units)：判断当前数字的百位和个位是否相同。
cout << i << endl;：如果满足对称条件，则输出这个数并换行。

这样的处理逻辑可以确保输出所有三位对称数。

1711. 输出满足条件的整数1

问题描述

需要找出并输出所有两位数，其中十位数字大于个位数字，并且两者之和为偶数。

解题思路

范围确定：两位数范围从10到99。
条件判断：
- 十位数字大于个位数字。
- 十位和个位数字之和为偶数。
输出：符合条件的两位数按顺序输出。

代码实现

遍历所有两位数，检查是否满足条件并输出。

#include <iostream>
using namespace std;

int main() {
    for (int i = 10; i < 100; i++) {  // 遍历所有两位数
        int tens = i / 10;  // 十位数字
        int units = i % 10;  // 个位数字

        // 十位大于个位且十位与个位之和为偶数
        if (tens > units && (tens + units) % 2 == 0) {
            cout << i << endl;  // 输出满足条件的数字
        }
    }

    return 0;  // 程序结束
}

代码解析

循环for (int i = 10; i < 100; i++)：遍历所有两位数。
int tens = i / 10;：计算当前数字的十位数。
int units = i % 10;：计算当前数字的个位数。
if (tens > units && (tens + units) % 2 == 0)：判断十位是否大于个位，并且它们的和是否为偶数。
cout << i << endl;：如果满足条件，则输出这个数字。

这样的处理逻辑可以确保输出所有满足条件的两位数。

1712. 输出满足条件的整数2

问题描述

寻找并输出所有满足特定条件的三位数：这些数的百位、十位、个位之和为偶数，且百位大于十位，十位大于个位。

解题思路

范围确定：三位数的范围从100到999。
条件判断：
- 百位、十位、个位之和为偶数。
- 百位大于十位，十位大于个位。
输出：符合条件的三位数按顺序输出。

代码实现

遍历所有三位数，检查是否满足条件并输出。

#include <iostream>
using namespace std;

int main() {
    for (int i = 100; i <= 999; i++) {  // 遍历所有三位数
        int hundreds = i / 100;  // 百位数字
        int tens = (i / 10) % 10;  // 十位数字
        int units = i % 10;  // 个位数字

        // 检查百位大于十位，十位大于个位，且和为偶数
        if (hundreds > tens && tens > units && (hundreds + tens + units) % 2 == 0) {
            cout << i << endl;  // 输出满足条件的整数
        }
    }

    return 0;  // 程序结束
}

代码解析

循环for (int i = 100; i <= 999; i++)：遍历所有三位数。
int hundreds = i / 100;：计算当前数字的百位数。
int tens = (i / 10) % 10;：计算当前数字的十位数。
int units = i % 10;：计算当前数字的个位数。
if (hundreds > tens && tens > units && (hundreds + tens + units) % 2 == 0)：判断百位大于十位，十位大于个位，并且它们的和为偶数。
cout << i << endl;：如果满足条件，则输出这个数字。

通过这个逻辑，我们可以确保所有满足条件的三位数都会被正确输出。

1713. 输出满足条件的整数3

问题描述

数列的前4个数为1, 4, 7, 10。输入一个正整数n，输出1∼n之间所有满足数列规律的数字。

解题思路

观察数列规律：从1开始，每个数比前一个数大3。
按照这个规律生成数列中的数。
输出不大于n的数列中的数。

代码实现

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;  // 从键盘读入n

    // 生成并输出满足条件的整数
    for (int i = 1; i <= n; i += 3) {
        cout << i << endl;  // 输出每个满足条件的整数
    }

    return 0;  // 程序结束
}

代码解析

int n;：定义整数n来存储用户输入。
cin >> n;：从键盘读入n。
for (int i = 1; i <= n; i += 3)：从1开始，每次增加3，直到超过n，循环生成数列中的数字。
cout << i << endl;：输出每个满足条件的整数。

通过这个逻辑，我们可以确保所有1∼n之间满足数列规律的数字都会被正确输出。

1714. 输出满足条件的整数4

问题描述

需要输出1∼n之间的整数，这些整数需要满足以下条件：含有数字3或5，并且是2的倍数。

解题思路

遍历1到n之间的每个数。
检查每个数是否包含数字3或5，并且能被2整除。
输出满足条件的数。

代码实现

#include <iostream>
using namespace std;

bool contains35(int num) {
    // 检查数字中是否包含3或5
    while (num > 0) {
        int digit = num % 10;  // 获取当前最低位的数字
        if (digit == 3 || digit == 5) {
            return true;  // 如果包含3或5，则返回true
        }
        num /= 10;  // 去掉当前最低位，继续检查下一位
    }
    return false;  // 如果没有包含3或5，返回false
}

int main() {
    int n;
    cin >> n;  // 从键盘读入n

    // 遍历并输出满足条件的整数
    for (int i = 2; i <= n; i += 2) {  // 由于是2的倍数，可以从2开始，步长为2
        if (contains35(i)) {
            cout << i << endl;  // 输出满足条件的整数
        }
    }

    return 0;  // 程序结束
}

代码解析

bool contains35(int num)：定义一个函数来检查一个数是否包含数字3或5。
while (num > 0)：使用循环来检查每一位数字。
int digit = num % 10;：获取最低位的数字。
if (digit == 3 || digit == 5)：如果数字为3或5，则返回true。
num /= 10;：去掉已检查的最低位，继续检查下一位。
在主函数中，通过从2开始，步长为2（因为只考虑偶数）来遍历，并使用contains35(i)判断每个数是否满足条件，满足则输出。

这样，程序能够正确地输出1∼n中符合条件的整数。

1715. 输出满足条件的整数5

问题描述

找出所有四位数，满足以下条件：

千位和百位之和为偶数。
十位和个位之和为奇数。
千位和百位之和大于十位和个位之和。
数字含有因数8。

解题思路

遍历1000到9999之间的所有整数。
对于每个数，分别计算千位、百位、十位和个位数字。
检查上述条件是否都满足。
输出满足条件的整数。

代码实现

#include <iostream>
using namespace std;

bool checkCondition(int num) {
    int thousand = num / 1000;                  // 千位
    int hundred = (num / 100) % 10;             // 百位
    int ten = (num / 10) % 10;                  // 十位
    int one = num % 10;                         // 个位

    int sum_first_two = thousand + hundred;     // 千位和百位之和
    int sum_last_two = ten + one;               // 十位和个位之和

    // 检查所有条件
    return sum_first_two % 2 == 0 &&            // 前两位之和为偶数
           sum_last_two % 2 == 1 &&             // 后两位之和为奇数
           sum_first_two > sum_last_two &&      // 前两位之和大于后两位
           num % 8 == 0;                        // 数字含有因数8
}

int main() {
    for (int i = 1000; i <= 9999; i++) {
        if (checkCondition(i)) {
            cout << i << endl;  // 输出满足条件的整数
        }
    }

    return 0;  // 程序结束
}

代码解析

bool checkCondition(int num)：定义一个函数来检查数字是否符合条件。
通过数学运算得到千位、百位、十位和个位上的数字。
判断条件是否满足：千位和百位之和为偶数，十位和个位之和为奇数，前两位之和大于后两位之和，且数字能被8整除。
主函数中遍历1000到9999的整数，对于每个数，调用checkCondition(i)函数判断是否满足条件，满足则输出。

通过这种方式，程序能够输出所有符合条件的四位数。

1721. 输出个位为5或者个位为8的数

问题描述

需要输出1至n范围内，所有个位数字为5或8的整数。

解题思路

遍历1至n的所有整数。
对于每个数，检查其个位数字是否为5或8。
如果满足条件，则输出该数字。

代码实现

这里给出一个程序示例，用于执行上述逻辑：

#include <iostream>
using namespace std;

void printSpecialNumbers(int n) {
    for (int i = 1; i <= n; i++) {
        int lastDigit = i % 10;  // 获取个位数
        if (lastDigit == 5 || lastDigit == 8) {
            cout << i << endl;  // 输出满足条件的数
        }
    }
}

int main() {
    int n;
    cin >> n;  // 从键盘读入n
    printSpecialNumbers(n);  // 输出个位为5或8的数
    return 0;
}

代码解析

printSpecialNumbers(int n)函数遍历1至n的每个整数，并检查每个数的个位是否为5或8。
在主函数中，读入整数n，并调用printSpecialNumbers(n)函数来输出满足条件的整数。

这样的程序逻辑可以确保所有满足条件的数被正确输出。

1722. 输出两位的巧数

问题描述

要找到并输出所有两位数，其各位数字之和加上各位数字之积等于该数本身的特殊数，即所谓的“巧数”。

解题思路

遍历所有两位数（从10到99）。
对于每个数，计算其十位和个位数字之和以及乘积。
检查这个和加乘积是否等于原数。
如果等于，输出这个数。

代码实现

示例代码如下：

#include <iostream>
using namespace std;

void findCleverNumbers() {
    for (int num = 10; num < 100; num++) {
        int tens = num / 10;  // 十位数字
        int ones = num % 10;  // 个位数字

        if ((tens + ones) + (tens * ones) == num) {
            cout << num << endl;  // 输出巧数
        }
    }
}

int main() {
    findCleverNumbers();  // 查找并输出所有的两位巧数
    return 0;
}

代码解析

函数findCleverNumbers遍历从10到99的所有两位数。
计算每个数的十位和个位数字之和及其乘积。
如果该数符合巧数的定义，即其和加乘积等于自身，则将其输出。

这样可以确保所有两位巧数都被找到并按顺序输出。

1017. 求零件个数

问题描述

求一个数，这个数除以3余2，除以5余3，除以7余5，要求这个数大于100。

解题思路

遍历从101开始的整数，因为题目指定零件数超过100。
对于每个数，检查它是否满足三个条件：
- 除以3的余数是2
- 除以5的余数是3
- 除以7的余数是5
当找到第一个满足条件的数时，这就是所求的最少零件数。

代码实现

示例代码如下：

#include <iostream>
using namespace std;

int findPartsNumber() {
    int num = 101;  // 从101开始遍历
    while (true) {
        if (num % 3 == 2 && num % 5 == 3 && num % 7 == 5) {
            return num;  // 找到符合条件的数，返回结果
        }
        num++;  // 继续检查下一个数
    }
}

int main() {
    cout << findPartsNumber();  // 输出零件的最少个数
    return 0;
}

代码解析

使用一个无限循环遍历每个整数，从101开始。
检查每个数是否满足给定的三个条件。
当找到符合条件的数时，结束循环并返回这个数。

这种方法可以确保找到并返回满足题目要求的最少零件数。

1021. 求数II

问题描述

找出在1至500之间能同时满足以下条件的所有整数：

被3除后余数为2
被5除后余数为3
被7除后余数为2

解题思路

遍历1至500之间的每个整数。
对每个整数检查它是否满足上述三个条件。
输出满足条件的整数。

代码实现

示例代码如下：

#include <iostream>
using namespace std;

int main() {
    for (int num = 1; num <= 500; num++) {
        if (num % 3 == 2 && num % 5 == 3 && num % 7 == 2) {
            cout << num << endl;  // 输出满足条件的数
        }
    }
    return 0;
}

代码解析

使用一个for循环从1到500遍历。
在循环内，通过条件判断语句检查每个数是否同时满足三个余数条件。
满足条件的数将被输出。

这种方法可以确保找出并输出1至500之间所有满足条件的整数。

1058. 求出100至999范围内的所有水仙花数。

问题描述

所谓水仙花数，就是指各位数字立方之和等于该数的数；(a^3) 称为 (a) 的立方，即等于a×a×a 的值。

例如：因为 (153 = 1^3 + 5^3 + 3^3) ，所以 (153) 是一个水仙花数。

解题思路

遍历从100到999的每个数。
对每个数，分解出其个位、十位、百位。
判断是否为水仙花数，即判断各位数字立方之和是否等于该数。
若是，则输出该数。

代码实现

#include <iostream>
using namespace std;

int main() {
    for (int num = 100; num <= 999; ++num) {
        int digit1 = num / 100;     // 百位
        int digit2 = (num / 10) % 10; // 十位
        int digit3 = num % 10;       // 个位

        if (num == digit1 * digit1 * digit1 + digit2 * digit2 * digit2 + digit3 * digit3 * digit3)
            cout << num << endl;
    }

    return 0;
}

代码解析

使用一个循环遍历从100到999的每个数。
对于每个数，分解出其个位、十位、百位。
判断是否为水仙花数，即判断各位数字立方之和是否等于该数。
若是，则输出该数。

1059. 求数

问题描述

输出 (1 ~ 999) 中有因数 (3) ，且至少有一位数字是 (5) 的数。

解题思路

遍历从1到999的每个数。
对每个数，判断是否有因数3且至少有一位数字是5。
若是，则输出该数。

代码实现

#include <iostream>
using namespace std;

int main() {
    for (int num = 1; num <= 999; ++num) {
        if (num % 3 == 0 && (num % 10 == 5 || (num / 10) % 10 == 5 || (num / 100) % 10 == 5))
            cout << num << endl;
    }

    return 0;
}

代码解析

使用一个循环遍历从1到999的每个数。
对于每个数，判断是否能被3整除且至少有一位数字是5。
若是，则输出该数。

1264. 4位反序数

问题描述

设 ( N ) 是一个四位数，它的 ( 9 ) 倍恰好是其反序数，求 ( N ) 。

反序数就是将整数的数字倒过来形成的整数。例如： ( 1234 ) 的反序数是 ( 4321 ) 。

解题思路

从1000开始遍历四位数。
对于每个数，计算其乘以9的结果，并求其反序数。
判断该反序数是否等于原数乘以9。
若是，则输出该数。

代码实现

#include <iostream>
using namespace std;

int main() {
    int N = 1000; // 从1000开始遍历
    int M1, M2;
    for (N = 1000; N < 10000; N++) {
        M1 = N * 9;
        if (M1 > 9999) 
            break;
        else {
            M2 = (M1 / 1000) + ((M1 % 1000) / 100) * 10 + (((M1 % 1000) % 100) / 10) * 100 + (((M1 % 1000) % 100) % 10) * 1000;
            if (M2 == N) 
                cout << N << endl;
        }
    }
    return 0;
}

代码解析

从1000开始遍历四位数。
对于每个数，计算其乘以9的结果，并求其反序数。
判断该反序数是否等于原数乘以9。
若是，则输出该数。

1266. 求最大数

问题描述

问 (555555) 的约数中最大的三位数是多少？

解题思路

遍历 (1) 到 (555555) 的所有数，找出能整除 (555555) 且小于 (1000) 的数中的最大值。

代码实现

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    int i = 555555;
    int m = 0;
    for(int n = 1; n < i; n++)
    {
        if(i % n == 0 && n < 1000)
        {
            m = n;
        }
    }
    cout << m << endl;
    return 0;
}

代码解析

从 (1) 到 (555555) 的所有数中，找出能整除 (555555) 且小于 (1000) 的最大数。
输出找到的最大数。

1392. 回文偶数？

问题描述

小明发现有一类数非常有趣，它们正过来读和反过来读是一样的，例如：121、202、383等，这些被称为回文数。现在要求找出所有3位的既是回文数又是偶数的数，例如：202满足条件，而121虽是回文数但不是偶数。

解题思路

遍历所有3位数，即从100到999。
判断每个数是否满足以下两个条件：
1. 数字是偶数（末尾数字是0、2、4、6或8）。
2. 数字是回文数（第一位和第三位数字相同）。
若一个数同时满足以上两个条件，则输出该数。

代码实现

#include <iostream>
using namespace std;

int main() {
    for (int num = 100; num <= 999; num += 2) { // 偶数可以每次增加2
        int first = num / 100; // 获取百位数
        int last = num % 10; // 获取个位数
        if (first == last) { // 判断是否为回文数
            cout << num << endl;
        }
    }
    return 0;
}

代码解析

使用一个从100到999的循环，但只遍历偶数，因为只有偶数才可能满足条件。
对每个数，计算其百位和个位数字，并判断是否相等来确定是否是回文数。
如果一个数既是偶数又是回文数，则输出该数。

1447. 统计4位的回文数

问题描述

回文数是指正读和反读都相同的数，例如1661和2772都是回文数。任务是编程找出所有4位的回文数。

解题思路

遍历所有4位数，即从1000到9999。
对每个数，检查其是否为回文数。对于4位数，第一位数字应与第四位相同，第二位数字应与第三位相同。
符合上述条件的数即为所求的4位回文数。

代码实现

#include <iostream>
using namespace std;

int main() {
    for (int num = 1000; num <= 9999; ++num) {
        int first = num / 1000; // 获取千位数
        int second = (num / 100) % 10; // 获取百位数
        int third = (num / 10) % 10; // 获取十位数
        int last = num % 10; // 获取个位数

        if (first == last && second == third) { // 判断是否为回文数
            cout << num << endl;
        }
    }
    return 0;
}

代码解析

使用从1000到9999的循环遍历每个4位数。
对每个数，通过整数除法和模运算提取其各个数字，并判断这些数字是否满足回文数的条件。
如果一个数满足回文条件，则将其输出。这样可以列出所有4位的回文数。

1466. 等差数

问题描述

Peter学习了等差数列的概念：一个数列，其中任意连续两个数的差值相等，例如：123、135、852。Peter定义了等差数，这种数的连续两位的差值相等，例如：123, 159, 1357, 852都是等差数。现在要编程找出给定范围内的所有等差数。

解题思路

遍历给定范围内的所有整数。
对每个数，检查其各位数字是否构成等差数列，即每两位数字的差值是否相等。
如果满足条件，输出该数。

代码实现

#include <iostream>
#include <vector>
using namespace std;

bool isArithmeticNumber(int num) {
    vector<int> digits;
    while (num > 0) {
        digits.push_back(num % 10);  // 获取每一位的数字
        num /= 10;
    }
    for (int i = 2; i < digits.size(); ++i) {
        if (digits[i] - digits[i - 1] != digits[1] - digits[0]) {
            return false;  // 判断差值是否相等
        }
    }
    return true;
}

int main() {
    int m, n;
    cin >> m >> n;
    for (int num = m; num <= n; ++num) {
        if (isArithmeticNumber(num)) {
            cout << num << endl;
        }
    }
    return 0;
}

代码解析

函数isArithmeticNumber判断一个数是否为等差数。它先把数的每一位分解到一个向量中，然后检查向量中是否每两位之间的差值相等。
主函数读取两个整数m和n，遍历这个区间，对于每个数，使用isArithmeticNumber函数判断是否是等差数，如果是，则输出该数。这样可以找出m到n之间的所有等差数。

1737. 奇怪的数？

问题描述

小明需要找出满足以下条件的奇怪整数：

数字为四位数。
数字的千位和十位对调，百位和个位对调后，数值仍等于本身。
数字为奇数。
任务是找出所有小于或等于给定整数n的奇怪整数。

解题思路

四位数的奇怪整数在对调位后等于自身，意味着这个数有特定的结构，即它由两个相同的两位数组成，形式为ABAB。
因为要求是奇数，所以B（个位）必须是奇数1, 3, 5, 7, 或9。
遍历可能的数字组合来寻找符合条件的数。

代码实现

#include <iostream>
using namespace std;

void findStrangeNumbers(int n) {
    for (int a = 1; a <= 9; a++) { // 千位数不能为0
        for (int b = 1; b <= 9; b += 2) { // 个位数为奇数
            int num = a * 1000 + b * 100 + a * 10 + b; // 构造ABAB形式的数
            if (num <= n) {
                cout << num << endl;
            }
        }
    }
}

int main() {
    int n;
    cin >> n;
    findStrangeNumbers(n);
    return 0;
}

代码解析

通过嵌套循环构造符合ABAB形式的四位数，其中a代表千位和十位，b代表百位和个位。
确保个位数b为奇数，以满足奇数的条件。
生成的数如果小于或等于输入的n，则输出该数，以列出所有满足条件的奇怪整数。

1746. 能被2、3、5、7中至少2个数整除的数

问题描述

需要输出1到n之间至少能被2、3、5、7中的两个及两个以上的数整除的数。例如，30能被2、3、5中的三个数整除，符合条件。

解题思路

遍历从1到n的每个数。
对每个数，检查它是否能被2、3、5、7整除，并计算能整除的数的数量。
如果一个数能被至少两个数整除，则输出该数。

代码实现

#include <iostream>
using namespace std;

void findDivisibleNumbers(int n) {
    for (int i = 1; i <= n; i++) {
        int count = 0;
        if (i % 2 == 0) count++;
        if (i % 3 == 0) count++;
        if (i % 5 == 0) count++;
        if (i % 7 == 0) count++;

        if (count >= 2) { // 检查是否至少被2个数整除
            cout << i << endl;
        }
    }
}

int main() {
    int n;
    cin >> n;
    findDivisibleNumbers(n);
    return 0;
}

代码解析

在函数findDivisibleNumbers中，使用一个循环从1到n遍历。
对每个数，使用一个计数器来统计它能被2、3、5、7中哪些数整除。
如果计数器的值至少为2，说明该数能被至少两个指定的数整除，于是输出该数。
通过这种方式，我们可以找出1到n之间所有符合条件的数。

1748. 山形数

问题描述

山形数是一个三位数，其十位数比个位和百位都要大，呈现出山的形状。

解题思路

遍历所有三位数（从100到999）。
对于每个数，比较百位、十位和个位的数值，确保十位的数值大于百位和个位的数值。
满足条件的数即为山形数。

代码实现

#include <iostream>
using namespace std;

int main() {
    for (int num = 100; num <= 999; num++) {
        int hundred = num / 100; // 获取百位数
        int ten = (num / 10) % 10; // 获取十位数
        int one = num % 10; // 获取个位数

        // 检查十位数是否大于百位和个位数
        if (ten > hundred && ten > one) {
            cout << num << endl;
        }
    }
    return 0;
}

代码解析

通过从100到999的循环来遍历所有三位数。
在循环中，通过整数除法和模运算获取每个数的百位、十位和个位数字。
然后检查这些数是否符合山形数的条件：十位的数字大于百位和个位的数字。
符合条件的数被认为是山形数，并输出。这样可以列出所有的山形数。

1861. 整除问题

问题描述

编写程序输入三个正整数 min、max 和 factor，然后输出min到max（包括两端）之间所有能被factor整除的整数。

解题思路

读取输入的min、max和factor。
遍历从min到max的每个整数。
检查每个数是否能被factor整除。
如果能整除，则输出该数。

代码实现

#include <iostream>
using namespace std;

int main() {
    int min, max, factor;
    cin >> min >> max >> factor; // 读取输入

    for (int i = min; i <= max; ++i) {
        if (i % factor == 0) { // 检查是否能被factor整除
            cout << i << " "; // 输出符合条件的数
        }
    }
    return 0;
}

代码解析

程序首先通过cin读取输入的三个整数min、max和factor。
使用一个循环从min遍历到max，在每次循环中检查当前数是否能够被factor整除。
若当前数能够被factor整除，则将其输出，并在数与数之间添加空格以分隔。
这样的逻辑能够确保从min到max之间所有能被factor整除的整数都会被正确输出。

1863. 特殊的数字四十

问题描述

需要找出所有四位数，它们的各位数字之和为10。

解题思路

遍历所有四位数（从1000到9999）。
对于每个数，计算其各位数字之和。
如果各位数字之和等于10，则输出该数。

代码实现

#include <iostream>
using namespace std;

int main() {
    for (int num = 1000; num <= 9999; num++) {
        int sum = 0;
        int currentNum = num;

        // 计算各位数字之和
        while (currentNum > 0) {
            sum += currentNum % 10; // 加上个位数
            currentNum /= 10; // 移除个位数
        }

        // 检查各位数字之和是否为10
        if (sum == 10) {
            cout << num << endl;
        }
    }
    return 0;
}

代码解析

程序通过一个从1000到9999的循环遍历所有四位数。
在每次循环中，使用一个辅助变量currentNum来处理当前的数，并逐位累加其数字之和到变量sum中。
当sum等于10时，输出当前遍历到的数，因为它的各位数字之和符合条件。
通过这种方法可以找出并列出所有各位数字之和为10的四位数。

1085. 寻找雷劈数

问题描述

雷劈数是这样一种四位整数，它可以被拆分为两个数，这两个数的和的平方等于原来的四位数。例如，3025可以拆分为30和25，它们的和是55，55的平方是3025。

解题思路

遍历所有四位数，即从1000到9999。
对于每个数，将其拆分为两个两位数，分别为数的前两位和后两位。
计算这两个两位数的和的平方。
如果和的平方等于原数，则原数为雷劈数。

代码实现

#include <iostream>
using namespace std;

int main() {
    for (int num = 1000; num <= 9999; num++) {
        int ab = num / 100; // 获取前两位
        int cd = num % 100; // 获取后两位
        int sum = ab + cd;

        if (sum * sum == num) { // 检查是否为雷劈数
            cout << num << endl;
        }
    }
    return 0;
}

代码解析

通过从1000到9999的循环遍历所有四位数。
在每次循环中，整数除法和模运算用于从当前数中分离出前两位和后两位数字。
计算这两部分数字的和，并求其平方。
如果这个平方等于原始四位数，则该数是雷劈数，输出该数。
通过这种方式可以找出所有的雷劈数并按从小到大的顺序输出。

1090. 同因查找

问题描述

需要找出10至1000之间所有能同时被2、3和7整除的数。

解题思路

遍历从10到1000的每个数。
对每个数，检查是否能同时被2、3和7整除。
如果能，输出该数。

代码实现

#include <iostream>
using namespace std;

int main() {
    for (int num = 10; num <= 1000; num++) {
        if (num % 2 == 0 && num % 3 == 0 && num % 7 == 0) {
            cout << num << endl; // 输出满足条件的数
        }
    }
    return 0;
}