筆試被虐慘，選擇題一半多的概率題，每道題差不多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");
    }