From 67a24d0b6686b0b56b913777cd6ca4f5238d9875 Mon Sep 17 00:00:00 2001
From: evgenysobko <jooohn127@gmail.com>
Date: Wed, 28 Feb 2018 22:28:28 +0300
Subject: [PATCH 01/10] =?UTF-8?q?=D0=92=20=D0=BF=D1=80=D0=BE=D1=86=D0=B5?=
 =?UTF-8?q?=D1=81=D1=81=D0=B5))0)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 gradle/wrapper/gradle-wrapper.properties |  3 +-
 src/main/java/myClass/Cube.java          | 92 ++++++++++++++++++++++++
 src/main/java/myClass/Main.java          | 69 ++++++++++++++++++
 src/main/java/myClass/PrintCube.java     | 57 +++++++++++++++
 4 files changed, 220 insertions(+), 1 deletion(-)
 create mode 100644 src/main/java/myClass/Cube.java
 create mode 100644 src/main/java/myClass/Main.java
 create mode 100644 src/main/java/myClass/PrintCube.java

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 2c2bbe5..666be29 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/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
diff --git a/src/main/java/myClass/Cube.java b/src/main/java/myClass/Cube.java
new file mode 100644
index 0000000..04ce9e4
--- /dev/null
+++ b/src/main/java/myClass/Cube.java
@@ -0,0 +1,92 @@
+package myClass;
+
+import java.util.Arrays;
+
+public class Cube {
+    private int n;
+    private char[][][] cube;
+
+    char[] symbols = {'W', 'R', 'B', 'O', 'Y', 'G'};
+    char[] symbolsAdd = {' ', ' ', ' ', ' ', ' ', ' '};
+
+    Cube(int n) {
+        this.n = n;
+        this.cube = new char[6][n][n];
+
+        for (int i = 0; i < 6; ++i) {
+            for (int j = 0; j < n; ++j) {
+                Arrays.fill(cube[i][j], symbols[i]);
+            }
+        }
+    }
+
+    public char[][][] Get() {
+        return cube;
+    }
+
+    public void RotateLeft() {
+        symbolsAdd[5] = symbols[1];
+        symbolsAdd[1] = symbols[2];
+        symbols[1] = symbolsAdd[1];
+        symbolsAdd[2] = symbols[3];
+        symbols[2] = symbolsAdd[2];
+        symbolsAdd[3] = symbols[5];
+        symbols[3] = symbolsAdd[3];
+        symbols[5] = symbolsAdd[5];
+        for (int i = 0; i < 6; ++i) {
+            for (int j = 0; j < n; ++j) {
+                Arrays.fill(cube[i][j], symbols[i]);
+            }
+        }
+    }
+
+    public void RotateRight() {
+        symbolsAdd[1] = symbols[5];
+        symbolsAdd[2] = symbols[1];
+        symbolsAdd[3] = symbols[2];
+        symbolsAdd[5] = symbols[3];
+        symbols[1] = symbolsAdd[1];
+        symbols[2] = symbolsAdd[2];
+        symbols[3] = symbolsAdd[3];
+        symbols[5] = symbolsAdd[5];
+        for (int i = 0; i < 6; ++i) {
+            for (int j = 0; j < n; ++j) {
+                Arrays.fill(cube[i][j], symbols[i]);
+            }
+        }
+    }
+
+    public void RotateUp() {
+        symbolsAdd[0] = symbols[2];
+        symbolsAdd[2] = symbols[4];
+        symbolsAdd[5] = symbols[0];
+        symbolsAdd[4] = symbols[5];
+        symbols[0] = symbolsAdd[0];
+        symbols[2] = symbolsAdd[2];
+        symbols[4] = symbolsAdd[4];
+        symbols[5] = symbolsAdd[5];
+        for (int i = 0; i < 6; ++i) {
+            for (int j = 0; j < n; ++j) {
+                Arrays.fill(cube[i][j], symbols[i]);
+            }
+        }
+    }
+
+    public void RotateDown() {
+        symbolsAdd[0] = symbols[5];
+        symbolsAdd[2] = symbols[0];
+        symbolsAdd[5] = symbols[4];
+        symbolsAdd[4] = symbols[2];
+        symbols[0] = symbolsAdd[0];
+        symbols[2] = symbolsAdd[2];
+        symbols[4] = symbolsAdd[4];
+        symbols[5] = symbolsAdd[5];
+        for (int i = 0; i < 6; ++i) {
+            for (int j = 0; j < n; ++j) {
+                Arrays.fill(cube[i][j], symbols[i]);
+            }
+        }
+    }
+}
+
+
diff --git a/src/main/java/myClass/Main.java b/src/main/java/myClass/Main.java
new file mode 100644
index 0000000..19a9499
--- /dev/null
+++ b/src/main/java/myClass/Main.java
@@ -0,0 +1,69 @@
+package myClass;
+
+import java.util.Objects;
+import java.util.Scanner;
+
+public class Main {
+    public static void main(String[] args) {
+        Scanner reader = new Scanner(System.in);
+        System.out.print("Введите размер кубика: ");
+        int n = reader.nextInt();
+
+        Cube cube = new Cube(n);
+
+        PrintCube prntC = new PrintCube(n);
+        prntC.Print(cube);
+        int k = 0;
+        do {
+            System.out.println("Что будем с ним делать?");
+            Scanner look = new Scanner(System.in);
+            String l = look.nextLine();
+            if (Objects.equals(l, "Закончить")) {
+                System.out.println("Досвидули))0)");
+                k = k - 1000000;
+            }
+            if (Objects.equals(l, "Влево")) {
+                cube.RotateLeft();
+                System.out.println("Кубик повернут влево. Вывести на экран?");
+                Scanner look1 = new Scanner(System.in);
+                String k1 = look1.nextLine();
+                if (Objects.equals(k1, "Да")) {
+                    PrintCube printC1 = new PrintCube(n);
+                    printC1.Print(cube);
+                }
+            }
+            if (Objects.equals(l, "Вправо")) {
+                cube.RotateRight();
+                System.out.println("Кубик повернут вправо. Вывести на экран?");
+                Scanner look2 = new Scanner(System.in);
+                String k2 = look2.nextLine();
+                if (Objects.equals(k2, "Да")) {
+                    PrintCube printC1 = new PrintCube(n);
+                    printC1.Print(cube);
+                }
+            }
+            if (Objects.equals(l, "Вверх")) {
+                cube.RotateUp();
+                System.out.println("Кубик повернут вверх. Вывести на экран?");
+                Scanner look3 = new Scanner(System.in);
+                String k3 = look3.nextLine();
+                if (Objects.equals(k3, "Да")) {
+                    PrintCube printC1 = new PrintCube(n);
+                    printC1.Print(cube);
+                }
+            }
+            if (Objects.equals(l, "Вниз")) {
+                cube.RotateDown();
+                System.out.println("Кубик повернут вниз. Вывести на экран?");
+                Scanner look4 = new Scanner(System.in);
+                String k4 = look4.nextLine();
+                if (Objects.equals(k4, "Да")) {
+                    PrintCube printC1 = new PrintCube(n);
+                    printC1.Print(cube);
+                }
+            }
+            ++k;
+        } while (k >= 0);
+    }
+}
+
diff --git a/src/main/java/myClass/PrintCube.java b/src/main/java/myClass/PrintCube.java
new file mode 100644
index 0000000..94eaf26
--- /dev/null
+++ b/src/main/java/myClass/PrintCube.java
@@ -0,0 +1,57 @@
+package myClass;
+
+public class PrintCube {
+
+    private char[][] arr;
+    private int n;
+
+    PrintCube(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");
+        }
+    }
+}

