魔方可以对它的6个面自由旋转。

我们来操作一个2阶魔方：
为了描述方便，我们为它建立了坐标系。

各个面的初始状态如下：
x轴正向：绿
x轴反向：蓝
y轴正向：红
y轴反向：橙
z轴正向：白
z轴反向：黄

假设我们规定，只能对该魔方进行3种操作。分别标记为：
x 表示在x轴正向做顺时针旋转
y 表示在y轴正向做顺时针旋转
z 表示在z轴正向做顺时针旋转

xyz 则表示顺序执行x,y,z 3个操作

题目的要求是：
用户从键盘输入一个串，表示操作序列。
程序输出：距离我们最近的那个小方块的3个面的颜色。
顺序是：x面，y面，z面。

例如：在初始状态，应该输出：
绿红白

初始状态下，如果用户输入：
x
则应该输出：
绿白橙

初始状态下，如果用户输入：
zyx
则应该输出：
红白绿

没人能给点思路吗?

楼主可以试想着把一个立方体的每一个面的颜色存到一个二维数组
该二维数组是把立体形式的立方体拆成平面的平铺图
每一个命令就对二维数组的部分数组操作变动
而作为我们视角部分所要取得的3个部分位置在二维数组中是固定坐标位置的
只需要取出相应的颜色值就行

成绩登记代码:

public class Test01 {

        public static void main(String[] args) {
                // TODO Auto-generated method stub
          //给定s1为空字符，便于后面循环赋值；
                        String s1= "";
                        //一个循环。当输入的为over时结束循环，即不能在输入成绩了
                        do{
                                //提示输入成绩
                                System.out.print("请输入成绩：");
                                //实例化scanner对象，用于获取输入的字符串
                                Scanner scanner= new Scanner(System.in);
                                //获取输入的字符串
                                s1= scanner.next();
                                //判断类型是否为int类型
                                try {
                                        int i = Integer.parseInt(s1);
                                        getNum(i);
                                } catch (NumberFormatException e) {
                                        // TODO Auto-generated catch block
                                        //e.printStackTrace();
                                        System.out.println("输入的不是整数！");
                                }
                               
                        }while(!(s1.equals("over")));
        }


        public static void getNum(int i){
                //判断i的大小是否超出范围
                if(i>=0&&i<=100){
                        //判断成绩等级
                        if(i<=100&&i>=90){
                                System.out.println("优");
                        }else if(i>=80&&i<=89){
                                System.out.println("良");
                        }else if(i>=70&&i<=79){
                                System.out.println("中");
                        }else if(i>=60&&i<=69){
                                System.out.println("及格");
                        }else{
                                System.out.println("不及格");
                        }
                       
                }else{
                        System.out.println("成绩超出范围！");
                }
        }
}



字符串代码：
public class Test02 {

        public static void main(String[] args) {
                // TODO Auto-generated method stub

                System.out.print("请输入字符串：");
                Scanner scanner= new Scanner(System.in);
                String s=scanner.next();
                //System.out.println(s.length());
                //定义 一个int类型的参数来获取字符串每个元素的char值的ASCII码值
                int changetemp;
                //定义一个char类型的参数用来设定获取每个字母将其转换后的字母
                char changechar;
                for (int i = 0; i <s.length(); i++) {
                        char tochar=s.substring(i, i+1).charAt(0);
                        //定义tochartemp来获取每个字母的ASCII值
                        int tochartemp=tochar;
                        if(tochartemp>=48&&tochartemp<=57){
                                System.out.print("#");
                        }else if(tochartemp<=96&&tochartemp>=65){
                                //将获取的字母转换成小写字母
                                 changetemp=tochar+32;
                                 //转换成char类型用于输出
                             changechar=(char)changetemp;
                            // System.out.print(changetemp);
                                System.out.print(changechar);
                        }else{
                                //将获取的字母转换成大写字母
                                 changetemp=tochar-32;
                                //转换成char类型用于输出
                             changechar=(char)changetemp;
                            // System.out.print(changetemp);
                                System.out.print(changechar);
                        }
                }
               
        }

}

华擦。。回复错了

