一排容器——数组的基础语法和打表

1.数组介绍

1.1.例题1——小鱼比可爱

小鱼比可爱 - 洛谷

题目描述

人比人，气死人；鱼比鱼，难死鱼。小鱼最近参加了一个“比可爱”比赛，比的是每只鱼的可爱程度。参赛的鱼被从左到右排成一排，头都朝向左边，然后每只鱼会得到一个整数数值，表示这只鱼的可爱程度，很显然整数越大，表示这只鱼越可爱，而且任意两只鱼的可爱程度可能一样。由于所有的鱼头都朝向左边，所以每只鱼只能看见在它左边的鱼的可爱程度，它们心里都在计算，在自己的眼力范围内有多少只鱼不如自己可爱呢。请你帮这些可爱但是鱼脑不够用的小鱼们计算一下。

输入格式

第一行输入一个正整数 $n$，表示鱼的数目。

第二行内输入 $n$ 个正整数，用空格间隔，依次表示从左到右每只小鱼的可爱程度 $a_i$。

输出格式

一行，输出 $n$ 个整数，用空格间隔，依次表示每只小鱼眼中有多少只鱼不如自己可爱。

输入输出样例

输入 #1

6
4 3 0 5 1 2

输出 #1

0 0 0 3 1 2

提示

对于 $100\%$ 的数据，$1\le n\le 100$，$0\le a_i\le 10$。

程序示例：

#include<iostream>
using namespace std;
int main()
{
    int n,i,j,s;//n:总只数 s:不如自己好看数 i,j:循环变量
    cin>>n;
    int a[110];
    for(i=0;i<n;i++)//从左至右计算每只鱼各自见不如自己好看的鱼。
    {                            
        s=0;//s是每条鱼各自看到的不如自己好看的，所以每过一条就清零。
        cin>>a[i];
        for(j=i;j>=0;j--)//切记往左看！也就是一直自减！
            if(a[i]>a[j])
                s++;//如果此鱼颜值更高，记一个。
        cout<<s<<" ";    //每比完一只鱼就输出一次，不用再额外循环。
    }
    return 0;
}

1.2.数组的基础语法

1.2.1.定义

    对于上面这道题，我们需要定义大量的变量来储存数据。

    在这里，我们可以使用数组。

    如果说以前定义的单个变量为一个小杯子的话,那么数组就是放在一起的一堆小杯子。我们把这些小杯子称为元素。

    定义一个数组的语法如下：

数组类型 数组名[数组元素个数];

比如：定义一个有10个元素的整形数组。
int a[10];

其中，数组元素个数应该为整数常量表达式。比如，这样就是不合法的。

int a[10+a];
int b[10.12];

但也要注意，这样是合法的。

int c[5+5*5];//表达式会自动计算
int d['a'];//'a'会自动转换成ASCII码值
int e[100.0];//同理,100.0会自动转换成100

1.2.2.数组初始化

在定义数组的时候，可以对数组初始化，基本语法如下：

数组类型 数组名[数组元素个数]={初值1,初值2,…,初值n};

注意：初值$1$就是对数组第$1$个元素的初始化，依次往后类推。没有被指明的元素会被初始化为0。比如这样：
int a[5]={1,2,3};

第一个元素被赋值成$1$。
第二个元素被赋值成$2$。
第三个元素被赋值成$3$。
第四个元素被赋值成$0$。
第五个元素被赋值成$0$。

想要把数组全部初始化为0可以这样操作：
int a[10]={0};
或者
int a[10]={};

当然，数组的定义还有这样一种形式
int a[]={1,2,3,4,5,6,7,8,9};
这样数组的大小就是初始化之后元素的个数。通常用在事先不清楚数组大小的情况下使用

如果想将数组的每一个元素都赋一个相同的初始值，可以使用memset函数，需要包含cstring头文件。

memset(数组名,值,sizeof(数组名));

注意：只有当这个初始值为$0$或$-1$时才有效。这里不懂得先不要深究，到后面自然会讲解。现在只需要把语法记一下就可以了。

1.2.3.下标

    数组内的元素是连续存放的。可以使用下标来访问数组中的每个元素。第n个元素和其下标的关系如下。

第几个	下标
1	0
2	1
3	2
4	3
…	…
n	n-1

