题目
标题：二阶魔方
魔方可以对它的6个面自由旋转。
我们来操作一个2阶魔方（如图1所示）
为了描述方便，我们为它建立了坐标系。
各个面的初始状态如下：
x轴正向：绿
x轴反向：蓝
y轴正向：红
y轴反向：橙
z轴正向：白
z轴反向：黄
假设我们规定，只能对该魔方进行3种操作。分别标记为：
x 表示在x轴正向做顺时针旋转
y 表示在y轴正向做顺时针旋转
z 表示在z轴正向做顺时针旋转
基本旋转后的效果如图2,3,4所示。
xyz 则表示顺序执行x,y,z 3个操作
题目的要求是：
从标准输入获得一个串，表示操作序列。
程序输出：距离我们最近的那个小方块的3个面的颜色。
顺序是：x面，y面，z面。
例如：在初始状态，应该输出：
绿红白
初始状态下，如果用户输入：
x
则应该输出：
绿白橙
初始状态下，如果用户输入：
zyx
则应该输出：
红白绿
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
package com.lanqiaobei.moni;
import java.util.Scanner;
import java.util.StringTokenizer;
public class Main {
//定义24个面的颜色
public String[] mian=new String[25];
public static void main(String[] args) {
// TODO Auto-generated method stub
Main m=new Main();
m.init();
m.getString();
m.getResult();
}
//定义读取函数
public void getString(){
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
for (int i=0;i<str.length();i++){
String next=str.substring(i, i+1);
if (next=="x"){
reX();
}
if (next=="y"){
reY();
}
if (next=="z"){
reZ();
}
}
}
//初始化24个面的颜色
public void init(){
for (int i=1;i<5;i++){ //x zheng
mian[i]="绿";
}
for (int i=5;i<9;i++){ //y zheng
mian[i]="红";
}
for (int i=9;i<13;i++){ //z zheng
mian[i]="白";
}
for (int i=13;i<17;i++){ //x fan
mian[i]="蓝";
}
for (int i=17;i<21;i++){ //y fan
mian[i]="橙";
}
for (int i=21;i<25;i++){ //z fan
mian[i]="黄";
}
}
//输出结果（最靠近我们那个正方体的三个面）
public void getResult(){
System.out.println(mian[2]+mian[5]+mian[9]);
}
//定义绕x轴旋转的函数
public void reX(){
String[] sa=revertZheng(mian[1],mian[2],mian[3],mian[4]);
for(int i=1;i<5;i++){
mian[i]=sa[i-1];
}
String[] sb=revertZheng(mian[10],mian[9],mian[5],mian[8],mian[22],mian[21],mian[19],mian[18]);
mian[10]=sb[0];mian[9]=sb[1];mian[5]=sb[2];mian[8]=sb[3];
mian[22]=sb[4];mian[21]=sb[5];mian[19]=sb[6];mian[18]=sb[7];
}
//定义绕y轴旋转的函数
public void reY(){
String[] sa=revertZheng(mian[5],mian[6],mian[7],mian[8]);
mian[5]=sa[0];mian[6]=sa[1];mian[7]=sa[2];mian[8]=sa[3];
String[] sb=revertZheng(mian[9],mian[12],mian[13],mian[16],mian[23],mian[22],mian[3],mian[2]);
mian[9]=sb[0];mian[12]=sb[1];mian[13]=sb[2];mian[16]=sb[3];
mian[23]=sb[4];mian[22]=sb[5];mian[3]=sb[6];mian[2]=sb[7];
}
//定义绕z轴旋转的函数
public void reZ(){
String[] sa=revertZheng(mian[10],mian[11],mian[12],mian[9]);
mian[10]=sa[0];mian[11]=sa[1];mian[12]=sa[2];mian[9]=sa[3];
String[] sb=revertZheng(mian[18],mian[17],mian[14],mian[13],mian[6],mian[5],mian[2],mian[1]);
mian[18]=sb[0];mian[17]=sb[1];mian[14]=sb[2];mian[13]=sb[3];
mian[6]=sb[4];mian[5]=sb[5];mian[2]=sb[6];mian[1]=sb[7];
}
//定义正对我们那四个面的旋转函数
public String [] revertZheng(String s1,String s2,String s3,String s4){
String a="";
a=s1;
s1=s4;
s4=s3;
s3=s2;
s2=a;
String[] ss=new String[4];
ss[0]=s1;ss[1]=s2;ss[2]=s3;ss[3]=s4;
return ss;
}
//侧面8个面的旋转函数
public String [] revertZheng(String s1,String s2,String s3,String s4,String s5,String s6,String s7,String s8){
String a="",b="";
a=s1;b=s2;
s1=s7;
s2=s8;
s7=s5;
s8=s6;
s5=s3;
s6=s4;
s3=a;
s4=b;
String[] ss=new String[8];
ss[0]=s1;ss[1]=s2;ss[2]=s3;ss[3]=s4;ss[4]=s5;ss[5]=s6;ss[6]=s7;ss[7]=s8;
return ss;
}
}