根据题目规定只要求三种操作可知，8个小块中，只有7个参与转动，看不到的那个不参与转动。又因为剩余7个块可以看见的部分，分布在可以看到的三个面（x正面，y正面，z正面）上,为了简便分析，我们只考虑这三个面。

7个块中离我们最近的定义为xyz(占了三个面)
占两个面的分别定义为xy，xz，yz
单独占一个面的定义为x，y，z

初始状态下的颜色分布为
轴  x y z
xyz=绿红白
xy=绿红橙
xz=绿橙白
yz=蓝红白
  x=绿橙黄
  y=蓝红橙
  z=蓝橙白
根据给出的"初始状态下，如果用户输入：x则应该输出：绿白橙"这一条件可判断，执行每一个操作时，即在相应轴顺时针转动90°

进行每一次操作时，位置发生改变的块只有4个，其他的块位置不发生改变。
因为xyz是三个面共有的，所以执行操作前，均以xyz为起点，

执行x操作前，x轴正面的4个块按顺时针方向排列为：
xyz，xy,x,xz
执行x操作后，四个块的顺序发生变换,颜色分布规则为x轴颜色不变，另外两个轴的颜色对调。

以xyz',xy',x',xz'作为变换后的新块
xyz'=xz，xy'=xyz,x'=xy xz'=x

对应的颜色分布：
xyz'=绿白橙
xy'=绿白红
  x'=绿橙红
xz'=绿黄橙

下面是利用第二条信息（“初始状态下，如果用户输入：zyx 则应该输出： 红白绿”）验证分析过程是否正确
z
xyz=红蓝白
xy=绿红橙
xz=红绿白
yz=橙蓝白
  x=绿橙黄
  y=蓝红橙
  z=橙绿白
y
xyz=橙红绿
xy=橙红蓝
xz=红绿白
yz=白蓝红
  x=绿橙黄
  y=白蓝橙
  z=橙绿白
x
xyz=红白绿
xy=橙绿红
xz=绿黄橙
yz=白蓝红
  x=橙蓝红
  y=白蓝橙
  z=橙绿白
最后xyz为“红白绿”符合题目给出的条件，可以验证分析过程合理。
我的思路就是这样的，思路清楚了，代码就很容易写了。

为了黑马，为了美好的未来，加油哈，兄弟

下面是完整的代码，实现了要求的功能，但是应该还可以改进

1. package bbs;
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. class Cube {
   
6.         private String x = "";
   
7.         private String y = "";
   
8.         private String z = "";
   
9. 
   
10.         Cube(String x, String y, String z) {
    
11.                 this.x = x;
    
12.                 this.y = y;
    
13.                 this.z = z;
    
14.         }
    
15. 
    
16.         public String getX() {
    
17.                 return x;
    
18.         }
    
19. 
    
20.         public void setX(String x) {
    
21.                 this.x = x;
    
22.         }
    
23. 
    
24.         public String getY() {
    
25.                 return y;
    
26.         }
    
27. 
    
28.         public void setY(String y) {
    
29.                 this.y = y;
    
30.         }
    
31. 
    
32.         public String getZ() {
    
33.                 return z;
    
34.         }
    
35. 
    
36.         public void setZ(String z) {
    
37.                 this.z = z;
    
38.         }
    
39. 
    
40.         public void getAttribute(Cube c) {
    
41.                 this.x = c.getX();
    
42.                 this.y = c.getY();
    
43.                 this.z = c.getZ();
    
44.         }
    
45.         
    
46.         public void getTurnedAttributeX(Cube c) {
    
47.                 this.x = c.getX();
    
48.                 this.y = c.getZ();
    
49.                 this.z = c.getY();
    
50.         }
    
51.         
    
52.         public void getTurnedAttributeY(Cube c) {
    
53.                 this.x = c.getZ();
    
54.                 this.y = c.getY();
    
55.                 this.z = c.getX();
    
56.         }
    
57.         
    
58.         public void getTurnedAttributeZ(Cube c) {
    
59.                 this.x = c.getY();
    
60.                 this.y = c.getX();
    
61.                 this.z = c.getZ();
    
62.         }
    
63. 
    
64.         public String Attribute() {
    
65.                 return this.getX() + this.getY() + this.getZ();
    
66.         }
    
67. }
    
