循环

while循环

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
using namespace std;
int main()
{
    int i = 0;
    while (i < 10)
    {
        cout << i << endl;
        i ++;
    }
    return 0;
}

练习

  1. 求1~100中所有数的立方和
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #include <iostream>
    using namespace std;
    int main()
    {
        int i, s;
        i = 1;
        s = 0;
        while (i <= 100)
        {
            s = s + i * i * i;
            i ++;
        }
        cout << s << endl;
        return 0;
    }
  2. 求斐波那契数列的第n项。f(1)=1, f(2)=1, f(3)=2, f(n)=f(n-1)+f(n-2)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    #include <iostream>
    using namespace std;
    int main()
    {
        int a, b;
        a = 1;
        b = 1;
        int i = 0;
        int n;
        cin >> n;
        while (i < n-1)
        {
            int c = a + b;
            a = b;
            b = c;
            i ++;
        }
        cout << a <<endl;
        return 0;
    }

do while循环

与while循环不同，do while循环是先执行循环体后判断条件，不管条件如何都至少执行一次循环体。而while循环是先判断再执行。

比如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
using namespace std;
int main()
{
    int x = 1;
    while (x < 1)
    {
        cout << "x" << endl;
        x ++ ;
    }

    int y = 1;
    do
    {
        cout << "y" << endl;
    } while (y < 1);

    return 0;
}

输出

1
y

练习

使用do while循环求1~100的立方和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
using namespace std;
int main()
{
    int i, s;
    i = 1;
    s = 0;
    do
    {
        s = s + i * i * i;
        i ++;
    } while (i <= 100);
    cout << s << endl;
    return 0;
}

for循环

把控制循环次数的变量从循环体中剥离。

1
2
3
4
for (init语句; 条件语句; 表达式)
{
    ……
}

其中inti初始化语句可以是声明语句、表达式、空语句，最先执行且整个循环过程只执行一次。

接着进入条件语句，条件语句可以为空，默认为true。

然后执行{}内命令。

最后执行表达式，一般负责修改循环变量，可以为空，每一次循环后都会执行。

练习

  1. 输出1~10
    1
    2
    3
    4
    5
    6
    7
    8
    #include <iostream>
    using namespace std;
    int main()
    {
        for(int i=1; i <= 10; i ++)
            cout << i << endl;
        return 0;
    }
  2. 求1~100中所有数的立方和
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #include <iostream>
    using namespace std;
    int main()
    {
        int s = 0;
        for(int i=1; i <= 100; i ++)
        {
            s = s + i * i *i;
        }
        cout << s << endl;
        return 0;
    }
  3. 求斐波那契数列的第n项。f(1)=1, f(2)=1, f(3)=2, f(n)=f(n-1)+f(n-2)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #include <iostream>
    using namespace std;
    int main()
    {
        int a, b, n;
        a = 1;
        b = 1;
        cin >> n;
        for (int i = 0; i < n-1; i ++)
        {
            int c = a + b;
            a = b;
            b = c;
        }
        cout << a << endl;
        return 0;
    }

跳转

break

可以提前从循环中退出，一般与if搭配。如果满足if内条件则跳出循环。

例题

从1加到100，但是在加到50时跳出循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;
int main()
{
    int s = 0;
    for (int i = 1; i <= 100; i ++)
    {
        if (i > 50)
            break;

        s = s + i;
    }
    cout << s << endl;
}

continue

可以直接跳到当前循环体的结尾。作用与if语句类似。

例题
从1加到100，但是在加到50时跳过一次循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;
int main()
{
    int s = 0;
    for (int i = 1; i <= 100; i ++)
    {
        if (i == 50)
            continue;

        s = s + i;
    }
    cout << s << endl;
}

※break若满足if条件直接跳出循环，而continue会跳过一次循环到表达式步骤继续执行。

练习

  1. 求1 * 10 + 2 * 9 + 3 * 8 + 4 * 7 + 5 * 6的值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>

using namespace std;

int main()
{
    int s = 0;
    for (int i = 1, j = 10; i < j; i ++, j --)
    {
        s = s + i * j;
    }
    cout << s << endl;
    return 0;
}

  1. 质数

    判断一个大于1的数是否是质数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
