第四讲 数组

最新推荐文章于 2024-07-17 17:57:05 发布
最新推荐文章于 2024-07-17 17:57:05 发布
阅读量2.1k 收藏 8
点赞数 3
分类专栏： C++语法基础练习题 文章标签： c语言 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44356316/article/details/119323062
版权

目录

1.基础知识

1.1 没有初始化的数组里面的数值，是随机化的。如果这样定义int a[10] = {0} 数组就自动全部初始化为 0 0 0了。定义在函数外面的数组，编译器初始化全是0，不同于定义在函数里的数组，编译器初始化为随机数。内存里有堆和栈，局部变量放栈里，全局变量放堆里。堆里开数组并没有真的使用空间，虚拟申请一下。用多少开多少，并且有个零页的操作，所以全局变量的数组全是零。而栈没有零页的操作所以局部变量的数组全是随机数。
1.2 c++默认开的栈空间是1兆，如果全用满，例如有1百万个数据就会存满了。一个int数据4个字节，1百万个数据就是4兆。因此，把数组变量放在函数外面，成一个全局变量，全局变量是存在于堆空间里的。函数内部不要定义很长的数组。指导意义：不要在函数里开一个很大的数组。
1.3 数组下标从0开始
1.4 为了防止越界，数组多开10个
1.5 数组清零，头文件<cstring>,memset(a,0,40)或者memset(a,0,sizeof a),第一个参数写数组的起始位置，第二个参数写初始化的数字，第三个参数写长度，该长度以字节为单位Byte，例如int是4个字节，数组10个数字，那就一共40个字节长度。注意：只有0和-1初始化是正常的。比如，初始化1，数组里每个元素并不是1，程序是将一个Byte初始化为1，int是四个Byte，二进制表示为 0000000100000001000000010000000 1 2 00000001000000010000000100000001_2 000000010000000100000001000000012​，十进制表示为 1684300 9 10 16843009_{10} 1684300910​；sizeof是一个运算符，不是函数，功能：计算对象占用字节的数量。写memset赋值的好处是赋值速度比for循环要快。
1.6 memcpy(b, a, sizeof a),第一个参数目标数组，第二个原数组，第三个数组长度

2.经典题型

2.1 用数组实现斐波那契数列

#include <iostream>
using namespace std;

int main()
{
	int f[100];
	f[0] = 1, f[1] = 1;

	int n;
	cin >> n;
	
	for(int i = 2; i < 50; i ++)
	{
		f[i] = f[i - 1] + f[i - 2];
	}
	
	cout << f[n] << endl;
	return 0;
}

2.2 翻转数组k次

输入一个n，再输入n个整数。将这个数组顺时针旋转k（k<=n）次，最后将结果输出。

eg.
//5个数
1 2 3 4 5
//旋转一次
5 1 2 3 4
//旋转两次
4 5 1 2 3
...

//版本一
//思路比较好想，算法的复杂度比较高
#include <iostream>
using namespace std;

int main()
{
	int n, k;
	//n为数组的个数，k为旋转的次数
	cin >> n >> k;
	int a[100];
	for(int i = 0; i < n; i ++)
	{
		cin >> a[i];
	}
	
	while(k --)
	{
		int tmp;
		tmp = a[n - 1];
		for(int i = n - 1; i > 0; i --)
		{
			a[i] = a[i - 1];
		}
		a[0] = tmp;
	}
	
	for(int i = 0; i < n; i ++) cout << a[i] << endl;
	return 0;
}

//版本二
//算法步骤：1.翻转a[];2.翻转前半部分;3.翻转后半部分
//例子：输入5 2
//数组 1 2 3 4 5
//1. 5 4 3 2 1
//2. 4 5 3 2 1
//3. 4 5 1 2 3
//翻转的函数是algorithm里的reverse(a, a + k)
//reverse参数，起始位置，终止位置的下一个位置
//这个做法的好处是只有一重循环，时间复杂度只有线性级别
#include <iostream>
#include <algorithm>
using namespace std;

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

2.3 高精度2的N次幂（N<10000）.

2.3.1 基础知识

通常int类型的数字一般只有10位有效数字，double一般只有15~16位有效数字。求 2 n 2^n 2n有几位？ l o g 10 2 n = n l o g 10 2 log_{10}2^n=nlog_{10}2 log10​2n=nlog10​2。
N最大的数字为1万，最多有3000多位。用数组来模拟一个数字，个位存储在 a [ 0 ] a[0] a[0]，十位存储在 a [ 1 ] a[1] a[1]，以此类推（加减乘除一般都这么存储）。

