Jump to content
Science Forums

Recommended Posts

Posted

I must say I am very surprised to find that there has been no thread discussing these little wonders yet!

 

So, whos done them? what method have you used to solve the buggars and how fast (or how many moves) can you do it in?

 

I just started doing one a few weeks back, I have adopted a layer method and have been able to get my time down to 2min 33sec - I think thats about as fast as I can get, while the layer method is a nice logical approach, it takes way to may moves to do..

 

Posted

I've never been able to do them. My spatial visualization abilities are nil. I've always assumed that's why I'm so sucky at chess.

 

Puzzled by puzzles,

Buffy

Posted

Corners first, top and bottom edge pieces next (top and bottom layers) middle edge pieces to finish. Best time on Rubik's traditional 3x3x3 is around 2 minutes, Rubik's Pocket Cube 2x2x2 around 10 seconds, Rubik's Revenge, 4x4x4, around 20 minutes and Rubik's Professor around an hour.

 

I've been a cubist since the original came out. I remember going into a Spencer Gifts one time and they had a whole end cap display full of cubes scrambled by shoppers soon after they came out. I picked one up and fixed it and the store manager told me he'd give me 50¢ apiece to fix the rest of them so they could sell them. I spent the whole afternoon fixing cubes for a growing crowd :)

Posted

hehehe, thats really cool :shrug:

 

I do them on the train ride to uni and sit there timing myself, some people are really amazed and dont understand how I do it, but people just love to watch them get solved :)

Posted

I have never solved it :shrug: ; even with a sheet of instructions. :doh: I see quite a few viral videos of contests & folks doing them blindfolded.

 

PS If they should happen to come apart, then I'm your turtle. ;) :D :)

Posted

I had the good fortune (and our instructors the aggravation) to be starting my abstract algebra block when the cube came out, so was instantly immersed in a community of people who recognized them as physical examples of cyclic sets. After about a week, everybody mostly solved their cubes algebraically on paper, using the physical cubes only as a quick algebra checker.

 

Speed solving contests weren’t very popular with my crowd. Minimum number of move contests were a bit more popular, though tended to be day’s long affairs, with all the work done on paper before actually picking up a physical cube.

 

Our most popular recreational game was a sort of 2-player mnemonic pissing contest that went like this:

  • Starting with a pristine cube, player 1 slowly and without trickery turns one slice of the cube, and hands it to player 2
  • Player 2 solves the cube in 1 move, scrambles it with 2 slice moves, and hands it to player 1
  • Player 1 solves it in 2 moves, scrambles it with 3 slice moves, and hands it to player 2
  • Etc., with each player scrambling the cube with one more move than before
  • Play ends when either player need more moves to solve the cube than were used to scramble it (the player looses), or can solve the cube in less moves than were used to scramble it

Quite a few non-math types were very good at this game. We had one person who was a sort of savant at it, though he frequently needed help to solve a cube he hadn’t seen scrambled.

 

Over the years, the Math department and individuals collected novel cube-type toys. We had a tetrahedron, the 2x2x2, various oddly labeled 3x3x3, and the 4x4x4, a dodecahedron, and a strange 3x3x3 cube that looked like a cylinder, where all the edges and corners weren’t interchangeable. We also had a arbitrarily weird menagerie of software simulated cubes, most never seen in physical form, some physically impossible.

 

The best cube for personal use, IMHO, is a 4x4x4 original Rubic’s Revenge, with the cube faces numerically labled. It’s sturdy, and capable of being used as a 2x2x2 or 3x3x3 cube. Cubes with more that 5 slices involve no techniques not used in 3x3x3 cubes, so are rather uninteresting.

I've never been able to do them. My spatial visualization abilities are nil.
AFAIK, the idea that one needs strong spatial skills to solve a cube is a misconception. Hardly anyone in my experience solves a cube by “holding it in her mind”, but by breaking it down into smaller sub-tasks of positioning and orienting collections of 3 side or corner pieces, usually with a few basic “routines”.

 

If someone handed me a cube to solve right now, I’d either have to consult notes, or spend a couple of hours rediscovering 2 basic routines for side and corner orientation. My memory is no good at holding that sort of information for more than a week or so.