using namespace std;
int main()
{
    int n;
    bool x = true;
    cin >> n;
    for (int i = 2; i < n; i ++)
    {
        if (n % i == 0)
            {
                x = false;
                break;
            }
    }
    if (x)
        cout << "yes" << endl;
    else
        cout << "no" << endl;
    return 0;
}
  1. 求1~100中所有偶数的和。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>

using namespace std;

int main()
{
    int s = 0;
    for (int i = 1; i <= 100; i ++)
    {
        if (i % 2 == 0)
            s = s + i;
        else
            continue;
    }
    cout << s << endl;
    return 0;
}

多层循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
using namespace std;
int main()
{
    int n;
    cin >> n;

    for (int i = 1, k = 1; i <= n; i ++)
    {
        for (int j= 1; j <= n; j ++, k ++)
        {
            cout << k << ' ';
        }
        cout << endl;
    }
    return 0;
}

输入

1
3

输出

1
2
3
1 2 3
4 5 6
7 8 9

输入

1
4

输出

1
2
3
4
1 2 3 4 
5 6 7 8
9 10 11 12
13 14 15 16

练习

  1. 打印1~100中的所有质数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
using namespace std;
int main()
{
    for (int i = 2; i <= 100; i ++)
    {
        bool x = true;
        for (int j = 2; j < i; j ++)
        {
            if (i % j == 0)
            {
                x = false;
                break;
            }
        }
        if (x)
            cout << i << endl;
    }
    return 0;
}
  1. 输入一个n，打印n阶菱形。n是奇数。

输入样例

1
9

输出样例

1
2
3
4
5
6
7
8
9
    *    
   ***   
  *****  
 ******* 
*********
 ******* 
  *****  
   ***   
    *   
方法1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
using namespace std;
int main()
{
    int n, l;
    cin >> n;
    l = (n + 1) / 2;

    for (int i = 1;i <= l;i ++)
    {
		for (int j = 1; j <= l - i; j ++)
			cout << " ";
		for (int k = 1; k <= i * 2 - 1; k ++)
			cout << "*";
		cout << endl;
	}

    for (int i = 1; i <= l - 1; i ++)
    {
        for (int j = 1; j <= i ; j ++)
            cout << " ";
        for (int j = 1; j <= (l - i) * 2 - 1; j ++)
			cout << "*";
        cout << endl;
    }
    return 0;
}

方法2

曼哈顿距离：平面上的两个点(x1, y1)和(x2, y2)的曼哈顿距离是
| x1 - x2 | + | y1 - y2|。

观察可得，若n = 5，则与中心点曼哈顿距离小于等于2的输出*，否则输出空格

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
    int n;
    cin >> n;

    int cx = n / 2, cy = n / 2;

    for (int i = 0; i < n; i ++)
    {
        for (int j = 0; j < n; j++)
        {
            if (abs(i - cx) + abs(j - cy) <= n / 2)
                cout << '*';
            else
                cout << ' ';
        }
        cout << endl;
    }
}