2.3.2 高精度运算核心原理

在这里插入图片描述在这里插入图片描述

2.3.3 代码

#include <iostream>
#include <cmath>
using namespace std;
// 
const int N = 3010;
int main()
{
	int a[N] = {1};
	int n;
	cin >> n;
	// 例如：n取50的时候，这种方法就爆表了
	cout << "用数学公式计算：" <<pow(2, n) << endl;

	int m = 1; 
	for(int i = 0; i < n; i ++)
	{
		int t = 0;
		for(int j = 0; j < m; j ++)
		{
			t += a[j] * 2;
			a[j] = t % 10;
			t /= 10;
		}	
		if(t) a[m ++] = 1;
	}
	
	cout << "用自己写的算法: ";
	for(int i = m - 1; i >= 0; i --) cout << a[i];
	cout << endl;
	
	return 0;
}

2.4 计算机中小数是近似存储的

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

int main()
{
   if(sqrt(3) * sqrt(3) < 3) puts("Inequal!");
	else if(sqrt(3) * sqrt(3) == 3) puts("Equal!");
   return 0;
}

3.练习题

3.1 数组替换

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

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

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

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

数据范围
−100≤X[i]≤100
输入样例：
10
-9
0
-4
-10
0
-2
-7
7
4
输出样例：
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

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

int main()
{
    int a[15];
    int tmp = 0;
    for(int i = 0; i < 10; i ++)
    {
        cin >> tmp;
        if(tmp > 0) a[i] = tmp;
        else a[i] = 1;
    }
    
    for(int i = 0; i < 10; i ++)
    {
        printf("X[%d] = %d\n", i, a[i]);
    }
    return 0;
}

3.2 数组填充

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

例如，如果输入整数为 1，则数组为：1,2,4,8…
输入格式
输入一个整数 V。

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

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

数据范围
1≤V≤50
输入样例：
1
输出样例：
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

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

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

3.3 数组选择

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

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

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

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

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

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

数据范围
−100≤A[i]≤100
输入样例：
0
-5
63
-8.5
…
输出样例：
A[0] = 0.0
A[1] = -5.0
A[3] = -8.5
…

#include <iostream>
using namespace std;

int main()
{
    double a[105];
    
    for(int i = 0; i < 100; i ++)
    {
        cin >> a[i];    
    }
    
    for(int i = 0; i < 100; i ++)
    {
        if(a[i] > 10.0) continue;
        else printf("A[%d] = %.1f\n", i, a[i]);
    }
    
    return 0;
}

3.4 数组中的行

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

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

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

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

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

数据范围
−100.0≤M[i][j]≤100.0
输入样例：
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
输出样例：
6.9

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

int main()
{
    double M[12][12];
    int L;
    char letter;
    // cin 会把空格和回车自动过滤掉，scanf不会自动空格
    cin >> L >> letter;
    
    for(int i = 0; i < 12; i ++)
    {
        for(int j = 0; j < 12; j ++)
        {
            cin >> M[i][j];
        }
    }
    
    double sum = 0;
    double avg = 0;
    if(letter == 'S')
    {
        for(int i = 0; i < 12; i ++)
        {
            sum += M[L][i];
        }
        printf("%.1f\n", sum);
    }
    else if(letter == 'M')
    {
        for(int i = 0; i < 12; i ++)
        {
            sum += M[L][i];
        }
        avg = sum / 12.0;
        printf("%.1f\n", avg);
    }
    return 0;
}

3.5 数组的右上半部分

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

右上半部分是指主对角线上方的部分，如下图所示，黄色部分为对角线，绿色部分为右上半部分：
在这里插入图片描述
输入格式
第一行输入一个大写字母，若为 S，则表示需要求出右上半部分的元素的和，若为 M，则表示需要求出右上半部分的元素的平均值。

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

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

数据范围
−100.0≤M[i][j]≤100.0
输入样例：
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.2

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

