笔试被虐惨，选择题一半多的概率题，每道题差不多3、5分钟，so，最后好几个没有算。
附加两个大题，一个是编写魔方，另一个是机器学习的分布不均衡问题和SVM。魔方题没有写完，机器学习的题目也只答了一问...
当天晚上把魔方的代码完善了下，没有找到好的解法，硬写的，麻烦的要死。
晚上的时候网上已经有题目了，详情如下，最后结果的输出其实不一定要与题目一致，因为每一面的方向没有明确定义，颜色对了即可，比如本文的程序里，Y面与题目的Y面相差180度：
一个三阶魔方由六个面组成，颜色分别是白色（W）、对面为黄色（Y）、红色（R）、对面为橙色（O）、绿色（G）、对面为蓝色（B）。如果手持魔方，白色向上，红色朝向自己，则绿色在左手侧。
请写一个程序，对一个处于还原状态（各面各块同色）的魔方，进行操作，打印操作后的魔方状态。操作指令为单个操作指令组成的字符串。单个操作指令包括：
1）U：白色面顺时针旋转90度
2）D：黄色面顺时针旋转90度
3）F：红色面顺时针旋转90度
4）B：橙色面顺时针旋转90度
5）L：绿色面顺时针旋转90度
6）R：蓝色面顺时针旋转90度
其中顺时针旋转定义为将该面朝向自己时的顺时针方向。
按WYROGB的顺序输出经过操作后6个面的状态。每个面首先输出中心块颜色，然后从此面面向自己时的左下角块开始，顺时针顺出每块的颜色。输出一面后换行。
请设计一个数据结构表示魔方，并基于该数据结构完成功能。
请用C/C++，Java或Python语言实现。请注意尽量以可成功编译或可直接运行为标准来编写代码。
示例：
输入：
LR
输出：
WOOOWRRRW
YRRRYOOOY
RWWWRYYYR
OYYYOWWWO
GGGGGGGGG
BBBBBBBBB
代码如下：
#include <stdio.h>
#include <stdlib.h>
struct panel {
//暴力解法，每个面的面板颜色和四个接触的边
int a[3][3]; //每个面的颜色
char status; //本面的颜色符号
struct panel *u; //四个相邻的面
int ul; //相邻的边是相应面的那一条1-6表示1-3行+1-3列，-号表示逆序
struct panel *r;
int rl;
struct panel *d;
int dl;
struct panel *l;
int ll;
};
typedef struct panel PP;
void initPanel(PP *p, int color);
void changePanel(PP *p, PP *u, PP *r, PP *d, PP *l);
void rot(PP *p);
void getLine(PP *p,int line,int b[]);
void setLine(PP *p,int line ,int b[]);
int abValue(int x);
void printPanel(PP *p, int check);
char intTochar(int i);
void printA(int a[]);
int main(int argc, char **argv)
{
char c;
PP Wp;
PP Op;
PP Bp;
PP Rp;
PP Gp;
PP Yp;
//定义每个面的颜色
initPanel(&Wp,1);
initPanel(&Op,2);
initPanel(&Bp,3);
initPanel(&Rp,4);
initPanel(&Gp,5);
initPanel(&Yp,6);
/*给白色面定义四个临边，尼玛太麻烦了，有好一点的算法没？
以这个方向定义，输出也是用的这个方向
---
| O |
--- --- --- ---
| G | W | B | Y |
--- --- --- ---
| R |
---
*/
Wp.status = 'W';
Wp.u = &Op;
Wp.ul = 3;
Wp.r = &Bp;
Wp.rl = 4;
Wp.d = &Rp;
Wp.dl = 1;
Wp.l = &Gp;
Wp.ll = 6;
//橘色定义
Op.status = 'O';
Op.u = &Yp;
Op.ul = -1;
Op.r = &Bp;
Op.rl = -1;
Op.d = &Wp;
Op.dl = 1;
Op.l = &Gp;
Op.ll = 1;
//蓝色定义
Bp.status = 'B';
Bp.u = &Op;
Bp.ul = -6;
Bp.r = &Yp;
Bp.rl = 4;
Bp.d = &Rp;
Bp.dl = 6;
Bp.l = &Wp;
Bp.ll = 6;
//红色定义
Rp.status = 'R';
Rp.u = &Wp;
Rp.ul = 3;
Rp.r = &Bp;
Rp.rl = 3;
Rp.d =&Yp;
Rp.dl = -3;
Rp.l = &Gp;
Rp.ll = -3;
//绿色定义
Gp.status = 'G';
Gp.u = &Op;
Gp.ul = 4;
Gp.r = &Wp;
Gp.rl = 4;
Gp.d = &Rp;
Gp.dl = -4;
Gp.l = &Yp;
Gp.ll = 6;
//黄色定义
Yp.status = 'Y';
Yp.u = &Op;
Yp.ul = -1;
Yp.r = &Gp;
Yp.rl = 4;
Yp.d = &Rp;
Yp.dl = -3;
Yp.l = &Bp;
Yp.ll = 6;
while((c = getchar()) != '\n'){
if(c == 'U')
changePanel(&Wp, Wp.u, Wp.r, Wp.d, Wp.l); //改变本面和相邻的四个面
if(c == 'D')
changePanel(&Yp, Yp.u, Yp.r, Yp.d, Yp.l);
if(c == 'F')
changePanel(&Rp, Rp.u, Rp.r, Rp.d, Rp.l);
if(c == 'B')
changePanel(&Op, Op.u, Op.r, Op.d, Op.l);
if(c == 'L')
changePanel(&Gp, Gp.u, Gp.r, Gp.d, Gp.l);
if(c == 'R')
changePanel(&Bp, Bp.u, Bp.r, Bp.d, Bp.l);
}
//输出每一个面，注意输出的顺序，1代表与定义顺序一致，0代表翻转180
printPanel(&Wp, 1);
printPanel(&Yp, 0);
printPanel(&Rp, 1);
printPanel(&Op, 1);
printPanel(&Gp, 1);
printPanel(&Bp, 1);
return 0;
}
//初始每个面的颜色
void initPanel(PP *p, int color){
int i,j;
for(i = 0;i < 3;i++)
for(j = 0;j < 3;j++)
p->a[i][j] = color;
}
//旋转
void changePanel(PP *p, PP *u, PP *r, PP *d, PP *l){
//旋转本面二维数组
rot(p);
//旋转四个边
int ua[3],ra[3],da[3],la[3];
int i,j;
getLine(p->u,p->ul,ua);
getLine(p->r,p->rl,ra);
getLine(p->d,p->dl,da);
getLine(p->l,p->ll,la);
//输出本面的当前四个边
printf("%c %dth is\n",p->u->status,p->ul);
printA(ua);
printf("%c %dth is\n",p->r->status,p->rl);
printA(ra);
printf("%c %dth is\n",p->d->status,p->dl);
printA(da);
printf("%c %dth is\n",p->l->status,p->ll);
printA(la);
printf("\n");
//转换4条边，由于下边和左边的定义顺序是左到右、上到下排列，与顺时针方向相反，在转换时要注意
for(i = 0;i < 3;i++){
j = ua[i];
ua[i] = la[2-i];
la[2-i] = da[2-i];
da[2-i] = ra[i];
ra[i] = j;
}
//输出旋转后本面的当前四个边
printf("%c %d th is\n",p->u->status,p->ul);
printA(ua);
printf("%c %d th is\n",p->r->status,p->rl);
printA(ra);
printf("%c %d th is\n",p->d->status,p->dl);
printA(da);
printf("%c %d th is\n",p->l->status,p->ll);
printA(la);
printf("\n");
//将旋转后的4个边赋值给相应的临面
setLine(p->u,p->ul,ua);
setLine(p->r,p->rl,ra);
setLine(p->d,p->dl,da);
setLine(p->l,p->ll,la);
}
//旋转二维数组，注意每一行交换两个
void rot(PP *p){
int i,j;
for(i = 0; i < 2; i++){
j = p->a[0][i];
p->a[0][i] = p->a[2-i][0];
p->a[2-i][0] = p->a[2][2-i];
p->a[2][2-i] = p->a[i][2];
p->a[i][2] = j;
}
}
//获取面的某条边数据
void getLine(PP *p,int line,int b[]){
int i;
if(abValue(line) < 4){
for(i = 0;i < 3;i++){
if(line < 0)
b[i] = p->a[abValue(line) - 1][2-i];
if(line > 0)
b[i] = p->a[line - 1][i];
}
}
else if(abValue(line) >= 4){
for(i = 0;i < 3;i++){
if(line < 0)
b[i] = p->a[2-i][abValue(line) - 4];
if(line > 0)
b[i] = p->a[i][line - 4];
}
}
}
//赋值面的某条边
void setLine(PP *p,int line ,int b[]){
int i;
if(abValue(line) < 4){
for(i = 0;i < 3;i++){
if(line < 0)
p->a[abValue(line) - 1][2-i] = b[i];
if(line > 0)
p->a[line - 1][i] = b[i];
}
}
else if(abValue(line) >= 4){
for(i = 0;i < 3;i++){
if(line < 0)
p->a[2-i][abValue(line) - 4] = b[i];
if(line > 0)
p->a[i][line - 4] = b[i];
}
}
}
//取绝对值
int abValue(int x){
if(x < 0)
return 0-x;
else
return x;
}
//check为定义如何输出，定义每一面时是按照正方体展开的方向，最下面的Y貌似与定义顺序不同
void printPanel(PP *p, int check){
int i,j,k;
if(check == 1){
//正序,j+k*正序下标,无变化
j = 0;
k = 1;
}
else if(check == 0){
//逆序下标=2-正序下标 j+k*正序下标
j = 2;
k = -1;
}
//输出二维数组，先输出中心点，再输出4个边，左下开始顺时针
printf("%c",intTochar(p->a[1][1]));
for(i = 0;i < 2;i++)
printf("%c",intTochar(p->a[j+k*(2-i)][j+k*0]));
for(i = 0;i < 2;i++)
printf("%c",intTochar(p->a[j+k*0][j+k*i]));
for(i = 0;i < 2;i++)
printf("%c",intTochar(p->a[j+k*i][j+k*2]));
for(i = 0;i < 2;i++)
printf("%c",intTochar(p->a[j+k*2][j+k*(2-i)]));
printf("\n");
}
//由数字颜色转为字符
char intTochar(int i){
switch(i){
case 1:
return 'W';
break;
case 2:
return 'O';
break;
case 3:
return 'B';
break;
case 4:
return 'R';
break;
case 5:
return 'G';
break;
case 6:
return 'Y';
break;
default:
return 'N';
break;
}
}
//输出暂存数组
void printA(int a[]){
printf("%c",intTochar(a[0]));
printf("%c",intTochar(a[1]));
printf("%c",intTochar(a[2]));
printf("\n");
}