Posted
… do you remember any on the math associated with the cube? What type is it, I hear you mentioned cyclic sets - Im intruiged …
The states a Rubik’s cube can form when acted on by a single operation is a cyclic group. Every state of a cube can be considered an operation – the operation performed to change a pristine cube into that state. If you repeat the same operation some number of times, the cube will return to the state in which it started.

 

The group formed by all the states a cube can form (using more than 1 operation) isn’t abelian. The main implication of this is that operations aren’t communicative – doing operation A followed by B doesn’t do the same thing as B followed by A. It’s possible to form subgroups that are abelian – that is, that can be done in any order to reach the same state. The common “routines” most people use to solve cubes are examples of operations of such subgroups. Imagine how hard it would be to solve a cube if the order in which you solved a particular collection of 3 corners or sides was significant!

 

Since my school days, it appears that 2-3 hour group theory classes focusing on the cube have entered college curriculum (ie: this one – looks like a fun class, though the online notes are sketchy) . Cube-related explorations were a popular subject for short 1-3 day classes we undergrads got to give – since then, they seems to have expanded into regular elective classes.

 

David Singmaster was one of the first mathematicians to write papers on the cube – his work was considered somewhat biblical among cube fans ca. 1980. He eventually fleshed his work out some good general public books – I read “notes on” (see the link), and see he wrote something longer and nicer looking in 1987, which I’ve not read.

Posted

Thats interesting, I thought they might be able to be solved by matrices of some description, with each move been some sort of row operation..

 

I also heard that solving a cube in the least moves possible from any one point - the most moves it can take is 20 - is this true?

Posted
Thats interesting, I thought they might be able to be solved by matrices of some description, with each move been some sort of row operation..
Though its common, especially when writing Rubik’s cube computer programs, to represent them using matrices, I’m not aware of any useful matrix arithmetic technique for solving them.

 

I usually represent the cube as a 1-dimensional array, mapping each element to a display graphic of the cube, and the allowed moves as a map of the array onto itself.

 

For an ordinary 3x3x3 cube, this requires a 54-place array, and a minimum of 3 move mappings (2 to rotate the cube through its 24 symmetries, 1 to turn any face 90°). This is also true for “cubes” shaped like any of the 5 regular polyhedra. Cubes with more than 3 slices (s) require an additional operation for the additional slices, that is, the minimum number of operations required for any regular polyhedral cube is [math]n = \frac{s+4}2[/math].

 

This is the MUMPS program I’m currently using to play with cubes.

