Library for simulating rubik's cubes of different sizes (N x N), for solving 2 x 2 and 3 x 3 cubes with kociemba algorithm, and for 3D visualization of cubes.
Project description
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)
Installation
pip install super-rubik-cube
Usage
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). When you define your own state, numeric values are being reset to default positions.
pocket_cube.define_state("RRRRRRRRRRRRRRRRRRRRRRRR")
pocket_cube.show()
pocket_cube.show(colors=True)
Output:
+--------+
| 1 2 |
| 3 4 |
+--------+--------+--------+--------+
| 5 6 | 9 10 | 13 14 | 17 18 |
| 7 8 | 11 12 | 15 16 | 19 20 |
+--------+--------+--------+--------+
| 21 22 |
| 23 24 |
+--------+
โฌโฌ ๐ฅ๐ฅ
โฌโฌ ๐ฅ๐ฅ
๐ฅ๐ฅ ๐ฅ๐ฅ ๐ฅ๐ฅ ๐ฅ๐ฅ
๐ฅ๐ฅ ๐ฅ๐ฅ ๐ฅ๐ฅ ๐ฅ๐ฅ
โฌโฌ ๐ฅ๐ฅ
โฌโฌ ๐ฅ๐ฅ
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]]]
You can also get color of element by using function get_color_by_element(element: int)
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()
rubiks_cube.show(colors=True)
Output:
L R2 D D2 F' F' U2 F2 U' B2 B2 U2 R' R2 L2 U2 B' F F2 B R U2 R F2 R' R' D' U' D' D
+------------+
| 25 47 52 |
| 44 5 17 |
| 10 38 19 |
+------------+------------+------------+------------+
| 46 53 1 | 39 2 7 | 12 49 16 | 45 26 18 |
| 11 14 29 | 6 23 40 | 33 32 51 | 35 41 4 |
| 3 13 27 | 34 31 21 | 9 15 36 | 43 20 30 |
+------------+------------+------------+------------+
| 48 24 28 |
| 42 50 22 |
| 37 8 54 |
+------------+
โฌโฌโฌ ๐ฉ๐จ๐จ
โฌโฌโฌ ๐ฆ๐ช๐ง
โฌโฌโฌ ๐ง๐ฆ๐ฉ
๐จ๐จ๐ช ๐ฆ๐ช๐ช ๐ง๐จ๐ง ๐ฆ๐ฉ๐ง
๐ง๐ง๐ฅ ๐ช๐ฉ๐ฆ ๐ฅ๐ฅ๐จ ๐ฅ๐ฆ๐ช
๐ช๐ง๐ฉ ๐ฅ๐ฅ๐ฉ ๐ช๐ง๐ฅ ๐ฆ๐ฉ๐ฅ
โฌโฌโฌ ๐จ๐ฉ๐ฅ
โฌโฌโฌ ๐ฆ๐จ๐ฉ
โฌโฌโฌ ๐ฆ๐ช๐จ
You can also scramble big cubes
print(n_cube.scramble())
n_cube.show()
n_cube.show(colors=True)
Output:
3D' L' R 3Bw' 3U2 F D 2Lw2 3L 3R2 R' 3Bw2 R' L2 2U' 2Lw2 2F2 R 3Uw2 3U2 3D2 D' D' 2Uw2 3Uw2 2Rw' 2R2 2Uw 3D 2Rw2
+-----------------------------------+
| 92 259 176 200 260 189 196 |
| 93 37 30 27 34 139 195 |
| 211 181 180 263 264 206 194 |
| 218 272 271 25 32 137 126 |
| 3 40 33 81 117 114 290 |
| 112 111 234 109 118 209 140 |
| 105 240 241 144 266 36 190 |
+-----------------------------------+-----------------------------------+-----------------------------------+-----------------------------------+
| 288 281 168 175 201 155 148 | 49 293 292 249 192 55 147 | 252 183 243 169 280 287 294 | 239 232 96 4 133 191 245 |
| 57 90 10 88 87 156 63 | 106 9 89 121 132 254 198 | 6 184 20 170 230 188 48 | 104 41 285 284 185 135 210 |
| 113 16 131 18 17 59 248 | 143 136 166 220 215 187 47 | 103 257 82 116 164 138 145 | 250 212 66 122 213 108 70 |
| 273 174 173 74 277 11 291 | 242 207 24 123 214 23 120 | 77 186 171 172 73 72 28 | 151 158 165 221 222 235 193 |
| 199 69 31 124 115 110 182 | 225 226 276 228 129 65 64 | 217 128 227 130 278 279 35 | 150 157 229 75 19 283 5 |
| 244 205 208 219 167 233 153 | 14 86 38 125 216 286 42 | 149 13 12 76 275 58 142 | 247 107 163 223 236 282 289 |
| 141 44 45 46 21 134 7 | 197 204 162 22 127 2 99 | 56 253 231 267 52 51 50 | 203 251 94 71 29 85 98 |
+-----------------------------------+-----------------------------------+-----------------------------------+-----------------------------------+
| 154 161 119 53 84 202 43 |
| 91 160 79 60 261 258 97 |
| 152 159 80 67 262 177 78 |
| 102 256 26 270 179 268 95 |
| 101 255 68 269 178 61 15 |
| 100 62 83 39 265 237 8 |
| 246 238 54 224 274 146 1 |
+-----------------------------------+
โฌโฌโฌโฌโฌโฌโฌ ๐ง๐จ๐ฅ๐ฆ๐จ๐ฅ๐ฅ
โฌโฌโฌโฌโฌโฌโฌ ๐ง๐ช๐ช๐ช๐ช๐ฉ๐ฅ
โฌโฌโฌโฌโฌโฌโฌ ๐ฆ๐ฅ๐ฅ๐จ๐จ๐ฆ๐ฅ
โฌโฌโฌโฌโฌโฌโฌ ๐ฆ๐จ๐จ๐ช๐ช๐ฉ๐ฉ
โฌโฌโฌโฌโฌโฌโฌ ๐ช๐ช๐ช๐ง๐ฉ๐ฉ๐จ
โฌโฌโฌโฌโฌโฌโฌ ๐ฉ๐ฉ๐ฆ๐ฉ๐ฉ๐ฆ๐ฉ
โฌโฌโฌโฌโฌโฌโฌ ๐ฉ๐ฆ๐ฆ๐ฉ๐จ๐ช๐ฅ
๐จ๐จ๐ฅ๐ฅ๐ฆ๐ฅ๐ฅ ๐ช๐จ๐จ๐จ๐ฅ๐ง๐ฉ ๐จ๐ฅ๐ฆ๐ฅ๐จ๐จ๐จ ๐ฆ๐ฆ๐ง๐ช๐ฉ๐ฅ๐ฆ
๐ง๐ง๐ช๐ง๐ง๐ฅ๐ง ๐ฉ๐ช๐ง๐ฉ๐ฉ๐จ๐ฆ ๐ช๐ฅ๐ช๐ฅ๐ฆ๐ฅ๐ช ๐ฉ๐ช๐จ๐จ๐ฅ๐ฉ๐ฆ
๐ฉ๐ช๐ฉ๐ช๐ช๐ง๐จ ๐ฉ๐ฉ๐ฅ๐ฆ๐ฆ๐ฅ๐ช ๐ฉ๐จ๐ง๐ฉ๐ฅ๐ฉ๐ฉ ๐จ๐ฆ๐ง๐ฉ๐ฆ๐ฉ๐ง
๐จ๐ฅ๐ฅ๐ง๐จ๐ช๐จ ๐ฆ๐ฆ๐ช๐ฉ๐ฆ๐ช๐ฉ ๐ง๐ฅ๐ฅ๐ฅ๐ง๐ง๐ช ๐ฅ๐ฅ๐ฅ๐ฆ๐ฆ๐ฆ๐ฅ
๐ฆ๐ง๐ช๐ฉ๐ฉ๐ฉ๐ฅ ๐ฆ๐ฆ๐จ๐ฆ๐ฉ๐ง๐ง ๐ฆ๐ฉ๐ฆ๐ฉ๐จ๐จ๐ช ๐ฅ๐ฅ๐ฆ๐ง๐ช๐จ๐ช
๐ฆ๐ฆ๐ฆ๐ฆ๐ฅ๐ฆ๐ฅ ๐ช๐ง๐ช๐ฉ๐ฆ๐จ๐ช ๐ฅ๐ช๐ช๐ง๐จ๐ง๐ฉ ๐จ๐ฉ๐ฅ๐ฆ๐ฆ๐จ๐จ
๐ฉ๐ช๐ช๐ช๐ช๐ฉ๐ช ๐ฆ๐ฆ๐ฅ๐ช๐ฉ๐ช๐ฉ ๐ง๐จ๐ฆ๐จ๐ง๐ง๐ง ๐ฆ๐จ๐ง๐ง๐ช๐ง๐ง
โฌโฌโฌโฌโฌโฌโฌ ๐ฅ๐ฅ๐ฉ๐ง๐ง๐ฆ๐ช
โฌโฌโฌโฌโฌโฌโฌ ๐ง๐ฅ๐ง๐ง๐จ๐จ๐ง
โฌโฌโฌโฌโฌโฌโฌ ๐ฅ๐ฅ๐ง๐ง๐จ๐ฅ๐ง
โฌโฌโฌโฌโฌโฌโฌ ๐ฉ๐จ๐ช๐จ๐ฅ๐จ๐ง
โฌโฌโฌโฌโฌโฌโฌ ๐ฉ๐จ๐ง๐จ๐ฅ๐ง๐ช
โฌโฌโฌโฌโฌโฌโฌ ๐ฉ๐ง๐ง๐ช๐จ๐ฆ๐ช
โฌโฌโฌโฌโฌโฌโฌ ๐จ๐ฆ๐ง๐ฆ๐จ๐ฉ๐ช
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' L2 U' F' D2 U U' B' D2 R' B F R2 F R' D' B2 R' B2 B2 B' L' U2 U2 U' F' L' L' U2 F'
+------------+
| 30 31 46 |
| 33 5 53 |
| 43 26 19 |
+------------+------------+------------+------------+
| 3 40 36 | 54 47 7 | 12 44 25 | 18 24 37 |
| 8 14 22 | 15 23 49 | 17 32 4 | 11 41 20 |
| 9 29 34 | 48 2 10 | 39 51 52 | 45 13 21 |
+------------+------------+------------+------------+
| 27 38 1 |
| 6 50 35 |
| 28 42 16 |
+------------+
R2 F B2 R2 U R L2 U2 L D2 F' U B2 D' L2 U' D2 B2 U' L2 U
+------------+
| 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.
3D Visualization
For 3D visualization you can use method show_3d(). Generation of big cubes may take some time due to large amount of 3D elements.
cube = supercube.NCube(5)
cube.scramble()
cube.show_3d()
Output:
To display cube with numbers on stickers just use argument numbers in method show_3d(numbers=True)
cube = supercube.NCube(5)
cube.scramble()
cube.show_3d(numbers=True)
Output:
Jupyter Notebook
It is also possible to display 3D cube in Jupyter Notebook with show_3d(notebook=True)
cube = supercube.NCube(5)
cube.scramble()
cube.show_3d(notebook=True)
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
super_rubik_cube-1.0.5.tar.gz
(4.0 MB
view hashes)
Built Distribution
Close
Hashes for super_rubik_cube-1.0.5-py3-none-any.whl
| Algorithm | Hash digest | |
|---|---|---|
| SHA256 | 68a2c459b756e40ccbc6477594b17fa2f8698fa38e019a5c52e1ab7717ca6822 |
|
| MD5 | 3e017201a68f30c6dd4f98f3a8567231 |
|
| BLAKE2b-256 | bdcbaf74cdaa5da6779f7ed071f3d66757cec2fc6c210cd1007ba9825f98b894 |
