程序 = 逻辑 + 数据，数组是存储数据的强而有力的手段。
1. 一维数组
1.1 数组的定义
数组的定义方式和变量类似。
数组类型+[]里面写上长度大小
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int a[10], b[10];
float f[33];
double d[123];
char c[21];//这个其实就是字符串
return 0;
}
1.2 数组的初始化
在main函数内部，未初始化的数组中的元素是随机的。
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int a[3] = {0, 1, 2};
// 含有3个元素的数组，元素分别是0, 1, 2
int b[] = {0, 1, 1};
// 维度是3的数组（编译器自动识别出来数组维度是3）
int c[5] = {0, 1, 2};
// 实际长度是5，后面没有给出的值默认是0 ；等价于c[] = {0, 1, 2, 0, 0}
char d[3] = {'a', 'b', 'c'};
// 字符数组的初始化，长度为3
int f[100]={0};
//数组内数据全是0；最常用！！！
return 0;
}
可以将a[0]直接看成b;
1.3 访问数组元素
通过下标访问数组。
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int a[3] = {0, 1, 2}; // 数组下标从0开始
cout << a[0] << ' ' << a[1] << ' ' << a[2] << endl;
//这里就是通过下标访问数组里存的实际的值
a[0] = 5;
cout << a[0] << endl;
return 0;
}//会输出0 1 2 5
补充：写在main函数里面，空间是栈，c++的默认空间是1M；所以说数组过大的话会爆掉，所以就可以定义在main函数的外面，外面空间是堆，（很大不会爆掉）
且定义在main函数外面的数组（全局变量数组）默认里面数据全是0；
练习题1： 使用数组实现求斐波那契数列的第 N 项。
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int n;
int f[100];
cin >> n;
f[0] = 0, f[1] = 1;
for (int i = 2; i <= n; i ++ ) f[i] = f[i - 1] + f[i - 2];
cout << f[n] << endl;
return 0;
}
练习题2：输入一个 n，再输入 n个整数。将这 n 个整数逆序输出。
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int n;
int a[100];
cin >> n;
for (int i = 0; i < n; i ++ ) cin >> a[i];
for (int i = n - 1; i >= 0; i -- ) cout << a[i] << ' ';
cout << endl;
return 0;
}
练习题3：输入一个 n，再输入 n个整数。将这个数组顺时针旋转 k(k≤n) 次，最后将结果输出。
旋转一次是指：将最右边的数放到最左边。
常规代码：
上述代码的思路：
n-1是最后一个数在一个循环里，先让t=a【n-1】，相当于把此时顺序的几个数里的最后一个数存起来
然后内循环，也就是那个for循环，从n-2也就是倒数第二个数开始，依次让后一个数等于前一个数，直到a【1】等于a【0】，然后for循环结束，再把a【0】=t。
这样一次while循环结束，也就是交换了一次，然后再进行下一次交换
巧妙思路：
其实就是比如五个数据1 2 3 4 5然后旋转两次；第一步就是翻转整个数组，那么就是5 4 3 2 1；第二步就是翻转5 4 ，最后翻转完是4 5 3 2 1；第三步步就是翻转3 2 1 ，最后翻转完是4 5 1 2 3；翻转环节用到的函数：reverse(起始位置，翻转终止位置的下一个位置）
注意这个函数在#include <algorithm>头文件里面
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int n, k;
int a[100];
cin >> n >> k;
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 i = 0; i < n; i ++ ) cout << a[i] << ' ';
cout << endl;
return 0;
}
练习题4：输入 n个数，将这 n 个数按从小到大的顺序输出。
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int n;
int a[100];
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;
}
练习题5：计算 2的 N次方。N≤10000
高精度运算
加减乘的时候数据存法（因为经常涉及进位问题）：
比如想存一个数据1234567891234，其实存的时侯经常翻转过来存，就是让最后一个4存进a[0]这样子
上图 t 代表进位
计算过程演示：
这个思想就是：倒着存最后一个是0 这样好进位
初始时数组A是a[]=[0000001]这种
#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 ++ )
{
t += a[i] * 2;
a[i] = t % 10;
t /= 10;
}
if (t) a[size ++ ] = t;
}
for (int i = size - 1; i >= 0; i -- ) cout << a[i];
cout << endl;
return 0;
}
2. 多维数组
多维数组就是数组的数组。
int a[3][4]; // 大小为3的数组，每个元素是含有4个整数的数组。
int arr[10][20][30] = {0}; // 将所有元素初始化为0
// 大小为10的数组，它的每个元素是含有20个数组的数组
// 这些数组的元素是含有30个整数的数组
三维数组：
二维数组的初始化：
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int b[3][4] =
{ // 三个元素，每个元素都是大小为4的数组
{0, 1, 2, 3}, // 第1行的初始值
{4, 5, 6, 7}, // 第2行的初始值
{8, 9, 10, 11} // 第3行的初始值
};
return 0;
}
练习题：输入一个 n行 m 列的矩阵，从左上角开始将其按回字形的顺序顺时针打印出来。（蛇形矩阵）
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int n, m;
int arr[50][50];
cin >> n >> m;
for (int i = 0; i < n; i ++ )
for (int j = 0; j < m; j ++ )
cin >> arr[i][j];
bool st[50][50] = {false};
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
int d = 1, x = 0, y = 0;
for (int i = 0; i < n * m; i ++ )
{
int a = x + dx[d], b = y + dy[d];
if (a < 0 || a >= n || b < 0 || b >= m || st[a][b])
{
d = (d + 1) % 4;
a = x + dx[d], b = y + dy[d];
}
cout << arr[x][y] << ' ';
st[x][y] = true;
x = a, y = b;
}
cout << endl;
return 0;
}
补充;：数组的初始化问题—memset函数
如果是有多组测试数据，每次都要数组初始化让数组里的数据变成0，
方法一：for循环 初始化数组；
方法二：（优化）--memset函数应用，在头文件#include <cstring>内才能调用
关于memset函数用法：三个参数：数组的名字；数组初始化的数值；初始化多长
memset函数所有的单位都是字节：
一个int 是4个bit（位）
例如下面的程序：
memset函数就是将从a开始的40个bit（字节）（就是相当于10个int数据）全都初始化成0
注意：程序中的0 是说将数组里的每个字节都赋值成0 不是说将数据直接赋值成0
上面程序的输出结果：
总结：因为是赋值字节，所以经常用函数将数组初始化为0（也就是上述程序）；
还有一种赋值就是将数组全部初始化为1；那么就是memset(a,-1,40);
最后的想要初始化的数据相当于字节可以不用自己算，就是比如这个10个int数据是40个字节问题；可以用sizeof（运算符）;
可以直接计算数组a的字节
数组复制问题（将一个数组复制到另一个数组）----memcpy函数
memcpy（目标转换的，原数组，复制多长）
上述代码就是将a数组复制到b数组里面。
用普通方法其实就是：
题目练习：
737. 数组替换
输入一个长度为 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
clude <bits/stdc++.h>
using namespace std;
int main()
{
int a[10]={0};int i;
for(i=0;i<10;i++)
{
cin>>a[i];
}
for(i=0;i<10;i++)
{
if(a[i]<=0) a[i]=1;
printf("X[%d] = %d\n",i,a[i]);
}
}
738. 数组填充
输入一个整数 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 <bits/stdc++.h>
using namespace std;
int main()
{
int n;int i;
cin>>n;//第一个数据
int a[10];
for(i=0;i<10;i++)
{
if(i==0) a[i]=n;
else a[i]=a[i-1]*2;
printf("N[%d] = %d\n",i,a[i]);
}
return 0;
}
或者：
#include <cstdio>
using namespace std;
int main()
{
int a[10],s,d;
scanf("%d",&s);
a[0]={s};//直接让第一个数据等于输入的值就行了；
for(d=1;d<=9;d++)
a[d]={a[d-1]*2};
for(int f=0;f<=9;f++)
printf("N[%d] = %d\n",f,a[f]);
}
739. 数组选择
输入一个长度为 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 <bits/stdc++.h>
using namespace std;
int main()
{
double n;int i;double A[100]={0};
for(i=0;i<100;i++)
{
cin>>n;//读入100个数据代表数组里面的数；
A[i]=n;//读入de数据代表数组里面的数；
if(n<=10)
printf("A[%d] = %.1f\n",i,n);
}
}
743. 数组中的行
输入一个二维数组 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 <bits/stdc++.h>
using namespace std;
double b[12][12];
//注意数组里的数据都是浮点型，所以定义的时候肯定是浮点类型
int main()
{
int l;//行数，（行数从 0 开始计数）
double sum=0;
char a; //第二行的字符
cin>>l>>a;//cin会自动忽略空格和换行
for(int i=0;i<12;i++)//行
{
for(int j=0;j<12;j++)//列
{
cin>>b[i][j];//读入数组数据；
}
}
for(int j=0;j<12;j++)
{
sum+=b[l][j];//行数也是从0开始的（题目上写了）
}
if(a=='S') printf("%.1f\n",sum);
else printf("%.1f",sum/12);
return 0;
}
745. 数组的右上半部分
输入一个二维数组 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 <bits/stdc++.h>
using namespace std;
double a[12][12];
int main()
{
char c;
cin>>c;
for(int i=0;i<12;i++)
{
for(int j=0;j<12;j++)
{
cin>>a[i][j];
}
}
int n=0;//记录数据个数；
double sum=0;
for(int i=0;i<12;i++)
{
for(int j=i+1;j<12;j++)
{
n++;
sum+=a[i][j];
}
}
if(c=='S') printf("%.1lf",sum);
else if (c=='M')printf("%.1f",sum/n);
}
747. 数组的左上半部分
输入一个二维数组 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
思路：
就是左边这个代表行，右边对应结束的列数数字；然后找规律；（和为定值10）
#include <bits/stdc++.h>
using namespace std;
double a[12][12];
int main()
{
char c;
cin>>c;
for(int i=0;i<12;i++)
{
for(int j=0;j<12;j++)
{
cin>>a[i][j];
}
}
int n=0;//记录数据的个数；
double sum=0;
for(int i=0;i<12;i++)
{
for(int j=0;j<11-i;j++)
//找规律，第一行少打印一个，第二行少打印两个
{
n++;
sum+=a[i][j];
}
}
if(c=='S') printf("%.1f\n",sum);
else if(c=='M') printf("%.1f\n",sum/n);
}
749. 数组的上方区域
输入一个二维数组 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 <bits/stdc++.h>
using namespace std;
double a[12][12];
int main()
{
char c;
cin>>c;
for(int i=0;i<12;i++)
for(int j=0;j<12;j++)
cin>>a[i][j];
int n=0;//记录次数
double sum=0;//记录总和；
for(int i=0;i<5;i++)//控制打印的行数
{
for(int j=i+1;j<11-i;j++)
//这里就是依次是打印时候的起始的位置和最终结束的位置；
{
n++;
sum+=a[i][j];
}
}
if(c=='M') printf("%.1f",sum/n);
else if(c=='S') printf("%.1f\n",sum);
}
751. 数组的左方区域
输入一个二维数组 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 <bits/stdc++.h>
using namespace std;
double a[12][12];
int main()
{
char c;
cin>>c;
for(int i=0;i<12;i++)
for(int j=0;j<12;j++)
cin>>a[i][j];
int n=0;
double sum=0;
for(int i=0;i<6;i++)
{
for(int j=0;j<i;j++)
//j<i有效的让程序从第二行才开始计算数据；
{
n++;
sum+=a[i][j];
}
}
for(int i=6;i<11;i++)
{
for(int j=0;j<=10-i;j++)
{
n++;
sum+=a[i][j];
}
}
if(c=='S') printf("%.1f\n",sum);
else if(c=='M') printf("%.1f\n",sum/n);
}
753. 平方矩阵 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
理解：
找规律：
图片上应该是n-j+1;写错了上面；，找规律
发现这个就是一个点的坐标（i,j);找到这个点距离上下左右的最短距离，这个就是他所处区域的数据了；
(i,j)到上面一条边的距离是i,到下面一条边的距离是n-i+1;到左边的距离是j;到右边的距离是j-i+1;
然后就是在这四个数据中寻找最小值；
#include <iostream>
#include <cstdio>
#include <algorithm>
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, left = j, down = n + 1 - i, right = n + 1 - j;
int a = min(min(up, down), min(left, right));
//寻找最小值，两个两个比较找到小的然后找二者中更小的那个
cout << a << ' ';
}
cout << endl;
}
cout << endl;
}
return 0;
}
740. 数组变换
输入一个长度为 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 <bits/stdc++.h>
using namespace std;
int main()
{
int a[20];
int n;
for(int i=0;i<20;i++)
{
cin>>a[i];
}
for(int i=19;i>=0;i--)//题目要求其实就是一个逆序输出的过程
printf("N[%d] = %d\n",19-i,a[i]);
}
741. 斐波那契数列
输入整数 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 <bits/stdc++.h>
using namespace std;
long long a[100];
int main()
{
int n;//数据总组数
cin>>n;
int x;//代表输入的数据
a[0]=0;
a[1]=1;
for(int i=2;i<=60;i++) a[i]=a[i-1]+a[i-2];
//计算第n项的值
while(n--)//控制循环次数
{
cin>>x;
printf("Fib(%d) = %lld\n",x,a[x]);
//这里a[x]其实就是x对应的数列的值；
}
}
742. 最小数和它的位置
输入一个整数 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 <bits/stdc++.h>
using namespace std;
int a[10000];
int main()
{
int n;
cin>>n;
for(int i=0;i<n;i++)
cin>>a[i];
int min=100000;int mi=0;
for(int i=0;i<n;i++)
{
if(a[i]<min)
{
min=a[i];
mi=i;//记录位置；
}
}
printf("Minimum value: %d\n",min);
printf("Position: %d",mi);
}
744. 数组中的列
输入一个二维数组 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 <bits/stdc++.h>
using namespace std;
double a[12][12];
int main()
{
int n;
char c;
cin>>n>>c;
for(int i=0;i<12;i++)
{
for(int j=0;j<12;j++)
{
cin>>a[i][j];
}
}
int m=0;//记录次数；
double sum=0;
for(int i=0;i<12;i++)
{
sum+=a[i][n];
m++;
}
if(c=='S') printf("%.1f\n",sum);
else if(c=='M') printf("%.1f\n",sum/m);
}
748. 数组的右下半部分
输入一个二维数组 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 <bits/stdc++.h>
using namespace std;
double a[12][12];
int main()
{
char c;
cin>>c;
for(int i=0;i<12;i++)
for(int j=0;j<12;j++)
cin>>a[i][j];
int n=0;
double sum=0;
for(int i=0;i<12;i++)
{
for(int j=12-i;j<12;j++)
//从最后一个数据往前打印的思想；
{
sum+=a[i][j];
n++;
}
}
if(c=='S') printf("%.1f\n",sum);
else if(c=='M') printf("%.1f\n",sum/n);
}
746. 数组的左下半部分
输入一个二维数组 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 <bits/stdc++.h>
using namespace std;
double a[12][12];
int main()
{
char c;
cin>>c;
for(int i=0;i<12;i++)
for(int j=0;j<12;j++)
cin>>a[i][j];
int n=0;
double sum=0;
for(int i=0;i<12;i++)
{
for(int j=0;j<i;j++)
{
sum+=a[i][j];
n++;
}
}
if(c=='S') printf("%.1f\n",sum);
else if(c=='M') printf("%.1f\n",sum/n);
}
750. 数组的下方区域
输入一个二维数组 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>
#include <cstdio>
using namespace std;
int main()
{
double a[13][13];
char sm;
double s = 0;
int c = 0;
cin >> sm;
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 = 5 - i; j <= 6 + i; j++)
{
c++;
s += a[i+7][j];
}
}
if (sm == 'S') printf("%.1f\n", s);
else printf("%.1f\n", s / c);
return 0;
}
752. 数组的右方区域
输入一个二维数组 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>
#include <cstdio>
using namespace std;
int main()
{
double a[13][13];
char sm;
double s = 0;
int c = 0;
cin >> sm;
for (int i = 0; i < 12; i++)
{
for (int j = 0; j < 12; j++)
cin >> a[i][j];
}
for (int i = 1; i <= 5; i++)
{
for (int j = 12 - i; j <= 11; j++)
{
c++;
s += a[i][j];
}
}
for (int i = 6; i <= 10; i++)
{
for (int j = 1 + i; j <= 11; j++)
{
c++;
s += a[i][j];
}
}
if (sm == 'S') printf("%.1f\n", s);
else printf("%.1f\n", s / c);
return 0;
}
754. 平方矩阵 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>
using namespace std;
int q[100][100];
int main()
{
int n;
while (cin >> n, n)
{
for (int i = 0; i < n; i ++ )
{
q[i][i] = 1;//对角线上的数写成1；
for (int j = i + 1, k = 2; j < n; j ++, k ++ ) q[i][j] = k;//从对角线开始向右延伸
for (int j = i + 1, k = 2; j < n; j ++, k ++ ) q[j][i] = k;//从对角线开始向下延伸
}
for (int i = 0; i < n; i ++ )
{
for (int j = 0; j < n; j ++ )
cout << q[i][j] << ' ';
cout << endl;
}
cout << endl;
}
return 0;
}
法二：曼哈顿距离
755. 平方矩阵 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>
#include <cstdio>
using namespace std;
int main()
{
int n;
while (cin >> n, n)
{
for (int i = 0; i < n; i ++ )
{
for (int j = 0; j < n; j ++ )
{
int v = 1;
for (int k = 0; k < i + j; k ++ ) v *= 2;
cout << v << ' ';
}
cout << endl;
}
cout << endl;
}
return 0;
}
756. 蛇形矩阵
输入两个整数 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, k = 1; k <= n * m; k ++ )
{
res[x][y] = k;
int a = x + dx[d], b = y + dy[d];
if (a < 0 || a >= n || b < 0 || b >= m || res[a][b])//撞墙
{
d = (d + 1) % 4;//改变方向
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 << res[i][j] << ' ';
cout << endl;
}
return 0;
}
偏移量技巧：
这个是传统的写法，那么可以将上述 转化成偏移量（绿色部分）
1281
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