1.2.4.元素访问

    根据上面提到的下标，我们可以知道如何访问数组中下标为n的元素。

数组名[n]

比如：输入并输出n个元素。

int a[110],n;
cin>>n;
for(int i=1;i<=n;i++)
    cin>>a[i];
for(int i=1;i<=n;i++)
    cout<<a[i]<<endl;

1.2.5.数组访问扩展

    对于一个数组，如果我们想一边储存这个数组的有效长度，一边储存数据，可以这样写。
a[++cnt]=num;//cnt为这个数组的有效长度,或者说cnt+1就是下一个空位置,num为要储存的数
    等同于:
++cnt;a[cnt]=num;
    当然，我们也可以这样写。
a[cnt++]=num;
    这两者还是有一定区别。可以先自己思考。实在不会就去看看i++和++i的区别这篇文章。

1.2.6.数组越界

    如果我只定义了$10$个元素，但我想访问a[10] (记得前面还有个$a[0]$)会怎样呢？那就是会产生数组越界。通常编译时不会报错，但是在竞赛中如果产生数组越界，那么这个测试点会被判为$0$分。

技巧1：因为数组下标是从$0$开始的，所以在写题的时候，要先估计数据规模，数组一般都要开大一点（具体根据实际情况而定）。比如上面的例题，$n$最大不超过$100$，数组就开$110$。
技巧2：当我们要定义一堆相同大小的数组时，为了方便改动，我么可以定义一个宏，存下数组大小。示例如下：

#define MAXN 110
int a[MAXN],b[MAXN],c[MAXN];

1.2.7.遍历

有序地访问数组中的每一个有效元素，叫做数组的遍历。比如：

int a[110]={},n;
cin>>n;
for(int i=1;i<=n;i++)
    cin>>a[i];
for(int i=1;i<=n;i++)//这就是数组的遍历
    a[i]++;
for(int i=1;i<=n;i++)//这也是数组的遍历
    cout<<a[i]<<endl;

1.3.练习1——校门外的树

校门外的树 - 洛谷

题目描述

某校大门外长度为 $l$ 的马路上有一排树，每两棵相邻的树之间的间隔都是 $1$ 米。我们可以把马路看成一个数轴，马路的一端在数轴 $0$ 的位置，另一端在 $l$ 的位置；数轴上的每个整数点，即 $0,1,2,\dots ,l$，都种有一棵树。

由于马路上有一些区域要用来建地铁。这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有重合的部分。现在要把这些区域中的树（包括区域端点处的两棵树）移走。你的任务是计算将这些树都移走后，马路上还有多少棵树。

输入格式

第一行有两个整数，分别表示马路的长度 $l$ 和区域的数目 $m$。

接下来 $m$ 行，每行两个整数 $u,v$，表示一个区域的起始点和终止点的坐标。

输出格式

输出一行一个整数，表示将这些树都移走后，马路上剩余的树木数量。

输入输出样例

输入 #1

500 3
150 300
100 200
470 471

输出 #1

298

提示

【数据范围】

• 对于 $20\%$ 的数据，保证区域之间没有重合的部分。
• 对于 $100\%$ 的数据，保证 $1\le l\le 10^4$，$1\le m\le 100$，$0\le u\le v\le l$。

题意分析
    如果我们直接用一个整数数组储存这个道路每个点的种树情况，可能会有区域重合。我们可以使用一个$bool$类型的数组储存这个道路每个点是否种树。代码如下：

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
    int i,j,l,m,n,u,v,sum=0;//用sum记录没有植树植树的区域的个数
	bool a[10010]={};//模拟公路植树情况
	cin>>l>>m;//输入道路长度和数据组数
	for(i=1;i<=m;i++)
	{
		cin>>u>>v;//输入左端点和右端点
		for(j=u;j<=v;j++)//模拟种树
		    a[j]=1;//直接赋值成1
	}
	for(i=0;i<=l;i++)//遍历数组
		if(a[i]==0)//如果没有植树
		    sum++;
	cout<<sum;
	return 0;
}

2.多维数组

2.1.二维数组语法介绍

    二维数组，也叫矩阵数组。如果说一维数组是一堆点的话,那二维数组就是一个平面。定义语法如下：

数组类型 数组名[行数][列数];

比如：
int a[10][10];

