[2021 마스터즈 코스 테스트] 3단계 : 루빅스 큐브 구현하기

2021 코드스쿼드 마스터즈 코스 테스트 문제와 저의 풀이를 공유하는 글입니다.

 

3단계: 루빅스 큐브 구현하기

• 참고 링크를 참고해서 루빅스 큐브를 구현한다.
• 큐브는 W, B, G, Y, O, R의 6가지 색깔을 가지고 있다.
• 입력: 각 조작법을 한 줄로 입력받는다.
• 출력: 큐브의 6면을 펼친 상태로 출력한다.
• Q를 입력받으면 프로그램을 종료하고, 조작 받은 명령의 갯수를 출력시킨다.

큐브의 초기 상태

     	B B B
        B B B
      	B B B
        
W W W 	O O O 	G G G 	Y Y Y
W W W 	O O O 	G G G 	Y Y Y
W W W 	O O O 	G G G 	Y Y Y

      	R R R
      	R R R 
      	R R R

프로그램 예시

(초기 상태 출력)

CUBE> FRR'U2R 

F
(큐브상태) 

R 
(큐브상태)

...

R
(큐브상태)

CUBE> Q 
경과시간: 00:31 //추가 구현 항목 
조작갯수: 6
이용해주셔서 감사합니다. 뚜뚜뚜. 

추가 구현 기능

• 프로그램 종료 시 경과 시간 출력
• 큐브의 무작위 섞기 기능
• 모든 면을 맞추면 축하 메시지와 함께 프로그램을 자동 종료

3단계 코딩 요구사항

• 가능한 한 커밋을 자주 하고 구현의 의미가 명확하게 전달되도록 커밋 메시지를 작성할 것
• 함수나 메소드는 한 번에 한 가지 일을 하고 가능하면 20줄이 넘지 않도록 구현한다.
• 함수나 메소드의 들여쓰기를 가능하면 적게(3단계까지만) 할 수 있도록 노력해 본다.

function main() {
    for() {// 들여쓰기 1단계
        if() { // 들여쓰기 2단계
        	return; // 들여쓰기 3단계
        } 
    }
}

 

 

---

소스코드

아래는 제가 제출한 파일입니다.

package Step3;

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Random;
import java.util.Objects;

public class Step3 { // 루빅스 큐브 구현하기
    Scanner sc = new Scanner(System.in);

    char[][] cubeUp = new char[3][3]; // 윗면
    char[][] cubeLeft = new char[3][3]; // 왼쪽면
    char[][] cubeFront = new char[3][3]; // 앞면
    char[][] cubeRight = new char[3][3]; // 오른쪽면
    char[][] cubeBack = new char[3][3]; // 뒷면
    char[][] cubeDown = new char[3][3]; // 아랫면
    int countNum = 0; // 조작 횟수
    long countTime = 0; // 경과시간

    public static void main(String[] args) {
        Step3 step3 = new Step3();
        System.out.println("🗝 루빅스 큐브를 풀어 보세요!");
        step3.initCube();
        step3.scramble(); // 처음부터 섞어서 보여주기
        step3.ready();
    }

    public void initCube() {
        for (int i = 0; i < 3; i++) {
            cubeUp[i] = new char[]{'W', 'W', 'W'}; // 윗면 기본 색 : White
            cubeLeft[i] = new char[]{'O', 'O', 'O'}; // 왼쪽면 기본 색 : Orange
            cubeFront[i] = new char[]{'G', 'G', 'G'}; // 앞면 기본 색 : Green
            cubeRight[i] = new char[]{'R', 'R', 'R'}; // 오른쪽면 기본 색 : Red
            cubeBack[i] = new char[]{'B', 'B', 'B'}; // 뒷면 기본 색 : Blue
            cubeDown[i] = new char[]{'Y', 'Y', 'Y'}; // 아랫면 기본 색 : Yellow
        }
        printCube();
    }