int main()
{
    char c;
    cin >> c;
    double a[12][12];
    for(int i = 0; i < 12; i ++)
    {
        for(int j = 0; j < 12; j ++)
        {
            cin >> a[i][j];
        }
    }
    
    if(c == 'S')
    {
        double sum = 0;
        for(int i = 0; i < 12; i ++)
        {
            for(int j = i + 1; j < 12; j ++)
            {
                sum += a[i][j];
            }
        }
        printf("%.1f", sum);
    }
    else if(c == 'M')
    {
        double sum = 0;
        for(int i = 0; i < 12; i ++)
        {
            for(int j = i + 1; j < 12; j ++)
            {
                sum += a[i][j];
            }
        }
        printf("%.1f", sum / 66);    
    }
    return 0;
}

3.6 数组的左上半部分

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

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

在这里插入图片描述

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

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

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

数据范围
−100.0≤M[i][j]≤100.0
输入样例：
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
输出样例：
-0.8

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

int main()
{
    char c;
    cin >> c;
    double a[12][12];
    for(int i = 0; i < 12; i ++)
    {
        for(int j = 0; j < 12; j ++)
        {
            cin >> a[i][j];
        }
    }
    
    if(c == 'S')
    {
        double sum = 0;
        for(int i = 0; i < 12; i ++)
        {
            for(int j = 0; j < 12 - i - 1; j ++)
            {
                sum += a[i][j];
            }
        }
        printf("%.1f", sum);
    }
    else if(c == 'M')
    {
        double sum = 0;
        for(int i = 0; i < 12; i ++)
        {
            for(int j = 0; j < 12 - i - 1; j ++)
            {
                sum += a[i][j];
            }
        }
        printf("%.1f", sum / 66);    
    }
    return 0;
}

3.7 数组的上方区域

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

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

在这里插入图片描述
输入格式
第一行输入一个大写字母，若为 S，则表示需要求出上方区域的元素的和，若为 M，则表示需要求出上方区域的元素的平均值。

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

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

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

数据范围
−100.0≤M[i][j]≤100.0
输入样例：
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
输出样例：
21.7

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

int main()
{
    char c;
    cin >> c;
    double a[12][12];
    for(int i = 0; i < 12; i ++)
    {
        for(int j = 0; j < 12; j ++)
        {
            cin >> a[i][j];
        }
    }
    
    if(c == 'S')
    {
        double sum = 0;
        for(int i = 0; i < 12; i ++)
        {
            for(int j = i + 1; j < 12 - i - 1 ; j ++)
            {
                sum += a[i][j];
            }
        }
        printf("%.1f", sum);
    }
    else if(c == 'M')
    {
        double sum = 0;
        for(int i = 0; i < 12; i ++)
        {
            for(int j = i + 1; j < 12 - i - 1; j ++)
            {
                sum += a[i][j];
            }
        }
        printf("%.1f", sum / 30);    
    }
    return 0;
}

3.8 数组的左方区域

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

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

在这里插入图片描述
输入格式
第一行输入一个大写字母，若为 S，则表示需要求出左方区域的元素的和，若为 M，则表示需要求出左方区域的元素的平均值。

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

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

数据范围
−100.0≤M[i][j]≤100.0
输入样例：
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
输出样例：
13.3

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

int main()
{
    char c;
    cin >> c;
    double a[12][12];
    for(int i = 0; i < 12; i ++)
    {
        for(int j = 0; j < 12; j ++)
        {
            cin >> a[i][j];
        }
    }
    
    if(c == 'S')
    {
        double sum = 0;
        for(int i = 0; i < 12; i ++)
        {
            for(int j = 0; abs(i - j) != 0 && i + j != 11; j ++)
            {
                sum += a[i][j];
                // cout << a[i][j] << " ";
            }
            // cout << "result:" <<sum << endl;
        }
        printf("%.1f", sum);
    }
    else if(c == 'M')
    {
        double sum = 0;
        for(int i = 0; i < 12; i ++)
        {
            for(int j = 0; abs(i - j) != 0 && i + j != 11; j ++)
            {
                sum += a[i][j];
            }
        }
        printf("%.1f", sum / 30);    
    }
    return 0;
}

3.9 平方矩阵 I

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

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

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

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

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

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

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

数据范围
0≤N≤100
输入样例：
1
2
3
4
5
0
输出样例：
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

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

int main()
{
    int a;
    
    while(cin >> a, a)
    {
        for(int i = 1; i <= a; i ++)
        {
            for(int j = 1; j <= a; j ++)
            {
                int up = i, down = a - i + 1, left = j, right = a - j + 1;
                cout << min(min(up, down), min(left, right)) << " ";
            }
            cout << endl;
        }
        cout << endl;    
    }
    
    return 0;
}

3.9.1回形矩阵

