POJ2993 Emag eht htiw Em Pleh

最新推荐文章于 2021-10-25 16:20:40 发布

Orange_CYH

最新推荐文章于 2021-10-25 16:20:40 发布

阅读量302

点赞数

分类专栏： POJ

本文链接：https://blog.csdn.net/Orange_CYH/article/details/78178190

版权

POJ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、思路分析

通过建立字符串数组来模拟棋盘，棋盘的内容由“+-|.:”等符号填充，将输入的两个字符串转化为棋盘上的位置坐标，再依次输出字符串数组。

二、方法设计

1、定义一下变量：white、black（string）：输入的两条字符串

KQRBN_count（int）：记录字符串white中字母K/Q/R/B/N的数量

kqrbn_count（int）：记录字符串black中字母K/Q/R/B/N的数量

P_count(int)：记录字符串white中字母P的数量

p_count(int)：记录字符串black中字母p的数量

white_len（int）：字符串white的长度

black_len（int）：字符串black的长度

2、用getline函数输入字符串white、black，并求出长度

3、遍历字符串，求出两条字符串中不同棋子的数量

4、初始化字符串数组string chess[17]

5、用查找大写字母的方法，找出各种棋子，将字符串的内容转换为棋盘上的坐标，并依次进行赋值替换

6、从字符串末尾进行倒推，找出所有棋子P的坐标进行替换

7、输出各行字符串

三、代码实现