行/列	0	1	2	3	…	n
0	a[0][0]	a[0][1]	a[0][2]	a[0][3]	…	a[0][n]
1	a[1][0]	a[1][1]	a[1][2]	a[1][3]	…	a[1][n]
2	a[2][0]	a[2][1]	a[2][2]	a[2][3]	…	a[2][n]
3	a[3][0]	a[3][1]	a[3][2]	a[3][3]	…	a[3][n]
…	…	…	…	…	…	…
n	a[n][0]	a[n][1]	a[n][2]	a[n][3]	…	a[n][n]

二维数组其实也可以理解成一堆数组,如:
int a[10][10];

a[10] a[10] a[10] a[10] a[10] a[10]…
   0       1        2       3       4        5…

2.2.二维数组的使用

    输入/输出二维数组的某一个数,需要在后面指明要调用的这个数的行和列。比如：

int a[10][10];
a[0][1]=20;
cout<<a[0][1];

2.3.多维数组

我们可以运用类似定义二维数组的方法来定义多维数组,比如：
int a[10][10][10];
多维数组的元素调用方法和二维数组也是差不多的,比如：

cin>>a[1][1][1];
cout<<a[1][1][1];

多维数组的含义一般都是特殊的,需要自己去寻找归律。

总结:$n$维数组的使用方法:

数组类型 数组名[大小][大小][大小]…($n$个)
$cout$<<$/cin$>>/…数组名[需调用的数的大小][需调用的数的大小][需调用的数的大小]…($n$个)

2.2.例题2——地毯

地毯 - 洛谷

题目描述

在 $n\times n$ 的格子上有 $m$ 个地毯。

给出这些地毯的信息，问每个点被多少个地毯覆盖。

输入格式

第一行，两个正整数 $n,m$。意义如题所述。

接下来 $m$ 行，每行两个坐标 $(x_1,y_1)$ 和 $(x_2,y_2)$，代表一块地毯，左上角是 $(x_1,y_1)$，右下角是 $(x_2,y_2)$。

输出格式

输出 $n$ 行，每行 $n$ 个正整数。

第 $i$ 行第 $j$ 列的正整数表示 $(i,j)$ 这个格子被多少个地毯覆盖。

输入输出样例

输入 #1

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

输出 #1

0 1 1 1 0
0 1 1 0 0
0 1 2 1 1
0 0 1 1 1
0 0 1 1 1

提示

样例解释

覆盖第一个地毯后：

$0$	$0$	$0$	$0$	$0$
$0$	$1$	$1$	$0$	$0$
$0$	$1$	$1$	$0$	$0$
$0$	$0$	$0$	$0$	$0$
$0$	$0$	$0$	$0$	$0$

覆盖第一、二个地毯后：

$0$	$0$	$0$	$0$	$0$
$0$	$1$	$1$	$0$	$0$
$0$	$1$	$2$	$1$	$1$
$0$	$0$	$1$	$1$	$1$
$0$	$0$	$1$	$1$	$1$

覆盖所有地毯后：

$0$	$1$	$1$	$1$	$0$
$0$	$1$	$1$	$0$	$0$
$0$	$1$	$2$	$1$	$1$
$0$	$0$	$1$	$1$	$1$
$0$	$0$	$1$	$1$	$1$

---

数据范围

对于 $20\%$ 的数据，有 $n\le 50$，$m\le 100$。

对于 $100\%$ 的数据，有 $n,m\le 1000$。

题意分析
    我们可以用一个二维数组储存这个区域。然后把每块地毯用双重循环覆盖上去就行了。

完整代码如下：

#include<iostream>
using namespace std;
#define MAXN 1010//数组的大小
int main()
{
	int n,m,x1,x2,y1,y2,t[MAXN][MAXN]={};//用t数组模拟这块区域
	cin>>n>>m;
	while(m--)//m组数据
	{
		cin>>x1>>y1>>x2>>y2;
		for(int i=x1;i<=x2;i++)//循环行
			for(int j=y1;j<=y2;j++)//循环列
				t[i][j]++;
	}
	for (int i=1;i<=n;i++)//循环行
	{
		for(int j=1;j<=n;j++)//循环列
			cout<<t[i][j]<<' ';
		cout<<endl;
	}
	return 0;
}

2.3.练习2——工艺品制作

题目描述

