一维数组

数组的定义

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

int main()
{
    int a[100], b[10];
    float c[11];
    double d[13];
    char e[14];
    string g[25];

    return 0;
}

数组初始化

直接定义

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

int main()
{
    int a[3] = {0, 1, 3}; //定义了一个长度为3的数组
    int b[] = {0, 1, 3}; //定义了一个长度为3的数组

    int c[5] = {0, 1, 3}; //定义了一个长度为5的数组，没给出的值默认是0

    char d[] = {'a', 'b', 'c'}; //定义了一个长度为3的数组

    int f[10] = {0}; //常用的将数组全部初始化为0的写法

    return 0;
}

清空数组

memset()函数用于批量初始化数组，可用于清空数组,共三个参数，第一个代表数组名字，第二个代表要初始化的值（一般只初始化为0或-1），第三个是要初始化的数组长度。

※memset()的第三个参数长度的单位是字节（Byte），相当于把参数个Byte初始化成第二个参数的值，如果4个Byte都是0，那么int型就等于0，也就是说如果第二个参数是1，最后得到的int型并不是1。1 Byte = 8 bit。一个int占用4个Byte。

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

int main()
{
    int a[10];

    memset(a, 0, 40);  //输入10个int型，总长度为40 Byte

    for (int i = 0; i < 10; i ++ )
        cout << a[i] << ' ';

    return 0;
}

也可以使用sizeof运算符，如sizeof a，就是a数组占用的字节数量。

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

int main()
{
    int a[10];

    memset(a, 0, sizeof a);

    for (int i = 0; i < 10; i ++ )
        cout << a[i] << ' ';

    return 0;
}

复制数组

memcopy()函数用于复制数组。共三个参数，第一个代表复制到的目标数组名字，第二个代表被复制的原数组的名字，第三个是要复制的数组长度。（单位Byte）

访问数组元素

数组下标从0开始，a[0], a[1], … , a[99]

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

int main()
{
    int a[3] = {0, 1, 2};
    cout << a[0] << ' ' << a[1] << ' ' << a[2] << endl;

    a[2] = 5;
    cout << a[2] << endl;

    return 0;
}

练习

  1. 使用数组实现求斐波那契数列的第 N 项。
    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;
            
        int f[100];
        f[0] = 0, f[1] = 1;
        for (int i = 2; i < 100; i ++)
            f[i] = f[i - 1] + f[i - 2];
            
        cout << f[n];

        return 0;
    }
  2. 输入一个 n，再输入 n 个整数。将这 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;
        int a[100];

        for (int i = 0; i < n; i ++)
            cin >> a[i];
        for (int j = n - 1; j >= 0; j --)
            cout << a[j] << ' ';
        
        return 0;
    }
  3. 输入一个 n，再输入 n 个整数。将这个数组顺时针旋转 k(k≤n) 次，最后将结果输出 (旋转一次是指：将最右边的数放到最左边。)
    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
    //法一
    #include <iostream>
    using namespace std;

    int main()
    {
        int n, k;
        cin >> n >> k;
        int a[100];
        
        for (int i = 0; i < n; i ++)
            cin >> a[i];

        while (k --)
        {
            int t = a[n - 1];
            for (int i = n-2; i >= 0; i --)
                a[i + 1] = a[i];
            a[0] = t;
        }
        
        for (int i = 0; i < n; i ++)
            cout << a[i] << ' ';

        return 0;
    }

使用<algorithm>头文件里的reverse(a,b)函数，将数组翻转，a是翻转的起始位置，b是要翻转的终止为止的下一个位置。
如，1 2 3 4 5这样的顺序，可以先翻转成5 4 3 2 1，再把前两个翻转，后三个翻转，成为4 5 1 2 3，也符合要求。

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 n, k;
    cin >> n >> k;
    int a[100];

    for (int i = 0; i < n; i ++)
        cin >> a[i];
    
    reverse(a, a + n);
    reverse(a, a + k);
    reverse(a + k, a + n);

    for (int j = 0; j < n; j ++)
        cout << a[j] << ' ';

    return 0;
}
  1. 先输入一个整数n，再输入 n 个数，将这 n 个数按从小到大的顺序输出。
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[100];
    int n;
    cin >> n;

    for (int i = 0; i < n; i ++)
        cin >> a[i];
    
    for (int i = 0; i < n; i ++)
    {
        for (int j = i + 1; j < n; j ++)
        {
            if (a[i] > a[j])
                swap(a[i], a[j]);
        }
    }

    for (int i = 0; i < n; i ++ )
        cout << a[i] << ' ';
    
    cout << endl;
    return 0;
}
  1. 计算2的N次方，N<=10000
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[10000], size = 1, n;
    a[0] = 1;

    cin >> n;
    while (n -- )
    {
        int t = 0;
        for (int i = 0; i < size; i ++ ) //size定义数组总位数
        {
            t += a[i] * 2; //此位乘2加上低位进位的t，代表这一位乘2得到的结果
            a[i] = t % 10; //这一位乘2得到的结果再除以10取余是此位的最终结果
            t /= 10; //这一位乘2得到的结果再除以10再下取整是进位的t
        }
        if (t) a[size ++ ] = t; //若所有已有位数都乘完了仍有进位t，则总位数应该多一位
    }

    for (int i = size - 1; i >= 0; i -- ) cout << a[i];
    cout << endl;

    return 0;
}

多维数组

多维数组定义

多维数组就是数组的数组

1
2
int a[3][4]; //定义了一个大小为3的数组，每个数组的元素是大小为4的数组
int b[10][20][30]; //定义了一个大小为10的数组，每个数组的元素是大小为20的数组，这些大小为20的数组里的每个元素都是大小为30的数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
using namespace std;