From 547a6cff40059b9a0f940156c48f0d373fd085c8 Mon Sep 17 00:00:00 2001
From: evgenysobko <jooohn127@gmail.com>
Date: Fri, 2 Mar 2018 10:16:29 +0300
Subject: [PATCH 02/10] Minor update Changelog: -a lot of bugs with rotate side
 -fix rotate cube

---
 src/main/java/myClass/Cube.java | 121 +++++++++++++++++++-------------
 src/main/java/myClass/Main.java |  60 ++++++----------
 2 files changed, 92 insertions(+), 89 deletions(-)

diff --git a/src/main/java/myClass/Cube.java b/src/main/java/myClass/Cube.java
index 04ce9e4..a7f35c1 100644
--- a/src/main/java/myClass/Cube.java
+++ b/src/main/java/myClass/Cube.java
@@ -3,11 +3,11 @@
 import java.util.Arrays;
 
 public class Cube {
-    private int n;
     private char[][][] cube;
+    private char[][] arr;
+    private int n;
 
     char[] symbols = {'W', 'R', 'B', 'O', 'Y', 'G'};
-    char[] symbolsAdd = {' ', ' ', ' ', ' ', ' ', ' '};
 
     Cube(int n) {
         this.n = n;
@@ -24,69 +24,92 @@ public char[][][] Get() {
         return cube;
     }
 
-    public void RotateLeft() {
-        symbolsAdd[5] = symbols[1];
-        symbolsAdd[1] = symbols[2];
-        symbols[1] = symbolsAdd[1];
-        symbolsAdd[2] = symbols[3];
-        symbols[2] = symbolsAdd[2];
-        symbolsAdd[3] = symbols[5];
-        symbols[3] = symbolsAdd[3];
-        symbols[5] = symbolsAdd[5];
-        for (int i = 0; i < 6; ++i) {
+    int x = 0, y = 0;
+
+    public void RotateOpposite() {
+        for (int i = 0; i < n; ++i) {
             for (int j = 0; j < n; ++j) {
-                Arrays.fill(cube[i][j], symbols[i]);
+                cube[x][i][j] = cube[x][j][i];
+                cube[y][i][j] = cube[y][j][i];
             }
         }
     }
 
+    char[][] help = new char[0][];
+    char[][] help1 = new char[0][];
+
+    public void RotateLeft() {
+        y = 5;
+        RotateOpposite();
+        help = cube[1];
+        help1 = cube[5];
+        cube[5] = help;
+        help = cube[2];
+        cube[1] = help;
+        help = cube[3];
+        cube[2] = help;
+        cube[3] = help1;
+    }
+
     public void RotateRight() {
-        symbolsAdd[1] = symbols[5];
-        symbolsAdd[2] = symbols[1];
-        symbolsAdd[3] = symbols[2];
-        symbolsAdd[5] = symbols[3];
-        symbols[1] = symbolsAdd[1];
-        symbols[2] = symbolsAdd[2];
-        symbols[3] = symbolsAdd[3];
-        symbols[5] = symbolsAdd[5];
-        for (int i = 0; i < 6; ++i) {
-            for (int j = 0; j < n; ++j) {
-                Arrays.fill(cube[i][j], symbols[i]);
-            }
-        }
+        RotateLeft();
+        RotateLeft();
+        RotateLeft();
     }
 
     public void RotateUp() {
-        symbolsAdd[0] = symbols[2];
-        symbolsAdd[2] = symbols[4];
-        symbolsAdd[5] = symbols[0];
-        symbolsAdd[4] = symbols[5];
-        symbols[0] = symbolsAdd[0];
-        symbols[2] = symbolsAdd[2];
-        symbols[4] = symbolsAdd[4];
-        symbols[5] = symbolsAdd[5];
-        for (int i = 0; i < 6; ++i) {
-            for (int j = 0; j < n; ++j) {
-                Arrays.fill(cube[i][j], symbols[i]);
-            }
-        }
+        x = 1;
+        y = 3;
+        RotateOpposite();
+        help1 = cube[0];
+        help = cube[5];
+        cube[5] = help1;
+        help1 = cube[2];
+        cube[0] = help1;
+        help1 = cube[4];
+        cube[2] = help1;
+        cube[4] = help;
     }
 
     public void RotateDown() {
-        symbolsAdd[0] = symbols[5];
-        symbolsAdd[2] = symbols[0];
-        symbolsAdd[5] = symbols[4];
-        symbolsAdd[4] = symbols[2];
-        symbols[0] = symbolsAdd[0];
-        symbols[2] = symbolsAdd[2];
-        symbols[4] = symbolsAdd[4];
-        symbols[5] = symbolsAdd[5];
-        for (int i = 0; i < 6; ++i) {
+        RotateUp();
+        RotateUp();
+        RotateUp();
+    }
+
+    public void SpinFront() {
+        char[][] help = cube[2].clone();
+        for (int i = 0; i < n; ++i) {
             for (int j = 0; j < n; ++j) {
-                Arrays.fill(cube[i][j], symbols[i]);
+                cube[2][i][j] = help[j][n - i - 1];
             }
         }
+        char[] h = cube[0][n - 1].clone();
+        char c;
+        for (int i = 0; i < n; ++i) {
+            cube[0][n - 1][i] = cube[1][n - i - 1][n - 1];
+        }
+        for (int i = 0; i < n; ++i) {
+            c = cube[3][i][0];
+            cube[3][i][0] = h[i];
+            h[i] = c;
+        }
+        for (int i = 0; i < n; ++i) {
+            c = cube[4][0][i];
+            cube[4][0][i] = h[n - i - 1];
+            h[n - i - 1] = c;
+        }
+        for (int i = 0; i < n; ++i) {
+            cube[1][i][n - 1] = h[n - i - 1];
+        }
+    }
+
+    public void SpinRight() {
+        RotateRight();
+        SpinFront();
+        RotateLeft();
     }
 }
 
 
+
diff --git a/src/main/java/myClass/Main.java b/src/main/java/myClass/Main.java
index 19a9499..1793b39 100644
--- a/src/main/java/myClass/Main.java
+++ b/src/main/java/myClass/Main.java
@@ -6,64 +6,44 @@
 public class Main {
     public static void main(String[] args) {
         Scanner reader = new Scanner(System.in);
-        System.out.print("Введите размер кубика: ");
+        System.out.print("Enter cube size: ");
         int n = reader.nextInt();
 
         Cube cube = new Cube(n);
 
         PrintCube prntC = new PrintCube(n);
         prntC.Print(cube);
-        int k = 0;
-        do {
-            System.out.println("Что будем с ним делать?");
+        while (true) {
+            System.out.println("What'll we do?");
             Scanner look = new Scanner(System.in);
             String l = look.nextLine();
-            if (Objects.equals(l, "Закончить")) {
+            if (Objects.equals(l, "Print")) {
+                PrintCube printC1 = new PrintCube(n);
+                printC1.Print(cube);
+            }
+            if (Objects.equals(l, "Stop")) {
                 System.out.println("Досвидули))0)");
-                k = k - 1000000;
+                break;
             }
-            if (Objects.equals(l, "Влево")) {
+            if (Objects.equals(l, "Left")) {
                 cube.RotateLeft();
-                System.out.println("Кубик повернут влево. Вывести на экран?");
-                Scanner look1 = new Scanner(System.in);
-                String k1 = look1.nextLine();
-                if (Objects.equals(k1, "Да")) {
-                    PrintCube printC1 = new PrintCube(n);
-                    printC1.Print(cube);
-                }
             }
-            if (Objects.equals(l, "Вправо")) {
+            if (Objects.equals(l, "Right")) {
                 cube.RotateRight();
-                System.out.println("Кубик повернут вправо. Вывести на экран?");
-                Scanner look2 = new Scanner(System.in);
-                String k2 = look2.nextLine();
-                if (Objects.equals(k2, "Да")) {
-                    PrintCube printC1 = new PrintCube(n);
-                    printC1.Print(cube);
-                }
             }
-            if (Objects.equals(l, "Вверх")) {
+            if (Objects.equals(l, "Up")) {
                 cube.RotateUp();
-                System.out.println("Кубик повернут вверх. Вывести на экран?");
-                Scanner look3 = new Scanner(System.in);
-                String k3 = look3.nextLine();
-                if (Objects.equals(k3, "Да")) {
-                    PrintCube printC1 = new PrintCube(n);
-                    printC1.Print(cube);
-                }
             }
-            if (Objects.equals(l, "Вниз")) {
+            if (Objects.equals(l, "Down")) {
                 cube.RotateDown();
-                System.out.println("Кубик повернут вниз. Вывести на экран?");
-                Scanner look4 = new Scanner(System.in);
-                String k4 = look4.nextLine();
-                if (Objects.equals(k4, "Да")) {
-                    PrintCube printC1 = new PrintCube(n);
-                    printC1.Print(cube);
-                }
             }
-            ++k;
-        } while (k >= 0);
+            if (Objects.equals(l, "F")) {
+                cube.SpinFront();
+            }
+            if (Objects.equals(l, "R")) {
+                cube.SpinRight();
+            }
+        }
     }
 }
 

From 2967a32e0c684d4f5d9d20a51c8053712dc8a59a Mon Sep 17 00:00:00 2001
From: evgenysobko <jooohn127@gmail.com>
Date: Sat, 3 Mar 2018 02:20:31 +0300
Subject: [PATCH 03/10] Coming soon

---
 src/main/java/myClass/Cube.java | 108 +++++++++++++++++---------------
 src/main/java/myClass/Main.java |  28 ++++++++-
 2 files changed, 85 insertions(+), 51 deletions(-)

diff --git a/src/main/java/myClass/Cube.java b/src/main/java/myClass/Cube.java
index a7f35c1..8282534 100644
--- a/src/main/java/myClass/Cube.java
+++ b/src/main/java/myClass/Cube.java
@@ -24,43 +24,31 @@ public char[][][] Get() {
         return cube;
     }
 
-    int x = 0, y = 0;
-
-    public void RotateOpposite() {
-        for (int i = 0; i < n; ++i) {
-            for (int j = 0; j < n; ++j) {
-                cube[x][i][j] = cube[x][j][i];
-                cube[y][i][j] = cube[y][j][i];
-            }
-        }
-    }
-
-    char[][] help = new char[0][];
-    char[][] help1 = new char[0][];
 
     public void RotateLeft() {
-        y = 5;
-        RotateOpposite();
-        help = cube[1];
-        help1 = cube[5];
+        rotate(1, 0);
+        rotate(0, 4);
+        char[][] help = cube[1];
+        cube[1] = cube[2];
+        cube[2] = cube[3];
+        cube[3] = cube[5];
         cube[5] = help;
-        help = cube[2];
-        cube[1] = help;
-        help = cube[3];
-        cube[2] = help;
-        cube[3] = help1;
+        rotate(5, 5);
+        rotate(5, 5);
     }
 
     public void RotateRight() {
         RotateLeft();
         RotateLeft();
         RotateLeft();
+        rotate(3, 1);
+        rotate(3, 1);
     }
 
     public void RotateUp() {
-        x = 1;
-        y = 3;
-        RotateOpposite();
+        char[][] help;
+        char[][] help1;
+
         help1 = cube[0];
         help = cube[5];
         cube[5] = help1;
@@ -69,6 +57,8 @@ public void RotateUp() {
         help1 = cube[4];
         cube[2] = help1;
         cube[4] = help;
+        rotate(3, 1);
+        rotate(1, 3);
     }
 
     public void RotateDown() {
@@ -77,39 +67,59 @@ public void RotateDown() {
         RotateUp();
     }
 
-    public void SpinFront() {
-        char[][] help = cube[2].clone();
-        for (int i = 0; i < n; ++i) {
-            for (int j = 0; j < n; ++j) {
-                cube[2][i][j] = help[j][n - i - 1];
-            }
-        }
-        char[] h = cube[0][n - 1].clone();
+    public void Spin(int t) {
+        rotate(t, 2);
         char c;
         for (int i = 0; i < n; ++i) {
-            cube[0][n - 1][i] = cube[1][n - i - 1][n - 1];
-        }
-        for (int i = 0; i < n; ++i) {
-            c = cube[3][i][0];
-            cube[3][i][0] = h[i];
-            h[i] = c;
-        }
-        for (int i = 0; i < n; ++i) {
-            c = cube[4][0][i];
-            cube[4][0][i] = h[n - i - 1];
-            h[n - i - 1] = c;
-        }
-        for (int i = 0; i < n; ++i) {
-            cube[1][i][n - 1] = h[n - i - 1];
+            if (t == 1) {
+                c = cube[1][n - i - 1][n - 1];
+                cube[1][n - i - 1][n - 1] = cube[4][0][n - i - 1];
+                cube[4][0][n - i - 1] = cube[3][i][0];
+                cube[3][i][0] = cube[0][n - 1][i];
+                cube[0][n - 1][i] = c;
+            } else {
+                c = cube[1][n - i - 1][n - 1];
+                cube[1][n - i - 1][n - 1] = cube[0][n - 1][i];
+                cube[0][n - 1][i] = cube[3][i][0];
+                cube[3][i][0] = cube[4][0][n - i - 1];
+                cube[4][0][n - i - 1] = c;
+            }
         }
     }
 
-    public void SpinRight() {
+    private void rotate(int t, int pos) {
+        char[][] help = new char[n][n];
+
+        if (t == 1) {
+            for (int i = 0; i < n; ++i) {
+                for (int j = 0; j < n; ++j) {
+                    help[i][j] = cube[pos][n - 1 - j][i];
+                }
+            }
+        } else {
+            for (int i = 0; i < n; ++i) {
+                for (int j = 0; j < n; ++j) {
+                    help[i][j] = cube[pos][j][n - 1 - i];
+                }
+            }
+        }
+        cube[pos] = help;
+    }
+    public void SpinR() {
+        RotateLeft();
+        Spin(1);
         RotateRight();
-        SpinFront();
+        rotate(3, 2);
+        rotate(3, 2);
+    }
+    public void SpinL() {
+        RotateRight();
+        Spin(1);
         RotateLeft();
     }
 }
 
 
 
+
+
diff --git a/src/main/java/myClass/Main.java b/src/main/java/myClass/Main.java
index 1793b39..fb31027 100644
--- a/src/main/java/myClass/Main.java
+++ b/src/main/java/myClass/Main.java
@@ -38,10 +38,34 @@ public static void main(String[] args) {
                 cube.RotateDown();
             }
             if (Objects.equals(l, "F")) {
-                cube.SpinFront();
+                cube.Spin(1);
+            }
+            if (Objects.equals(l, "F'")) {
+                cube.Spin(2);
             }
             if (Objects.equals(l, "R")) {
-                cube.SpinRight();
+                cube.SpinR();
+            }
+            if (Objects.equals(l, "R'")) {
+                cube.SpinR();
+            }
+            if (Objects.equals(l, "L")) {
+                cube.SpinL();
+            }
+            if (Objects.equals(l, "L'")) {
+                cube.RotateLeft();
+                cube.Spin(2);
+                cube.RotateRight();
+            }
+            if (Objects.equals(l, "U")) {
+                cube.RotateDown();
+                cube.Spin(1);
+                cube.RotateUp();
+            }
+            if (Objects.equals(l, "U'")) {
+                cube.RotateUp();
+                cube.Spin(2);
+                cube.RotateDown();
             }
         }
     }

From 83870457f19bb76df141677ba16cbee24f4b9f1a Mon Sep 17 00:00:00 2001
From: evgenysobko <jooohn127@gmail.com>
Date: Sat, 3 Mar 2018 12:42:14 +0300
Subject: [PATCH 04/10] Bang

---
 src/main/java/myClass/Cube.java | 15 +++++++--------
 src/main/java/myClass/Main.java |  4 ++--
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/main/java/myClass/Cube.java b/src/main/java/myClass/Cube.java
index 8282534..b8b40fd 100644
--- a/src/main/java/myClass/Cube.java
+++ b/src/main/java/myClass/Cube.java
@@ -26,23 +26,23 @@ public char[][][] Get() {
 
 
     public void RotateLeft() {
-        rotate(1, 0);
-        rotate(0, 4);
         char[][] help = cube[1];
         cube[1] = cube[2];
         cube[2] = cube[3];
         cube[3] = cube[5];
         cube[5] = help;
-        rotate(5, 5);
-        rotate(5, 5);
+        rotate(1, 0);
+        rotate(0, 4);
+        rotate(1, 5);
+        rotate(1, 5);
+        rotate(1, 3);
+        rotate(1, 3);
     }
 
     public void RotateRight() {
         RotateLeft();
         RotateLeft();
         RotateLeft();
-        rotate(3, 1);
-        rotate(3, 1);
     }
 
     public void RotateUp() {
@@ -109,9 +109,8 @@ public void SpinR() {
         RotateLeft();
         Spin(1);
         RotateRight();
-        rotate(3, 2);
-        rotate(3, 2);
     }
+
     public void SpinL() {
         RotateRight();
         Spin(1);
diff --git a/src/main/java/myClass/Main.java b/src/main/java/myClass/Main.java
index fb31027..c31cbb1 100644
--- a/src/main/java/myClass/Main.java
+++ b/src/main/java/myClass/Main.java
@@ -63,9 +63,9 @@ public static void main(String[] args) {
                 cube.RotateUp();
             }
             if (Objects.equals(l, "U'")) {
-                cube.RotateUp();
-                cube.Spin(2);
                 cube.RotateDown();
+                cube.Spin(2);
+                cube.RotateUp();
             }
         }
     }

From 11dc4072d0c22644683031390a47e1adee3aaf88 Mon Sep 17 00:00:00 2001
From: evgenysobko <jooohn127@gmail.com>
Date: Sun, 4 Mar 2018 02:10:23 +0300
Subject: [PATCH 05/10] Add random cube

---
 src/main/java/myClass/Cube.java | 65 ++++++++++++++++++++++++++++-----
 src/main/java/myClass/Main.java | 21 +++++++----
 2 files changed, 69 insertions(+), 17 deletions(-)

diff --git a/src/main/java/myClass/Cube.java b/src/main/java/myClass/Cube.java
index b8b40fd..1bc64fc 100644
--- a/src/main/java/myClass/Cube.java
+++ b/src/main/java/myClass/Cube.java
@@ -1,10 +1,10 @@
 package myClass;
 
 import java.util.Arrays;
+import java.util.Random;
 
 public class Cube {
     private char[][][] cube;
-    private char[][] arr;
     private int n;
 
     char[] symbols = {'W', 'R', 'B', 'O', 'Y', 'G'};
@@ -105,16 +105,61 @@ private void rotate(int t, int pos) {
         }
         cube[pos] = help;
     }
-    public void SpinR() {
-        RotateLeft();
-        Spin(1);
-        RotateRight();
-    }
 
-    public void SpinL() {
-        RotateRight();
-        Spin(1);
-        RotateLeft();
+    public void Random() {
+        String[] array = new String[]{"F", "F'", "R", "R'", "L", "L'", "U", "U'", "Left", "Right", "Up", "Down"};
+        for (int i = 0; i < 100; ++i) {
+            Random random = new Random();
+            int number = random.nextInt(11);
+            if (number == 0) {
+                Spin(1);
+            }
+            if (number == 1) {
+                Spin(2);
+            }
+            if (number == 2) {
+                RotateLeft();
+                Spin(1);
+                RotateRight();
+            }
+            if (number == 3) {
+                RotateLeft();
+                Spin(2);
+                RotateRight();
+            }
+            if (number == 4) {
+                RotateRight();
+                Spin(1);
+                RotateLeft();
+            }
+            if (number == 5) {
+                RotateRight();
+                Spin(2);
+                RotateLeft();
+            }
+            if (number == 6) {
+                RotateDown();
+                Spin(1);
+                RotateUp();
+            }
+            if (number == 7) {
+                RotateDown();
+                Spin(2);
+                RotateUp();
+            }
+            if (number == 8) {
+                RotateLeft();
+            }
+            if (number == 9) {
+                RotateRight();
+            }
+            if (number == 10) {
+                RotateUp();
+            }
+            if (number == 11) {
+                RotateDown();
+            }
+        }
     }
 }
 
diff --git a/src/main/java/myClass/Main.java b/src/main/java/myClass/Main.java
index c31cbb1..cd33be2 100644
--- a/src/main/java/myClass/Main.java
+++ b/src/main/java/myClass/Main.java
@@ -11,8 +11,6 @@ public static void main(String[] args) {
 
         Cube cube = new Cube(n);
 
-        PrintCube prntC = new PrintCube(n);
-        prntC.Print(cube);
         while (true) {
             System.out.println("What'll we do?");
             Scanner look = new Scanner(System.in);
@@ -44,18 +42,24 @@ public static void main(String[] args) {
                 cube.Spin(2);
             }
             if (Objects.equals(l, "R")) {
-                cube.SpinR();
+                cube.RotateLeft();
+                cube.Spin(1);
+                cube.RotateRight();
             }
             if (Objects.equals(l, "R'")) {
-                cube.SpinR();
+                cube.RotateLeft();
+                cube.Spin(2);
+                cube.RotateRight();
             }
             if (Objects.equals(l, "L")) {
-                cube.SpinL();
+                cube.RotateRight();
+                cube.Spin(1);
+                cube.RotateLeft();
             }
             if (Objects.equals(l, "L'")) {
-                cube.RotateLeft();
-                cube.Spin(2);
                 cube.RotateRight();
+                cube.Spin(2);
+                cube.RotateLeft();
             }
             if (Objects.equals(l, "U")) {
                 cube.RotateDown();
@@ -67,6 +71,9 @@ public static void main(String[] args) {
                 cube.Spin(2);
                 cube.RotateUp();
             }
+            if (Objects.equals(l, "Random cube")) {
+                cube.Random();
+            }
         }
     }
 }

From 3eee69c19e12915f9a66c8844124b27900da39a1 Mon Sep 17 00:00:00 2001
From: evgenysobko <jooohn127@gmail.com>
Date: Sun, 4 Mar 2018 13:52:47 +0300
Subject: [PATCH 06/10] Minor

---
 src/main/java/myClass/Cube.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/main/java/myClass/Cube.java b/src/main/java/myClass/Cube.java
index 1bc64fc..2997beb 100644
--- a/src/main/java/myClass/Cube.java
+++ b/src/main/java/myClass/Cube.java
@@ -107,7 +107,6 @@ private void rotate(int t, int pos) {
     }
 
     public void Random() {
-        String[] array = new String[]{"F", "F'", "R", "R'", "L", "L'", "U", "U'", "Left", "Right", "Up", "Down"};
         for (int i = 0; i < 100; ++i) {
             Random random = new Random();
             int number = random.nextInt(11);

From ca299c80752d19df3f23160dc91fd056e81491be Mon Sep 17 00:00:00 2001
From: evgenysobko <jooohn127@gmail.com>
Date: Sun, 4 Mar 2018 17:00:52 +0300
Subject: [PATCH 07/10] Minor

---
 src/main/java/myClass/Cube.java | 14 ++++++++++++--
 src/main/java/myClass/Main.java | 12 +++++++++++-
 2 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/src/main/java/myClass/Cube.java b/src/main/java/myClass/Cube.java
index 2997beb..10c7a4f 100644
--- a/src/main/java/myClass/Cube.java
+++ b/src/main/java/myClass/Cube.java
@@ -107,9 +107,9 @@ private void rotate(int t, int pos) {
     }
 
     public void Random() {
-        for (int i = 0; i < 100; ++i) {
+        for (int i = 0; i < 20; ++i) {
             Random random = new Random();
-            int number = random.nextInt(11);
+            int number = random.nextInt(13);
             if (number == 0) {
                 Spin(1);
             }
@@ -158,6 +158,16 @@ public void Random() {
             if (number == 11) {
                 RotateDown();
             }
+            if (number == 12) {
+                RotateUp();
+                Spin(1);
+                RotateDown();
+            }
+            if (number == 13) {
+                RotateUp();
+                Spin(2);
+                RotateDown();
+            }
         }
     }
 }
diff --git a/src/main/java/myClass/Main.java b/src/main/java/myClass/Main.java
index cd33be2..3251efa 100644
--- a/src/main/java/myClass/Main.java
+++ b/src/main/java/myClass/Main.java
@@ -71,7 +71,17 @@ public static void main(String[] args) {
                 cube.Spin(2);
                 cube.RotateUp();
             }
-            if (Objects.equals(l, "Random cube")) {
+            if (Objects.equals(l, "D")) {
+                cube.RotateUp();
+                cube.Spin(1);
+                cube.RotateDown();
+            }
+            if (Objects.equals(l, "D'")) {
+                cube.RotateUp();
+                cube.Spin(2);
+                cube.RotateDown();
+            }
+            if (Objects.equals(l, "Random")) {
                 cube.Random();
             }
         }

From 6a25a6cef9bc6c239057f1dc0e4377a8839110a5 Mon Sep 17 00:00:00 2001
From: evgenysobko <jooohn127@gmail.com>
Date: Wed, 7 Mar 2018 00:58:50 +0300
Subject: [PATCH 08/10] Add easy tests

---
 src/main/java/myClass/Cube.java               |  8 +--
 src/main/java/myClass/Main.java               | 32 ++++++------
 .../java/ru/spbstu/kspt/task1/MainTest.java   | 49 ++++++++++++++++++-
 3 files changed, 67 insertions(+), 22 deletions(-)

diff --git a/src/main/java/myClass/Cube.java b/src/main/java/myClass/Cube.java
index 10c7a4f..e927266 100644
--- a/src/main/java/myClass/Cube.java
+++ b/src/main/java/myClass/Cube.java
@@ -4,12 +4,12 @@
 import java.util.Random;
 
 public class Cube {
-    private char[][][] cube;
-    private int n;
+    public char[][][] cube;
+    public int n;
 
     char[] symbols = {'W', 'R', 'B', 'O', 'Y', 'G'};
 
-    Cube(int n) {
+    public Cube(int n) {
         this.n = n;
         this.cube = new char[6][n][n];
 
@@ -87,7 +87,7 @@ public void Spin(int t) {
         }
     }
 
-    private void rotate(int t, int pos) {
+    public void rotate(int t, int pos) {
         char[][] help = new char[n][n];
 
         if (t == 1) {
diff --git a/src/main/java/myClass/Main.java b/src/main/java/myClass/Main.java
index 3251efa..4ebe06b 100644
--- a/src/main/java/myClass/Main.java
+++ b/src/main/java/myClass/Main.java
@@ -19,69 +19,69 @@ public static void main(String[] args) {
                 PrintCube printC1 = new PrintCube(n);
                 printC1.Print(cube);
             }
-            if (Objects.equals(l, "Stop")) {
+            else if (Objects.equals(l, "Stop")) {
                 System.out.println("Досвидули))0)");
                 break;
             }
-            if (Objects.equals(l, "Left")) {
+            else if (Objects.equals(l, "Left")) {
                 cube.RotateLeft();
             }
-            if (Objects.equals(l, "Right")) {
+            else if (Objects.equals(l, "Right")) {
                 cube.RotateRight();
             }
-            if (Objects.equals(l, "Up")) {
+            else if (Objects.equals(l, "Up")) {
                 cube.RotateUp();
             }
-            if (Objects.equals(l, "Down")) {
+            else if (Objects.equals(l, "Down")) {
                 cube.RotateDown();
             }
-            if (Objects.equals(l, "F")) {
+            else if (Objects.equals(l, "F")) {
                 cube.Spin(1);
             }
-            if (Objects.equals(l, "F'")) {
+            else if (Objects.equals(l, "F'")) {
                 cube.Spin(2);
             }
-            if (Objects.equals(l, "R")) {
+            else if (Objects.equals(l, "R")) {
                 cube.RotateLeft();
                 cube.Spin(1);
                 cube.RotateRight();
             }
-            if (Objects.equals(l, "R'")) {
+            else if (Objects.equals(l, "R'")) {
                 cube.RotateLeft();
                 cube.Spin(2);
                 cube.RotateRight();
             }
-            if (Objects.equals(l, "L")) {
+            else if (Objects.equals(l, "L")) {
                 cube.RotateRight();
                 cube.Spin(1);
                 cube.RotateLeft();
             }
-            if (Objects.equals(l, "L'")) {
+            else if (Objects.equals(l, "L'")) {
                 cube.RotateRight();
                 cube.Spin(2);
                 cube.RotateLeft();
             }
-            if (Objects.equals(l, "U")) {
+            else if (Objects.equals(l, "U")) {
                 cube.RotateDown();
                 cube.Spin(1);
                 cube.RotateUp();
             }
-            if (Objects.equals(l, "U'")) {
+            else if (Objects.equals(l, "U'")) {
                 cube.RotateDown();
                 cube.Spin(2);
                 cube.RotateUp();
             }
-            if (Objects.equals(l, "D")) {
+            else if (Objects.equals(l, "D")) {
                 cube.RotateUp();
                 cube.Spin(1);
                 cube.RotateDown();
             }
-            if (Objects.equals(l, "D'")) {
+            else if (Objects.equals(l, "D'")) {
                 cube.RotateUp();
                 cube.Spin(2);
                 cube.RotateDown();
             }
-            if (Objects.equals(l, "Random")) {
+            else if (Objects.equals(l, "Random")) {
                 cube.Random();
             }
         }
diff --git a/src/test/java/ru/spbstu/kspt/task1/MainTest.java b/src/test/java/ru/spbstu/kspt/task1/MainTest.java
index 21d5f4a..75e7014 100644
--- a/src/test/java/ru/spbstu/kspt/task1/MainTest.java
+++ b/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 myClass.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]);
+    }
+}

From 2ed1efdc38814890db9448b7e1dfecd876cd6e9c Mon Sep 17 00:00:00 2001
From: evgenysobko <jooohn127@gmail.com>
Date: Sun, 11 Mar 2018 22:13:55 +0300
Subject: [PATCH 09/10] =?UTF-8?q?=C2=AF\=5F(=E3=83=84)=5F/=C2=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/myClass/Cube.java               | 178 ------------------
 src/main/java/myClass/Main.java               |  90 ---------
 src/main/java/myRubiksCube/Cube.java          | 138 ++++++++++++++
 .../CubePrinter.java}                         |   6 +-
 src/main/java/myRubiksCube/Main.java          | 110 +++++++++++
 .../java/ru/spbstu/kspt/task1/MainTest.java   |  10 +-
 6 files changed, 256 insertions(+), 276 deletions(-)
 delete mode 100644 src/main/java/myClass/Cube.java
 delete mode 100644 src/main/java/myClass/Main.java
 create mode 100644 src/main/java/myRubiksCube/Cube.java
 rename src/main/java/{myClass/PrintCube.java => myRubiksCube/CubePrinter.java} (95%)
 create mode 100644 src/main/java/myRubiksCube/Main.java

diff --git a/src/main/java/myClass/Cube.java b/src/main/java/myClass/Cube.java
deleted file mode 100644
index e927266..0000000
--- a/src/main/java/myClass/Cube.java
+++ /dev/null
@@ -1,178 +0,0 @@
-package myClass;
-
-import java.util.Arrays;
-import java.util.Random;
-
-public class Cube {
-    public char[][][] cube;
-    public int n;
-
-    char[] symbols = {'W', 'R', 'B', 'O', 'Y', 'G'};
-
-    public Cube(int n) {
-        this.n = n;
-        this.cube = new char[6][n][n];
-
-        for (int i = 0; i < 6; ++i) {
-            for (int j = 0; j < n; ++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 t) {
-        rotate(t, 2);
-        char c;
-        for (int i = 0; i < n; ++i) {
-            if (t == 1) {
-                c = cube[1][n - i - 1][n - 1];
-                cube[1][n - i - 1][n - 1] = cube[4][0][n - i - 1];
-                cube[4][0][n - i - 1] = cube[3][i][0];
-                cube[3][i][0] = cube[0][n - 1][i];
-                cube[0][n - 1][i] = c;
-            } else {
-                c = cube[1][n - i - 1][n - 1];
-                cube[1][n - i - 1][n - 1] = cube[0][n - 1][i];
-                cube[0][n - 1][i] = cube[3][i][0];
-                cube[3][i][0] = cube[4][0][n - i - 1];
-                cube[4][0][n - i - 1] = c;
-            }
-        }
-    }
-
-    public void rotate(int t, int pos) {
-        char[][] help = new char[n][n];
-
-        if (t == 1) {
-            for (int i = 0; i < n; ++i) {
-                for (int j = 0; j < n; ++j) {
-                    help[i][j] = cube[pos][n - 1 - j][i];
-                }
-            }
-        } else {
-            for (int i = 0; i < n; ++i) {
-                for (int j = 0; j < n; ++j) {
-                    help[i][j] = cube[pos][j][n - 1 - i];
-                }
-            }
-        }
-        cube[pos] = help;
-    }
-
-    public void Random() {
-        for (int i = 0; i < 20; ++i) {
-            Random random = new Random();
-            int number = random.nextInt(13);
-            if (number == 0) {
-                Spin(1);
-            }
-            if (number == 1) {
-                Spin(2);
-            }
-            if (number == 2) {
-                RotateLeft();
-                Spin(1);
-                RotateRight();
-            }
-            if (number == 3) {
-                RotateLeft();
-                Spin(2);
-                RotateRight();
-            }
-            if (number == 4) {
-                RotateRight();
-                Spin(1);
-                RotateLeft();
-            }
-            if (number == 5) {
-                RotateRight();
-                Spin(2);
-                RotateLeft();
-            }
-            if (number == 6) {
-                RotateDown();
-                Spin(1);
-                RotateUp();
-            }
-            if (number == 7) {
-                RotateDown();
-                Spin(2);
-                RotateUp();
-            }
-            if (number == 8) {
-                RotateLeft();
-            }
-            if (number == 9) {
-                RotateRight();
-            }
-            if (number == 10) {
-                RotateUp();
-            }
-            if (number == 11) {
-                RotateDown();
-            }
-            if (number == 12) {
-                RotateUp();
-                Spin(1);
-                RotateDown();
-            }
-            if (number == 13) {
-                RotateUp();
-                Spin(2);
-                RotateDown();
-            }
-        }
-    }
-}
-
-
-
-
-
diff --git a/src/main/java/myClass/Main.java b/src/main/java/myClass/Main.java
deleted file mode 100644
index 4ebe06b..0000000
--- a/src/main/java/myClass/Main.java
+++ /dev/null
@@ -1,90 +0,0 @@
-package myClass;
-
-import java.util.Objects;
-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);
-
-        while (true) {
-            System.out.println("What'll we do?");
-            Scanner look = new Scanner(System.in);
-            String l = look.nextLine();
-            if (Objects.equals(l, "Print")) {
-                PrintCube printC1 = new PrintCube(n);
-                printC1.Print(cube);
-            }
-            else if (Objects.equals(l, "Stop")) {
-                System.out.println("Досвидули))0)");
-                break;
-            }
-            else if (Objects.equals(l, "Left")) {
-                cube.RotateLeft();
-            }
-            else if (Objects.equals(l, "Right")) {
-                cube.RotateRight();
-            }
-            else if (Objects.equals(l, "Up")) {
-                cube.RotateUp();
-            }
-            else if (Objects.equals(l, "Down")) {
-                cube.RotateDown();
-            }
-            else if (Objects.equals(l, "F")) {
-                cube.Spin(1);
-            }
-            else if (Objects.equals(l, "F'")) {
-                cube.Spin(2);
-            }
-            else if (Objects.equals(l, "R")) {
-                cube.RotateLeft();
-                cube.Spin(1);
-                cube.RotateRight();
-            }
-            else if (Objects.equals(l, "R'")) {
-                cube.RotateLeft();
-                cube.Spin(2);
-                cube.RotateRight();
-            }
-            else if (Objects.equals(l, "L")) {
-                cube.RotateRight();
-                cube.Spin(1);
-                cube.RotateLeft();
-            }
-            else if (Objects.equals(l, "L'")) {
-                cube.RotateRight();
-                cube.Spin(2);
-                cube.RotateLeft();
-            }
-            else if (Objects.equals(l, "U")) {
-                cube.RotateDown();
-                cube.Spin(1);
-                cube.RotateUp();
-            }
-            else if (Objects.equals(l, "U'")) {
-                cube.RotateDown();
-                cube.Spin(2);
-                cube.RotateUp();
-            }
-            else if (Objects.equals(l, "D")) {
-                cube.RotateUp();
-                cube.Spin(1);
-                cube.RotateDown();
-            }
-            else if (Objects.equals(l, "D'")) {
-                cube.RotateUp();
-                cube.Spin(2);
-                cube.RotateDown();
-            }
-            else if (Objects.equals(l, "Random")) {
-                cube.Random();
-            }
-        }
-    }
-}
-
diff --git a/src/main/java/myRubiksCube/Cube.java b/src/main/java/myRubiksCube/Cube.java
new file mode 100644
index 0000000..693e05c
--- /dev/null
+++ b/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 numCube) {
+        rotate(numCube, 2);
+        char c;
+        for (int i = 0; i < size; ++i) {
+            if (numCube == 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;
+            }
+        }
+    }
+}
+
+
+
+
+
diff --git a/src/main/java/myClass/PrintCube.java b/src/main/java/myRubiksCube/CubePrinter.java
similarity index 95%
rename from src/main/java/myClass/PrintCube.java
rename to src/main/java/myRubiksCube/CubePrinter.java
index 94eaf26..8cc00ee 100644
--- a/src/main/java/myClass/PrintCube.java
+++ b/src/main/java/myRubiksCube/CubePrinter.java
@@ -1,11 +1,11 @@
-package myClass;
+package myRubiksCube;
 
-public class PrintCube {
+public class CubePrinter {
 
     private char[][] arr;
     private int n;
 
-    PrintCube(int n) {
+    CubePrinter(int n) {
         this.arr = new char[n * 8 + 1][n * 18 + 1];
         this.n = n;
 
diff --git a/src/main/java/myRubiksCube/Main.java b/src/main/java/myRubiksCube/Main.java
new file mode 100644
index 0000000..a31c377
--- /dev/null
+++ b/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;
+                }
+            }
+        }
+    }
+}
+
diff --git a/src/test/java/ru/spbstu/kspt/task1/MainTest.java b/src/test/java/ru/spbstu/kspt/task1/MainTest.java
index 75e7014..d5d7e07 100644
--- a/src/test/java/ru/spbstu/kspt/task1/MainTest.java
+++ b/src/test/java/ru/spbstu/kspt/task1/MainTest.java
@@ -1,6 +1,6 @@
 package ru.spbstu.kspt.task1;
 
-import myClass.Cube;
+import myRubiksCube.Cube;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.junit.jupiter.api.Test;
@@ -26,7 +26,7 @@ class testCube {
 
     @Test
     public void rotateUp() {
-        result.RotateUp();
+        result.rotateUp();
         assertArrayEquals(result.cube[0], actual.cube[2]);
         assertArrayEquals(result.cube[2], actual.cube[4]);
         assertArrayEquals(result.cube[4], actual.cube[5]);
@@ -35,7 +35,7 @@ public void rotateUp() {
 
     @Test
     void rotateRight() {
-        result.RotateRight();
+        result.rotateRight();
         assertArrayEquals(result.cube[1], actual.cube[5]);
         assertArrayEquals(result.cube[2], actual.cube[1]);
         assertArrayEquals(result.cube[3], actual.cube[2]);
@@ -44,7 +44,7 @@ void rotateRight() {
 
     @Test
     public void rotateDown() {
-        result.RotateDown();
+        result.rotateDown();
         assertArrayEquals(result.cube[0], actual.cube[5]);
         assertArrayEquals(result.cube[2], actual.cube[0]);
         assertArrayEquals(result.cube[4], actual.cube[2]);
@@ -53,7 +53,7 @@ public void rotateDown() {
 
     @Test
     void rotateLeft() {
-        result.RotateLeft();
+        result.rotateLeft();
         assertArrayEquals(result.cube[5], actual.cube[1]);
         assertArrayEquals(result.cube[1], actual.cube[2]);
         assertArrayEquals(result.cube[2], actual.cube[3]);

From fe61fc07781fe441a804bb06ecb85606ef5cdc59 Mon Sep 17 00:00:00 2001
From: evgenysobko <jooohn127@gmail.com>
Date: Tue, 13 Mar 2018 15:50:39 +0300
Subject: [PATCH 10/10] =?UTF-8?q?=C2=AF\=5F(=E3=83=84)=5F/=C2=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/myRubiksCube/Cube.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/java/myRubiksCube/Cube.java b/src/main/java/myRubiksCube/Cube.java
index 693e05c..e50b3f6 100644
--- a/src/main/java/myRubiksCube/Cube.java
+++ b/src/main/java/myRubiksCube/Cube.java
@@ -69,11 +69,11 @@ public void rotateDown() {
         rotateUp();
     }
 
-    public void spin(int numCube) {
-        rotate(numCube, 2);
+    public void spin(int direction) {
+        rotate(direction, 2);
         char c;
         for (int i = 0; i < size; ++i) {
-            if (numCube == 1) {
+            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];