x XRUBCUBE3B ;XRUBCUBE: rubic's cube subroutines -not a stand-alone app
n (XRUBCUBE,RC,M,W) m M=RC("M") s R="" f  x XRUBCUBE(2):R'="?",XRUBCUBE(3) q:R=""  ;XRUBCUBE(1): interactive Rubic's cube display & read command
n (RC,W) s X="" f Y=1:1:$o(W(""),-1) f  s X=$o(W(Y,X)) w:X="" ! q:X=""  w ?X-1,$e(RC,W(Y,X)) ;XRUBCUBE(2): display
n (XRUBCUBE,RC,M,R) r "XRUBCUBE>",R q:R=""  X XRUBCUBE(3,2),XRUBCUBE(3,3),XRUBCUBE(3,4) I R'?1"?".e X XRUBCUBE(3,1) f P=1:1:$l(R,",") s E=$p(R,",",P) i E]"" w:'$d(M(E)) " -",E,"?",! q:'$d(M(E))  w:P=1 ! s M=E x XRUBCUBE(4) ;XRUBCUBE(3)
x XRUBCUBE(3,1,1) i I="" s R=$tr(R,",") f I=$l(R):-1:2 s $e(R,I)=","_$e(R,I) ;XRUBCUBE(3,1): allow undelimited
s I="" f  s I=$o(M(I)) q:$l(I)>1!'$l(I) ;XRUBCUBE(3,1,1)
i R="?" w !,"This application simulates a particular kind of Rubic's cube.",!,"To perform an operation, enter one or more valid opcodes, separated by commas.",!,"Valid opcodes are: " x XRUBCUBE(3,2,1) w !,"To define or redefine an opcode, enter an opcode followed by = followed by one",!,"or more valid opcodes, separated by commas. Defined opcodes are: " x XRUBCUBE(3,2,2) w !,"To reset the cube, enter !.  To scramble it, enter *.  To exit, press Enter.",! ;XRUBCUBE(3,2)
n (M) s (I,D)="" f  s I=$o(M(I)) q:I=""  w D,I s D="," ;XRUBCUBE(3,2,1)
n (M) s (I,D)="" f  s I=$o(M(I)) q:I=""  i $d(M(I))=1,$L(M(I)) s E=I_"="_M(I) w:$l(D_E)+$x>79 ! s:'$x D="" w D,E s D="; " ;XRUBCUBE(3,2,2)
n (XRUBCUBE,RC,M,R) i R?1.e1"=".e s A=$p(R,"="),B=$p(R,"=",2,3) x XRUBCUBE(3,3,1),XRUBCUBE(3,3,2) W ! i P s M(A)=B,RC("M",A)=B,R="?" ;XRUBCUBE(3,3): define macro
n (XRUBCUBE,B) s R=B x XRUBCUBE(3,1) s B=R ;XRUBCUBE(3,3,1)
s:$d(M(A))>9 B=A_"=" s P=1 i B]"" f P=1:1:$l(B,",") s E=$p(B,",",P) i $s(E="":1,$d(M(E)):0,1:1) w " -",E,"?" s P=0 q  ;XRUBCUBE(3,3,2)
i R?1(1"!",1"*".e) x XRUBCUBE(3,4,2):R="!",XRUBCUBE(3,4,1):R?1"*".e ;XRUBCUBE(3,4)
n (XRUBCUBE,RC,M,R) x XRUBCUBE(3,4,1,1) s I=$e(R,2,9),R="" f I=1:1:$s(I>0:I,1:30) s R=R_$s(R="":"",1:",")_$p(A,",",$r($l(A,","))+1) ;XRUBCUBE(3,4,1): scramble
s (A,I)="" f  s I=$o(M(I)) q:I=""  s:$d(M(I))>9 A=A_$s(A="":"",1:",")_I ;XRUBCUBE(3,4,1,1)
s RC=RC(0),R="?!" w ! ;XRUBCUBE(3,4,2): clear
n (XRUBCUBE,RC,M) x XRUBCUBE(4,$s($d(M(M))<9:2,1:1)) ;XRUBCUBE(4): move (w/recursive macros)
s PC=RC,P="" f  s P=$o(M(M,P)) q:P=""  s $e(RC,M(M,P))=$e(PC,P) ;XRUBCUBE(4,1): move
n MR,P s MR=M(M) f P=1:1:$l(MR,",") s M=$p(MR,",",P) x XRUBCUBE(4) ;XRUBCUBE(4,2): macro
x XRUBCUBE3B ;XRUBCUBE3: 3x3x3 rubic's cube subroutines -not a stand-alone app
x XRUBCUBE3(1,1) s:$s($l($g(RC))-54:1,$tr(RC,123456)="":0,1:1) RC=RC(0) ;XRUBCUBE3(1): initialize 3x3x3 cube
n (RC) s RC(0)="" f I=1:1:6 s RC(0)=RC(0)_$tr($j("",9)," ",I) ;XRUBCUBE3(1,1)
n (XRUBCUBE3,M) s M="" f  s M=$o(XRUBCUBE3(3,1,M)) q:M=""  s A=$p(XRUBCUBE3(3,1,M)," "),(I,J)="" f P=1:1:$l(A,",") s LI=I,LJ=J,E=$p(A,",",P),I=$p(E,"-"),J=$p(E,"-",2) s:'I I=LI+1 s:'J J=LJ+1 s M(M,I)=J ;XRUBCUBE3(3): minimal moves
7-28,8-31,9-34,28-48,31-47,34-46,48-18,47-15,46-12,12-9,15-8,18-7,19-21,20-24,21-27,24-26,27-25,26-22,25-19,22-20 ;XRUBCUBE3(3,1,"+")
10-19,,,,,,,,,19-28,,,,,,,,,28-37,,,,,,,,,37-10,,,,,,,,,1-7,2-4,3-1,6-2,9-3,8-6,7-9,4-8,46-48,47-51,48-54,51-53,54-52,53-49,52-46,49-47 ;XRUBCUBE3(3,1,"H")
1-19,,,,,,,,,19-46,,,,,,,,,54-37,53,52,51,50,49,48,47,46,45-1,44,43,42,41,40,39,38,37,10-12,11-15,12-18,15-17,18-16,17-13,16-10,13-11,30-28,33-29,36-30,35-33,34-36,31-35,28-34,29-31 ;XRUBCUBE3(3,1,"V")n (XRUBCUBE,XRUBCUBE3,XRUBCUBE3B,RC) x XRUBCUBE3(1),XRUBCUBE3B(2),XRUBCUBE3(3),XRUBCUBE(1) ;XRUBCUBE3B: 3x3x3 Rubic's cube simulator, basic view
n (W) s C=0 f A=105,401,405,409,413,705 f Y=A\100:1:A\100+2 f X=A#100:1:A#100+2 s (C,W(Y,X))=C+1 ;XRUBCUBE3B(2): display map