现有一个长宽高分别为 $w,x,h$ 组成的实心玻璃立方体，可以认为是由 $1\times 1\times 1$ 的数个小方块组成的，每个小方块都有一个坐标 $ ( i,j,k ) $。现在需要进行 $q$ 次切割。每次切割给出 $(x_1,y_1,z_1),(x_2,y_2,z_2)$ 这 6 个参数，保证 $x_1\le x_2$，$y_1\le y_2$，$z_1\le z_2$；每次切割时，使用激光工具切出一个立方体空洞，空洞的壁平行于立方体的面，空洞的对角点就是给出的切割参数的两个点。

换句话说，所有满足 $x_1\le i\le x_2$，$y_1\le j \le y_2 $，$z_1\le k\le z_2$ 的小方块 $(i,j,k)$ 的点都会被激光蒸发。例如有一个 $4\times 4\times 4$ 的大方块，其体积为 $64$；给出参数 $(1,1,1),(2,2,2)$ 时，中间的 $8$ 块小方块就会被蒸发，剩下 $56$ 个小方块。现在想知道经过所有切割操作后，剩下的工艺品还剩下多少格小方块的体积？

输入格式

第一行三个正整数 $w,x,h$。

第二行一个正整数 $q$。

接下来 $q$ 行，每行六个整数 $(x_1,y_1,z_1),(x_2,y_2,z_2)$。

输出格式

输出一个整数表示答案。

输入输出样例

样例输入 #1

4 4 4
1
1 1 1 2 2 2

样例输出 #1

56

提示

数据保证，$1\le w,x,h\le 20$，$1\le q\le 100$。$1\le x_1\le x_2\le w$，$1\le y_1\le y_2\le x$，$1\le z_1\le z_2\le h$。

题意分析
    跟上一道题一样，我们用一个三维数组储存这个工艺品。并使用三重循环切割。

代码如下：

#include<iostream>
using namespace std;
#define MAXN 25
int main()
{
    int w,x,h,q,x1,y1,z1,x2,y2,z2,sum=0,op[MAXN][MAXN][MAXN]={};
    //使用op数组存储这个工艺品,sum存储答案
	cin>>w>>x>>h>>q;
	while(q--)//q组数据
	{
		cin>>x1>>y1>>z1>>x2>>y2>>z2;
		for(int i=x1;i<=x2;i++)//循环行
			for(int j=y1;j<=y2;j++)//循环列
			   for(int k=z1;k<=z2;k++)//循环高
			   	     op[i][j][k]=1;
	} 
	for(int i=1;i<=w;i++)//循环行
		for(int j=1;j<=x;j++)//循环列
		{
			for(int k=1;k<=h;k++)//循环高
			    if(op[i][j][k]==0)//统计
			        sum++;
		}
	cout<<sum;
	return 0;
}

3.打表介绍

3.1.打表简介

    打表，我们也可以叫它"面向数据编程"通常会使用数组分别存储不同输入时的不同输出。这种写法虽然简单粗暴，但是需要有极大的耐心。比赛时不会关注你是如何得出答案的，而只会关注你的答案是否正确，这就是黑盒测试法。打表一般只适用于数据规模较小的情况。

3.2.例题3——数字游戏

数字游戏 - 洛谷

题目描述

小 K 同学向小 P 同学发送了一个长度为 $8$ 的 01 字符串来玩数字游戏，小 P 同学想要知道字符串中究竟有多少个 $1$。

注意：01 字符串为每一个字符是 $0$ 或者 $1$ 的字符串，如 101 为一个长度为 $3$ 的 01 字符串。

输入格式

输入文件只有一行，一个长度为 $8$ 的 01 字符串 $s$。

输出格式

输出文件只有一行，包含一个整数，即 01 字符串中字符 $1$ 的个数。

输入输出样例

输入 #1

00010100

输出 #1

2

输入 #2

11111111

输出 #2

8

提示

样例 1 说明

该 01 字符串中有 $2$ 个字符 $1$。

样例 2 说明

该 01 字符串中有 $8$ 个字符 $1$。

数据规模与约定

• 对于 $20\%$ 的数据，保证输入的字符全部为 $0$。
• 对于 $100\%$ 的数据，输入只可能包含字符 $0$ 和字符 $1$，字符串长度固定为 $8$。

$1.$程序打表
这种写法还不算太简单粗暴，代码如下：

