• Welcome to SpeedSolving.com — the world’s largest puzzle community!

    You’re currently browsing as a guest, which means you have limited access to discussions, resources, member profiles, and community features.

    Join 50,000+ cubers and puzzle enthusiasts from around the world to ask questions, share solves, improve faster, and be part of the community.

    Registration is free, fast, and easy — create your account today.

    Already a member? Log in here to hide this message and start participating.

The 4x4x4 example solve game


http://alg.cubing.net/?alg=R-_F_R_U...2_U_Rw-_Fw_Uw-_F-_Uw-_U-_R_B_R_U&puzzle=4x4x4

Next : r' R' b2 f l R2 d' U2 b2 f F' U' B d' R2 f2 F' U2 b D' U B F' l' d u L' u U b2
F2 d R' d' //white center
l2 L2 f' L2 f //yellow center
F U' r //2 edges
F B' //place them
U' r2 //1 edge
R' B' //place it
r2 //1 edge
R2 L F' //place it
U R B r2 R U' r //red center
R2 F' r R' F //2 blue "half centers" + 1 edge
r' //red center
L R F2 //180° F center
r2 R2' F2 r2 //blue
x2 R L2 l' U' l //3/4 of orange/green centers + 1 edge
R' l F' l' //orange/green centers + 1 edge
z' R2 B //prepare "2 more edges"
d' L' U' L d //2 more edges
z2 U' L B' //prepare "3 more edges"
u L' U2 L u' //3 more edges
r' E u2 f u r' 2R' f' 2R f r u' f' u 2R u E' r //OLL parity
F' L U L F' L' //cross
F' U' F U2 R U' R' y2 D'//2 F2L pairs keyhole
F' U' F L' U' L //3rd pair
R U R' U' F R' F' R //F2L
R U R' U R U2 R' U R U R' U' R' F R F' //OLL 29
L U F L' U' L U L F' L2 U L U L' U' L U' L' //PLL F


Next : D2 d U' B' b f2 R2 B l' d2 u' U F r2 D' b u R B f' L' l' U2 b L l2 D2 l' r U2
 
Your own is 100 moves faster (I was just solving them 1 by 1 with intuitive commutators...)

I have a bunch of center algs that I use. I can solve any 2-adjacent, 3-adjacent, or 4-adjacent centers (as well as all of the other well-known center swaps) in the minimum number of moves. 3-adjacent centers can always be swapped in 14 moves or less, it's the hardest. 4 adjacent centers is a 10-mover.

Next: r' u2 f2 U u2 R' r' L' U' L2 D' R F f D' B2 u R2 B' F' D B D2 L2 R2 D2 r L' f2 F

This is as far as I got transcribing tonight.

https://alg.cubing.net/?setup=r-_u2_f2_U_u2_R-_r-_L-_U-_L2_D-_R_F_f_D-_B2_u_R2_B-_F-_D_B_D2_L2_R2_D2_r_L-_f2_F&puzzle=4x4x4&alg=U_B2_L-_F_D-_B2_D-_B_R-%0A2U-_F2_2L_U2_2R2_D2_B2%0AD-_F-_2U2_F_D-_2B_D2%0AR_F_2L-_F-_2D_R2_F_B-_D-_2R-_2L_D2%0AL_F-_U-_2R-_U_F_L-%0A2D2_L_F_2L2_F-_L-_2D2%0A
 
Next: r' u2 f2 U u2 R' r' L' U' L2 D' R F f D' B2 u R2 B' F' D B D2 L2 R2 D2 r L' f2 F

Well, this is the first time I'm solving a 4x4x4 for movecount...so let me try the Yau method:

L' b' r' // red center
L b' r B' r' B' d' R2 d // orange center
f' R b' U R' D F2 D b' F' U // 3 red edge pairs
D' f' F D' f2 // yellow center
U2 b' U b F R' F' b U2 b' // blue center
b' U b U f F' U f' // last 2 centers
f2 R' B' R f2 F' D2 // last red edge pair
D' B2 D U B' U' L B L' b D' B2 D U B U' R B R' b' R' B R b U' B2 U R B R' b' // edge pairing (woo no OLL parity!)
D' B' D // yellow-green dedge
F B2 U' B' U2 B2 U' // white-green (keyhole) F2L pair
R B R2 B2 R // yellow-blue (keyhole) F2L pair
U' B' U F' // F2L-2C
L U B U' B' L' // EOLL
b2 u2 B2 u2 U2 B2 u2 b2 // PLL parity
B L' F R L B' L' B R' F' B' L // corner 3-cycle
L' B L F2 L' B' L F2 // L3C


Final solution: L' b' r' L b' r B' r' B' d' R2 d f' R b' U R' D F2 D b' F' U D' f' F D' f2 U2 b' U b F R' F' b U2 b2 U b U f F' U f R' B' R f2 F' D B2 D U B' U' L B L' b D' B2 D U B U' R B R' b' R' B R b U' B2 U R B R' b' D' B' D F B2 U' B' U2 B2 U' R B R2 B2 R U' B' U F' L U B U' B' L' b2 u2 B2 u2 U2 B2 u2 b2 B L' F R L B' L' B R' F' L F2 L' B' L F2 (130 OBTM)