It’s core, XRUBCUBE, is capable of running any kind of cube-type puzzle, including unusual, 4+ dimensional, or physically impossible polyhedra, but as listed here, just simulates a 3x3x3 cube, displaying it “flattened”, like this:

USER>x XRUBCUBE
   313
   513
   543
144 661 266 454
225 632 644 151
221 543 632 631
   432
   561
   525
XRUBCUBE>?
This application simulates a particular kind of Rubic's cube.
To perform an operation, enter one or more valid opcodes, separated by commas.
Valid opcodes are: +,-,H,L,U,V
To define or redefine an opcode, enter an opcode followed by = followed by one
or more valid opcodes, separated by commas. Defined opcodes are: -=+,+,+
L=H,H,H; U=V,V,V
To reset the cube, enter !.  To scramble it, enter *.  To exit, press Enter.
XRUBCUBE>

Notice that it starts only with 3 operations, + (twist the face), H (turn the cube horizontally), and V (turn the cube vertically), but allows the user to define any operation he wants out of these, as his cubing style prefers.

I also heard that solving a cube in the least moves possible from any one point - the most moves it can take is 20 - is this true?
I’ve also heard this, and suspect it’s true, but haven’t seen a proof. I’m thinking of trying to prove this with an exhaustive computer program, its 3 minimal operations, and a lot of storage, but suspect it will take too long on my hardware for anything larger than a 2x2x2 cube.
  • 2 weeks later...
Posted
I also heard that solving a cube in the least moves possible from any one point - the most moves it can take is 20 - is this true?
I’ve also heard this, and suspect it’s true, but haven’t seen a proof. I’m thinking of trying to prove this with an exhaustive computer program, its 3 minimal operations, and a lot of storage, but suspect it will take too long on my hardware for anything larger than a 2x2x2 cube.

 

After a couple of false starts and squandered runs (programming goofs), I ran this exhaustive program for a 2x2x2 cube. The result: any 2x2x2 cube can be solved in at most 14 moves (single face rotations), provided you don’t care which solved face is up and forward when you’re done.

 

Here’s a summary of the number of possible cubes, and the moves required to solve them:

#Moves  #States        #States/Total  
0        1                              
1        6  6.000000  0.000002  0.000002
2       27  4.500000  0.000007  0.000009
3      120  4.444444  0.000033  0.000042
4      534  4.450000  0.000145  0.000187
5     2256  4.224719  0.000614  0.000801
6     8969  3.975621  0.002441  0.003242
7    33058  3.685807  0.008997  0.012240
8   114149  3.452992  0.031068  0.043308
9   360508  3.158223  0.098120  0.141427
10   930588  2.581324  0.253279  0.394707
11  1350852  1.451611  0.367663  0.762369
12   782536  0.579291  0.212984  0.975353
13    90280  0.115368  0.024572  0.999925
14      276  0.003057  0.000075  1.000000
   3674160                              