int main()
{
    int a[3][4];
    for (int i = 0; i < 3; i ++)
    {
        for (int j = 0; j < 4; j ++ )
            a[i][j] = i + j;
    }

    for (int i = 0; i < 3; i ++)
    {
        for (int j = 0; j < 4; j ++ )
            cout << a[i][j] << ' ';
        
        cout << endl;
    }

    return 0;   
}

输出

1
2
3
0 1 2 3 
1 2 3 4 
2 3 4 5

多维数组初始化

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 a[3][4] = {{0, 1, 2, 3}, {1, 2, 3, 4}, {2, 3, 4, 5}};

    for (int i = 0; i < 3; i ++ )
    {
        for (int j= 0; j < 4; j ++ )
            cout << a[i][j] << ' ';
        
        cout << endl;
    }
    
    return 0;
}

例题

  1. 数组替换

    输入一个长度为 10 的整数数组 X[10]，将里面的非正整数全部替换为 1，输出替换完成后的数组。

    输入格式

    输入包含 10 个整数，每个整数占一行。

    输出格式

    输出新数组中的所有元素，每个元素占一行。

    输出格式为 X[i] = x，其中 i 为元素编号（从 0 开始），x 为元素的值。

    输入样例

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

    输出样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    X[0] = 10
    X[1] = 1
    X[2] = 1
    X[3] = 1
    X[4] = 1
    X[5] = 1
    X[6] = 1
    X[7] = 1
    X[8] = 7
    X[9] = 4

    解

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

    int main()
    {
        int a[10];

        for (int i = 0; i < 10; i ++ )
        {
            cin >> a[i];

            if (a[i] <= 0)
                a[i] = 1;

            printf("X[%d] = %d\n", i, a[i]);
        }

        return 0;
    }

  2. 数组填充

    输入一个整数 V，输出一个长度为 10 的数组 N，数组中的第一个元素为 V，每个后续元素的值都为上一个元素的值的 2 倍。

    例如，如果输入整数为 1，则数组为：1,2,4,8…

    输入格式

    输入一个整数 V。

    输出格式

    输出数组中的所有元素，每个元素占一行。

    输出格式为 N[i] = x，其中 i 为元素编号（从 0 开始），x 为元素的值。

    输入样例

    1
    1

    输出样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    N[0] = 1
    N[1] = 2
    N[2] = 4
    N[3] = 8
    N[4] = 16
    N[5] = 32
    N[6] = 64
    N[7] = 128
    N[8] = 256
    N[9] = 512

    解

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

    int main()
    {
        int a[10];

        cin >> a[0];
        
        for (int i = 1; i < 10; i ++)
            a[i] = a[i - 1] * 2;
        
        for (int i = 0; i < 10; i ++)
            printf("N[%d] = %d\n", i, a[i]);
        
        return 0;
    }

  3. 数组选择

    输入一个长度为 100 的数组 A，请你按顺序输出其中不大于 10 的所有元素。

    输入格式

    输入 100 个数，每个数占一行，表示数组的所有元素的值。

    每个数可能是整数也可能是浮点数。

    输出格式

    按顺序输出数组中的所有不大于 10 的元素，每个元素占一行。

    输出格式为 A[i] = x，其中 i 为元素编号，x 为元素的值。

    注意，所有的 x 均保留一位小数。

    输入样例

    1
    2
    3
    4
    5
    0
    -5
    63
    -8.5
    ...

    输出样例

    1
    2
    3
    4
    A[0] = 0.0
    A[1] = -5.0
    A[3] = -8.5
    ...

    解

    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()
    {
        double a[100];
        
        for (int i = 0; i < 100; i ++ )
            cin >> a[i];
        
        for (int i = 0; i < 100; i ++ )
        {
            if (a[i] <= 10)
                {
                    printf("A[%d] = %.1lf\n", i, a[i]);
                }
        }

        return 0;
    }

  4. 数组中的行

    输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组中某一行的元素的平均值或元素的和。

    输入格式

    第一行输入整数 L，表示所求的具体行数（行数从 0 开始计数）。

    第二行包含一个大写字母，若为 S，则表示需要求出第 L 行的元素的和，若为 M，则表示需要求出第 L 行的元素的平均值。

    接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

    输出格式

    输出一个数，表示所求的平均数或元素的和的值，保留一位小数。

    输入样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    7
    S
    8.3 -9.4 -5.6 9.9 2.2 3.2 6.9 7.7 -2.9 -6.3 3.9 -1.4
    -0.5 4.3 -0.3 2.3 0.7 -3.1 -6.3 5.7 -7.7 -3.7 9.7 3.8
    5.8 -9.1 3.5 7.0 2.5 -2.3 6.9 2.7 5.8 -4.6 -7.8 4.3
    -1.7 -8.9 -2.6 7.5 -9.6 6.4 -4.7 -8.0 0.6 6.7 -1.8 -0.4
    -9.8 8.9 -3.8 -2.1 5.8 -9.4 1.3 6.3 -1.3 -6.3 -6.6 8.8
    -6.3 -7.2 -6.3 -5.9 6.2 9.3 2.0 -4.3 2.7 3.6 -4.6 8.7
    3.8 7.4 8.7 -2.8 6.0 -9.2 1.9 3.1 -7.2 -6.0 9.7 -8.4
    -9.8 6.6 8.6 2.3 1.1 -2.9 6.6 -1.5 2.1 -5.1 6.4 -7.5
    -0.6 -1.6 9.5 -6.6 3.0 3.4 -7.5 -7.9 3.1 2.0 1.7 -7.6
    -9.0 9.4 6.6 -0.2 1.4 6.5 8.6 2.0 -1.3 0.2 4.0 -2.4
    -7.3 -6.3 -8.6 -7.5 8.5 1.4 -3.3 7.1 0.8 3.3 3.0 0.1
    3.3 9.0 1.7 5.2 -3.7 8.9 3.8 -7.4 -2.8 0.6 -2.4 7.1

    输出样例

    1
    6.9

    解

    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 <cstdio>
    using namespace std;

    int main()
    {
        double m[12][12];
        int L;
        char t;
        
        cin >> L >> t;

        for (int i = 0; i < 12; i ++ )
            for (int j = 0; j < 12; j ++)
                cin >> m[i][j];
        
        double s = 0;

        for (int i = 0; i < 12; i ++ )
            s = s + m[L][i];

        
        if (t == 'S')
            printf("%.1lf\n", s);
        else
            printf("%.1lf\n", s / 12);

        return 0;
    }

  5. 数组的右上半部分

    输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的右上半部分元素的平均值或元素的和。

    右上半部分是指主对角线上方的部分，如下图所示，黄色部分为对角线，绿色部分为右上半部分：
    topright

    输入格式

    第一行输入一个大写字母，若为 S，则表示需要求出右上半部分的元素的和，若为 M，则表示需要求出右上半部分的元素的平均值。

    接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

    输出格式

    输出一个数，表示所求的平均数或元素的和的值，保留一位小数。

    输入样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    M
    -6.5 8.2 0.7 9.0 0.8 -4.3 0.9 -0.0 -7.9 7.1 -1.6 4.6
    -9.4 -9.0 1.5 -9.0 -5.1 -0.5 -2.8 -9.1 8.0 -6.9 -5.5 -6.6
    -6.8 0.3 3.8 6.1 -9.9 -9.3 8.5 8.6 5.0 6.9 -3.6 -3.0
    -0.8 -1.6 -7.3 -6.7 4.4 -9.1 -9.0 1.6 0.3 -6.0 6.0 -0.8
    -0.8 -6.0 -4.9 -3.9 6.4 6.2 -4.2 -0.9 7.9 1.6 -8.2 -9.2
    7.8 -5.8 -5.8 -5.8 7.2 0.5 -7.9 1.2 -6.8 -9.1 0.3 -1.4
    4.3 -7.2 3.5 -6.4 -9.1 -6.0 3.5 -5.1 -5.6 -6.9 -9.1 -2.1
    -7.6 -7.1 0.7 -1.7 5.0 -9.0 1.4 -6.2 7.6 4.8 -7.5 4.0
    -0.2 0.3 -4.2 8.4 0.7 -6.4 -2.7 3.5 -0.9 3.7 0.9 -2.7
    7.1 0.1 8.4 -5.1 -7.9 -0.5 -5.3 -5.7 -4.6 9.6 -8.3 7.0
    9.6 -9.8 3.3 -9.9 -6.8 6.7 3.1 1.2 -9.5 -4.3 -1.7 -9.7
    1.8 5.0 8.3 -0.7 -0.9 3.2 2.5 0.5 7.3 8.3 0.3 0.9

    输出样例

    1
    -1.2

    解

    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
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        double a[12][12];
        char t;
        double s = 0;

        cin >> t;
        for (int i = 0; i < 12; i ++ )
            for (int j = 0; j < 12; j ++)
                cin >> a[i][j];
        
        for (int i =0; i < 11; i ++ )
            for (int j = i + 1; j < 12; j ++)
                s = s + a[i][j];

        if (t == 'S')
            printf("%.1lf", s);
        else
            printf("%.1lf", s / 66);

        return 0;
    }

  6. 数组的左上半部分

    输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的左上半部分元素的平均值或元素的和。

    左上半部分是指次对角线上方的部分，如下图所示，黄色部分为对角线，绿色部分为左上半部分：
    topleft

    输入格式

    第一行输入一个大写字母，若为 S，则表示需要求出左上半部分的元素的和，若为 M，则表示需要求出左上半部分的元素的平均值。

    接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

    输出格式

    输出一个数，表示所求的平均数或和的值，保留一位小数。

    输入样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    M
    -0.4 -7.7 8.8 1.9 -9.1 -8.8 4.4 -8.8 0.5 -5.8 1.3 -8.0
    -1.7 -4.6 -7.0 4.7 9.6 2.0 8.2 -6.4 2.2 2.3 7.3 -0.4
    -8.1 4.0 -6.9 8.1 6.2 2.5 -0.2 -6.2 -1.5 9.4 -9.8 -3.5
    -2.3 8.4 1.3 1.4 -7.7 1.3 -2.3 -0.1 -5.4 -7.6 2.5 -7.7
    6.2 -1.5 -6.9 -3.9 -7.9 5.1 -8.8 9.0 -7.4 -3.9 -2.7 0.9
    -6.8 0.8 -9.9 9.1 -3.7 -8.4 4.4 9.8 -6.3 -6.4 -3.7 2.8
    -3.8 5.0 -4.6 2.0 4.0 9.2 -8.9 0.5 -3.9 6.5 -4.3 -9.9
    -7.2 6.2 -1.2 4.1 -7.4 -4.6 4.7 -0.4 -2.2 -9.1 0.4 -5.8
    9.1 -6.4 9.2 0.7 10.0 -5.7 -9.7 -4.4 4.7 4.7 4.9 2.1
    -1.2 -6.2 -8.2 7.0 -5.3 4.9 5.5 7.2 3.4 3.2 -0.2 9.9
    -6.9 -6.2 5.1 8.5 7.1 -0.8 -0.7 2.7 -6.0 4.2 -8.2 -9.8
    -3.5 7.7 5.4 2.8 1.6 -1.0 6.1 7.7 -6.5 -8.3 -8.5 9.4

    输出样例

    1
    -0.8

    解

    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
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        double a[12][12];
        char t;
        double s = 0;

        cin >> t;
        for (int i = 0; i < 12; i ++ )
            for (int j = 0; j < 12; j ++)
                cin >> a[i][j];
        
        for (int i =0; i < 11; i ++ )
            for (int j = 0; j < 11 - i; j ++)
                s = s + a[i][j];

        if (t == 'S')
            printf("%.1lf", s);
        else
            printf("%.1lf", s / 66);

        return 0;
    }

  7. 数组的上方区域

    输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的上方区域元素的平均值或元素的和。

    数组的两条对角线将数组分为了上下左右四个部分，如下图所示，黄色部分为对角线，绿色部分为上方区域：
    top

    输入格式

    第一行输入一个大写字母，若为 S，则表示需要求出上方区域的元素的和，若为 M，则表示需要求出上方区域的元素的平均值。

    接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

    输出格式

    输出一个数，表示所求的平均数或和的值，保留一位小数。

    输出结果与标准答案据对误差不超过 0.1 即视为正确。

    输入样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    S
    -4.8 -8.0 -2.9 6.7 -7.0 2.6 6.5 1.7 1.9 5.6 -1.6 -6.3
    -4.3 1.5 8.7 -0.3 5.4 -9.3 4.8 7.0 3.6 -8.3 -1.0 1.3
    -9.9 9.7 -6.3 5.8 2.9 2.9 -7.7 4.9 -0.6 7.2 6.4 7.7
    2.8 -5.8 -0.0 2.2 4.0 7.7 -3.0 -7.5 -3.5 9.7 -4.3 -8.6
    -1.8 -0.1 5.4 0.6 9.9 -3.7 -1.1 0.8 -0.2 -0.0 9.9 4.5
    3.0 -3.9 2.1 -9.7 5.5 9.4 -4.6 3.3 -9.6 5.1 -4.5 1.5
    4.3 -5.4 -7.9 9.2 -7.7 -9.6 -1.5 -1.6 -7.2 2.0 -3.7 -0.7
    8.0 2.8 -4.1 7.1 8.4 -5.6 3.9 -9.7 -1.1 3.0 -8.5 -3.3
    1.7 5.1 0.1 9.2 4.5 9.7 7.2 8.6 8.7 1.1 6.7 0.3
    -3.6 -7.1 -8.9 7.1 -5.9 1.6 -7.4 6.7 3.9 4.3 -2.4 -3.7
    8.9 -6.2 5.0 -8.6 -1.3 -8.8 2.6 8.9 5.5 9.0 -2.2 -4.4
    5.7 3.7 1.8 -2.1 -7.3 -7.9 4.7 6.0 3.3 -2.8 1.4 -6.9

    输出样例

    1
    21.7

    解

    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
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        double a[12][12];
        char t;
        double s = 0;

        cin >> t;
        for (int i = 0; i < 12; i ++ )
            for (int j = 0; j < 12; j ++)
                cin >> a[i][j];
        
        for (int i =0; i < 5; i ++ )
            for (int j = i + 1; j < 11 - i; j ++)
                s = s + a[i][j];

        if (t == 'S')
            printf("%.1lf", s);
        else
            printf("%.1lf", s / 30);

        return 0;
    }

  8. 数组的左方区域

    输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的左方区域元素的平均值或元素的和。

    数组的两条对角线将数组分为了上下左右四个部分，如下图所示，黄色部分为对角线，绿色部分为左方区域：
    left

    输入格式

    第一行输入一个大写字母，若为 S，则表示需要求出左方区域的元素的和，若为 M，则表示需要求出左方区域的元素的平均值。

    接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

    输出格式

    输出一个数，表示所求的平均数或和的值，保留一位小数。

    输入样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    S
    4.7 -3.3 -2.3 4.5 -7.0 8.7 -4.1 -3.0 -7.6 6.3 -6.6 -4.7
    -7.2 9.3 -7.6 9.1 9.2 9.0 5.5 -7.5 -9.3 -1.6 -3.5 -4.2
    0.5 -7.5 -8.3 -9.0 -6.4 3.8 0.1 -3.5 7.9 2.1 2.4 -6.2
    7.0 5.7 -9.0 -5.8 1.6 2.6 -9.2 -6.2 4.6 8.2 -8.3 -1.4
    3.8 -9.9 6.2 -2.5 -3.5 9.4 1.6 7.0 3.3 -0.5 6.7 6.0
    1.6 -3.8 5.0 8.8 4.2 7.7 0.7 7.4 7.9 -5.9 4.4 3.3
    3.7 6.2 6.7 -1.4 6.1 -6.0 8.5 9.1 5.7 -4.2 5.9 -3.5
    5.0 0.3 2.2 -3.6 6.3 -10.0 9.5 -4.7 2.7 8.1 7.5 -8.4
    -5.7 -0.3 -3.7 -3.3 7.7 9.3 -1.3 1.0 0.3 1.9 9.9 9.0
    -7.4 1.3 -9.6 -3.6 2.2 3.4 -3.6 3.5 8.3 0.5 9.7 -6.8
    1.0 -2.7 -1.5 5.4 -6.5 -3.7 5.6 8.0 -9.9 0.1 2.2 7.6
    5.6 4.3 1.5 -0.8 5.8 -5.1 5.5 6.2 -5.8 8.8 -0.6 -2.3

    输出样例

    1
    13.3

    解

    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
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        double a[12][12];
        char t;
        double s = 0;

        cin >> t;
        for (int i = 0; i < 12; i ++ )
            for (int j = 0; j < 12; j ++)
                cin >> a[i][j];
        
        for (int i = 0; i < 5; i ++ )
            for (int j = i + 1; j < 11 - i; j ++)
                s = s + a[j][i];

        if (t == 'S')
            printf("%.1lf", s);
        else
            printf("%.1lf", s / 30);

        return 0;
    }

  9. 平方矩阵

    输入整数 N，输出一个 N 阶的回字形二维数组。

    数组的最外层为 1，次外层为 2，以此类推。
    输入格式

    输入包含多行，每行包含一个整数 N。

    当输入行为 N=0 时，表示输入结束，且该行无需作任何处理。

    输出格式

    对于每个输入整数 N，输出一个满足要求的 N 阶二维数组。

    每个数组占 N 行，每行包含 N 个用空格隔开的整数。

    每个数组输出完毕后，输出一个空行。

    输入样例

    1
    2
    3
    4
    5
    6
    1
    2
    3
    4
    5
    0

    输出样例

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

    1 1
    1 1

    1 1 1
    1 2 1
    1 1 1

    1 1 1 1
    1 2 2 1
    1 2 2 1
    1 1 1 1

    1 1 1 1 1
    1 2 2 2 1
    1 2 3 2 1
    1 2 2 2 1
    1 1 1 1 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
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        int n;
        while (cin >> n, n)
        {
            for (int i = 1; i <= n; i ++ )
            {
                for (int j = 1; j <= n; j ++ )
                {
                    int up = i, down = n - i + 1, left = j, right = n - j + 1;
                    cout << min(min(up, down), min (left, right)) << ' ';
                }

                cout << endl;
            }

            cout << endl;
        }

        return 0;
    }