#include<iostream>
using namespace std;
int main()
{
	int n,a[11111112]={};//最大的情况是8个1,注意还有一个下标为0的,要多定义一个。
	cin>>n;
	for(int i=0;i<=1;i++)//枚举每一位
		for(int j=0;j<=1;j++)
			for(int k=0;k<=1;k++)
				for(int l=0;l<=1;l++)
					for(int m=0;m<=1;m++)
						for(int n=0;n<=1;n++)
							for(int o=0;o<=1;o++)
								for(int p=0;p<=1;p++)
	                                a[i*10000000+j*1000000+k*100000+l*10000+m*1000+n*100+o*10+p]=i+j+k+l+m+n+o+p;
	                                //采用位值原理计算每一个答案
	cout<<a[n];//直接输出
	return 0;
}

$2.$直接打表
还有一种更简单粗暴的方法，需要纯手工计算。代码如下：

#include<iostream>
using namespace std;
int main()
{
	int n,a[11111112]={};
	cin>>n;
	a[0]=0;//依次计算
	a[1]=1;
	a[10]=1;
	a[11]=2;
	a[100]=1;
	a[101]=2;
	a[110]=2;
	a[111]=3;
	a[1000]=1;
	a[1001]=2;
	a[1010]=2;
	a[1011]=3;
	a[1100]=2;
	a[1101]=3;
	a[1110]=3;
	a[1111]=4;
	a[10000]=1;
	a[10001]=2;
	a[10010]=2;
	a[10011]=3;
	a[10100]=2;
	a[10101]=3;
	a[10110]=3;
	a[10111]=4;
	a[11000]=2;
	a[11001]=3;
	a[11010]=3;
	a[11011]=4;
	a[11100]=3;
	a[11101]=4;
	a[11110]=4;
	a[11111]=5;
	a[100000]=1;
	a[100001]=2;
	a[100010]=2;
	a[100011]=3;
	a[100100]=2;
	a[100101]=3;
	a[100110]=3;
	a[100111]=4;
	a[101000]=2;
	a[101001]=3;
	a[101010]=3;
	a[101011]=4;
	a[101100]=3;
	a[101101]=4;
	a[101110]=4;
	a[101111]=5;
	a[110000]=2;
	a[110001]=3;
	a[110010]=3;
	a[110011]=4;
	a[110100]=3;
	a[110101]=4;
	a[110110]=4;
	a[110111]=5;
	a[111000]=3;
	a[111001]=4;
	a[111010]=4;
	a[111011]=5;
	a[111100]=4;
	a[111101]=5;
	a[111110]=5;
	a[111111]=6;
	a[1000000]=1;
	a[1000001]=2;
	a[1000010]=2;
	a[1000011]=3;
	a[1000100]=2;
	a[1000101]=3;
	a[1000110]=3;
	a[1000111]=4;
	a[1001000]=2;
	a[1001001]=3;
	a[1001010]=3;
	a[1001011]=4;
	a[1001100]=3;
	a[1001101]=4;
	a[1001110]=4;
	a[1001111]=5;
	a[1010000]=2;
	a[1010001]=3;
	a[1010010]=3;
	a[1010011]=4;
	a[1010100]=3;
	a[1010101]=4;
	a[1010110]=4;
	a[1010111]=5;
	a[1011000]=3;
	a[1011001]=4;
	a[1011010]=4;
	a[1011011]=5;
	a[1011100]=4;
	a[1011101]=5;
	a[1011110]=5;
	a[1011111]=6;
	a[1100000]=2;
	a[1100001]=3;
	a[1100010]=3;
	a[1100011]=4;
	a[1100100]=3;
	a[1100101]=4;
	a[1100110]=4;
	a[1100111]=5;
	a[1101000]=3;
	a[1101001]=4;
	a[1101010]=4;
	a[1101011]=5;
	a[1101100]=4;
	a[1101101]=5;
	a[1101110]=5;
	a[1101111]=6;
	a[1110000]=3;
	a[1110001]=4;
	a[1110010]=4;
	a[1110011]=5;
	a[1110100]=4;
	a[1110101]=5;
	a[1110110]=5;
	a[1110111]=6;
	a[1111000]=4;
	a[1111001]=5;
	a[1111010]=5;
	a[1111011]=6;
	a[1111100]=5;
	a[1111101]=6;
	a[1111110]=6;
	a[1111111]=7;
	a[10000000]=1;
	a[10000001]=2;
	a[10000010]=2;
	a[10000011]=3;
	a[10000100]=2;
	a[10000101]=3;
	a[10000110]=3;
	a[10000111]=4;
	a[10001000]=2;
	a[10001001]=3;
	a[10001010]=3;
	a[10001011]=4;
	a[10001100]=3;
	a[10001101]=4;
	a[10001110]=4;
	a[10001111]=5;
	a[10010000]=2;
	a[10010001]=3;
	a[10010010]=3;
	a[10010011]=4;
	a[10010100]=3;
	a[10010101]=4;
	a[10010110]=4;
	a[10010111]=5;
	a[10011000]=3;
	a[10011001]=4;
	a[10011010]=4;
	a[10011011]=5;
	a[10011100]=4;
	a[10011101]=5;
	a[10011110]=5;
	a[10011111]=6;
	a[10100000]=2;
	a[10100001]=3;
	a[10100010]=3;
	a[10100011]=4;
	a[10100100]=3;
	a[10100101]=4;
	a[10100110]=4;
	a[10100111]=5;
	a[10101000]=3;
	a[10101001]=4;
	a[10101010]=4;
	a[10101011]=5;
	a[10101100]=4;
	a[10101101]=5;
	a[10101110]=5;
	a[10101111]=6;
	a[10110000]=3;
	a[10110001]=4;
	a[10110010]=4;
	a[10110011]=5;
	a[10110100]=4;
	a[10110101]=5;
	a[10110110]=5;
	a[10110111]=6;
	a[10111000]=4;
	a[10111001]=5;
	a[10111010]=5;
	a[10111011]=6;
	a[10111100]=5;
	a[10111101]=6;
	a[10111110]=6;
	a[10111111]=7;
	a[11000000]=2;
	a[11000001]=3;
	a[11000010]=3;
	a[11000011]=4;
	a[11000100]=3;
	a[11000101]=4;
	a[11000110]=4;
	a[11000111]=5;
	a[11001000]=3;
	a[11001001]=4;
	a[11001010]=4;
	a[11001011]=5;
	a[11001100]=4;
	a[11001101]=5;
	a[11001110]=5;
	a[11001111]=6;
	a[11010000]=3;
	a[11010001]=4;
	a[11010010]=4;
	a[11010011]=5;
	a[11010100]=4;
	a[11010101]=5;
	a[11010110]=5;
	a[11010111]=6;
	a[11011000]=4;
	a[11011001]=5;
	a[11011010]=5;
	a[11011011]=6;
	a[11011100]=5;
	a[11011101]=6;
	a[11011110]=6;
	a[11011111]=7;
	a[11100000]=3;
	a[11100001]=4;
	a[11100010]=4;
	a[11100011]=5;
	a[11100100]=4;
	a[11100101]=5;
	a[11100110]=5;
	a[11100111]=6;
	a[11101000]=4;
	a[11101001]=5;
	a[11101010]=5;
	a[11101011]=6;
	a[11101100]=5;
	a[11101101]=6;
	a[11101110]=6;
	a[11101111]=7;
	a[11110000]=4;
	a[11110001]=5;
	a[11110010]=5;
	a[11110011]=6;
	a[11110100]=5;
	a[11110101]=6;
	a[11110110]=6;
	a[11110111]=7;
	a[11111000]=5;
	a[11111001]=6;
	a[11111010]=6;
	a[11111011]=7;
	a[11111100]=6;
	a[11111101]=7;
	a[11111110]=7;
	a[11111111]=8;
	cout<<a[n];
	return 0;
}

4.课后作业

数组题单 - 洛谷

喜欢就订阅此专辑吧！

【蓝胖子编程教育简介】
蓝胖子编程教育，是一家面向青少年的编程教育平台。平台为全国青少年提供最专业的编程教育服务，包括提供最新最详细的编程相关资讯、最专业的竞赛指导、最合理的课程规划等。本平台利用趣味性和互动性强的教学方式，旨在激发孩子们对编程的兴趣，培养他们的逻辑思维能力和创造力，让孩子们在轻松愉快的氛围中掌握编程知识，为未来科技人才的培养奠定坚实基础。

欢迎扫码关注蓝胖子编程教育