Note that the total number of states, 3674160, is [math]\frac{8! 3^7}{24}[/math].

 

Here’re examples of the greatest and least-valued canonic cube states for each number of moves:

0: 111122223333444455556666    0: 111122223333444455556666
  11                             11
  11                             11
22 33 44 55                    22 33 44 55
22 33 44 55                    22 33 44 55
  66                             66
  66                             66

1: 111122333344445555226666    1: 113351512222636344445566
  11                             11
  11                             33
22 33 44 55                    51 22 63 44
33 44 55 22                    51 22 63 44
  66                             55
  66                             66

2: 111122443355442255336666    2: 116635354444353522221166
  11                             11
  11                             66
22 33 44 55                    35 44 35 22
44 55 22 33                    35 44 35 22
  66                             11
  66                             66

3: 111222653623341455546436    3: 143254611525636164335422
  11                             14
  12                             32
22 36 34 55                    54 15 63 64
65 23 14 54                    61 25 61 33
  64                             54
  36                             22

4: 111222123535646655336444    4: 144625611533416635542232
  11                             14
  12                             46
22 35 64 55                    25 15 41 35
12 35 66 33                    61 33 66 54
  64                             22
  44                             32

5: 111222133645342555636644    5: 154623336261514545612324
  11                             15
  12                             46
22 36 34 55                    23 62 51 45
13 45 25 63                    33 61 45 61
  66                             23
  44                             24

6: 111122253324445455666633    6: 166124243355424255336116
  11                             16
  11                             61
22 33 44 55                    24 33 42 55
25 24 54 66                    24 55 42 33
  66                             61
  33                             16

7: 111122233346442555656364    7: 166125434343432525256116
  11                             16
  11                             61
22 33 44 55                    25 43 43 25
23 46 25 65                    43 43 25 25
  63                             61
  64                             16

8: 111122233342446455566536    8: 166125434325432525431661
  11                             16
  11                             61
22 33 44 55                    25 43 43 25
23 42 64 56                    43 25 25 43
  65                             16
  36                             61

9: 111122223465536645365434    9: 166125344435542335221661
  11                             16
  11                             61
22 34 53 45                    25 44 54 35
22 65 66 36                    34 35 23 22
  54                             16
  34                             61

10: 111122223463534445565636   10: 166125434422523455331661
  11                             16
  11                             61
22 34 53 45                    25 44 52 55
22 63 44 56                    43 22 34 33
  56                             16
  36                             61

11: 111122223364446655465335   11: 166125454323442235356116
  11                             16
  11                             61
22 33 44 55                    25 43 44 35
22 64 66 46                    45 23 22 35
  53                             61
  35                             16

12: 111122223334446655456365   12: 166125454342423355231661
  11                             16
  11                             61
22 33 44 55                    25 43 42 55
22 34 66 45                    45 42 33 23
  63                             16
  65                             61

13: 111122223334445355456666   13: 166125454345432325231661
  11                             16
  11                             61
22 33 44 55                    25 43 43 25
22 34 53 45                    45 45 23 23
  66                             16
  66                             61

14: 111122353324445355426666   14: 153621262424343465153165
  11                             15
  11                             36
22 33 44 55                    21 24 34 65
35 24 53 42                    26 24 34 15
  66                             31
  66                             65

It’s interesting that, except for cubes solvable in 3, 4, or 5 moves, there’s a cube solvable in 0 to 14 moves for which at least one face shows the same colors, and, it appears, for most numbers of moves, including 14, one in which one face is solved. In other words, at least one “most scrambled” 2x2x2 cube is “half solved”.

 

This is the MUMPS code used (x XRUBCUBES2):

