Metadata-Version: 2.1
Name: super-rubik-cube
Version: 1.0.2
Summary: Library for simulating rubik's cubes of different sizes (N x N), and for solving 2 x 2 and 3 x 3 cubes with kociemba algorithm.
Author: Ilmi28
Author-email: <ilmialiev28@gmail.com>
Keywords: python,rubik,cube,solve,3x3,2x2,rubik's cube,pocket cube,NxN,kociemba,supercube
Description-Content-Type: text/markdown
License-File: LICENSE

# Description
Library for Rubik's Cube manipulation. Creator and customizer for cubes of any size, and solver for 2x2 and 3x3 cubes (Herbert Kociemba's algorithms)

# Usage
> Note: 2D number cube grid looks a bit weird in output examples, but in console everything looks fine.
## Creating instance of cube
You can create Rubik's cube, Pocket cube and NxN cube, where N means positive number.
```
import supercube

rubiks_cube = supercube.RubiksCube() # creates 3X3 cube
pocket_cube = supercube.PocketCube() # creates 2x2 cube
n_cube = supercube.NCube(7) # creates NxN cube (in this case N is 7)

rubiks_cube.show()
rubiks_cube.show(colors=True)

pocket_cube.show()
pocket_cube.show(colors=True)

n_cube.show()
n_cube.show(colors=True)
```
Output:
```
             ┌────────────┐
             │  1   2   3 │
             │  4   5   6 │
             │  7   8   9 │
┌────────────┼────────────┼────────────┬────────────┐
│ 10  11  12 │ 19  20  21 │ 28  29  30 │ 37  38  39 │ 
│ 13  14  15 │ 22  23  24 │ 31  32  33 │ 40  41  42 │ 
│ 16  17  18 │ 25  26  27 │ 34  35  36 │ 43  44  45 │ 
└────────────┼────────────┼────────────┴────────────┘
             │ 46  47  48 │
             │ 49  50  51 │
             │ 52  53  54 │
             └────────────┘
⬛⬛⬛ 🟪🟪🟪
⬛⬛⬛ 🟪🟪🟪
⬛⬛⬛ 🟪🟪🟪

🟧🟧🟧 🟩🟩🟩 🟥🟥🟥 🟦🟦🟦 
🟧🟧🟧 🟩🟩🟩 🟥🟥🟥 🟦🟦🟦 
🟧🟧🟧 🟩🟩🟩 🟥🟥🟥 🟦🟦🟦 

⬛⬛⬛ 🟨🟨🟨
⬛⬛⬛ 🟨🟨🟨
⬛⬛⬛ 🟨🟨🟨


         ┌────────┐
         │  1   2 │
         │  3   4 │
┌────────┼────────┼────────┬────────┐
│  5   6 │  9  10 │ 13  14 │ 17  18 │ 
│  7   8 │ 11  12 │ 15  16 │ 19  20 │ 
└────────┼────────┼────────┴────────┘
         │ 21  22 │
         │ 23  24 │
         └────────┘
⬛⬛ 🟪🟪
⬛⬛ 🟪🟪

🟧🟧 🟩🟩 🟥🟥 🟦🟦 
🟧🟧 🟩🟩 🟥🟥 🟦🟦 

⬛⬛ 🟨🟨
⬛⬛ 🟨🟨


                                    ┌───────────────────────────────────┐
                                    │   1    2    3    4    5    6    7 │
                                    │   8    9   10   11   12   13   14 │
                                    │  15   16   17   18   19   20   21 │
                                    │  22   23   24   25   26   27   28 │
                                    │  29   30   31   32   33   34   35 │
                                    │  36   37   38   39   40   41   42 │
                                    │  43   44   45   46   47   48   49 │
┌───────────────────────────────────┼───────────────────────────────────┼───────────────────────────────────┬───────────────────────────────────┐
│  50   51   52   53   54   55   56 │  99  100  101  102  103  104  105 │ 148  149  150  151  152  153  154 │ 197  198  199  200  201  202  203 │ 
│  57   58   59   60   61   62   63 │ 106  107  108  109  110  111  112 │ 155  156  157  158  159  160  161 │ 204  205  206  207  208  209  210 │ 
│  64   65   66   67   68   69   70 │ 113  114  115  116  117  118  119 │ 162  163  164  165  166  167  168 │ 211  212  213  214  215  216  217 │ 
│  71   72   73   74   75   76   77 │ 120  121  122  123  124  125  126 │ 169  170  171  172  173  174  175 │ 218  219  220  221  222  223  224 │ 
│  78   79   80   81   82   83   84 │ 127  128  129  130  131  132  133 │ 176  177  178  179  180  181  182 │ 225  226  227  228  229  230  231 │ 
│  85   86   87   88   89   90   91 │ 134  135  136  137  138  139  140 │ 183  184  185  186  187  188  189 │ 232  233  234  235  236  237  238 │ 
│  92   93   94   95   96   97   98 │ 141  142  143  144  145  146  147 │ 190  191  192  193  194  195  196 │ 239  240  241  242  243  244  245 │ 
└───────────────────────────────────┼───────────────────────────────────┼───────────────────────────────────┴───────────────────────────────────┘
                                    │ 246  247  248  249  250  251  252 │
                                    │ 253  254  255  256  257  258  259 │
                                    │ 260  261  262  263  264  265  266 │
                                    │ 267  268  269  270  271  272  273 │
                                    │ 274  275  276  277  278  279  280 │
                                    │ 281  282  283  284  285  286  287 │
                                    │ 288  289  290  291  292  293  294 │
                                    └───────────────────────────────────┘
⬛⬛⬛⬛⬛⬛⬛ 🟪🟪🟪🟪🟪🟪🟪
⬛⬛⬛⬛⬛⬛⬛ 🟪🟪🟪🟪🟪🟪🟪
⬛⬛⬛⬛⬛⬛⬛ 🟪🟪🟪🟪🟪🟪🟪
⬛⬛⬛⬛⬛⬛⬛ 🟪🟪🟪🟪🟪🟪🟪
⬛⬛⬛⬛⬛⬛⬛ 🟪🟪🟪🟪🟪🟪🟪
⬛⬛⬛⬛⬛⬛⬛ 🟪🟪🟪🟪🟪🟪🟪
⬛⬛⬛⬛⬛⬛⬛ 🟪🟪🟪🟪🟪🟪🟪

🟧🟧🟧🟧🟧🟧🟧 🟩🟩🟩🟩🟩🟩🟩 🟥🟥🟥🟥🟥🟥🟥 🟦🟦🟦🟦🟦🟦🟦 
🟧🟧🟧🟧🟧🟧🟧 🟩🟩🟩🟩🟩🟩🟩 🟥🟥🟥🟥🟥🟥🟥 🟦🟦🟦🟦🟦🟦🟦 
🟧🟧🟧🟧🟧🟧🟧 🟩🟩🟩🟩🟩🟩🟩 🟥🟥🟥🟥🟥🟥🟥 🟦🟦🟦🟦🟦🟦🟦 
🟧🟧🟧🟧🟧🟧🟧 🟩🟩🟩🟩🟩🟩🟩 🟥🟥🟥🟥🟥🟥🟥 🟦🟦🟦🟦🟦🟦🟦 
🟧🟧🟧🟧🟧🟧🟧 🟩🟩🟩🟩🟩🟩🟩 🟥🟥🟥🟥🟥🟥🟥 🟦🟦🟦🟦🟦🟦🟦 
🟧🟧🟧🟧🟧🟧🟧 🟩🟩🟩🟩🟩🟩🟩 🟥🟥🟥🟥🟥🟥🟥 🟦🟦🟦🟦🟦🟦🟦 
🟧🟧🟧🟧🟧🟧🟧 🟩🟩🟩🟩🟩🟩🟩 🟥🟥🟥🟥🟥🟥🟥 🟦🟦🟦🟦🟦🟦🟦 

⬛⬛⬛⬛⬛⬛⬛ 🟨🟨🟨🟨🟨🟨🟨
⬛⬛⬛⬛⬛⬛⬛ 🟨🟨🟨🟨🟨🟨🟨
⬛⬛⬛⬛⬛⬛⬛ 🟨🟨🟨🟨🟨🟨🟨
⬛⬛⬛⬛⬛⬛⬛ 🟨🟨🟨🟨🟨🟨🟨
⬛⬛⬛⬛⬛⬛⬛ 🟨🟨🟨🟨🟨🟨🟨
⬛⬛⬛⬛⬛⬛⬛ 🟨🟨🟨🟨🟨🟨🟨
⬛⬛⬛⬛⬛⬛⬛ 🟨🟨🟨🟨🟨🟨🟨
```
You can also define your own state (number of elements of specific colors is not limited)
```
pocket_cube.define_state("RYWRRWOBGWOBWRRGGGGGGGGG")
pocket_cube.show()
pocket_cube.show(colors=True)
```
Output:
```
         ┌────────┐
         │ 13  21 │
         │  1  14 │
┌────────┼────────┼────────┬────────┐
│ 15   2 │  9   3 │  4  16 │ 11  12 │ 
│  5  17 │  6  18 │ 16  10 │ 12  12 │ 
└────────┼────────┼────────┴────────┘
         │ 12  12 │
         │ 12  12 │
         └────────┘
⬛⬛ 🟥🟨
⬛⬛ 🟪🟥

🟥🟪 🟩🟪 🟪🟥 🟩🟩 
🟧🟦 🟧🟦 🟥🟩 🟩🟩 

⬛⬛ 🟩🟩
⬛⬛ 🟩🟩

```
You can get your current state using method `get_state`, the return will be 3d array.
```
print(rubiks_cube.get_state())
```
Output:
```
[[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]], [[28, 29, 30], [31, 32, 33], [34, 35, 36]], [[37, 38, 39], [40, 41, 42], [43, 44, 45]], [[46, 47, 48], [49, 50, 51], [52, 53, 54]]]
```
## Moves
### Basic moves
You can move cube using method `move`
```
rubiks_cube.move("L B' F2 U R2 F L2 U B2 R2 F D L' D L' D2 R' U' B2 F' L R'")
rubiks_cube.show()
```
Output:
```
             ┌────────────┐
             │ 30   4  36 │
             │ 31   5  38 │
             │ 27  49  10 │
┌────────────┼────────────┼────────────┬────────────┐
│  3  24  48 │ 34  17   1 │ 39   2  54 │ 43  11  37 │ 
│ 26  14  40 │ 33  23  53 │ 44  32  51 │ 35  41  47 │ 
│ 46  22  52 │ 45  42   7 │ 19   8   9 │ 28   6  25 │ 
└────────────┼────────────┼────────────┴────────────┘
             │ 16  13  12 │
             │ 15  50  20 │
             │ 18  29  21 │
             └────────────┘

```
### Advanced moves
Advanced moves are also supported. For each basic move there are:

