蓝桥杯--基础练习--BASIC-3字母图形

来源：互联网发布：单桂敏淘宝哪个真的编辑：程序博客网时间：2024/06/10 00:49

问题描述

利用字母可以组成一些美丽的图形，下面给出了一个例子：

ABCDEFG

BABCDEF

CBABCDE

DCBABCD

EDCBABC

这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。

输入格式

输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。

输出格式

输出n行，每个m个字符，为你的图形。

样例输入

5 7

样例输出

ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC

数据规模与约定

1 <= n, m <= 26。

方法一：寻找简单规律。（使用二维数组）

#include<iostream>

using namespace std;

int main()
{
int n,m,i,j;
cin>>n>>m; /////根据需求c++动态建立数组
char **p=new char *[n]; //////////p[n][m];
for(i=0;i<n;i++)
p[i]=new char[m];
for(i=0,p[i][0]='A';i<n;i++,p[i][0]=p[i-1][0]+1) ///数组下标越界（有左边界和右边界越界两种），解决做法：
{ ///1：给数组建立多几个元素（右边界越界）2：在条件里面仔细的控制
for(j=0;j<m;j++)
{
if(p[i][0]>'A')
{
while(p[i][j]>'A'&&j<m) /////////不加 &&j<m的话，就是另一种下标越界了，会多输出其他的字符。
{ /////下面的j++产生的下标越界。
cout<<p[i][j];
p[i][j+1]=p[i][j]-1;
j++;
}
p[i][0]='0';
}
if(j<m)
{
cout<<p[i][j];
p[i][j+1]=p[i][j]+1;
}
}
cout<<endl;
p[i][0]='A'+i;
if(i+1==n)
break;
}
for( i=0;i<n;i++)
{

delete [] p[i]; // 要在指针前加[] ，否则的话只释放p[i]所指的第一个单元所占的空间
}

return 0;
}

///////////////////////////下面对第一种方法进行补充/////////////////

1:c++如何动态建立数组：

（1）建立数组：

很多情况下，在预编译过程阶段，数组的长度是不能预先知道的，必须在程序运行时动态的给出
但是问题是，c++要求定义数组时，必须明确给定数组的大小，要不然编译通不过

如： int Array[5];正确

       int i=5;
       int Array[i]; 错误因为在编译阶段，编译器并不知道 i 的值是多少

   那么，我们该如何解决定义长度未知的数组呢？
   答案是：new 动态定义数组

   因为new 就是用来动态开辟空间的，所以当然可以用来开辟一个数组空间

   这样，下面的语句：
    int size=50;
    int *p=new int[size]; 是正确的

   但是二维动态数组能不能也这样定义呢

int size=50,Column=50;
int (*p)[Column]=new int [size][Column]

这样的语句，编译器通不过，为什么呢？
首先 new int[size][Column] 就是动态生成时确定的，所以它没有错
那么就是 int（*p）[Column]，这句有问题了，这句为什么不对呢，那是因为，这是一个定义语句，而定义语句先经过编译器进行编译，当编译器运行到此处时，发现Column 不是常数，因此不能通过编译。而之所以编译器认为Column 不是常数，是因为编译阶段，编译器起的作用是查语法错误，和预分配空间，它并不执行程序，因此，没有执行那个赋值语句（只是对这个语句检查错误，和分配空间），因此编译阶段，它将认为column 是个变量。所以上面的二维数组定义是错误的，它不能通过编译。

改成这样：
int size=50
int (*p)[50]=new int [size][50]
便正确了。

   由此可见，这种动态分配数组，仅对一维数组空间是真正动态分配的。
   但是如何真正的动态分配二维数组呢，即如果Column 也不能预先知道的话，该如何处理呢？

   上面的动态分配已经不能满足我们的要求，因为上面动态分配只对一维数组是真正动态的，对二维数组的话，必须编译之前预先知道二维数组每一列的长度，而这个长度在很多情况下是不能预先知道的，所以我们得结合其他方法来解决这个问题。

   既然一维是真正的动态分配的话，那我们利用这一特性定义一个指针数组。

   int **p= new int*[size];//定义指针数组
   int *p[5];// 假若知道二维数组的行数为5

   然后对指针数组中的每一个指针分配一个一维数组空间，这样便动态定义了二维数组

   事实上，我认为指针数组的主要用途，就在于动态定义多维数组

    for(int i=0;i<size;i++)
   {
     p[i]=new int[Column];
   }

   运行完毕后，一个二维数组便被动态的成功建立

（2）delete动态建立的数组

for(int i=0;i<size;i++)
{

delete [] p[i]; // 要在指针前加[] ，否则的话只释放p[i]所指的第一个单元所占的空间
}

delete [] p; //最后不要忘掉释放掉开辟的指针数组

2.数组下标越界

在此程序中第一次遇到了数组下标越界的问题：

数组下标越界（有左边界和右边界越界两种），解决做法：1：给数组建立多几个元素（右边界越界）2：在条件里面仔细的控制。

3.本程序的算法选择的不合理，程序看起来杂乱。对程序修改如下：

#include<iostream>
using namespace std;
int main()
{
int n,m,i,j;
cin>>n>>m;
char **p=new char *[n]; //////////数组p[n][m];
for(i=0;i<n;i++)
p[i]=new char[m];
for(i=0;i<n;i++)
{
for(j=0,p[i][j]='A'+i;p[i][j]>'A'&&j<m;j++)
{
cout<<p[i][j];
p[i][j+1]=p[i][j]-1;
}
for(p[i][j]='A';p[i][j]<'z'&&j<m;j++)
{
cout<<p[i][j];
p[i][j+1]=1+p[i][j];
}
cout<<endl;

}
for( i=0;i<n;i++)
{

delete [] p[i]; // 要在指针前加[] ，否则的话只释放p[i]所指的第一个单元所占的空间
}
delete [] p;
return 0;
}

方法二：不难看出每行数据都是由都是有两部分构成的，前面部分是降序，后面部分是升序。（未使用数组）

#include<iostream>
using namespace std;
int main()
{
int n; //输出的行数
int m; //输出的列数
cin>>n>>m;
for(int i=0;i<n;i++) /////里面包含了两个内循环，程序执行内循环进去之后再判断应该选择哪一条循环。
{
int j=0;
for(char a='A'+i;a>'A'&&j<m;a--) //第一个for循环，控制输出前面部分，字符的值在增加。
{
cout<<a;
j++;
}
for(char a='A';a<='Z'&&j<m;a++) ////第二个for循环，控制输出后面的部分，字符的值在减少。
{
cout<<a;
j++;
} ///////for循环同时也担负起了判断的作用，程序简介高效。
cout<<endl;
}
return 0;
}

....................

0 0