习题

  1. 数组变换

    输入一个长度为 20 的整数数组 N，将整个数组翻转，使得第一个元素成为倒数第一个元素，第二个元素成为倒数第二个元素，…，倒数第二个元素成为第二个元素，倒数第一个元素成为第一个元素。

    输出翻转后的数组。

    输入格式

    输入包含 20 个整数，每个数占一行。

    输出格式

    输出新数组中的所有元素，每个元素占一行。

    输出格式为 N[i] = x，其中 i 为元素编号（从 0 开始），x 为元素的值。

    输入样例

    1
    2
    3
    4
    5
    0
    -5
    ...
    63
    23

    输出样例

    1
    2
    3
    4
    5
    N[0] = 23
    N[1] = 63
    ...
    N[18] = -5
    N[19] = 0

    解

    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 <algorithm>
    #include <cstdio>
    using namespace std;
    int main()
    {
        int a[20];
        
        for (int i = 0; i < 20; i ++ )
        {
            cin >> a[i];
        }

        reverse(a, a + 20);

        for (int i = 0; i < 20; i ++ )
        {
            printf("N[%d] = %d\n", i, a[i]);
        }

        return 0;
    }

  2. 斐波那契数列

    输入整数 N，求出斐波那契数列中的第 N 项是多少。

    斐波那契数列的第 0 项是 0，第 1 项是 1，从第 2 项开始的每一项都等于前两项之和。

    输入格式

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

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

    输出格式

    每个测试数据输出一个结果，每个结果占一行，

    结果格式为 Fib(N) = x，其中 N 为项数，x 为第 N 项的值。

    输入样例

    1
    2
    3
    4
    3
    0
    4
    2

    输出样例

    1
    2
    3
    Fib(0) = 0
    Fib(4) = 3
    Fib(2) = 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
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        long long a[100]; //用int存会溢出
        a[0] = 0;
        a[1] = 1;
        int n, m;

        for (int i = 2; i < 100; i ++ )
            a[i] = a[i - 1] + a[i - 2];
        
        cin >> n;
        
        while(n --)
        {
            cin >> m;
            printf("Fib(%d) = %lld\n", m, a[m]);
        }
        
        return 0;
    }

  3. 最小数和它的位置

    输入一个整数 N 和一个长度为 N 的整数数组 X。

    请你找到数组中最小的元素，并输出它的值和下标。

    注意，如果有多个最小值，则返回下标最小的那个。

    输入格式

    第一行包含整数 N。

    第二行包含 N 个用空格隔开的整数 X[i]。

    输出格式

    第一行输出 Minimum value: x，其中 x 为数组元素最小值。

    第二行输出 Position: y，其中 y 为最小值元素的下标（下标从 0 开始计数）。

    输入样例

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

    输出样例

    1
    2
    Minimum value: -5
    Position: 4

    解

    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>
    #include <cstdio>
    using namespace std;

    int main()
    {
        int a[1001];
        int n;

        cin >> n;
        for (int i = 0; i < n; i ++)
        {
            cin >> a[i];
        }

        int p = 1;
        for (int i = 2; i < n; i ++)
        {
            if (a[i] < a[p])
                p = i;
        }

        printf("Minimum value: %d\n", a[p]);
        printf("Position: %d\n", p);

        return 0;
    }

  4. 数组中的列

    输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组中某一列的元素的平均值或元素的和。

    输入格式

    第一行输入整数 C，表示所求的具体列数（列数从 0 开始计数）。

    第二行包含一个大写字母，若为 S，则表示需要求出第 C 列的元素的和，若为 M，则表示需要求出第 C 列的元素的平均值。

    接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

    输出格式

    输出一个数，表示所求的平均数或元素的和的值，保留一位小数。

    输入样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    1
    S
    -9.0 -2.4 -3.3 2.4 -9.7 -5.7 -5.3 6.5 -7.3 4.8 -4.1 3.9
    1.6 -0.9 9.2 -7.5 1.0 -8.0 -4.1 -4.0 -0.1 -9.0 8.4 4.9
    -8.2 -0.3 -5.1 -5.6 6.6 0.9 -1.0 -5.4 -2.1 -4.5 -8.7 -1.1
    -4.2 6.5 -8.2 3.6 -4.6 -9.2 -1.7 6.9 -9.0 -9.8 7.7 -3.4
    -8.0 5.7 4.8 0.3 -1.4 2.8 -6.3 9.3 0.3 6.3 1.5 -1.7
    1.7 -0.0 9.7 -6.6 1.3 -2.0 -6.1 2.0 -7.8 -4.7 -9.1 6.0
    -8.2 -1.7 9.4 -1.2 -1.0 -9.0 -7.0 -6.9 -1.6 -6.8 -6.7 1.8
    4.8 1.3 -6.1 -0.6 0.5 -2.9 -6.8 1.5 5.8 3.2 0.0 7.7
    6.3 1.1 4.7 7.3 7.6 5.6 0.9 9.2 1.3 -4.9 7.8 -4.9
    0.5 3.5 -5.0 9.0 8.8 8.7 7.5 7.5 -9.6 -6.9 -1.6 6.9
    7.8 5.6 -6.4 3.6 2.3 0.5 4.1 6.1 8.6 -9.3 2.2 -0.4
    9.9 0.9 6.4 -2.8 -4.2 -7.6 0.6 9.6 3.0 0.9 5.1 4.5

    输出样例

    1
    19.3

    解

    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
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        double a[12][12];
        int c;
        char t;

        cin >> c >> t;
        for (int i = 0; i < 12; i ++ )
        {
            for (int j = 0; j < 12; j ++ )
                cin >> a[i][j];
        }
        
        double s = 0;
        for (int i = 0; i < 12; i ++ )
        {
            s = s + a[i][c];
        }
            
        
        if (t == 'S')
            printf("%.1lf", s);
        else
            printf("%.1lf", s / 12);
        
        return 0;
    }

  5. 数组的右下半部分

    输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的右下半部分元素的平均值或元素的和。

    右下半部分是指次对角线下方的部分，如下图所示，黄色部分为对角线，绿色部分为右下半部分：
    downright

    输入格式

    第一行输入一个大写字母，若为 S，则表示需要求出右下半部分的元素的和，若为 M，则表示需要求出右下半部分的元素的平均值。

    接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

    输出格式

    输出一个数，表示所求的平均数或和的值，保留一位小数。

    输入样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    S
    9.7 -4.9 6.1 -6.1 -9.6 1.0 -3.2 0.6 3.2 -9.8 4.9 1.2
    -2.8 -5.3 2.8 -1.9 -5.4 7.5 -2.0 5.7 2.3 5.3 -7.5 8.9
    6.0 4.3 3.8 -6.7 8.1 -0.5 7.8 -2.2 -1.0 4.0 -4.9 -9.4
    5.4 3.7 -6.5 -3.9 -3.3 4.1 -2.5 -4.7 8.2 1.4 1.8 4.7
    2.4 9.0 -4.3 9.6 8.6 -6.1 -7.4 8.6 5.6 0.5 -0.4 5.2
    -5.2 2.9 -5.6 4.0 -0.2 3.8 -4.1 -1.6 -3.8 -3.1 -1.1 3.3
    -9.4 -1.4 0.6 6.5 -4.3 -8.3 6.1 2.9 -5.2 2.5 9.8 -7.7
    -2.9 -3.6 7.9 -5.8 -4.7 8.2 -6.2 1.0 7.4 -1.0 -4.4 -4.5
    0.1 9.5 4.9 1.5 0.8 -8.2 0.4 9.5 -0.8 -0.9 9.7 -2.1
    0.1 -7.6 7.8 -6.9 5.5 1.4 4.0 7.8 1.0 -1.2 9.7 -1.9
    -4.6 2.3 -5.5 8.2 -4.8 -3.7 5.4 0.2 -2.4 -0.8 7.4 0.0
    -0.1 8.2 0.8 -3.5 -7.6 -0.5 5.6 8.4 -8.6 0.9 9.0 -7.5

    输出样例

    1
    53.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
    30
    31
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        char t;
        double a[12][12];

        cin >> t;
        for (int i = 0; i < 12; i ++)
            for (int j = 0; j < 12; j ++)
                cin >> a[i][j];
        
        double s = 0;
        int k = 0;

        for (int i = 1; i < 12; i ++)
            for (int j = 12 - i; j < 12; j ++)
            {
                s += a[i][j];
                k ++;
            }

        if (t == 'S')
            printf("%.1lf", s);
        else
            printf("%.1lf", s / k);

        return 0;
    }

  6. 数组的左下半部分

    输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的左下半部分元素的平均值或元素的和。

    左下半部分是指主对角线下方的部分，如下图所示，黄色部分为对角线，绿色部分为左下半部分：
    downleft

    输入格式

    第一行输入一个大写字母，若为 S，则表示需要求出左下半部分的元素的和，若为 M，则表示需要求出左下半部分的元素的平均值。

    接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

    输出格式

    输出一个数，表示所求的平均数或和的值，保留一位小数。
    输入样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    S
    8.7 5.6 -2.0 -2.1 -7.9 -9.0 -6.4 1.7 2.9 -2.3 8.4 4.0
    -7.3 -2.1 0.6 -9.8 9.6 5.6 -1.3 -3.8 -9.3 -8.0 -2.0 2.9
    -4.9 -0.5 -5.5 -0.2 -4.4 -6.1 7.6 6.9 -8.0 6.8 9.1 -8.5
    -1.3 5.5 4.6 6.6 8.1 7.9 -9.3 9.6 4.6 0.9 -3.5 -4.3
    -7.0 -1.2 7.0 7.1 -5.7 7.8 -2.3 4.3 0.2 -0.4 -6.6 7.6
    -3.2 -5.4 -4.7 4.7 3.6 8.8 5.1 -3.1 -2.9 2.8 -4.3 -1.4
    -1.8 -3.3 -5.6 1.8 8.3 -0.5 2.0 -3.9 -1.0 -8.6 8.0 -3.3
    -2.5 -9.8 9.2 -0.8 -9.4 -0.5 1.6 1.5 3.4 -0.1 7.0 -6.2
    -1.0 4.9 2.2 -8.7 -0.9 4.8 2.3 2.0 -3.2 -7.5 -4.0 9.9
    -1.1 -2.9 8.7 3.6 7.4 7.8 10.0 -9.0 1.6 8.3 6.3 -5.8
    -9.9 0.6 2.0 -3.8 -6.3 0.6 7.3 3.8 -7.1 9.5 2.2 1.3
    -2.8 -9.1 7.1 -0.2 0.6 -6.5 1.1 -0.1 -3.6 4.0 -5.4 1.1

    输出样例

    1
    -2.8

    解

    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
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        char t;
        double a[12][12];

        cin >> t;
        for (int i = 0; i < 12; i ++)
            for (int j = 0; j < 12; j ++)
                cin >> a[i][j];
        
        double s = 0;
        int k = 0;

        for (int i = 1; i < 12; i ++)
            for (int j = 0; j <= i - 1; j ++)
            {
                s += a[i][j];
                k ++;
            }

        if (t == 'S')
            printf("%.1lf", s);
        else
            printf("%.1lf", s / k);

        return 0;
    }

  7. 数组的下方区域

    输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的下方区域元素的平均值或元素的和。

    数组的两条对角线将数组分为了上下左右四个部分，如下图所示，黄色部分为对角线，绿色部分为下方区域：
    down

    输入格式

    第一行输入一个大写字母，若为 S，则表示需要求出下方区域的元素的和，若为 M，则表示需要求出下方区域的元素的平均值。

    接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

    输出格式

    输出一个数，表示所求的平均数或和的值，保留一位小数。

    输入样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    S
    -6.0 0.7 -8.4 -5.7 -4.1 7.6 9.5 -9.7 4.1 0.6 -6.5 -4.9
    6.6 4.9 -3.1 5.3 0.3 -4.5 3.9 -1.5 6.6 7.0 5.1 2.5
    -8.5 1.8 -2.7 0.1 -4.9 -7.2 4.3 6.0 -1.4 2.7 -3.0 2.0
    4.8 -7.0 -1.3 0.8 1.0 4.5 -1.1 -2.9 -3.9 -3.9 -8.9 5.8
    -2.1 -9.6 5.1 0.2 1.0 -1.7 6.4 4.1 2.8 -6.9 2.4 9.3
    -6.0 -9.1 -7.0 -7.0 7.8 5.1 6.9 -7.6 0.4 -7.2 5.5 6.0
    -1.9 5.5 1.9 -8.5 -5.3 2.3 -9.3 2.0 -0.2 1.2 5.6 -1.8
    8.2 2.3 3.5 1.4 4.0 -5.1 -6.9 -2.8 1.7 -7.0 7.8 1.8
    -6.0 -4.1 -4.6 -9.4 -4.9 -4.1 4.2 6.3 -2.8 8.7 8.1 -0.9
    8.8 -6.5 -4.3 6.1 -6.2 -3.9 -7.0 7.3 5.0 -0.9 -0.0 5.6
    -2.4 1.4 8.5 -2.2 0.9 5.3 3.6 8.8 -8.1 3.0 -3.1 6.5
    -3.8 -6.4 2.3 4.2 -9.8 -0.3 -9.9 -7.4 3.5 1.5 -0.2 7.0

    输出样例

    1
    -11.9

    解

    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
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        char t;
        double a[12][12];

        cin >> t;
        for (int i = 0; i < 12; i ++)
            for (int j = 0; j < 12; j ++)
                cin >> a[i][j];
        
        double s = 0;
        int k = 0;

        for (int i = 7; i < 12; i ++)
            for (int j = 12 - i; j < i; j ++)
            {
                s += a[i][j];
                k ++;
            }

        if (t == 'S')
            printf("%.1lf", s);
        else
            printf("%.1lf", s / k);

        return 0;
    }

  8. 数组的右方区域

    输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的右方区域元素的平均值或元素的和。

    数组的两条对角线将数组分为了上下左右四个部分，如下图所示，黄色部分为对角线，绿色部分为右方区域：
    right

    输入格式

    第一行输入一个大写字母，若为 S，则表示需要求出右方区域的元素的和，若为 M，则表示需要求出右方区域的元素的平均值。

    接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

    输出格式

    输出一个数，表示所求的平均数或和的值，保留一位小数。

    输入样例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    S
    2.4 7.8 9.4 -5.6 6.9 -4.9 4.8 0.8 3.6 1.7 -1.4 9.7
    -6.8 -3.7 -2.0 -4.9 -4.5 -5.3 6.1 7.5 -4.3 5.9 -9.5 9.7
    -6.5 -0.4 1.6 3.7 -4.4 -3.3 1.9 7.7 -1.4 4.5 7.4 -3.0
    -1.2 0.4 9.8 9.8 -4.3 -1.3 -1.6 0.5 2.8 -4.0 8.5 3.9
    0.2 -2.0 -6.4 -9.8 3.7 -2.0 1.7 -3.6 -3.4 2.4 -1.2 -3.9
    -8.3 5.8 -1.0 -4.4 1.0 -2.4 2.8 -4.6 2.1 8.7 -6.8 -8.3
    6.3 -6.8 -7.0 9.3 -7.7 -1.7 8.2 -6.5 -1.8 6.7 8.2 4.4
    0.4 8.6 -1.2 8.6 -4.6 1.8 9.6 1.6 2.0 -1.0 3.9 -9.2
    7.5 -3.1 6.2 -4.5 -3.0 2.5 -7.7 2.9 0.3 3.3 -2.7 3.4
    -5.0 3.0 -0.0 4.3 9.5 -0.0 -9.9 -8.6 -0.9 -5.5 7.7 6.5
    4.9 -9.6 -2.9 8.5 2.0 -9.9 -4.9 -1.5 -2.4 -7.6 1.7 8.5
    -6.4 6.8 -3.7 -4.7 0.2 5.8 -5.4 0.6 7.0 -4.2 -7.5 -2.4

    输出样例

    1
    40.9

    解

    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
    #include <iostream>
    #include <cstdio>
    using namespace std;

    int main()
    {
        char t;
        double a[12][12];

        cin >> t;
        for (int i = 0; i < 12; i ++)
            for (int j = 0; j < 12; j ++)
                cin >> a[i][j];
        
        double s = 0;
        int k = 0;

        for (int i = 7; i < 12; i ++)
            for (int j = 12 - i; j < i; j ++)
            {
                s += a[j][i];
                k ++;
            }

        if (t == 'S')
            printf("%.1lf", s);
        else
            printf("%.1lf", s / k);

        return 0;
    }

  9. 平方矩阵 II

    输入整数 N，输出一个 N 阶的二维数组。

    数组的形式参照样例。

    输入格式

    输入包含多行，每行包含一个整数 N。

    当输入行为 N=0 时，表示输入结束，且该行无需作任何处理。

    输出格式

    对于每个输入整数 N，输出一个满足要求的 N 阶二维数组。

    每个数组占 N 行，每行包含 N 个用空格隔开的整数。

    每个数组输出完毕后，输出一个空行。

    输入样例

    1
    2
    3
    4
    5
    6
    1
    2
    3
    4
    5
    0

    输出样例

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

    1 2
    2 1

    1 2 3
    2 1 2
    3 2 1

    1 2 3 4
    2 1 2 3
    3 2 1 2
    4 3 2 1

    1 2 3 4 5
    2 1 2 3 4
    3 2 1 2 3
    4 3 2 1 2
    5 4 3 2 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
    28
    29
    30
    31
    32
    33
    34
    35
    #include <iostream>
    #include <cstdio>
    #include <cmath>
    using namespace std;

    int main()
    {
        int n;

        while (cin >> n, n)
        {
            int a[n][n];

            for (int i = 0; i < n; i ++)
                a[i][i] = 1; //先把对角线元素都定义为1
            
            for (int i = 0; i < n; i ++ )
            {
                for (int j = 0; j < n; j ++)
                    a[i][j] = 1 + abs(i - j); //当i即行确定时，非对角线元素的值与对角线元素的差为列数的差的绝对值
            }

            for (int i = 0; i < n; i ++ )
            {
                for (int j = 0; j < n; j ++)
                    cout << a[i][j] << ' ';
                
                cout << endl;
            }

            cout << endl;
        }

        return 0;
    }

  10. 平方矩阵 III

    输入整数 N，输出一个 N 阶的二维数组 M。

    这个 N 阶二维数组满足 M[i][j]=2i+j。

    具体形式可参考样例。

    输入格式

    输入包含多行，每行包含一个整数 N。

    当输入行为 N=0 时，表示输入结束，且该行无需作任何处理。

    输出格式

    对于每个输入整数 N，输出一个满足要求的 N 阶二维数组。

    每个数组占 N 行，每行包含 N 个用空格隔开的整数。

    每个数组输出完毕后，输出一个空行。

    输入样例

    1
    2
    3
    4
    5
    6
    1
    2
    3
    4
    5
    0

    输出样例

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

    1 2
    2 4

    1 2 4
    2 4 8
    4 8 16

    1 2 4 8
    2 4 8 16
    4 8 16 32
    8 16 32 64

    1 2 4 8 16
    2 4 8 16 32
    4 8 16 32 64
    8 16 32 64 128
    16 32 64 128 256

    解

    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
    #include <iostream>
    #include <cstdio>
    #include <cmath>
    using namespace std;

    int main()
    {
        int n;

        while (cin >> n, n)
        {
            int a[n][n];
            a[0][0] = 1;

            for (int i = 1; i < n; i ++)
                a[i][0] = a[i - 1][0] * 2;

            for (int i = 0; i < n; i ++)
            {
                for (int j = 1; j < n; j ++ )
                    a[i][j] = a[i][j - 1] * 2;
            }
            
            for (int i = 0; i < n; i ++)
            {
                for (int j = 0; j < n; j ++ )
                    cout << a[i][j] << ' ';
                
                cout << endl;
            }

            cout << endl;
        }

        return 0;
    }

  11. 蛇形矩阵

    输入两个整数 n 和 m，输出一个 n 行 m 列的矩阵，将数字 1 到 n×m 按照回字蛇形填充至矩阵中。

    具体矩阵形式可参考样例。

    输入格式

    输入共一行，包含两个整数 n 和 m。

    输出格式

    输出满足要求的矩阵。

    矩阵占 n 行，每行包含 m 个空格隔开的整数。

    输入样例

    1
    3 3

    输出样例

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

    解

    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
    #include <iostream>
    using namespace std;


    int main()
    {
        int n, m;
        cin >> n >> m;
        int arr[100][100] = {0};

        int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};  //使用数组表示前进的方向

        for (int x = 0, y = 0, d = 0, k = 1; k <= n * m; k ++)
        {
            arr[x][y] = k; //把k的值放到当前位置
            int a = x + dx[d], b = y + dy[d]; //用a、b表示下一位置的方向

            if (a < 0 || a >= n || b < 0 || b >= m || arr[a][b]) //判断下一位置是否在矩形范围内或是否未走过，如果是继续前进 ，如果不是将方向顺时针变化90度
            {
                d = (d + 1) % 4;  //在0、1、2、3四个数之间循环
                a = x + dx[d], b = y + dy[d];  //得到新的前进方向
            }
            x = a, y = b;
        }

        for (int i = 0; i < n; i ++ )
        {
            for (int j = 0; j < m; j ++)
                cout << arr[i][j] << ' ';

            cout << endl;
        }

        return 0;
    }