#include<iostream>
#include<cstring>
#include<string>
using namespace std;
string white;//输入的字符串
string black;//输入的字符串
int KQRBN_count=0;//记录字符串white中KQRBN的数量
int kqrbn_count=0;// 记录字符串black中KQRBN的数量
int P_count=0;//记录white中P的数量
int p_count=0;//记录black中p的数量	
int white_len;//记录字符串white的长度
int black_len;//记录字符串black的长度
int main()
{
	getline(cin,white);
	getline(cin,black);

	white_len=white.length();
	black_len=black.length();
//求出两条字符串的长度

	for(int i=7;i<white_len;i++)
	{
		if(white[i]=='K'||white[i]=='Q'||white[i]=='R'||white[i]=='B'||white[i]=='N')
			KQRBN_count++;
		if(white[i]>='1'&&white[i]<='8')
			P_count++;
	}
	P_count-=KQRBN_count;
	
	for(int i=7;i<black_len;i++)
	{
		if(black[i]=='K'||black[i]=='Q'||black[i]=='R'||black[i]=='B'||black[i]=='N')
			kqrbn_count++;
		if(black[i]>='0'&&black[i]<='8')
			p_count++;
	}
	p_count-=kqrbn_count;
//遍历字符串，求出字符串中各类棋子的数量，遇到大写字母，KQRBN_count、kqrbn_count加1，遇到小写字母，P_count、p_count加1。得到白黑棋子KQRBN的数量依次为KQRBN_count、kqrbn_count，得到白黑棋子P的数量依次为P_count-KQRBN_count、p_count-kqrbn_count

	string chess[17]={"+---+---+---+---+---+---+---+---+","|...|:::|...|:::|...|:::|...|:::|","+---+---+---+---+---+---+---+---+","|:::|...|:::|...|:::|...|:::|...|","+---+---+---+---+---+---+---+---+","|...|:::|...|:::|...|:::|...|:::|","+---+---+---+---+---+---+---+---+","|:::|...|:::|...|:::|...|:::|...|","+---+---+---+---+---+---+---+---+","|...|:::|...|:::|...|:::|...|:::|","+---+---+---+---+---+---+---+---+","|:::|...|:::|...|:::|...|:::|...|","+---+---+---+---+---+---+---+---+","|...|:::|...|:::|...|:::|...|:::|","+---+---+---+---+---+---+---+---+","|:::|...|:::|...|:::|...|:::|...|","+---+---+---+---+---+---+---+---+"};
//初始化字符串数组，模拟棋盘

	for(int i=0;i<KQRBN_count;i++)
	{
		int x,y;
		x=('8'-white[9+4*i])*2+1;
		y=(white[8+4*i]-'a')*4+2;
//x表示自下而上的纵坐标，字符串中纵坐标为数子（Ke1中的1），从9号位字符开始，每4个字符出现一次，所以white[9+4*i]取出纵坐标。假设棋盘是8*8的格局，由于棋盘是自下而上开始排列，则该坐标在8*8数组中为‘8’-white[9+4*i],若在chess[17]数组中对应的位置为('8'-white[9+4*i])*2+1 
//y表示自左往右的横坐标，字符串中横坐标为字母（Ke1中的e），从8号位字符开始，每4个字符出现一次，所以white[8+4*i]取出横坐标。假设棋盘是8*8的格局，由于棋盘是自左往右开始排列，则该坐标在8*8数组中为white[8+4*i]-‘a’，若在chess[17]数组中对应的位置为(white[8+4*i]-'a')*4+2

		switch(white[7+4*i])//棋子KQRBN在字符串中从7号位字符开始，每4次出现一次
		{
			case 'K':
			{
				chess[x][y]='K'; 
				break;	
			} 
			case 'Q':
			{
				chess[x][y]='Q';
				break; 	
			} 
			case 'R':
			{
				chess[x][y]='R'; 
				break;
			} 
			case 'B':
			{
				chess[x][y]='B';
				break; 
			} 
			case 'N':
			{
				chess[x][y]='N';
				break;	
			} 
		}
//出现PQRBN的棋子，就在相应位置的“:”或者“.”替换成对应字符
	}

	for(int i=0;i<kqrbn_count;i++)
	{
		int x,y;
		x=('8'-black[9+4*i])*2+1;
		y=(black[8+4*i]-'a')*4+2;
		switch(black[7+4*i])
		{
			case 'K':
			{
				chess[x][y]='k'; 
				break;	
			} 
			case 'Q':
			{
				chess[x][y]='q';
				break; 	
			} 
			case 'R':
			{
				chess[x][y]='r'; 
				break;
			} 
			case 'B':
			{
				chess[x][y]='b';
				break; 
			} 
			case 'N':
			{
				chess[x][y]='n';
				break;	
			} 
		}
	}
//黑色棋子类同白色棋子，只是讲替换的时候换成小写字母

	for(int i=0;i<P_count;i++)
	{
		int x,y;
		x=('8'-white[white_len-1-3*i])*2+1;
		y=(white[white_len-2-3*i]-'a')*4+2;
		chess[x][y]='P'; 
	}
//x表示自下而上的纵坐标，字符串中纵坐标为数子（Ke1中的1），从倒数第一个开始计数，即white_len-1号位字符开始，每3个字符出现一次，所以white[white_len-1-3*i]取出纵坐标。假设棋盘是8*8的格局，由于棋盘是自下而上开始排列，则该坐标在8*8数组中为‘8’- white[white_len-1-3*i]，若在chess[17]数组中对应的位置为('8'- white[white_len-1-3*i])*2+1 
//y表示自左而右的横坐标，字符串中横坐标为数子（Ke1中的e），从倒数第2个开始计数，即white_len-2号位字符开始，每3个字符出现一次，所以white[white_len-2-3*i]取出横坐标。假设棋盘是8*8的格局，由于棋盘是从左往右开始排列，则该坐标在8*8数组中为white[white_len-2-3*i]-‘a’，若在chess[17]数组中对应的位置为(white[white_len-1-3*i]-‘a’’)*4+2

	for(int i=0;i<p_count;i++)
	{
		int x,y;
		x=('8'-black[black_len-1-3*i])*2+1;
		y=(black[black_len-2-3*i]-'a')*4+2;
		chess[x][y]='p'; 
	}
//步骤类似于白色棋子，只是将大写P改为小写p

	for(int i=0;i<17;i++)
	{
		cout<<chess[i]<<endl;
	}
	return 0;
}