回形矩阵是怎么打印出来的，关键要抓住，点到矩形四条边的距离最小值即为显示的数值。

3.10 数组变换

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

输出翻转后的数组。

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

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

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

数据范围
−100≤N[i]≤100
输入样例：
0
-5
…
63
23
输出样例：
N[0] = 23
N[1] = 63
…
N[18] = -5
N[19] = 0

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

int main()
{   
    int a[20];
    for(int i = 0; i < 20; i ++)
    {
        cin >> a[i];
    }
    
    int b[20];
    for(int j = 0; j < 20; j ++)
    {
        b[j] = a[19 - j];
    }
    
    
    for(int i = 0; i < 20; i ++)
    {
        printf("N[%d] = %d\n", i, b[i]);
          
    }
    
    return 0;
}

3.11 斐波那契数列

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

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

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

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

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

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

数据范围
0≤N≤60
输入样例：
3
0
4
2
输出样例：
Fib(0) = 0
Fib(4) = 3
Fib(2) = 1

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

const int N = 60;
int main()
{
    long int a[N] = {0, 1};
    for(int i = 2; i < N; i ++)
    {
        a[i] = a[i - 1] + a[i - 2];
    }
    
    int n;
    cin >> n;
    
    while(n)
    {
        int tmp;
        cin >> tmp;
        printf("Fib(%d) = %ld\n", tmp, a[tmp]);
        n --;
    }
    
    return 0;
}

3.12 最小数和它的位置

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

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

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

输入格式
第一行包含整数 N。

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

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

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

数据范围
1<N≤1000,
−1000≤X[i]≤1000
输入样例：
10
1 2 3 4 -5 6 7 8 9 10
输出样例：
Minimum value: -5
Position: 4

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

int main()
{
    int t, _min, flag;
    _min = INT_MAX;
    cin >> t;
    int a[t];
    
    for(int i = 0; i < t; i ++)
    {
        cin >> a[i];
        if(a[i] < _min) _min = a[i], flag = i;
    }
    
    printf("Minimum value: %d\n", _min);
    printf("Position: %d\n", flag);
    return 0;
}

3.13 数组中的列

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

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

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

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

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

数据范围
−100.0≤M[i][j]≤100.0
输入样例：
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
输出样例：
19.3

#include <iostream>
using namespace std;

int main()
{
    int row;
    cin >> row;
    char flag;
    cin >> flag;
    double a[12][12];
    for(int i = 0; i < 12; i ++)
    {
        for(int j = 0; j < 12; j ++)
        {
            cin >> a[i][j];
        }
    }
    
    double sum = 0;
    for(int i = 0; i < 12; i ++)
    {
        sum += a[i][row];
    }
    if(flag == 'S') printf("%.1f", sum);
    else if(flag == 'M') printf("%.1f", sum / 12.0);
    return 0;
}

3.14 数组的右下半部分

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

右下半部分是指次对角线下方的部分，如下图所示，黄色部分为对角线，绿色部分为右下半部分：在这里插入图片描述
输入格式
第一行输入一个大写字母，若为 S，则表示需要求出右下半部分的元素的和，若为 M，则表示需要求出右下半部分的元素的平均值。

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

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

数据范围
−100.0≤M[i][j]≤100.0
输入样例：
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
输出样例：
53.0

#include <iostream>
using namespace std;

int main()
{
    char flag;
    cin >> flag;
    
    double a[12][12];
    for(int i = 0; i < 12; i ++)
    {
        for(int j = 0; j < 12; j ++)
        {
            cin >> a[i][j];
        }
    }
    
    double sum = 0;
    int c = 0;
    for(int i = 1; i < 12; i ++)
    {
        for(int j = 12 - i; j < 12; j ++)
        {
            sum += a[i][j];
            c ++;
        }
    }
    
    if(flag == 'S') printf("%.1f", sum);
    else if(flag == 'M') printf("%.1f", sum / c);
    return 0;
}

3.15 数组的左下半部分

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

左下半部分是指主对角线下方的部分，如下图所示，黄色部分为对角线，绿色部分为左下半部分：
在这里插入图片描述
输入格式
第一行输入一个大写字母，若为 S，则表示需要求出左下半部分的元素的和，若为 M，则表示需要求出左下半部分的元素的平均值。

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

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

数据范围
−100.0≤M[i][j]≤100.0
输入样例：
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
输出样例：
-2.8