68. 
    
69. public class RubikCube {
    
70.         public static void main(String[] args) {
    
71.                 Scanner scan = new Scanner(System.in);
    
72.                 System.out.println("请输入操作序列，请勿输入x、y、z以外的字符，不区分大小写！");
    
73.                 String str = scan.next();
    
74.                 turn(str);
    
75.                 scan.close();
    
76.         }
    
77. 
    
78.         public static void turn(String str) {
    
79.                 char[] arr = str.toCharArray();
    
80.                 //初始化7个块
    
81.                 Cube xyz = new Cube("绿", "红", "白");
    
82.                 Cube xy = new Cube("绿", "红", "橙");
    
83.                 Cube xz = new Cube("绿", "橙", "白");
    
84.                 Cube yz = new Cube("蓝", "红", "白");
    
85.                 Cube x = new Cube("绿", "橙", "黄");
    
86.                 Cube y = new Cube("蓝", "红", "橙");
    
87.                 Cube z = new Cube("蓝", "橙", "白");
    
88.                 Cube temp1 = new Cube(null, null, null);
    
89.                 Cube temp2 = new Cube(null, null, null);
    
90.                 Cube temp3 = new Cube(null, null, null);
    
91.                 Cube temp4 = new Cube(null, null, null);
    
92.                 for (int i = 0; i <= arr.length - 1; i++) {
    
93.                         if (arr[i] == 'x' ||arr[i]=='X') {//沿x轴转动时，x面颜色不变，y面和z面颜色对调
    
94.                                 temp1.getTurnedAttributeX(xz);
    
95.                                 temp2.getTurnedAttributeX(xyz);
    
96.                                 temp3.getTurnedAttributeX(xy);
    
97.                                 temp4.getTurnedAttributeX(x);
    
98. 
    
99.                                 xyz.getAttribute(temp1);
    
100.                                 xy.getAttribute(temp2);
     
101.                                 x.getAttribute(temp3);
     
102.                                 xz.getAttribute(temp4);
     
103.                         }
     
104.                         if (arr[i] == 'y'|| arr[i] == 'Y') {//沿y轴转动时，y面颜色不变，x面和z面颜色对调
     
105.                                 temp1.getTurnedAttributeY(xy);
     
106.                                 temp2.getTurnedAttributeY(xyz);
     
107.                                 temp3.getTurnedAttributeY(yz);
     
108.                                 temp4.getTurnedAttributeY(y);
     
109. 
     
110.                                 xyz.getAttribute(temp1);
     
111.                                 yz.getAttribute(temp2);
     
112.                                 y.getAttribute(temp3);
     
113.                                 xy.getAttribute(temp4);
     
114.                         }
     
115.                         if (arr[i] == 'z' || arr[i]=='Z') {//沿z轴转动时，z面颜色不变，x面和y面颜色对调
     
116.                                 temp1.getTurnedAttributeZ(yz);
     
117.                                 temp2.getTurnedAttributeZ(xyz);
     
118.                                 temp3.getTurnedAttributeZ(xz);
     
119.                                 temp4.getTurnedAttributeZ(z);
     
120. 
     
121.                                 xyz.getAttribute(temp1);
     
122.                                 xz.getAttribute(temp2);
     
123.                                 z.getAttribute(temp3);
     
124.                                 yz.getAttribute(temp4);
     
125.                         }
     
126. 
     
127.                 }
     
128.                 System.out.println(xyz.Attribute());
     
129.                 /*System.out.println("xyz=" + xyz.Attribute()
     
130.                                                 + "\nxy=" + xy.Attribute()
     
131.                                                 + "\nxz=" + xz.Attribute()
     
132.                                                 + "\nyz=" + yz.Attribute()
     
133.                                                 + "\nx=" + x.Attribute()
     
134.                                                 + "\ny=" + y.Attribute()
     
135.                                                 + "\nz="+ z.Attribute());*/
     
136.         }
     
137. }
     

复制代码