[JAVA][2013蓝桥杯模拟赛 JAVA本科B组][第四题：二阶魔方]

第四题：二阶魔方

题目描述：

魔方可以对它的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
则应该输出：
红白绿

样例输入：

xy
xxyyy
xyzzzzyyyxxx
xyyzzz
xyxyzzxyxyzz

样例输出：

红白绿
白红蓝
绿红白
黄绿橙
白绿红

解答

分析，设置方块类（取名叫Main而已）

对应正面的四个方块为

front[0] front[1]

front[2] front[3]

和正面方块相邻的反面方块的下标相同（即front[0]后面是back[0],1后面是back[1]）

其他只要注意转动时的变化就行

[java]  view plain copy print ?

1. import java.util.Scanner;  
2.   
3. public class Main {  
4.   
5.     char front;  
6.     char back;  
7.     char left;  
8.     char right;  
9.     char up;  
10.     char down;  
11.   
12.     public Main() {  
13.         super();  
14.         front = 'G';// 绿色  
15.         back = 'B';// 蓝色  
16.         left = 'O';// 橙色  
17.         right = 'R';// 红色  
18.         up = 'W';// 白色  
19.         down = 'Y';// 黄色  
20.     }  
21.   
22.     public void x() {  
23.         char tmp = up;  
24.         up = left;  
25.         left = down;  
26.         down = right;  
27.         right = tmp;  
28.     }  
29.   
30.     public void y() {  
31.         char tmp = up;  
32.         up = front;  
33.         front = down;  
34.         down = back;  
35.         back = tmp;  
36.     }  
37.   
38.     public void z() {  
39.         char tmp = front;  
40.         front = right;  
41.         right = back;  
42.         back = left;  
43.         left = tmp;  
44.     }  
45.   
46.     public void print() {  
47.         System.out.println(print(front) + print(right) + print(up));  
48.     }  
49.   
50.     public static String print(char c) {  
51.         String color = null;  
52.         switch (c) {  
53.         case 'G':  
54.             color = "绿";  
55.             break;  
56.         case 'B':  
57.             color = "蓝";  
58.             break;  
59.         case 'O':  
60.             color = "橙";  
61.             break;  
62.         case 'R':  
63.             color = "红";  
64.             break;  
65.         case 'W':  
66.             color = "白";  
67.             break;  
68.         case 'Y':  
69.             color = "黄";  
70.             break;  
71.         default:  
72.             break;  
73.         }  
74.         return color;  
75.     }  
76.   
77.     public static void main(String[] args) {  
78.         Scanner sc = new Scanner(System.in);  
79.         while (sc.hasNext()) {  
80.             String op = sc.next();  
81.             Main front[] = new Main[4];// 正面4个方块  
82.             Main back[] = new Main[4];// 背面对应正面位置的4个方块  
83.             for (int i = 0; i < 4; i++) {  
84.                 front[i] = new Main();  
85.                 back[i] = new Main();  
86.             }  
87.             for (int i = 0; i < op.length(); i++) {  
88.                 switch (op.charAt(i)) {  
89.                 case 'x':  
90.                     for (int j = 0; j < 4; j++) {// 正面4个方块转动  
91.                         front[j].x();  
92.                     }  
93.                     Main tmp = front[0];  
94.                     front[0] = front[2];  
95.                     front[2] = front[3];  
96.                     front[3] = front[1];  
97.                     front[1] = tmp;  
98.                     break;  
99.                 case 'y':  
100.                     for (int j = 1; j <= 3; j += 2) {// 右侧转动  
101.                         front[j].y();  
102.                         back[j].y();  
103.                     }  
104.                     Main tmp2 = front[1];  
105.                     front[1] = front[3];  
106.                     front[3] = back[3];  
107.                     back[3] = back[1];  
108.                     back[1] = tmp2;  
109.                     break;  
110.                 case 'z':  
111.                     for (int j = 0; j <= 1; j++) {  
112.                         front[j].z();  
113.                         back[j].z();  
114.                     }  
115.                     Main tmp3 = back[0];  
116.                     back[0] = front[0];  
117.                     front[0] = front[1];  
118.                     front[1] = back[1];  
119.                     back[1] = tmp3;  
120.                 default:  
121.                     break;  
122.                 }  
123.             }  
124.             front[1].print();  
125.         }  
126.     }  
127. }