    public void scramble() { // 섞기 메서드
        char[][] tempUp = new char[3][3];
        char[][] tempLeft = new char[3][3];
        char[][] tempFront = new char[3][3];
        char[][] tempRight = new char[3][3];
        char[][] tempBack = new char[3][3];
        char[][] tempDown = new char[3][3];
        Random random = new Random();
        int randomNum1 = random.nextInt(4); // 0~3까지 랜덤하게 호출. bound5이상이 되면 360도를 돌아서 안 섞일떄가 많아 조정함.
        int randomNum2 = random.nextInt(4);
        int randomNum3 = random.nextInt(4);
        for (int i = 0; i < randomNum1; i++) {
            whenU(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
            whenDDot(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
        }
        for (int i = 0; i < randomNum2; i++) {
            whenF(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
            whenB(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
        }
        for (int i = 0; i < randomNum3; i++) {
            whenL(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
            whenD(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
        }
        for (int i = 0; i < randomNum1; i++) {
            whenR(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
            whenFDot(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
        }
        System.out.println("\n\n 🔀 🔀 큐브를 무작위로 섞었습니다.");
        printCube();
        countTime = System.currentTimeMillis();
    }

    public void ready() {
        String input = start();
        ArrayList<String> inputList = trimInput(input);
        checkInput(inputList);
    }

    public void printCube() {
        for (int i = 0; i < 3; i++) {
            System.out.printf("%n %6c %1c %1c %1c %6c", ' ', cubeUp[i][0], cubeUp[i][1], cubeUp[i][2], ' ');
        }
        for (int i = 0; i < 3; i++) {
            System.out.printf("%n %1c %1c %1c  %1c %1c %1c  %1c %1c %1c  %1c %1c %1c",
                    cubeLeft[i][0], cubeLeft[i][1], cubeLeft[i][2],
                    cubeFront[i][0], cubeFront[i][1], cubeFront[i][2],
                    cubeRight[i][0], cubeRight[i][1], cubeRight[i][2],
                    cubeBack[i][0], cubeBack[i][1], cubeBack[i][2]);
        }
        System.out.printf("%n %6c %1c %1c %1c %15c %1c%1c", ' ', cubeDown[0][0], cubeDown[0][1], cubeDown[0][2], ' ', ' ', 'U');
        System.out.printf("%n %6c %1c %1c %1c %15c %1c%1c%1c%1c", ' ', cubeDown[1][0], cubeDown[1][1], cubeDown[1][2], ' ', 'L', 'F', 'R', 'B');
        System.out.printf("%n %6c %1c %1c %1c %15c %1c%1c", ' ', cubeDown[2][0], cubeDown[2][1], cubeDown[2][2], ' ', ' ', 'D');
    }

    public String start() {
        System.out.println("\n❓ ------------------------- ↗ 「전개도 도움말」 ------------------------------");
        System.out.println(">>   U = Up = 윗면,  L = Left = 왼쪽 면,  F = Front = 앞면, ");
        System.out.println(">>   R = Right = 오른쪽 면,  B = Back = 뒷면,  D = Down = 아랫면을 뜻합니다.");
        System.out.println("--------------------------------------------------------------------------");
        System.out.println("⤵ 아래 명령어에 따라 '시계방향'으로 '1/4바퀴' 돌아갑니다.");
        System.out.println(" U : 윗면,  L : 왼쪽 면,  F : 앞면,  R : 오른쪽 면,  B : 뒷면,  D : 아랫면");
        System.out.println("⤴ 아래 명령어에 따라 '반시계방향'으로 '1/4바퀴' 돌아갑니다.");
        System.out.println(" U' : 윗면,  L' : 왼쪽 면,  F' : 앞면,  R' : 오른쪽 면,  B' : 뒷면,  D' : 아랫면");
        System.out.println("🔃 아래 명령어에 따라 '시계방향'으로 '1/2바퀴' 돌아갑니다.");
        System.out.println(" U2 : 윗면,  L2 : 왼쪽 면,  F2 : 앞면,  R2 : 오른쪽 면,  B2 : 뒷면,  D2 : 아랫면");
        System.out.println("⛔ Q 를 입력하면 프로그램이 종료됩니다.");
        System.out.print("CUBE > ");
        String input = sc.nextLine();
        System.out.println(); // 개행
        return input;
    }

    public ArrayList<String> trimInput(String input) { // 입력값 다듬기
        String[] inputArr = input.split("");
        int inputArrLength = inputArr.length;
        ArrayList<String> inputList = new ArrayList<>();
        for (int i = 0; i < inputArrLength; i++) { // 요소가 '나 2이면 직전 요소에 '나 2를 붙이기
            String inputElement = inputArr[i];
            if (inputElement.equals("'")) {
                inputArr[i - 1] = inputArr[i - 1] + "'";
            }
            if (inputElement.equals("2")) {
                inputArr[i - 1] = inputArr[i - 1] + "2";
            }
        }
        for (int i = 0; i < inputArrLength; i++) { // 요소가 '이 아니고 2가 아닐 때 inputList에 추가
            String inputElement = inputArr[i];
            if (!inputElement.equals("'") && !inputElement.equals("2")) {
                inputList.add(inputElement);
            }
        }
        return inputList;
    }

    public void checkInput(ArrayList<String> inputList) {
        int inputListSize = inputList.size();
        for (int i = 0; i < inputListSize; i++) {
            String anInput = inputList.get(i);
            if (anInput.equals("U'") || anInput.equals("U") || anInput.equals("F'") || anInput.equals("F")
                    || anInput.equals("L'") || anInput.equals("L") || anInput.equals("R'") || anInput.equals("R")
                    || anInput.equals("B'") || anInput.equals("B") || anInput.equals("D'") || anInput.equals("D")
                    || anInput.equals("U2") || anInput.equals("L2") || anInput.equals("F2") || anInput.equals("R2")
                    || anInput.equals("B2") || anInput.equals("D2") || anInput.equals("Q")) {
                guideInput(anInput);
            } else {
                System.out.println("❗ 지정되지 않은 명령어가 포함되어 있습니다. 다시 입력해 주세요.");
                String reInput = start();
                ArrayList<String> reInputList = trimInput(reInput);
                checkInput(reInputList);
            }
        }
        isComplete();
        ready();
    }

    public void isComplete() {
        char[][] completeUp = new char[3][3];
        char[][] completeLeft = new char[3][3];
        char[][] completeFront = new char[3][3];
        char[][] completeRight = new char[3][3];
        char[][] completeBack = new char[3][3];
        char[][] completeDown = new char[3][3];
        for (int i = 0; i < 3; i++) {
            completeUp[i] = new char[]{'W', 'W', 'W'}; // completeUp : White
            completeLeft[i] = new char[]{'O', 'O', 'O'}; // completeLeft : Orange
            completeFront[i] = new char[]{'G', 'G', 'G'}; // completeFront : Green
            completeRight[i] = new char[]{'R', 'R', 'R'}; // completeRight : Red
            completeBack[i] = new char[]{'B', 'B', 'B'}; // completeBack : Blue
            completeDown[i] = new char[]{'Y', 'Y', 'Y'}; // completeDown : Yellow
        }
        if (Objects.deepEquals(cubeUp, completeUp) && Objects.deepEquals(cubeLeft, completeLeft)
                && Objects.deepEquals(cubeFront, completeFront) && Objects.deepEquals(cubeRight, completeRight)
                && Objects.deepEquals(cubeBack, completeBack) && Objects.deepEquals(cubeDown, completeDown)) {
            System.out.println("🎉🎉🎉 축하드립니다! 큐브를 완성했습니다! 🎉🎉🎉");
            terminate();
        }
    }

    public void terminate() { // 종료 메서드
        sc.close();
        long timeGap = calTime();
        long timeGapMinute = (timeGap) / (1000 * 60); // 밀리초를 분 단위로 나누기
        long timeGapSecond = (timeGap - (timeGapMinute * 1000 * 60)) / 1000; // 분을 다시 밀리초단위로 바꿔서 밀리초-분을 초 단위로 나누기
        System.out.println("\n🕐 경과시간 : " + timeGapMinute + "분 " + timeGapSecond + "초");
        System.out.println("🔄 조작 횟수 : " + countNum + "회");
        System.out.println("\n😊 이용해 주셔서 감사합니다.");
        System.exit(0);
    }

    public long calTime() {
        long startTime = countTime;
        long endTime = System.currentTimeMillis();
        long timeGap = endTime - startTime;
        return timeGap;
    }

    public void guideInput(String anInput) {
        char[][] tempUp = new char[3][3];
        char[][] tempLeft = new char[3][3];
        char[][] tempFront = new char[3][3];
        char[][] tempRight = new char[3][3];
        char[][] tempBack = new char[3][3];
        char[][] tempDown = new char[3][3];
        switch (anInput) {
            case "U":
                System.out.println("\nU : 윗면을 시계방향으로 1/4 회전");
                whenU(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "U2":
                System.out.println("\nU2 : 윗면을 시계방향으로 1/2 회전");
                whenU(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                whenU(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "U'":
                System.out.println("\nU' : 윗쪽 면을 반시계방향으로 1/4 회전");
                whenUDot(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "F":
                System.out.println("\nF : 앞면을 시계방향으로 1/4 회전");
                whenF(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "F2":
                System.out.println("\nF2 : 앞면을 시계방향으로 1/2 회전");
                whenF(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                whenF(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "F'":
                System.out.println("\nF' : 앞쪽 면을 반시계방향으로 1/4 회전");
                whenFDot(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "L":
                System.out.println("\nL : 왼쪽 면을 시계방향으로 1/4 회전");
                whenL(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "L2":
                System.out.println("\nL2 : 왼쪽 면을 시계방향으로 1/2 회전");
                whenL(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                whenL(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "L'":
                System.out.println("\nL' : 왼쪽 면을 반시계방향으로 1/4 회전");
                whenLDot(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "R":
                System.out.println("\nR : 오른쪽 면을 시계방향으로 1/4 회전");
                whenR(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "R2":
                System.out.println("\nR2 : 오른쪽 면을 시계방향으로 1/2 회전");
                whenR(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                whenR(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "R'":
                System.out.println("\nR' : 오른쪽 면을 반시계방향으로 1/4 회전");
                whenRDot(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "B":
                System.out.println("\nB : 뒷면을 시계방향으로 1/4 회전");
                whenB(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "B2":
                System.out.println("\nB2 : 뒷면을 시계방향으로 1/2 회전");
                whenB(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                whenB(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "B'":
                System.out.println("\nB' : 뒷면을 반시계방향으로 1/4 회전");
                whenBDot(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "D":
                System.out.println("\nD : 아랫면을 시계방향으로 1/4 회전");
                whenD(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "D2":
                System.out.println("\nD2 : 아랫면을 시계방향으로 1/2 회전");
                whenD(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                whenD(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "D'":
                System.out.println("\nD' : 아랫면을 반시계방향으로 1/4 회전");
                whenDDot(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);
                break;
            case "Q":
                System.out.println("⛔ 프로그램 종료");
                terminate();
                break;
        }
        countNum++;
        printCube();
        System.out.println(); // 줄바꿈
    }

    public void copyToTemp(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        for (int i = 0; i < 3; i++) { // 임시변수에 cube내용 복사
            for (int j = 0; j < 3; j++) {
                tempUp[i][j] = cubeUp[i][j];
                tempLeft[i][j] = cubeLeft[i][j];
                tempFront[i][j] = cubeFront[i][j];
                tempRight[i][j] = cubeRight[i][j];
                tempBack[i][j] = cubeBack[i][j];
                tempDown[i][j] = cubeDown[i][j];
            }
        }
    }

    public void copyToCube(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) { //파라미터5개
        for (int i = 0; i < 3; i++) { // cube에 임시변수 내용 복사
            for (int j = 0; j < 3; j++) {
                cubeUp[i][j] = tempUp[i][j];
                cubeLeft[i][j] = tempLeft[i][j];
                cubeFront[i][j] = tempFront[i][j];
                cubeRight[i][j] = tempRight[i][j];
                cubeBack[i][j] = tempBack[i][j];
                cubeDown[i][j] = tempDown[i][j];
            }
        }
    }

    public void clockWise(char[][] temp, char[][] cube) { // 해당 면 cube를 시계방향으로 1/4 회전해 temp에 대입.
        temp[0][0] = cube[2][0];
        temp[0][1] = cube[1][0];
        temp[0][2] = cube[0][0];
        temp[1][0] = cube[2][1];
        temp[1][2] = cube[0][1];
        temp[2][0] = cube[2][2];
        temp[2][1] = cube[1][2];
        temp[2][2] = cube[0][2];
    }

    public void counterClockWise(char[][] temp, char[][] cube) { // 해당 면 cube를 시계방향으로 1/4 회전해 temp에 대입.
        temp[0][0] = cube[0][2];
        temp[0][1] = cube[1][2];
        temp[0][2] = cube[2][2];
        temp[1][0] = cube[0][1];
        temp[1][2] = cube[2][1];
        temp[2][0] = cube[0][0];
        temp[2][1] = cube[1][0];
        temp[2][2] = cube[2][0];
    }

    public void whenU(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        // U : 윗쪽 면을 시계방향으로 1/4 회전
        copyToTemp(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 임시변수에 cube 내용 복사
        clockWise(tempUp, cubeUp);// U면 시계방향 1/4 회전
        tempLeft[0][0] = cubeFront[0][0]; // U면의 옆면 - L면 변경사항
        tempLeft[0][1] = cubeFront[0][1];
        tempLeft[0][2] = cubeFront[0][2];
        tempBack[0][0] = cubeLeft[0][0];// U면의 옆면 - B면 변경사항
        tempBack[0][1] = cubeLeft[0][1];
        tempBack[0][2] = cubeLeft[0][2];
        tempFront[0][0] = cubeRight[0][0];// U면의 옆면 - F면 변경사항
        tempFront[0][1] = cubeRight[0][1];
        tempFront[0][2] = cubeRight[0][2];
        tempRight[0][0] = cubeBack[0][0];// U면의 옆면 - R면 변경사항
        tempRight[0][1] = cubeBack[0][1];
        tempRight[0][2] = cubeBack[0][2];
        copyToCube(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);//바뀐 임시변수를 cube에 복사
    }

    public void whenUDot(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        // U' : 윗쪽 면을 반시계방향으로 1/4 회전
        copyToTemp(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 임시변수에 cube 내용 복사
        counterClockWise(tempUp, cubeUp);// U면 반시계방향 1/4 회전
        tempLeft[0][0] = cubeBack[0][0]; // U면의 옆면 - L면 변경사항
        tempLeft[0][1] = cubeBack[0][1];
        tempLeft[0][2] = cubeBack[0][2];
        tempFront[0][0] = cubeLeft[0][0];// U면의 옆면 - F면 변경사항
        tempFront[0][1] = cubeLeft[0][1];
        tempFront[0][2] = cubeLeft[0][2];
        tempRight[0][0] = cubeFront[0][0];// U면의 옆면 - R면 변경사항
        tempRight[0][1] = cubeFront[0][1];
        tempRight[0][2] = cubeFront[0][2];
        tempBack[0][0] = cubeRight[0][0];// U면의 옆면 - B면 변경사항
        tempBack[0][1] = cubeRight[0][1];
        tempBack[0][2] = cubeRight[0][2];
        copyToCube(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown); //바뀐 임시변수를 cube에 복사
    }

    public void whenL(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        // L : 왼쪽 면을 시계방향으로 1/4 회전
        copyToTemp(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 임시변수에 cube 내용 복사
        clockWise(tempLeft, cubeLeft);// L면 시계방향 1/4 회전
        tempUp[0][0] = cubeBack[2][2];// L면의 옆면 - U면 변경사항
        tempUp[1][0] = cubeBack[1][2];
        tempUp[2][0] = cubeBack[0][2];
        tempFront[0][0] = cubeUp[0][0];// L면의 옆면 - F면 변경사항
        tempFront[1][0] = cubeUp[1][0];
        tempFront[2][0] = cubeUp[2][0];
        tempDown[0][0] = cubeFront[0][0];// L면의 옆면 - D면 변경사항
        tempDown[1][0] = cubeFront[1][0];
        tempDown[2][0] = cubeFront[2][0];
        tempBack[0][2] = cubeDown[2][0]; // L면의 옆면 - B면 변경사항
        tempBack[1][2] = cubeDown[1][0];
        tempBack[2][2] = cubeDown[0][0];
        copyToCube(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 바뀐 임시변수를 cube에 복사
    }

    public void whenLDot(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        // L' : 왼쪽 면을 반시계방향으로 1/4 회전
        copyToTemp(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 임시변수에 cube 내용 복사
        counterClockWise(tempLeft, cubeLeft);// L면 반시계방향 1/4 회전
        tempUp[0][0] = cubeFront[0][0];// L면의 옆면 - U면 변경사항
        tempUp[1][0] = cubeFront[1][0];
        tempUp[2][0] = cubeFront[2][0];
        tempFront[0][0] = cubeDown[0][0]; // L면의 옆면 - F면 변경사항
        tempFront[1][0] = cubeDown[1][0];
        tempFront[2][0] = cubeDown[2][0];
        tempDown[0][0] = cubeBack[2][2];// L면의 옆면 - D면 변경사항
        tempDown[1][0] = cubeBack[1][2];
        tempDown[2][0] = cubeBack[0][2];
        tempBack[0][2] = cubeUp[2][0];// L면의 옆면 - B면 변경사항
        tempBack[1][2] = cubeUp[1][0];
        tempBack[2][2] = cubeUp[0][0];
        copyToCube(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 바뀐 임시변수를 cube에 복사
    }

    public void whenF(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        // F : 앞쪽 면을 시계방향으로 1/4 회전
        copyToTemp(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 임시변수에 cube 내용 복사
        clockWise(tempFront, cubeFront);// F면 시계방향 1/4 회전
        tempUp[2][0] = cubeLeft[2][2];// F면의 옆면 - U면 변경사항
        tempUp[2][1] = cubeLeft[1][2];
        tempUp[2][2] = cubeLeft[0][2];
        tempLeft[0][2] = cubeDown[0][0]; // F면의 옆면 - L면 변경사항
        tempLeft[1][2] = cubeDown[0][1];
        tempLeft[2][2] = cubeDown[0][2];
        tempRight[0][0] = cubeUp[2][0];// F면의 옆면 - R면 변경사항
        tempRight[1][0] = cubeUp[2][1];
        tempRight[2][0] = cubeUp[2][2];
        tempDown[0][0] = cubeRight[2][0];// F면의 옆면 - D면 변경사항
        tempDown[0][1] = cubeRight[1][0];
        tempDown[0][2] = cubeRight[0][0];
        copyToCube(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown); // 바뀐 임시변수를 cube에 복사
    }

    public void whenFDot(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        // F' : 앞쪽 면을 반시계방향으로 1/4 회전
        copyToTemp(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown); // 임시변수에 cube 내용 복사
        counterClockWise(tempFront, cubeFront);// F면 반시계방향 1/4 회전
        tempUp[2][0] = cubeRight[0][0];// F면의 옆면 - U면 변경사항
        tempUp[2][1] = cubeRight[1][0];
        tempUp[2][2] = cubeRight[2][0];
        tempLeft[0][2] = cubeUp[2][2]; // F면의 옆면 - L면 변경사항
        tempLeft[1][2] = cubeUp[2][1];
        tempLeft[2][2] = cubeUp[2][0];
        tempRight[0][0] = cubeDown[0][2];// F면의 옆면 - R면 변경사항
        tempRight[1][0] = cubeDown[0][1];
        tempRight[2][0] = cubeDown[0][0];
        tempDown[0][0] = cubeLeft[0][2];// F면의 옆면 - D면 변경사항
        tempDown[0][1] = cubeLeft[1][2];
        tempDown[0][2] = cubeLeft[2][2];
        copyToCube(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 바뀐 임시변수를 cube에 복사
    }

    public void whenR(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        // R : 오른쪽 면을 시계방향으로 1/4 회전
        copyToTemp(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 임시변수에 cube 내용 복사
        clockWise(tempRight, cubeRight);// R면 시계방향 1/4 회전
        tempUp[0][2] = cubeFront[0][2];// R면의 옆면 - U면 변경사항
        tempUp[1][2] = cubeFront[1][2];
        tempUp[2][2] = cubeFront[2][2];
        tempFront[0][2] = cubeDown[0][2];// R면의 옆면 - F면 변경사항
        tempFront[1][2] = cubeDown[1][2];
        tempFront[2][2] = cubeDown[2][2];
        tempDown[0][2] = cubeBack[2][0];// R면의 옆면 - D면 변경사항
        tempDown[1][2] = cubeBack[1][0];
        tempDown[2][2] = cubeBack[0][0];
        tempBack[0][0] = cubeUp[2][2]; // R면의 옆면 - B면 변경사항
        tempBack[1][0] = cubeUp[1][2];
        tempBack[2][0] = cubeUp[0][2];
        copyToCube(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 바뀐 임시변수를 cube에 복사
    }

    public void whenRDot(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        // R' : 오른쪽 면을 반시계방향으로 1/4 회전
        copyToTemp(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 임시변수에 cube 내용 복사
        counterClockWise(tempRight, cubeRight);// R면 반시계방향 1/4 회전
        tempUp[0][2] = cubeBack[2][0];// R면의 옆면 - U면 변경사항
        tempUp[1][2] = cubeBack[1][0];
        tempUp[2][2] = cubeBack[0][0];
        tempFront[0][2] = cubeUp[0][2]; // R면의 옆면 - F면 변경사항
        tempFront[1][2] = cubeUp[1][2];
        tempFront[2][2] = cubeUp[2][2];
        tempDown[0][2] = cubeFront[0][2];// R면의 옆면 - D면 변경사항
        tempDown[1][2] = cubeFront[1][2];
        tempDown[2][2] = cubeFront[2][2];
        tempBack[0][0] = cubeDown[2][2];// R면의 옆면 - B면 변경사항
        tempBack[1][0] = cubeDown[1][2];
        tempBack[2][0] = cubeDown[0][2];
        copyToCube(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 바뀐 임시변수를 cube에 복사
    }

    public void whenB(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        // B : 뒷면을 시계방향으로 1/4 회전
        copyToTemp(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 임시변수에 cube 내용 복사
        clockWise(tempBack, cubeBack);// B면 시계방향 1/4 회전
        tempUp[0][0] = cubeRight[0][2];// B면의 옆면 - U면 변경사항
        tempUp[0][1] = cubeRight[1][2];
        tempUp[0][2] = cubeRight[2][2];
        tempLeft[0][0] = cubeUp[0][2];// B면의 옆면 - L면 변경사항
        tempLeft[1][0] = cubeUp[0][1];
        tempLeft[2][0] = cubeUp[0][0];
        tempRight[0][2] = cubeDown[2][2]; // B면의 옆면 - R면 변경사항
        tempRight[1][2] = cubeDown[2][1];
        tempRight[2][2] = cubeDown[2][0];
        tempDown[2][0] = cubeLeft[0][0];// B면의 옆면 - D면 변경사항
        tempDown[2][1] = cubeLeft[1][0];
        tempDown[2][2] = cubeLeft[2][0];
        copyToCube(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 바뀐 임시변수를 cube에 복사
    }

    public void whenBDot(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        // B' : 뒷면을 반시계방향으로 1/4 회전
        copyToTemp(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 임시변수에 cube 내용 복사
        counterClockWise(tempBack, cubeBack);// B면 반시계방향 1/4 회전
        tempUp[0][0] = cubeLeft[2][0];// B면의 옆면 - U면 변경사항
        tempUp[0][1] = cubeLeft[1][0];
        tempUp[0][2] = cubeLeft[0][0];
        tempLeft[0][0] = cubeDown[2][0]; // B면의 옆면 - L면 변경사항
        tempLeft[1][0] = cubeDown[2][1];
        tempLeft[2][0] = cubeDown[2][2];
        tempRight[0][2] = cubeUp[0][0];// B면의 옆면 - R면 변경사항
        tempRight[1][2] = cubeUp[0][1];
        tempRight[2][2] = cubeUp[0][2];
        tempDown[2][0] = cubeRight[2][2];// B면의 옆면 - D면 변경사항
        tempDown[2][1] = cubeRight[1][2];
        tempDown[2][2] = cubeRight[0][2];
        copyToCube(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 바뀐 임시변수를 cube에 복사
    }

    public void whenD(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        // D : 아랫면을 시계방향으로 1/4 회전
        copyToTemp(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 임시변수에 cube 내용 복사
        clockWise(tempDown, cubeDown);// D면 시계방향 1/4 회전
        tempLeft[2][0] = cubeBack[2][0];// D면의 옆면 - L면 변경사항
        tempLeft[2][1] = cubeBack[2][1];
        tempLeft[2][2] = cubeBack[2][2];
        tempFront[2][0] = cubeLeft[2][0];// D면의 옆면 - F면 변경사항
        tempFront[2][1] = cubeLeft[2][1];
        tempFront[2][2] = cubeLeft[2][2];
        tempRight[2][0] = cubeFront[2][0]; // D면의 옆면 - R면 변경사항
        tempRight[2][1] = cubeFront[2][1];
        tempRight[2][2] = cubeFront[2][2];
        tempBack[2][0] = cubeRight[2][0];// D면의 옆면 - B면 변경사항
        tempBack[2][1] = cubeRight[2][1];
        tempBack[2][2] = cubeRight[2][2];
        copyToCube(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 바뀐 임시변수를 cube에 복사
    }

    public void whenDDot(char[][] tempUp, char[][] tempLeft, char[][] tempFront, char[][] tempRight, char[][] tempBack, char[][] tempDown) {
        // D' : 아랫면을 반시계방향으로 1/4 회전
        copyToTemp(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 임시변수에 cube 내용 복사
        counterClockWise(tempDown, cubeDown);// D면 반시계방향 1/4 회전
        tempLeft[2][0] = cubeFront[2][0]; // D면의 옆면 - L면 변경사항
        tempLeft[2][1] = cubeFront[2][1];
        tempLeft[2][2] = cubeFront[2][2];
        tempFront[2][0] = cubeRight[2][0];// D면의 옆면 - F면 변경사항
        tempFront[2][1] = cubeRight[2][1];
        tempFront[2][2] = cubeRight[2][2];
        tempRight[2][0] = cubeBack[2][0];// D면의 옆면 - R면 변경사항
        tempRight[2][1] = cubeBack[2][1];
        tempRight[2][2] = cubeBack[2][2];
        tempBack[2][0] = cubeLeft[2][0];// D면의 옆면 - B면 변경사항
        tempBack[2][1] = cubeLeft[2][1];
        tempBack[2][2] = cubeLeft[2][2];
        copyToCube(tempUp, tempLeft, tempFront, tempRight, tempBack, tempDown);// 바뀐 임시변수를 cube에 복사
    }
} // class

 

출력형태 

 

 

---

설명

Step3.java 코드 설명

• 전역변수

  • sc : Scanner
  • cubeUp, cubeLeft, cubeFront, cubeRight, cubeBack, cubeDown
    • 큐브의 6면(윗쪽, 왼쪽, 앞쪽, 오른쪽, 뒷쪽, 아랫쪽)을 담당하는 3*3 이차원배열
  • countNum : 조작 횟수를 카운팅하는 변수
  • countTime : 경과시간을 측정하는 변수

• initCube() : 큐브를 초기화하는 메서드.

  • 큐브의 6면을 기본 색으로 설정
  • 윗면 = White, 왼쪽면 = Orange, 앞면 = Green
  • 오른쪽면 = Red, 뒷면 = Blue, 아랫면 = Yellow

• scramble() : 큐브를 무작위로 섞는 메서드.

  • 루빅스 큐브를 푸는 프로그램이기 떄문에 첫 화면을 제시한 뒤 자동으로 섞어준다.
  • random.nextInt(4)를 통해 0~3까지의 무작위 숫자를 3개 호출
  • 일부 큐브회전 메서드들을 통해 무작위 숫자만큼 큐브를 섞은 뒤 그 모습을 출력한다.
  • 섞인 큐브가 출력된 시점부터 시간이 계산된다(countTime).

• ready() : start()-trimInput()-checkInput()을 차례로 호출하는 메서드.

  • 각각 앞 함수의 리턴값을 파라미터로 받는다.

• printCube() : 현재 큐브 6면의 상태를 전개도 모양으로 출력하고, 전개도 도움말을 제공하는 메서드.

  • printf()를 활용해 큐브의 6면을 전개도 모양으로 출력
  • 현재 큐브의 모양 오른쪽에, 전개도의 각 면에 대한 명령어 기호를 제공
    • 실제로 사용자에게는 각 면에 대한 설명이 필요할 것 같아 추가함.

• start() : 도움말 및 명령어 설명을 제공하고, 사용자에게 명령어를 입력받는 메서드.

  • return : input (사용자로부터 입력받은 명령어)

• trimInput(input) : 사용자로부터 입력받은 명령어를 처리하기 좋은 형태로 다듬는 메서드.

  • 사용자의 입력값을 split("")로 한 문자씩 쪼개어 배열로 만듦
  • 결과값을 담을 ArrayList인 inputList를 선언.
  • 각 요소가 ' 또는 2와 일치하면, 그 요소의 직전 요소에 ' 또는 2를 붙임.
  • 각 요소가 '도 아니고 2도 아닐 때만 inputList에 추가.
  • return : inputList

• checkInput(inputList) : 사용자로부터 입력받은 명령어를 검사하는 메서드.

  • inputList의 각 요소(anInput)를 하나씩 확인.
  • anInput이 U U' L L' F F' R R' B B' D D' U2 L2 F2 R2 B2 D2 중 하나일 때만 guideInput(anInput) 호출.
  • 그렇지 않을 때는 오류 메시지를 출력하고 start()-trimInput()-checkInput()을 다시 실행.
  • inputList의 모든 명령어 처리가 완료되면 isComplete()로 큐브가 완성되었는지 확인하고 ready()호출.

• isComplete() : 큐브가 완성되었는지 검사하는 메서드.

  • (이 프로그램에서는) 큐브의 6면의 가운데 요소(이차원배열로는 [1][1])는 반드시 초기값과 같다.
  • 즉 윗면은 모두 W, 왼쪽 면은 모두 L, 앞쪽 면은 모두 G, 오른쪽 면은 모두 R, 뒷면은 모두 B, 아랫면은 모두 Y여야 한다.
  • 검사 방법 : 초기 큐브와 똑같은 임시큐브를 만들고, 현재 큐브의 6면이 임시큐브의 6면과 같은지 비교한다.
    • 만약 완성되었다면 축하 메시지를 출력한 뒤 terminate()를 호출.

• terminate() : 프로그램 종료 메서드

  • Scanner를 닫고 calTime()을 호출해 경과시간(밀리초 단위)을 받는다.
  • 받은 경과시간을 분, 초 단위로 계산해 출력한다.
  • countNum에 저장된 조작횟수를 출력한다.
  • 프로그램을 종료한다.

• calTime() : 경과시간을 계산하는 메서드.

  • countTime에 저장된 시작시간을 받아온다. (시작시간은 scramble()에서 저장됨)
  • calTime()이 호출된 시간을 종료시간으로 한다.
  • timeGap : 종료시간 - 시작시간 (밀리초 단위)을 계산한 결과값
  • return : timeGap

• guideInput(anInput) : 사용자의 명령어 하나에 대한 큐브회전메서드를 호출하는 메서드.

  • 각 큐브회전메서드들에 넘길 파라미터인 temp임시큐브(윗면,왼쪽면,앞면,오른쪽면,뒷면,아랫면)를 선언
  • switch-case문을 통해 anInput과 일치하는 큐브회전메서드로 연결하고, 입력값에 대한 메시지를 출력
  • U2처럼 1/2바퀴 회전하는 명령어는 whenU()를 두 번 호출.
  • 각 큐브회전메서드 처리가 끝나면 countNum(조작횟수) 에 1을 더하고, 현재 큐브를 출력

• copyToTemp(temp) / copyToCube(temp) : 임시큐브에 현재 큐브를 복사하는 메서드.

  • 6면의 임시큐브 값을 받아 현재 큐브에 복사하거나 / 현재 큐브 6면의 값을 임시큐브에 복사하는 메서드
  • 모든 큐브회전메서드에 필요한 메서드

• clockWise(temp, cube) / counterClockWise(temp, cube) :

  • 어떤 면을 시계방향 / 반시계방향으로 1/4 회전하는 메서드.
  • 어떤 면의 현재 큐브를 시계방향 / 반시계방향으로 1/4 회전해 임시큐브에 대입함.
  • 모든 큐브회전메서드에 필요한 메서드

• [큐브회전메서드]

  • whenU(temp), whenUDot(temp),whenL(temp), whenLDot(temp),whenF(temp), whenFDot(temp),
  • whenR(temp), whenRDot(temp),whenB(temp), whenBDot(temp),whenD(temp), whenDDot(temp),
  • 명령어에 따라 큐브를 회전시키는 메서드들.
  • 모든 변경사항은 임시큐브에 먼저 적용되고, 변경된 내용이 현재 큐브에 복사된다.
  • (1) 임시큐브에 현재 큐브 내용을 복사해 넣는다
    • why? 큐브회전메서드에서 조작되는 요소를 제외한 요소들은 그대로여야 하기 떄문
  • (2) 각 회전메서드의 회전하는 면을 시계방향/반시계방향으로 회전시킨 결과를 임시큐브에 저장한다.
    • 시계방향이면 clockWise(temp, cube), 반시계방향이면 counterClockWise(temp, cube)
  • (3) 회전하는 면에 인접한 4면에 대한 변경사항을 조작하여 임시큐브에 저장한다. = (4) 임시큐브에 저장된 내용이 현재 큐브 상태가 되도록 복사해 넣는다.