* wide moves (e.g. Fw, 4Fw', 5Fw2) - for wide move default value is 2 (when there is no number before move)
* specific layer moves (e.g 3U, 5D')

```
n_cube.move("3Bw 3R2 D' 3Bw 2Rw' 3Fw R2 3Rw' 2B' 3R 2Fw2 3U2 L' 2Dw B")
n_cube.show()

```
Output:
```
                                    ┌───────────────────────────────────┐
                                    │  43   36  176  267  260  191  190 │
                                    │ 140  160  167  174  283  188  195 │
                                    │  54  279  278  277  276   40  101 │
                                    │ 126   23   24   25  271   72  102 │
                                    │  52   89   82   75   68   16  231 │
                                    │  51  107   65  158  157  156  155 │
                                    │  50  106   64  151  150  149  148 │
┌───────────────────────────────────┼───────────────────────────────────┼───────────────────────────────────┬───────────────────────────────────┐
│  99  183   29  169   15    8    1 │ 203   63  217   28   35   42   49 │ 105  112   78   46   45  287  147 │ 252  259   96   95  133   55   56 │ 
│  93  184  285  170  110  237  244 │ 289   62   30   27   34   41   48 │ 104  111   79   39   38  286  146 │ 251  258   59  125   61  139  281 │ 
│ 290  181   31   26   33  118  119 │ 162  132  117  124  131  138  145 │ 250   12  264   67  180  177   47 │ 103  185  215  222  229  236  243 │ 
│ 291   60   32   74   81   88  144 │ 249  223  116  123  130  137  193 │ 273  272  171  172  269  284   71 │ 224  186  214  221  228  235  242 │ 
│ 292  187   80  173  166  159  152 │  21  216  115  122  129  136  192 │ 266  265  178  179  262  208  143 │ 248  255  213  220  227  234  241 │ 
│ 293   58  257  207  206  205  153 │  14   13   87   11  275  282  142 │ 247  209  114  121  128  135   44 │ 100   86  212  219  226  233  240 │ 
│ 288   57  201  200  199  198  294 │ 196  189   94  175  168  161  154 │   7  202  113  120  127  134  141 │ 246  253  280   22  225   85   92 │ 
└───────────────────────────────────┼───────────────────────────────────┼───────────────────────────────────┴───────────────────────────────────┘
                                    │ 239  232  274  218  211  204  197 │
                                    │   6  254   20  256  163    9    2 │
                                    │   5  261   19  263  164   69   70 │
                                    │   4  268   18  270  165   76   77 │
                                    │   3   10   17   73   66   83   84 │
                                    │ 210   37  230  109  108   90   91 │
                                    │ 245  238  182   53  194   97   98 │
                                    └───────────────────────────────────┘
```
## Scrambling
You can scramble cube by using method `scramble(number_of_moves=30)`(default value is 30)
```
print(rubiks_cube.scramble())
rubiks_cube.show()
```
Output:
```
B' F' D' B2 F' R' F' L B2 B2 U F D' D2 F' U2 F' R R U' B U L D2 U2 R' U' D D2 F2 
             ┌────────────┐
             │ 36  51  21 │
             │ 26   5  44 │
             │ 10  33  19 │
┌────────────┼────────────┼────────────┬────────────┐
│ 43  47   1 │ 39  40   7 │ 12  53  28 │  9  35  54 │ 
│ 42  14   8 │ 20  23  49 │ 17  32  38 │  2  41  13 │ 
│ 18  15  16 │ 52  24  48 │ 27   4   3 │ 37   6  46 │ 
└────────────┼────────────┼────────────┴────────────┘
             │ 45  31  34 │
             │ 22  50  11 │
             │ 25  29  30 │
             └────────────┘
```
You can also scramble big cubes 
```
print(n_cube.scramble())
n_cube.show()
```
Output:
```
U' 2Bw 2Rw2 3Uw 3L 2B2 3Dw2 2B 2Bw' 2L 3Fw' D2 2Rw 3R 2Rw' 2Bw 2R 3Rw' 2Fw' 3Fw 3B2 L2 2F' 3R2 R' 3Uw2 2Bw 3F' B' B 
                                    ┌───────────────────────────────────┐
                                    │ 294  134  292   71  113    6  197 │
                                    │ 289  205   59   11   87  254  161 │
                                    │  54  181  215   32   68  138  119 │
                                    │  46  174  271   25  214  137  267 │
                                    │ 248  118  264  171  227  257  211 │
                                    │ 195   90  208   27   20   13  253 │
                                    │  98  104   84    4  217    2  148 │
┌───────────────────────────────────┼───────────────────────────────────┼───────────────────────────────────┬───────────────────────────────────┐
│ 196  244   29  102  143  287  246 │ 141   48  127  200   64  202   49 │ 105   97  168   95  162  204    7 │ 154  198   70  224  241   91  239 │ 
│ 140  237   89   88  110  282  281 │  93   41   30   60   65   62  293 │ 240  233   69  158  114  286  247 │ 142    9  128  125  185  184  183 │ 
│ 133  212  166   73  117  108   52 │  15  136  229   26   80  206    3 │ 201   61  164  165   82  275  199 │   5   83  262  222  178  177  176 │ 
│ 291  219  263   74   75  284   28 │ 151  186  179  123   67  223  120 │  77   76  220  172  277  170  249 │ 144   39  130  221  124  235  242 │ 
│ 243  236  180  116  213  132  152 │  21   10   17   24  276  230  182 │ 225  226  129  173   19  163  250 │ 145   40  131  269   66   34  290 │ 
│  14  160  261  109  157  139  106 │  63   37   16   23  285   86   57 │ 210  111   12  256  187  156  189 │ 232  188  234  207  255  209  153 │ 
│  43    8  260   53   47  100   50 │ 203   42   35  126  194   36  288 │ 245  238  231  218  274  146  147 │ 190  191  192  193  101  112   56 │ 
└───────────────────────────────────┼───────────────────────────────────┼───────────────────────────────────┴───────────────────────────────────┘
                                    │   1  149  150  169  280   55   92 │
                                    │  44  135   79   72   38   58   85 │
                                    │ 103  283  115   81  278  216   78 │
                                    │  22  268  122  270  228  121  175 │
                                    │  96  167   31   18   33  279   94 │
                                    │  51  107  159  272  265  258  251 │
                                    │  99  155   45  273  266  259  252 │
                                    └───────────────────────────────────┘
```

# Solving
Only Rubik's cube and Pocket cube can be solved. Cubes are solved with Herbert Kociemba's algorithm.
```
print(rubiks_cube.scramble())
rubiks_cube.show()

print(rubiks_cube.solve())
rubiks_cube.show()
```
Output:
```
D U2 D B L D2 R D B' L D2 L2 D' U U U' F B' B B R' D U D' F2 B F2 U U B 
             ┌────────────┐
             │ 18   8  48 │
             │ 33   5  44 │
             │  9  17  39 │
┌────────────┼────────────┼────────────┬────────────┐
│ 25  40  21 │ 28  49  10 │  1  53  34 │ 27  20  46 │ 
│ 26  14   6 │ 29  23  35 │ 51  32  13 │ 42  41  47 │ 
│  3   4  12 │  7  22  43 │ 54  24  45 │ 16  38  30 │ 
└────────────┼────────────┼────────────┴────────────┘
             │ 19  15  36 │
             │ 11  50  31 │
             │ 37   2  52 │
             └────────────┘
U F' L B2 L2 B D L2 F' D2 F' B2 U' R2 D' B2 U F2 D2 L2 F2
             ┌────────────┐
             │  1   2   3 │
             │  4   5   6 │
             │  7   8   9 │
┌────────────┼────────────┼────────────┬────────────┐
│ 10  11  12 │ 19  20  21 │ 28  29  30 │ 37  38  39 │ 
│ 13  14  15 │ 22  23  24 │ 31  32  33 │ 40  41  42 │ 
│ 16  17  18 │ 25  26  27 │ 34  35  36 │ 43  44  45 │ 
└────────────┼────────────┼────────────┴────────────┘
             │ 46  47  48 │
             │ 49  50  51 │
             │ 52  53  54 │
             └────────────┘
```
Pocket cube solving procedure is the same.