#include <iostream>
using namespace std;

int main()
{
    char flag;
    cin >> flag;
    double a[12][12];
    for(int i = 0; i < 12; i ++)
    {
        for(int j = 0; j < 12; j ++)
        {
            cin >> a[i][j];
        }
    }
    
    double sum = 0;
    int c = 0;
    for(int i = 0; i < 12; i ++)
    {
        for(int j = 0; j < i; j ++)
        {
            sum += a[i][j];
            c ++;
        }
    }
    
    if(flag == 'S') printf("%.1f", sum);
    else if(flag == 'M') printf("%.1f", sum / c);
    return 0;
}

3.16 数组的下方区域

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

数组的两条对角线将数组分为了上下左右四个部分，如下图所示，黄色部分为对角线，绿色部分为下方区域：
在这里插入图片描述
输入格式
第一行输入一个大写字母，若为 S，则表示需要求出下方区域的元素的和，若为 M，则表示需要求出下方区域的元素的平均值。

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

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

数据范围
−100.0≤M[i][j]≤100.0
输入样例：
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
输出样例：
-11.9

#include <iostream>
using namespace std;

int main()
{
    char flag;
    cin >> flag;
    double a[12][12];
    for(int i = 0; i < 12; i ++)
    {
        for(int j = 0; j < 12; j ++)
        {
            cin >> a[i][j];
        }
    }
    
    double sum = 0;
    int c = 0;
    for(int i = 7; i < 12; i ++)
    {
        for(int j = 12 - i; j < i; j ++)
        {
            sum += a[i][j];
            c ++;
        }
    }
    
    if(flag == 'S') printf("%.1f", sum);
    else if(flag == 'M') printf("%.1f", sum / c);
    return 0;
}

3.17 数组的右方区域

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

数组的两条对角线将数组分为了上下左右四个部分，如下图所示，黄色部分为对角线，绿色部分为右方区域：
在这里插入图片描述

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

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

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

数据范围
−100.0≤M[i][j]≤100.0
输入样例：
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
输出样例：
40.9

#include <iostream>
using namespace std;

int main()
{
    char flag;
    cin >> flag;
    
    double a[12][12];
    for(int i = 0; i < 12; i ++)
    {
        for(int j = 0; j < 12; j ++)
        {
            cin >> a[i][j];
        }
    }
    
    double sum = 0;
    int c = 0;
    for(int i = 1; i < 6; i ++)
    {
        for(int j = 12 - i; j < 12; j ++)
        {
            sum += a[i][j];
            c ++;
        }
    }
    
    for(int i = 6; i < 12; i ++)
    {
        for(int j = i + 1; j < 12; j ++)
        {
            sum += a[i][j];
            c ++;
        }
    }
    
    if(flag == 'S') printf("%.1f", sum);
    else if(flag == 'M') printf("%.1f", sum / c);
    return 0;
}

3.18 平方矩阵 II

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

数组的形式参照样例。

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

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

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

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

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

数据范围
0≤N≤100
输入样例：
1
2
3
4
5
0
输出样例：
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

方法一：
这种方法找到了数学规律，思路比较简洁；缺点是这个规律不容易找。

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

int main()
{
    int t;
    while(cin >> t, t)
    {
        
        
        for(int i = 0; i < t; i ++)
        {
            for(int j = 0 ; j < t; j ++)
            {
                cout << abs(i - j) + 1 << ' ';
            }
            cout << endl;
        }
        cout << endl;
    }
    
    return 0;
}

方法二：
虽然方法二相对于方法一体现出数学之美，但是思路十分清晰，好像模拟了人写这个矩阵的的过程。

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

int main()
{
    int t;
    while(cin >> t, t)
    {
        int a[t][t];
        
        for(int i = 0; i < t; i ++)
        {
            a[i][i] = 1;//首先第一步写对角线上的数字为1
            for(int j = i + 1, k = 2; j < t; j ++, k ++) a[i][j] = k;//然后写行，起点是对角线左边
            for(int j = i + 1, k = 2; j < t; j ++, k ++) a[j][i] = k;//最后写列，起点是对角线下面
        }
        
        for(int i = 0; i < t; i ++)
        {
            for(int j = 0; j < t; j ++)
            {
                cout << a[i][j] << " ";
            }
            cout << endl;
        }
        cout << endl;
    }
    
    return 0;
}

3.19 平方矩阵 III

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

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

具体形式可参考样例。

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

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

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

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

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