If anybody has a different method I can use that may reduce average movecount, let me know.

Next: B R' u b' U' r B' U2 f d2 U2 L2 u B2 d' U' F' U2 B2 f R B f' u' f' L u2 L2 R2 f F L R' B' U' R2 b' R2 d' r'
 
Just out of curiosity, does reduction pretty much guarantee a shorter move count per solution?

I don't think so...
First of all it depends of the definition of a move... if a method as the one you use ends by the center, it will have a very weaker move count in SSHTM than in OBHTM... (I asked about the different turn metrics here but no one answered : https://www.speedsolving.com/forum/showthread.php?p=1061840 )
Moreover reduction method isn't made in order to have a low move count but in order to be easy if we already know how to solve a 3x3x3...
Well, the question is interresting...
 
I don't think so...
First of all it depends of the definition of a move... if a method as the one you use ends by the center, it will have a very weaker move count in SSHTM than in OBHTM... )
Moreover reduction method isn't made in order to have a low move count but in order to be easy if we already know how to solve a 3x3x3...

I see. I never understood why a move such as r was defined to be 2 moves, the outer right face and the inner right slice. That forces a single slice turn to require 3 moves, the outer block turn and inner block turn, then reversing the outer block turn. Peculiar.

If an outer face can move "all by itself" then an inner slice should have the same capability.

I can see how reduction turns the 4x4x4 into a 3x3x3 for ease of learning. But what happens if you remembered the center layout incorrectly? :) Oops, you get to resolve at least 8 centers.

I always do the corners first on the 4x4x4; it tells me what centers must go where. I am searching for better edge-pairing algorithms to reduce the movecount for that phase. My last layer solving is optimized now that I learned all of the algs. That leaves me a "ring" around the cube. I am having my program solve as many of these as possible. Currently it has every 4-turn, 5-turn, 6-turn, and 7-turn solution mapped. It can also probe these positions in RAM during the search, so that an 8-move search really is capable of seeing up to 15 moves into the future. Once it hits any such pre-computed position, the solution is applied, and the cube is solved.

I am solving the 8-turn center database right now, but it will take a while to finish. The reason is, I solve each distance from each of the 24 possible rotated states. So I have 24 times as many positions, but the lookup speed is incredibly fast.

centers_8_computing.png


I have enough RAM to solve the 9- and 10-turn center databases. I'm not sure what the longest "centers-unsolved-only" position is, but it will be cool if my program will be able to go instantly from the last-layer to the solved state :)
 
Last edited:
Next : F2 L2 B L D F D B U F' D2 B' D2 F2 R2 F' U2 L2 D2 R2 Fw2 U2 Fw2 L' D' Fw2 F2 R' U' Fw2 F2 U Fw' L2 F2 L' U' L Rw' D' Fw' Rw L2 Uw Rw2

Solution using a method I use to apply ZZ to the 4x4:
U2 r2 f' // First center
F' r F r' y2 z' F' d R2 d' // Second center
L F r U' // First cross edge
L' U2 r2 U' // Second cross edge
R2 F' D r L' U x // Third cross edge
3r U2 3r' U' r U' // Half centers
3r' U' r2 U r U' r' U2 3r' U2 r U r' // Finish centers
3R' R' U' R U 3R L F' // Last "cross" edge
z' u U F' L F L' U2 R U' R' y R U R' F R' F' R u' y2 // 5 more edges
U' F R' F' R u' R U2 R' u D' // Finish edges
U F // EO
L U' L' r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2 // Parity
D U L U' L' R U2 R L' U2 L // L block
U' R U' R' U R U' R U2 R' U' R' U R U' R' U' R // R block
U2 R' U R2' D 3r' U2 3r D' R2 U' R // COLL
U' R2 U R U R' U' R' U' R' U R' // PLL

alg.cubing.net

Next: R2 f R' r' U' r' f2 F u2 U' B r2 F' U' u' L' u' F U' B L2 u F' L' D R2 U' D2 F' r U2 D2 R2 u2 L2 U2 u' f R U'
 
z
U' r2 x' R' u // first center
z x' U' r U' r' x' U r U2 r' // 2nd center
y' U' D l D' // first cross edge
F' R' U r L U // 2nd cross edge
x U2 r 3r2 U // 3rd cross edge
x U' 3r2 U2 3r' // half centers
r U' r2 // orange center
U2 r U' r' // green center
r' U r // L2C
x2 z' R u' R U R' F R' F' R u R' D' // cross
u' y U' L' U L u R U R' u' y2 R U2 R' U L' U' L u // eww edges case
y' U' R U R' u' R U R' u // L2E
R' U R U2 R' U R // first pair
U' D R U' R' D' // 2nd pair
L U L' U y' L' U' L // 3rd pair
R U' R' U' R U' R' U R U' R' // 4th pair
R' U' R' F R F' U R // OLL
M2 U' M2 U2 M2 U' M2 // PLL

NEXT: Uw' F' U2 B2 Rw2 F2 U' Rw' F2 U' R Fw F' Uw B D2 Fw Uw Rw' Fw' Uw F' Uw' F2 Rw U B R2 B' Rw B' D Rw R2 Fw B R' B' Rw' L'
 
Back
Top