例题

  1. 偶数

    编写一个程序，输出 1 到 100 之间（包括 1 和 100）的全部偶数。

    输入格式

    无输入。

    输出格式

    输出全部偶数，每个偶数占一行。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    //法一
    #include <iostream>

    using namespace std;

    int main()
    {
        for (int i = 1; i <= 100; i ++)
        {
            if (i % 2 != 0)
                continue;
            
            cout << i << endl;
        }
        return 0;
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    //法二
    #include <iostream>

    using namespace std;

    int main()
    {
        for (int i = 2; i <= 100; i += 2)
            cout << i << endl;
        return 0;
    }

  2. 奇数

    输入一个整数 X，输出 1 到 X 之间（包括 1 和 X）的全部奇数。

    输入格式

    一个整数 X。

    输出格式

    输出所有满足条件的奇数，每个数占一行。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #include <iostream>
    using namespace std;
    int main()
    {
        int x;
        cin >> x;
        for (int i = 1; i <= x; i ++)
        {
            if (i % 2 == 0)
                continue;

            cout << i << endl;
        }
        return 0;
    }

  3. 正数

    输入 6 个实数，它们要么是正数，要么是负数。

    请你统计并输出正数的个数。

    输入格式

    六个数字，每个占一行。

    输出格式

    输出格式为 x positive numbers，其中 x 为正数的个数。

    数据范围

    输入数字的绝对值不超过 100。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #include <iostream>
    using namespace std;
    int main()
    {
        int s = 0;
        double a;
        for (int i = 0; i < 6; i ++)
        {
            cin >> a;
            if (a > 0)
                {
                    s ++;
                }
        }
        cout << s << " positive numbers" << endl;
        return 0;
    }

  4. 连续奇数的和

    给定两个整数 X 和 Y，输出在他们之间（不包括 X 和 Y）的所有奇数的和。

    输入格式

    第一行输入 X，第二行输入 Y。

    输出格式

    输出一个整数，表示所有满足条件的奇数的和。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #include <iostream>
    #include <algorithm>
    using namespace std;
    int main()
    {
        int x, y, z, s = 0;
        cin >> x >> y;
        
        if (x > y)
            swap(x, y);

        for (int i = x + 1; i < y; i ++)
        {
            if (i % 2 != 0)
                s = s + i;
        }
        cout << s << endl;
        return 0;
    }

    ※ swap(x, y) 用于交换x、y的顺序，包含在头文件#include <algorithm>中。

  5. 最大数和它的位置

    给定 100 个整数，请你找出其中最大的数字，以及它的输入位置（位置从 1 开始）。

    输入格式

    共 100 行，每行包含一个整数。

    输出格式

    第一行输出最大的数字，第二行输出该数字的输入位置。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    //法一：猪鼻了//
    #include <iostream>
    #include <algorithm>

    using namespace std;

    int main()
    {
        int a, m, p, n;
        cin >> a;
        m = a;
        n = a;
        for (int i = 2; i <= 100; i ++)
        {
            cin >> a;
            if (a > m)
            {
                swap(a, m);
                p = i;
            }
        }
        cout << m << endl;
        if (m == n)
            cout << '1' << endl;
        else
            cout << p << endl;
        return 0;
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    //法二：简单//
    #include <iostream>
    #include <algorithm>

    using namespace std;

    int main()
    {
        int a, m, p, n;
        m = 0;
        for (int i = 1; i <= 100; i ++)
        {
            cin >> a;
            if (a > m)
            {
                swap(a, m);
                p = i;
            }
        }
        cout << m << endl;
        cout << p << endl;
        return 0;
    }

  6. 递增序列

    读取一系列的整数 X，对于每个 X，输出一个 1,2,…,X 的序列。

    输入格式

    输入文件中包含若干个整数，其中最后一个为 0，其他的均为正整数。

    每个整数占一行。

    对于输入的正整数，按题目要求作输出处理。

    对于最后一行的整数 0，不作任何处理。

    输出格式

    对于每个输入的正整数 X，输出一个从 1 到 X 的递增序列，每个序列占一行。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #include <iostream>

    using namespace std;

    int main()
    {
        for (int i = 1; i <= 100; i ++)
        {
            int n;
            cin >> n;

            for (int j = 1; j <= n; j ++)
            {
                cout << j << ' ';
            }
            if (n == 0)
                break;
            cout << endl;
        }
        return 0;
    }

    输入

    1
    2
    3
    4
    5
    10
    3
    0

    输出

    1
    2
    3
    1 2 3 4 5
    1 2 3 4 5 6 7 8 9 10
    1 2 3

  7. 连续整数相加

    读入两个整数值 A 和 N，计算从 A 开始的 N 个连续整数的和。

    注意，如果读入的 N 为 0 或负数，则继续读取数字直至读入 N 值为正整数为止。

    输入格式

    共一行，包含整数 A 和若干个整数 N（不超过 100 个）。

    输出格式

    一个整数，表示从 A 开始的 N 个连续整数的和。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    #include <iostream>
    using namespace std;

    int main()
    {
        int a, n, s = 0;
        cin >> a;
        for (int i = 1; i <= 100; i ++)
        {
            cin >> n;

            if (n > 0)
                break;
        }
        
        for (int j = a; j < n + a; j ++)
            s = s + j;
        cout << s << endl;
        return 0;
    }

    输入

    1
    3 -1 0 -2 2

    输出

    1
    7

  8. 约数

    输入一个整数 N，按照从小到大的顺序输出它的全部约数。

    输入格式

    一个整数 N。

    输出格式

    输出全部约数，每个约数占一行。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #include <iostream>
    using namespace std;

    int main()
    {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i ++)
        {
            if (n % i == 0)
                cout << i << endl;
        }
        return 0;
    }

    输入

    1
    6

    输出

    1
    2
    3
    4
    1
    2
    3
    6

  9. PUM

    输入两个整数 N 和 M，构造一个 N 行 M 列的数字矩阵，矩阵中的数字从第一行到最后一行，按从左到右的顺序依次为 1,2,3,…,N×M。

    矩阵构造完成后，将每行的最后一个数字变为 PUM。输出最终矩阵。

    输入格式

    共一行，包含两个整数 N 和 M。

    输出格式

    输出最终矩阵，具体形式参照输出样例。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    #include <iostream>
    using namespace std;

    int main()
    {
        int n, m, k;
        cin >> n >> m;
        k = 1;
        for (int i = 1; i <= n; i ++)
        {
            for (int j = 1; j <= m - 1; j ++)
            {
                cout << k << ' ';
                k ++;
            }
            cout << "PUM" << endl;
            k ++;
        }
        return 0;
    }

    输入

    1
    7 4

    输出

    1
    2
    3
    4
    5
    6
    7
    1 2 3 PUM
    5 6 7 PUM
    9 10 11 PUM
    13 14 15 PUM
    17 18 19 PUM
    21 22 23 PUM
    25 26 27 PUM

习题

  1. 余数

    输入一个整数 N，请按顺序输出 1 到 10000 之间（不包括 1 和 10000）的所有除以 N 余 2 的数字。

    输入格式

    一个整数 N。

    输出格式

    输出所有满足条件的数字，从小到大每行输出一个。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    #include <iostream>
    using namespace std;

    int main()
    {
        int n;
        cin >> n;
        
        for (int i = 2; i < 10000; i ++)
        {
            if (i % n == 2)
                cout << i << endl;
        }
        
        return 0;
    }

    输入

    1
    13

    输出

    1
    2
    3
    4
    5
    2
    15
    28
    41
    ...

  2. 六个奇数

    读取一个整数 X，输出 X 之后的 6 个奇数，如果 X 也是奇数，那么它也算作 6 个奇数之一。

    输入格式

    一个整数 X。

    输出格式

    所有满足条件的奇数，每个占一行。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    #include <iostream>
    using namespace std;

    int main()
    {
        int x;
        cin >> x;

        for (int i = x; i < x + 12; i ++)
        {
            if (i % 2 == 0)
                continue;

            cout << i << endl;
        }
        
        return 0;
    }

    输入

    1
    8

    输出

    1
    2
    3
    4
    5
    6
    9
    11
    13
    15
    17
    19

  3. 乘法表

    输入一个整数 N，输出 N 的乘法表，如下：

    1
    2
    3
    4
    1 x N = N      
    2 x N = 2N        
    ...       
    10 x N = 10N

    输入格式

    一个整数 N。

    输出格式

    输出 N 的乘法表，具体形式参照输出样例。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        int n;
        cin >> n;

        for (int i = 1; i <= 10; i ++)
        {
            printf("%d x %d = %d\n", i, n, n * i);
        }

        return 0;
    }

    输入

    1
    140

    输出

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    1 x 140 = 140
    2 x 140 = 280
    3 x 140 = 420
    4 x 140 = 560
    5 x 140 = 700
    6 x 140 = 840
    7 x 140 = 980
    8 x 140 = 1120
    9 x 140 = 1260
    10 x 140 = 1400

  4. 实验

    医学部一共进行了 N 场动物实验。

    共有三种小动物可用来实验，分别是青蛙、老鼠和兔子。

    每次实验都会选取其中一种动物来参与实验，选取数量若干。

    现在请你统计一下医学部一共用了多少小动物，每种分别用了多少，每种动物使用数量占总量的百分比分别是多少。

    输入格式

    第一行包含整数 N，表示实验次数。

    接下来 N 行，每行包含一个整数 A（表示一次实验使用的小动物的数量）和一个字符 T（表示一次实验使用的小动物的类型，C 表示兔子(coney)，R 表示老鼠(rat)，F 表示青蛙(frog)）。

    输出格式

    请你参照输出样例，输出所用动物总数，每种动物的数量，以及每种动物所占百分比。保留两位小数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        int n;
        cin >> n;
        int c = 0, r = 0, f = 0, s = 0;

        for (int i = 0; i < n; i ++)
        {
            int k;
            char t;
            cin >> k >> t;

            if (t == 'C')
                c = c + k;
            else if (t == 'R')
                r = r + k;
            else
                f = f + k;

        }

        s = c + r + f;

        printf("Total: %d animals\n", s);
        printf("Total coneys: %d\n", c);
        printf("Total rats: %d\n", r);
        printf("Total frogs: %d\n", f);
        printf("Percentage of coneys: %.2lf %%\n", (double)c / s * 100);
        printf("Percentage of rats: %.2lf %%\n", (double)r / s * 100);
        printf("Percentage of frogs: %.2lf %%\n", (double)f / s * 100);

        return 0;
    }

    输入

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    10
    10 C
    6 R
    15 F
    5 C
    14 R
    9 C
    6 R
    8 F
    5 C
    14 R

    输出

    1
    2
    3
    4
    5
    6
    7
    Total: 92 animals
    Total coneys: 29
    Total rats: 40
    Total frogs: 23
    Percentage of coneys: 31.52 %
    Percentage of rats: 43.48 %
    Percentage of frogs: 25.00 %

  5. 区间2

    读取 N 个整数 X1,X2,…,XN，判断这 N 个整数中有多少个在 [10,20] 的范围内，有多少个在范围外。

    输入格式

    第一行包含整数 N，表示共有 N 个整数需要进行判断。

    接下来 N 行，每行包含一个整数 Xi。

    输出格式

    第一行输出 x in，其中 x 为在范围内的整数的数量。

    第二行输出 y out，其中 y 为在范围外的整数的数量。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #include <iostream>
    using namespace std;

    int main()
    {
        int n, s;
        cin >> n;
        
        for (int i = 1; i <= n; i ++)
        {
            int k;
            cin >> k;
            
            if (k >= 10 && k <= 20)
                s ++;
        }
        cout << s << " in" <<endl;
        cout << n - s << " out" <<endl;

        return 0;
    }

    输入

    1
    2
    3
    4
    5
    4
    14
    123
    10
    -25

    输出

    1
    2
    2 in
    2 out

  6. 连续奇数的和 2

    输入 N 对整数对 X,Y，对于每对 X,Y，请你求出它们之间（不包括 X 和 Y）的所有奇数的和。

    输入格式

    第一行输入整数 N，表示共有 N 对测试数据。

    接下来 N 行，每行输入一组整数 X 和 Y。

    输出格式

    每对 X,Y 输出一个占一行的奇数和。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    #include <iostream>
    #include <algorithm>
    using namespace std;

    int main()
    {
        int n;
        cin >> n;

        for (int i = 1; i <= n; i ++)
        {
            int x, y, s = 0;
            cin >> x >> y;

            if (x > y)
                swap(x, y);

            for (int j = x + 1; j < y; j ++)
            {
                if (j % 2 == 0)
                    continue;
                
                s = s + j;        
                
            }
        cout << s << endl;
        }

        return 0;
    }

    输入

    1
    2
    3
    4
    5
    6
    7
    8
    7
    4 5
    13 10
    6 4
    3 3
    3 5
    3 4
    3 8

    输出

    1
    2
    3
    4
    5
    6
    7
    0
    11
    5
    0
    0
    0
    12

  7. 简单斐波那契

    输入一个整数 N，输出斐波那契数列的前 N 项。

    输入格式

    一个整数 N。

    输出格式

    在一行中输出斐波那契数列的前 N 项，数字之间用空格隔开。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #include <iostream>
    using namespace std;

    int main()
    {
        int n;
        cin >> n;
        int a = 0, b = 1;

        for (int i = 0; i < n; i ++)
        {
            cout << a << ' ';
            int c = a + b;
            a = b; 
            b = c;
        }

        return 0;
    }

    输入

    1
    5

    输出

    1
    0 1 1 2 3

  8. 数字序列和它的和

    输入若干个整数对 M,N，对于每个数对，输出以这两个数为最大值和最小值的公差为 1 的等差数列。

    注意，当输入整数对中，任意一个数为 0 或负整数时，立即停止输入，且该组数对无需作任何处理。

    输入格式

    输入共若干行，每行包含两个整数。

    最后一行的两个整数中，至少有一个是非正整数。

    输出格式

    对于每组需作处理的数对，输出一个结果，每个结果占一行。

    结果包含从最小值到最大值的数字序列以及数字序列各数字之和。

    具体格式请参照输出样例。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    #include <iostream>
    #include <algorithm>
    using namespace std;

    int main()
    {
        for (int i = 1; i > 0; i ++)
        {
            int m, n, s = 0;
            cin >> m >> n;

            if (m <= 0 || n <=0)
                break;

            if (m > n)
                swap(m, n);

            for (int j = m; j <= n; j ++)
            {
                cout << j << ' ';
                s = s + j;
            }
                
            cout << "Sum=" << s;
            cout << endl;
        }

        return 0;
    }

    输入

    1
    2
    3
    2 5
    6 3
    5 0

    输出

    1
    2
    2 3 4 5 Sum=14
    3 4 5 6 Sum=18

  9. 完全数

    一个整数，除了本身以外的其他所有约数的和如果等于该数，那么我们就称这个整数为完全数。

    例如，6 就是一个完全数，因为它的除了本身以外的其他约数的和为 1+2+3=6。

    现在，给定你 N 个整数，请你依次判断这些数是否是完全数。

    输入格式

    第一行包含整数 N，表示共有 N 个测试用例。

    接下来 N 行，每行包含一个需要你进行判断的整数 X。

    输出格式

    每个测试用例输出一个结果，每个结果占一行。

    如果测试数据是完全数，则输出 X is perfect，其中 X 是测试数据。

    如果测试数据不是完全数，则输出 X is not perfect，其中 X 是测试数据。
    错误答案
    输入

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    #include <iostream>
    using namespace std;

    int main()
    {
        int n;
        cin >> n;
        
        for (int i = 1; i <= n; i ++)
        {
            int x;
            int s = 0;
            cin >> x;

            for (int j = 1; j < x; j ++)
            {
                if (x % j == 0)
                {
                    s = s + j;
                }
                    
            }
            if (s == x)
                    cout << x << " is perfect" << endl;
                else
                    cout << x << " is not perfect" << endl;
        }

        return 0;
    }

    输出

    1
    Time Limit Exceeded

    优化

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    #include <iostream>
    using namespace std;

    int main()
    {
        int n;
        cin >> n;
        
        for (int i = 1; i <= n; i ++)
        {
            int x;
            int s = 0;
            cin >> x;

            for (int j = 1; j * j <= x; j ++)  //12 = 3 * 4，只需要统计3的同时把4加上，可以减少运算量与时间
            {
                if (x % j == 0)
                {
                    if (j < x) //排除x = 1的情况
                        s = s + j;
                    if (j != s / j && x / j < x) //排除 x / j = 1的情况
                        s = s + x / j;
                }

            }

            if (s == x)
                    cout << x << " is perfect" << endl;
            else
                    cout << x << " is not perfect" << endl;
        }

        return 0;
    }

  10. 质数

    一个大于 1 的自然数，如果除了 1 和它自身外，不能被其他自然数整除则称该数为质数。

    例如 7 就是一个质数，因为它只能被 1 和 7 整除。

    现在，给定你 N 个大于 1 的自然数，请你依次判断这些数是否是质数。

    输入格式

    第一行包含整数 N，表示共有 N 个测试数据。

    接下来 N 行，每行包含一个自然数 X。

    输出格式

    每个测试用例输出一个结果，每个结果占一行。

    如果测试数据是质数，则输出 X is prime，其中 X 是测试数据。

    如果测试数据不是质数，则输出 X is not prime，其中 X 是测试数据。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    #include <iostream>
    using namespace std;

    int main()
    {
        int n;
        cin >> n;

        while (n --)
        {   
            int a;
            bool is_prime = true;
            cin >> a;

            for (int i = 2; i * i <= a; i ++)
            {
                if (a % i == 0)
                    is_prime = false;
            }
            if (is_prime)
                cout << a << " is prime" << endl;
            else
                cout << a << " is not prime" << endl;
        }

        return 0;
    }

    输入

    1
    2
    3
    4
    3
    8
    51
    7

    输出

    1
    2
    3
    8 is not prime
    51 is not prime
    7 is prime