Евгений Собко. Кубик Рубика

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
+#Tue Feb 20 16:38:03 MSK 2018
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.4.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.4.1-all.zip

src/main/java/myRubiksCube/Cube.java

@@ -0,0 +1,138 @@
+package myRubiksCube;
+
+import java.util.Arrays;
+import java.util.Random;
+
+public class Cube {
+    public char[][][] cube;
+    public int size;
+
+    char[] symbols = {'W', 'R', 'B', 'O', 'Y', 'G'};
+
+    public Cube(int size) {
+        this.size = size;
+        this.cube = new char[6][size][size];
+
+        // Кубик заполняется в собранное состояние
+
+        for (int i = 0; i < 6; ++i) {
+            for (int j = 0; j < size; ++j) {
+                Arrays.fill(cube[i][j], symbols[i]);
+            }
+        }
+    }
+
+    public char[][][] Get() {
+        return cube;
+    }
+
+
+    public void rotateLeft() {
+        char[][] help = cube[1];
+        cube[1] = cube[2];
+        cube[2] = cube[3];
+        cube[3] = cube[5];
+        cube[5] = help;
+        rotate(1, 0);
+        rotate(0, 4);
+        rotate(1, 5);
+        rotate(1, 5);
+        rotate(1, 3);
+        rotate(1, 3);
+    }
+
+    public void rotateRight() {
+        rotateLeft();
+        rotateLeft();
+        rotateLeft();
+    }
+
+    public void rotateUp() {
+        char[][] help;
+        char[][] help1;
+
+        help1 = cube[0];
+        help = cube[5];
+        cube[5] = help1;
+        help1 = cube[2];
+        cube[0] = help1;
+        help1 = cube[4];
+        cube[2] = help1;
+        cube[4] = help;
+        rotate(3, 1);
+        rotate(1, 3);
+    }
+
+    public void rotateDown() {
+        rotateUp();
+        rotateUp();
+        rotateUp();
+    }
+
+    public void spin(int direction) {
+        rotate(direction, 2);
+        char c;
+        for (int i = 0; i < size; ++i) {
+            if (direction == 1) {
+                c = cube[1][size - i - 1][size - 1];
+                cube[1][size - i - 1][size - 1] = cube[4][0][size - i - 1];
+                cube[4][0][size - i - 1] = cube[3][i][0];
+                cube[3][i][0] = cube[0][size - 1][i];
+                cube[0][size - 1][i] = c;
+            } else {
+                c = cube[1][size - i - 1][size - 1];
+                cube[1][size - i - 1][size - 1] = cube[0][size - 1][i];
+                cube[0][size - 1][i] = cube[3][i][0];
+                cube[3][i][0] = cube[4][0][size - i - 1];
+                cube[4][0][size - i - 1] = c;
+            }
+        }
+    }
+
+    public void rotate(int position, int numCube) {
+        char[][] help = new char[size][size];
+
+        if (position == 1) {
+            for (int i = 0; i < size; ++i) {
+                for (int j = 0; j < size; ++j) {
+                    help[i][j] = cube[numCube][size - 1 - j][i];
+                }
+            }
+        } else {
+            for (int i = 0; i < size; ++i) {
+                for (int j = 0; j < size; ++j) {
+                    help[i][j] = cube[numCube][j][size - 1 - i];
+                }
+            }
+        }
+        cube[numCube] = help;
+    }
+
+    public void shuffle() {
+        for (int i = 0; i < 20; ++i) {
+            Random random = new Random();
+            int number = random.nextInt(13);
+            switch (number) {
+                case 0: spin(1); break;
+                case 1: spin(2); break;
+                case 2: rotateLeft(); spin(1); rotateRight(); break;
+                case 3: rotateLeft(); spin(2); rotateRight(); break;
+                case 4: rotateRight(); spin(1); rotateLeft(); break;
+                case 5: rotateRight(); spin(2); rotateLeft(); break;
+                case 6: rotateDown(); spin(1); rotateUp(); break;
+                case 7: rotateDown(); spin(2); rotateUp(); break;
+                case 8: rotateLeft();
+                case 9: rotateRight();
+                case 10: rotateUp();
+                case 11: rotateDown();
+                case 12: rotateUp(); spin(1); rotateDown(); break;
+                case 13: rotateUp(); spin(2); rotateDown(); break;
+            }
+        }
+    }
+}
+
+
+
+
+

src/main/java/myRubiksCube/CubePrinter.java

@@ -0,0 +1,57 @@
+package myRubiksCube;
+
+public class CubePrinter {
+
+    private char[][] arr;
+    private int n;
+
+    CubePrinter(int n) {
+        this.arr = new char[n * 8 + 1][n * 18 + 1];
+        this.n = n;
+
+        for (int i = 0; i < n * 8 + 1; ++i) {
+            for (int j = 0; j < n * 18 + 1; ++j) {
+                arr[i][j] = ' ';
+            }
+        }
+
+        for (int i = 0; i < n * 8 + 1; i = i + 2) {
+            for (int j = 1; j < n * 18 + 1; j = j + 6) {
+                for (int k = j; k < j + 5; k++) {
+                    arr[i][k] = '-';
+                }
+            }
+        }
+
+        for (int i = 1; i < n * 8 + 1; i = i + 2) {
+            for (int j = 0; j < n * 18 + 1; j = j + 6) {
+                arr[i][j] = '|';
+                arr[i - 1][j] = '+';
+            }
+        }
+        for (int j = 0; j < n * 18 + 1; j = j + 6) {
+            arr[n * 8][j] = '+';
+        }
+    }
+
+    public void Print(Cube cube) {
+        char[][][] ptr = cube.Get();
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
+                arr[i * 2 + 1][n * 6 + 3 + j * 6] = ptr[0][i][j];
+                arr[i * 2 + n * 2 + 1][3 + j * 6] = ptr[1][i][j];
+                arr[i * 2 + n * 2 + 1][n * 6 + 3 + j * 6] = ptr[2][i][j];
+                arr[i * 2 + n * 2 + 1][n * 12 + 3 + j * 6] = ptr[3][i][j];
+                arr[i * 2 + n * 4 + 1][n * 6 + 3 + j * 6] = ptr[4][i][j];
+                arr[i * 2 + n * 6 + 1][n * 6 + 3 + j * 6] = ptr[5][i][j];
+            }
+        }
+
+        for (int i = 0; i < n * 8 + 1; ++i) {
+            for (int j = 0; j < n * 18 + 1; ++j) {
+                System.out.print(arr[i][j]);
+            }
+            System.out.print("\n");
+        }
+    }
+}