x XRUBCUBE2B ;XRUBCUBE2: 2x2x2 rubic's cube subroutines -not a stand-alone app
x XRUBCUBE2(1,1) s:$s($l($g(RC))-24:1,$tr(RC,123456)="":0,1:1) RC=RC(0) ;XRUBCUBE2(1): initialize 3x3x3 cube
n (RC) s RC(0)="" f I=1:1:6 s RC(0)=RC(0)_$tr($j("",4)," ",I) ;XRUBCUBE2(1,1)
n (XRUBCUBE2,M) s M="" f  s M=$o(XRUBCUBE2(3,1,M)) q:M=""  s A=$p(XRUBCUBE2(3,1,M)," "),(I,J)="" f P=1:1:$l(A,",") s LI=I,LJ=J,E=$p(A,",",P),I=$p(E,"-"),J=$p(E,"-",2) s:'I I=LI+1 s:'J J=LJ+1 s M(M,I)=J ;XRUBCUBE2(3): minimal moves
3-13,4-15,13-22,15-21,22-8,21-6,8-3,6-4,9-10,10-12,12-11,11-9 ;XRUBCUBE2(3,1,"+")
5-9,,,,9-13,,,,13-17,,,,17-5,,,,1-3,2-1,4-2,3-4,21-22,22-24,24-23,23-21 ;XRUBCUBE2(3,1,"H")
1-9,,,,9-21,,,,24-17,23,22,21,20-1,19,18,17,5-6,6-8,8-7,7-5,13-15,14-13,16-14,15-16 ;XRUBCUBE2(3,1,"V")
n (XRUBCUBE,XRUBCUBE2,XRUBCUBES2) x XRUBCUBE2(1),XRUBCUBE2(3),XRUBCUBES2(1),XRUBCUBES2(2),XRUBCUBES2(3) ;XRUBCUBES2: create space of 2x2x2 cube
x XRUBCUBES2(1,1),XRUBCUBES2(1,2),XRUBCUBES2(1,3),XRUBCUBES2(1,4) ;XRUBCUBES2(1): create operations
s RCZ="" f F=1:1:$l(RC) s RCZ=RCZ_$c(F+32) ;XRUBCUBES2(1,1)
s (SO,SO("+"))="" f R="-=+++","B=HH+++HH","b=HH+HH","L=H+++HHH","l=H+HHH","R=HHH+H","r=HHH+++H","U=V+VVV","u=V+++VVV","D=VVV+V","d=VVV+++V" s SO($P(R,"="))="" X XRUBCUBE(3,3) ;XRUBCUBES2(1,2)
s SO="" f  s (M,SO)=$o(SO(SO)) q:M=""  s RC=RCZ x XRUBCUBE(4) s SO(SO)=RC ;XRUBCUBES2(1,3): slice operations
f M="H","V" s RC=RCZ x XRUBCUBE(4) s SOC(M)=RC ;XRUBCUBES2(1,4): rotation operations
s RC=RC(0) i '$d(^XD("XRUBCUBES2")) s (^XD("XRUBCUBES2",1,RC),^XD("XRUBCUBES2",3,RC))="",(^XD("XRUBCUBES2",4),^XD("XRUBCUBES2",4,0))=1,^XD("XRUBCUBES2",4,0,RC)="" ;XRUBCUBES2(2): initialize space
s ^XD("XRUBCUBES2",0,1)=0 f  q:'$d(^XD("XRUBCUBES2",3))!^XD("XRUBCUBES2",0,1)  s F=$d(^XD("XRUBCUBES2",2)) m:'F ^XD("XRUBCUBES2",2)=^XD("XRUBCUBES2",3) k:'F ^XD("XRUBCUBES2",3) f  s RC1=$o(^XD("XRUBCUBES2",2,"")) q:RC1=""!^XD("XRUBCUBES2",0,1)  k ^XD("XRUBCUBES2",2,RC1) s SO1=^XD("XRUBCUBES2",1,RC1),SO1L=$l(SO1,",") f  s SO=$o(SO(SO)) q:SO=""  s M=SO,RC=$tr(SO(SO),RCZ,RC1) x XRUBCUBES2(4) i '$d(^XD("XRUBCUBES2",1,RC)) s ^XD("XRUBCUBES2",1,RC)=SO1_","_SO,^XD("XRUBCUBES2",3,RC)="",^(4)=^XD("XRUBCUBES2",4)+1,^(SO1L)=$g(^(4,SO1L))+1,^(SO1L,RC)="" ;XRUBCUBES2(3): expand space
s RCC=RC f M="H","H","H","H","V","H","H","H","H","V","H","H","H","H","V","H","H","H","V","H","H","H","H","V","V","H","H","H" s RCC=$tr(SOC(M),RCZ,RCC) s:RC]RCC RC=RCC ;XRUBCUBES2(4): cannocize RC

 