数据范围
0≤N≤15
输入样例：
1
2
3
4
5
0
输出样例：
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

#include <iostream>
using namespace std;

int main()
{
    int n;
    while(cin >> n, n)
    {
        int a[n][n];
        
        for(int i = 0; i < n; i ++)
        {
            for(int j = 0; j < n; j ++)
            {
                long long tmp = 1;
                for(int k = 0; k < i + j; k ++) tmp *= 2;
                cout << tmp << " "; 
            }
            cout << endl;
        }
        cout << endl;
    }
    
    return 0;
}

3.20 蛇形矩阵

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

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

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

输出格式
输出满足要求的矩阵。

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

数据范围
1≤n,m≤100
输入样例：
3 3
输出样例：
1 2 3
8 9 4
7 6 5
在这里插入图片描述

#include <iostream>
using namespace std;

int res[100][100];

int main()
{
    int n, m;
    cin >> n >> m;
    
    int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
    
    for(int x = 0, y = 0, d = 0, i = 1; i <= n * m; i ++)
    {
        res[x][y] = i;
        int next_x = x + dx[d], next_y = y + dy[d];
        if(next_x >= n || next_x < 0 || next_y >= m || next_y < 0 || res[next_x][next_y])
        {
            d = (d + 1) % 4;
            next_x = x + dx[d], next_y = y + dy[d];
        }
        x = next_x, y = next_y;
    }
    
    for(int i = 0; i < n; i ++)
    {
        for(int j = 0; j < m; j ++)
        {
            cout << res[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}
董洞洞同学
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数组查找及替换c++题解
Cjeiwnsjc的博客
01-02 530
题目描述 给定某整数数组和某一整数b。要求删除数组中可以被b整除的所有元素，同时将该数组各元素按从小到大排序。如果数组元素数值在A到Z的ASCII之间，替换为对应字母。元素个数不超过100，b在1至100之间。 输入格式 第一行为数组元素个数和整数b 第二行为数组各个元素 输出格式 按照要求输出 样例输入 7 2 77 11 66 22 44 33 55 样例输出 11 33 55 M
c++上机实验5-项目三
wueryong123的博客
05-07 370
/* * 文件名称： 项目三 * 作    者：  吴二用 * 完成日期：   2016   年  5  月   7 日  * 版 本 号：v1.0  * 对任务及求解方法的描述部分: * 输入描述： 略 * 问题描述： 略 * 程序输出： 略 * 问题分析： 略 * 算法设计： */   #include using namespace std
C++ 数组输出
热门推荐
Happinesspills
02-24 1万+
C++数组输出 C++中输出数组数据分两种情况：字符型数组和非字符型数组 当定义变量为字符型数组时，采用cout<<数组名; 系统会输出数组中的字符，如 char arr[] = {'1', '2'}; cout << arr << endl ; //输出12 如果想输出字符数组的地址，则需要进行强制转换，如： char arr[] = {'1', '2'}; cout << static_cast < void *> (arr) <&lt
C语言/C++数组选择【简单易懂，代码可以直接运行】
于笨笨的博客
10-06 343
C语言/C++数组选择【简单易懂，代码可以直接运行】 输入一个长度为 100 的数组 A，请你按顺序输出其中不大于 10 的所有元素。 输入格式 输入 100 个数，每个数占一行，表示数组的所有元素的值。 每个数可能是整数也可能是浮点数。 输出格式 按顺序输出数组中的所有不大于 10 的元素，每个元素占一行。 输出格式为 A[i] = x，其中 i 为元素编号，x 为元素的值。 注意，所有的 x 均保留一位小数。 数据范围 −100≤A[i]≤100 比较简单，不在多做解释了，代码如下： #include&
C语言/C++数组替换【简单易懂，代码可以直接运行】
于笨笨的博客
10-06 3640
C语言/C++数组替换【简单易懂，代码可以直接运行】 输入一个长度为 10 的整数数组 X[10]，将里面的非正整数全部替换为 1，输出替换完成后的数组。 输入格式 输入包含 10 个整数，每个整数占一行。 输出格式 输出新数组中的所有元素，每个元素占一行。 输出格式为 X[i] = x，其中 i 为元素编号（从 0 开始），x 为元素的值。 数据范围 −100≤X[i]≤100 难度为简单，代码如下： #include<iostream> #include<cstring> usi
第四章 数组
weixin_42023744的博客
09-02 122
第四章 数组 4.1 数组的概念 ​ 所谓数组(array)，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，以便统一管理他们，然后用编号区分他们，这个名字称为数组名，编号称为下标或索引(index)。组成数组的各个变量称为数组的元素(element)。数组中元素的个数称为数组的长度(length)。 ​ 注：数组的长度一旦确定，就不能修改。 4.2 数组的定...
c++ 第四讲数组与指针
04-17
数组与指针 利用数组表示一组相关 数据项  声明数组、初始化数组、 应用数组中的单个元素  将数组传递给函数  声明和使用多维数组
第二讲-MATLAB数组PPT实用.ppt
10-31
2. **范围访问**：使用 `:` 可以获取连续的元素子集，如 `x(1:3)` 获取前三个元素，`x(4:end)` 获取从第四个到最后一个元素。 3. **步长访问**：`x(9:-2:2)` 使用负步长返回倒序的子集。 4. **查找功能**：`find` ...
第6讲 数组第6讲 数组第6讲 数组第6讲 数组
04-29
数组索引从0开始，例如，对于数组`a`，`a[0]`是第一个元素，`a[1]`是第二个元素，以此类推。 值得注意的是，数组有`length`属性，它表示数组元素的数量。Java会检查数组的下标是否越界，以防止非法访问。一旦数组被...
Week12_第4讲_数组
12-02
在讲解数组之前，我们先看一个简单的例子，假设我们要找到4个整数中的最大值。我们可以通过定义四个整数变量a、b、c和d，然后逐一比较它们的大小来实现： ```java int a = 40, b = 60, c = 30, d = 65; int max = a...
第四讲java数组和字符串.doc
09-30
数组的初始化可以在声明数组的同时给数组一个初始值，例如：int num [ ] = {2, 4, 4, 1};创建数组后，系统会给每个元素一个默认的值，可以在程序中修改。 数组的使用包括数组的访问和数组的复制。数组可以通过下标...
C语言/C++ 数组的上方区域【简单易懂，代码可以直接运行】
于笨笨的博客
10-07 261
C语言/C++ 数组的上方区域【简单易懂，代码可以直接运行】 输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的上方区域元素的平均值或元素的和。 数组的两条对角线将数组分为了上下左右四个部分，如下图所示，黄色部分为对角线，绿色部分为上方区域： 输入格式 第一行输入一个大写字母，若为 S，则表示需要求出上方区域的元素的和，若为 M，则表示需要求出上方区域的元素的平均值。 接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元
742. 最小数和它的位置
一个字，学
04-11 435
742. 最小数和它的位置 输入一个整数 N 和一个长度为 N 的整数数组 X。 请你找到数组中最小的元素，并输出它的值和下标。 注意，如果有多个最小值，则返回下标最小的那个。 输入格式 第一行包含整数 N。 第二行包含 N 个用空格隔开的整数 X[i]。 输出格式 第一行输出 Minimum value: x，其中 x 为数组元素最小值。 第二行输出 Position: y，其中 y 为最小值元素的下标（下标从 0 开始计数）。 数据范围 1<N≤1000, −1000≤X[i]≤1000 输入样例
【头歌C语言程序与设计】数组
m0_73222051的博客
12-08 3618
头歌数组
python数组的右上半部分【简单易懂，代码可以直接运行】
于笨笨的博客
01-09 544
C语言/C++ 数组的右上半部分【简单易懂，代码可以直接运行】 输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的右上半部分元素的平均值或元素的和。 右上半部分是指主对角线上方的部分，如下图所示，黄色部分为对角线，绿色部分为右上半部分： 输入格式 第一行输入一个大写字母，若为 S，则表示需要求出右上半部分的元素的和，若为 M，则表示需要求出右上半部分的元素的平均值。 接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素
【【2022.12.8每天四个简单题之简单题大智慧系列2】（数组的右上半部分，数组的左上半部分 ，数组的上方区域，数组的左方区域）】
m0_74018560的博客
12-08 325
【【2022.12.8每天四个简单题之简单题大智慧系列2】（数组的右上半部分，数组的左上半部分 ，数组的上方区域，数组的左方区域）】
2022/10/27每日训练 acwing第747题
zhang_dehong的博客
10-27 188
2022/10/27 acwing 第747题日常训练
学懂C语言系列（二）：C程序结构
最新发布
martian665的专栏
07-17 497
学懂C语言系列，C程序结构概念及实例讲解

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值