src/main/java/myRubiksCube/Main.java

@@ -0,0 +1,110 @@
+package myRubiksCube;
+
+import java.util.Scanner;
+
+public class Main {
+    public static void main(String[] args) {
+        Scanner reader = new Scanner(System.in);
+        System.out.print("Enter cube size: ");
+        int n = reader.nextInt();
+
+        Cube cube = new Cube(n);
+
+        boolean B = true;
+
+        while (B) {
+            System.out.println("What'll we do?");
+            Scanner look = new Scanner(System.in);
+            String l = look.nextLine();
+            switch (l) {
+                case "Print": {
+                    CubePrinter printC1 = new CubePrinter(n);
+                    printC1.Print(cube);
+                    break;
+                }
+                case "Stop": {
+                    System.out.println("Досвидули))0)");
+                    B = false;
+                    break;
+                }
+                case "Left": {
+                    cube.rotateLeft();
+                    break;
+                }
+                case "Right": {
+                    cube.rotateRight();
+                    break;
+                }
+                case "Up": {
+                    cube.rotateUp();
+                    break;
+                }
+                case "Down": {
+                    cube.rotateDown();
+                    break;
+                }
+                case "F": {
+                    cube.spin(1);
+                    break;
+                }
+                case "F'": {
+                    cube.spin(2);
+                    break;
+                }
+                case "R": {
+                    cube.rotateLeft();
+                    cube.spin(1);
+                    cube.rotateRight();
+                    break;
+                }
+                case "R'": {
+                    cube.rotateLeft();
+                    cube.spin(2);
+                    cube.rotateRight();
+                    break;
+                }
+                case "L": {
+                    cube.rotateRight();
+                    cube.spin(1);
+                    cube.rotateLeft();
+                    break;
+                }
+                case "L'": {
+                    cube.rotateRight();
+                    cube.spin(2);
+                    cube.rotateLeft();
+                    break;
+                }
+                case "U": {
+                    cube.rotateDown();
+                    cube.spin(1);
+                    cube.rotateUp();
+                    break;
+                }
+                case "U'": {
+                    cube.rotateDown();
+                    cube.spin(2);
+                    cube.rotateUp();
+                    break;
+                }
+                case "D": {
+                    cube.rotateUp();
+                    cube.spin(1);
+                    cube.rotateDown();
+                    break;
+                }
+                case "D'": {
+                    cube.rotateUp();
+                    cube.spin(2);
+                    cube.rotateDown();
+                    break;
+                }
+                case "Shuffle": {
+                    cube.shuffle();
+                    break;
+                }
+            }
+        }
+    }
+}
+

src/test/java/ru/spbstu/kspt/task1/MainTest.java

@@ -1,9 +1,12 @@
 package ru.spbstu.kspt.task1;
 
-import org.junit.jupiter.api.Test;
+import myRubiksCube.Cube;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 class MainTest {
     private static final Logger logger = LogManager.getLogger(MainTest.class);
@@ -15,3 +18,45 @@ void exampleTest() {
         logger.info("Test finished");
     }
 }
+
+class testCube {
+
+    Cube result = new Cube(3);
+    Cube actual = new Cube(3);
+
+    @Test
+    public void rotateUp() {
+        result.rotateUp();
+        assertArrayEquals(result.cube[0], actual.cube[2]);
+        assertArrayEquals(result.cube[2], actual.cube[4]);
+        assertArrayEquals(result.cube[4], actual.cube[5]);
+        assertArrayEquals(result.cube[5], actual.cube[0]);
+    }
+
+    @Test
+    void rotateRight() {
+        result.rotateRight();
+        assertArrayEquals(result.cube[1], actual.cube[5]);
+        assertArrayEquals(result.cube[2], actual.cube[1]);
+        assertArrayEquals(result.cube[3], actual.cube[2]);
+        assertArrayEquals(result.cube[5], actual.cube[3]);
+    }
+
+    @Test
+    public void rotateDown() {
+        result.rotateDown();
+        assertArrayEquals(result.cube[0], actual.cube[5]);
+        assertArrayEquals(result.cube[2], actual.cube[0]);
+        assertArrayEquals(result.cube[4], actual.cube[2]);
+        assertArrayEquals(result.cube[5], actual.cube[4]);
+    }
+
+    @Test
+    void rotateLeft() {
+        result.rotateLeft();
+        assertArrayEquals(result.cube[5], actual.cube[1]);
+        assertArrayEquals(result.cube[1], actual.cube[2]);
+        assertArrayEquals(result.cube[2], actual.cube[3]);
+        assertArrayEquals(result.cube[3], actual.cube[5]);
+    }
+}