As I suspected, “filling the space” of a 2x2x2 cube took a long time (over 48 hours) on my PC. As a 3x3x3 cube has many ([math]12! 2^{10}[/math]) more possible states than a 2x2x2 one, I won’t be trying this anytime soon, or on any hardware I’m likely to have at hand!

Posted

LOL 48 hours! What kind of computer?

 

I think if you where going to try the 3x3x3 you would have to come up with some more efficient programming - if that is all possible..

 

I dont know how you do it Craig, but its amazing :)

Posted
LOL 48 hours! What kind of computer?
A 2004 Toshiba A65-S126 laptop, 2.8 Ghz Celron, 1 GB RAM. A bit of a clunky machine – it hard drive access and transfer speed has always been an issue – but, a supercomputer by 1980s standards. The fact that my antivirus decided to scan all files sometime in the middle of the night didn’t help any. ;)

 

I’ve access to some better machines – 8 CPU IBM RS-6000s with RAM-based EMC storage – that on occasion benchmark better than 1000 times my PC, but still, the program would have taken at least an hour or 2 to complete. There’s no obvious way to parallelize it.

 

It’s also written in a language, MUMPS, best suited to database manipulation, not cube-crunching. It’s very fast and easy to program this sort of thing in, though, taking. One of these days, I’d like to write a true compiler for stand-alone (intrinsically, ordinary MUMPS programs can interact with one another and with one another’s data) MUMPS programs, just for this sort of thing, which

I think if you where going to try the 3x3x3 you would have to come up with some more efficient programming - if that is all possible..
The killer is the number of states for a 3x3x3 cube – 1802166803103744000 vs. 3674160 for a 2x2x2.

 

If I could optimize my code and hardware to get the current program to complete in 1 s, it would still, by its simple, exhaustive nature, take about 16000 years to complete a 3x3x3 cube.

 

Storage is an issue, too. The representation of 3674160 cube states this program builds requires about 32 MB – pretty trivial. A 3x3x3 cube would require more than 14 exabytes (14000 TB, or 1.6e19 bytes). All the storage devices in the world could hold about 200 exabytes, increasing to about 1 zetabyte (1024 exabytes) by 2010. So, right now, I’d need about 10% of the world’s storage – high on anyone’s list of “not gonna happen”.

 

Fortunately, people with a penchant for analysis, rather than writing simple programs and turning them loose, have been working on the domain of the cube problem for the past few decades, resulting last year in a proof that any 3x3x3 cube could be solved in at most 35 moves (or 27 if “super flips” – 2 quarter face turns are allowed). The wikipedia article “Optimal solutions for Rubik's Cube” has a decent summary of this, including links to Silviu Radu’s paper on the 35 move maximum, and a cube discussion forum (which has my hard-won summary on it’s first page :( Ah, but I can now solve any 2x2x2 cube in the fewest possible moves! :) )

Posted

Storage is an issue, too. The representation of 3674160 cube states this program builds requires about 32 MB – pretty trivial. A 3x3x3 cube would require more than 14 exabytes (14000 TB, or 1.6e19 bytes). All the storage devices in the world could hold about 200 exabytes, increasing to about 1 zetabyte (1024 exabytes) by 2010. So, right now, I’d need about 10% of the world’s storage – high on anyone’s list of “not gonna happen”.

 

Well really the storage isnt the issue, because you would have plenty of time to get more hard drives :)

  • 1 month later...
Posted

I'm glad this thread came up again. Perfect timing.

I bought a Rubik's cube the other day, and do it whenever I'm bored.

My best time is down to 1:20.

 

I watch videos online with people doing it in like 15 seconds. It's so crazy to see them do it. I would imagine they must lube their's up, because I could never get mine to glide like that.

Posted

yeah I think there is a whole different class of cubes for competition spinning :phones: mine sticks sometimes if you dont line it up well enough.. slows me down but only minorly.

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Loading...
×
×
  • Create New...