Thread starter
#1
BLL 3Look 24alg
This is a 3Look LL method designed for efficient solving with few algs to memorize. While this isn't a speedsolving method, and isn't recommended for competitions, it is however good for intermediate cubers who want to improve their times to around if not under 30 seconds (depending of course on the F2L and fingertrick fluency). This was posted in the new methods thread, and having received a few responses, and modifications having been made, I present it here.
I was working on the creation of a method a a few years ago, that reduced the LL solve to 3 steps or less, using only 24 algorithms for memorization. Though certain recognition steps might require more time to get used to, they should bring major benefits to cubers trying to get below 30sec.
After developing the method, and memorizing only the few parts of it that I found easiest and most important to apply, I had shaved my time down from 5055 sec to 3540sec. That's a good 15 seconds difference with only half of the method in use.
The theory behind the method is that the edge orientation and permutation could be done in one step with very few algs required for memorization (15 in total). The corners are done in two steps, orientation (6 algs (5 excluding reuses of an edge alg)) and permutation (4 algs).
Putting together this method, I was looking at all the possible combinations of LL positions with respect to the edges, then corners, and finding one effective algorithm for each of them. The algorithms I chose for each situation were chosen because of the possible speed achievable with them, and not because of the number of moves (meaning that if an 11 move algorithm's time was able to be reduced effectively enough with the simplest/quickest fingertricks as opposed to an 8 move algorithm that could not, then the 11 move algorithm was chosen). Any redundant position solves (mirrors, rotations, reversed order of effects, and even cube orientations) have been discarded, requiring that recognition be more specific no matter the LL rotation; also because of this, a quick rotation of the last layer may be required (or removed from the first step) before beginning an edge algorithm, and a cube reorientation might be required before a corner orientation. You can also perform a simple cube reorientation before any algorithm if you feel your fingertricks will be more optimal with certain sides. I encourage the exploration of possible new fingertricks (for example U R' L can be done with one swift movement holding the U side by it's edges).
I will put the algorithms here, but I do not yet have a clean way of presenting exactly what they do, which I am working on getting images for and will add in an edit soon. In the meantime, you can experiment to see what each one does.
A bracketed {U} move at the beginning of some algorithms is left for a more organized understanding of what the algorithm does. These can (and should) be excluded when the orientation of the U layer is appropriate.
This method isn't designed to be a professional/competition solving speed method, but is simply meant to be a method for beginnerintermediate cubers to be able to get almost 30 second times (if not faster) using only a small handful of algorithms. It also isn't designed to be a static orientation method, though it can be adapted to that if your fingers are talented enough, and that does shave many precious seconds off. This method is meant to be adapted to the needs and the skill of the cuber using it, so any use of reorientation, fingertricks, and solve recognition methods are up to the cuber.
As opposed to other methods I looked at the cases and algorithms required in other combinations. Specifically the following cases:
Common method 1: OLL(avg moves 10)+PLL(avg moves 12) = 57+21 = 78 algorithms (avg moves 22).
Common method 2: CLL(avg moves 10)+ELL(avg moves 11) = 42+29 = 71 algorithms (avg moves 21). Out of the question for my goal of few algorithms.
Common 3step/3Look method: 2Look OLL(avg moves 6+8)+PLL(avg moves 12) = 3+7+21 = 31 algorithms (avg moves 26). Good, but still too many algorithms (21) requiring very difficult recognition techniques. The recognition skill required for the final step to be effective serves as an impediment to speed and simplicity of learning and executing the method.
This method: LLEF(avg moves 8)+OCLLEPP(avg moves 10)+CPLL(avg moves 9) = 15+5+4 = 24 algorithms (avg moves 27) with only a 6 move difference from CLL+ELL, and there are only 510 cases requiring a somewhat tricky recognition stage (the edge "merges").
So at the sacrifice of 6 extra moves (let's say it takes about two seconds to do that, to be modest) and one extra (and simple) recognition pause (lets also say about two seconds), we're talking about a 4 second difference between CLL+ELL and this method. So in terms of simplicity and benefit, this is, theoretically, a very effective method to achieve fast times.
Now, while it's nothing compared to the ZZ and Roux methods (for obvious reasons), it can be adapted to be used with the ZZ F2L (if you're into frankensteining things), and because of the initial edge orientation from ZZ, the LLEF is reduced to 2 algorithms, making 11 algs in total for a 3Look last layer. In order to maintain the consistency of ZZ in not using the F and B sides, the algorithms can be traded to those of your own making should you so desire. This method, after all, isn't about the algorithms used, but simply the efficient order of operations.
Right now, I'm looking at the possibilities of a 2LLL based on this origin point. There is the obvious L4C step (combining the two corner steps into one) with 84 algs, making a 99 alg 2LLL method. Mixing any steps between edges and corners (ex: Solve edges and Orient Corners, or solve edges and permute corners) requires massive amounts of algorithms due to the possible rotations of each relative to each other (E+CO = 360 algs?, E+CP = 240? unless of course some of the case I'm thinking are nonexistent, which I both doubt and don't have the drive to go and find out). So in looking to create a 2LLL method using Edges First as a base, while it is possible to do, requires at least 99 algs for memorization and becomes an unrealistic 74 alg step up from the 25 algs for 3LLL.
But what if the F2L already oriented the edges?
Well then. We would have an E+CO of 48 algs (8 of which are already known), added to the 4 CP algs, which makes a 52 alg 2LLL with only a 40 alg learning curve. We could also perform an E+CP of 32 algs (6 of which are already memorized), added to 7 Corner orientation algs (between 25 of the current algs might need replaced with algs that respect permutation) for a 2LLL of only 39 algs, with a 26 alg learning curve. Compared to OCLL/PLL (28 algs), it could be worth it to just learn OCLL/PLL instead. But at the same time, it's still better than the 44 alg COLL/EPLL.
All in all, these are the possibilities.
Questions? Comments? Critique? Unfunny jokes?
This is a 3Look LL method designed for efficient solving with few algs to memorize. While this isn't a speedsolving method, and isn't recommended for competitions, it is however good for intermediate cubers who want to improve their times to around if not under 30 seconds (depending of course on the F2L and fingertrick fluency). This was posted in the new methods thread, and having received a few responses, and modifications having been made, I present it here.
I first got a cube when I was 5. I loved it, but couldn’t even solve one side for a while. But I was determined. So I eventually learned to get a side, and I was satisfied. Whenever the cube got mixed, I would use the famous “Rob’s Rubix Repair” from over 12 years ago (found here). That is until I turned 11. I then wanted to know how to solve it myself, and after quite some time and determination, I figured out the basics of F2L, and I found the following method for LL.
BLL SuperBeginner Method
This method provided only the necessities for solving the last layer by combining the algorithms in logical ways (no recog, just cog).
Sometimes the method would be anywhere from 2Look to a frustrating 8Look, but on average it was 45 Look. Though, that served me well for a while (and to this day, I can still get good sub50 times with it), but it wasn’t enough, having watched Dan Knights solve the cube in 22ish seconds every time. So I thought harder. And maintaining 3 of the above algorithms, I came up with this:
BLL 4LLL Method
This method is the evolution of the first method. By adding a few algorithms to the edges and corners, the method was constrained to 4Looks or less, with a good chance (5/16) of skipping one or both edge steps, making it 3 step 4/16 of the time, and two step 1/16 the time (already solved to begin). Take a look:
Edges (Just enough algs to reduce the edge steps to at most 2 when used wisely)
Corners (same algs from full BLL)
This method proved to quickly bring me sub40 times consistently, even though I hadn’t yet trained my F2L for optimization. And thanks to the great luck in the skipping department, I got some 35 second times, and sometimes faster. I once even got a 25.5 time using this method.
But still, I wasn’t averaging sub30. So I went on to learn intuitive F2L, and to create the BLL method presented here.
BLL SuperBeginner Method
This method provided only the necessities for solving the last layer by combining the algorithms in logical ways (no recog, just cog).
Edges (orient first, then permute)
Flip the front and left edges (orientation):
M’ U’ M U2 M’ U’ M
Trade the front and right edges (permuting):
U [R U R’ U R U2 R’](bracketed part will be used in corners as well)
Corners (permute first, then orient)
Trade the front left, front right, and back left in a clockwise manner (permuting):
R’ U L U’ R U L’ U’
Rotate the front left and back left corners outward from the inside (orienting):
[R U R’ U R U2 R’] + [L’ U’ L U’ L’ U2 L](mirror of the bracketed alg)
Flip the front and left edges (orientation):
M’ U’ M U2 M’ U’ M
Trade the front and right edges (permuting):
U [R U R’ U R U2 R’](bracketed part will be used in corners as well)
Corners (permute first, then orient)
Trade the front left, front right, and back left in a clockwise manner (permuting):
R’ U L U’ R U L’ U’
Rotate the front left and back left corners outward from the inside (orienting):
[R U R’ U R U2 R’] + [L’ U’ L U’ L’ U2 L](mirror of the bracketed alg)
Sometimes the method would be anywhere from 2Look to a frustrating 8Look, but on average it was 45 Look. Though, that served me well for a while (and to this day, I can still get good sub50 times with it), but it wasn’t enough, having watched Dan Knights solve the cube in 22ish seconds every time. So I thought harder. And maintaining 3 of the above algorithms, I came up with this:
BLL 4LLL Method
This method is the evolution of the first method. By adding a few algorithms to the edges and corners, the method was constrained to 4Looks or less, with a good chance (5/16) of skipping one or both edge steps, making it 3 step 4/16 of the time, and two step 1/16 the time (already solved to begin). Take a look:
Edges (Just enough algs to reduce the edge steps to at most 2 when used wisely)
Front and right edges. (3 algs)
(F = flip, S = switch(trade), SF = switchflip)
F
R' F R U2 F' U' F' U F2 U2 F'
S
U [R U R’ U R U 2 R’](bracketed part will be used in corners as well)
SF
F2 R U R2 F R F’ U L F L’ U2 F2
Opposite edges (1 alg)
SF
R U' R' F' U F R U R2 F R F'
(F = flip, S = switch(trade), SF = switchflip)
F
R' F R U2 F' U' F' U F2 U2 F'
S
U [R U R’ U R U 2 R’](bracketed part will be used in corners as well)
SF
F2 R U R2 F R F’ U L F L’ U2 F2
Opposite edges (1 alg)
SF
R U' R' F' U F R U R2 F R F'
Corner Orientation algs:
Based on the orientation of the LL color faces. x means it's correctly oriented. (6 algs)
F U R' U' R2 U' R2 U2 R U2 R U R' F'
R B' R B R2 F R' F' R F' U2 F U2
R' U L U' R U L' U'
L U' R' U L' U' R U (Simply a mirror of the above. Also, can be solved by using the above algorithm twice after U')
R U R' U R U2 R' (then mirror it) L' U' L U' L' U2 L
(The same as above, simply perform a Z' reorientation first. Or if you're talented with the down layer: D R D' R D R2 D' (then mirror) U' R' U R' U' R2 U making 25 algs in total)
L' U' L' U R U' L U R' L (These last two moves can be replaced with a slice move, or the last three with an odd fingertrick)
Corner Permutation algs:
(4 algs)
Threecorner trade clockwise (the three corners are the two back corners and the front right corner)
(X) R' U R' D2 R U' R' D2 R2 (X’) (or if you don't want to reorient and can do the Front and Back layers well enough: R' F R' B2 R F' R' B2 R2)
Threecorner trade counterclockwise
(X) R2 D2 R U R' D2 R U' R (X') (literally just backwards of the first one. Without reorientation: R2 B2 R F R' B2 R F' R)
Front to back (and viceversa)
{U} R2' U R' d' R U R' U' R U R' U' R U R' F U' F2
Cross (front right trading to back left, and front left trading to back right. Equal to trading all edge pieces to opposite sides.)
L2 R2' U L2 R2' U2 L2 R2' U L2 R2' (I recommend that this be modified with slice moves to: M2 U M2 U2 M2 U M2)
Based on the orientation of the LL color faces. x means it's correctly oriented. (6 algs)
Code:
_

 _
Code:
_ _
_ _
Code:
_
x
_ 
Code:
_
x
 _
Code:
_
x
_ x
Code:
x 
x 
Code:
_
x
 x
Corner Permutation algs:
(4 algs)
Threecorner trade clockwise (the three corners are the two back corners and the front right corner)
(X) R' U R' D2 R U' R' D2 R2 (X’) (or if you don't want to reorient and can do the Front and Back layers well enough: R' F R' B2 R F' R' B2 R2)
Threecorner trade counterclockwise
(X) R2 D2 R U R' D2 R U' R (X') (literally just backwards of the first one. Without reorientation: R2 B2 R F R' B2 R F' R)
Front to back (and viceversa)
{U} R2' U R' d' R U R' U' R U R' U' R U R' F U' F2
Cross (front right trading to back left, and front left trading to back right. Equal to trading all edge pieces to opposite sides.)
L2 R2' U L2 R2' U2 L2 R2' U L2 R2' (I recommend that this be modified with slice moves to: M2 U M2 U2 M2 U M2)
But still, I wasn’t averaging sub30. So I went on to learn intuitive F2L, and to create the BLL method presented here.
After developing the method, and memorizing only the few parts of it that I found easiest and most important to apply, I had shaved my time down from 5055 sec to 3540sec. That's a good 15 seconds difference with only half of the method in use.
The theory behind the method is that the edge orientation and permutation could be done in one step with very few algs required for memorization (15 in total). The corners are done in two steps, orientation (6 algs (5 excluding reuses of an edge alg)) and permutation (4 algs).
Putting together this method, I was looking at all the possible combinations of LL positions with respect to the edges, then corners, and finding one effective algorithm for each of them. The algorithms I chose for each situation were chosen because of the possible speed achievable with them, and not because of the number of moves (meaning that if an 11 move algorithm's time was able to be reduced effectively enough with the simplest/quickest fingertricks as opposed to an 8 move algorithm that could not, then the 11 move algorithm was chosen). Any redundant position solves (mirrors, rotations, reversed order of effects, and even cube orientations) have been discarded, requiring that recognition be more specific no matter the LL rotation; also because of this, a quick rotation of the last layer may be required (or removed from the first step) before beginning an edge algorithm, and a cube reorientation might be required before a corner orientation. You can also perform a simple cube reorientation before any algorithm if you feel your fingertricks will be more optimal with certain sides. I encourage the exploration of possible new fingertricks (for example U R' L can be done with one swift movement holding the U side by it's edges).
I will put the algorithms here, but I do not yet have a clean way of presenting exactly what they do, which I am working on getting images for and will add in an edit soon. In the meantime, you can experiment to see what each one does.
A bracketed {U} move at the beginning of some algorithms is left for a more organized understanding of what the algorithm does. These can (and should) be excluded when the orientation of the U layer is appropriate.
(F = flip, S = switch(trade), SF = switchflip)
Opposite twoedge combos. (8 algs)
(front and right edges  back and left edges)
FØ
R' F R U2 F' U' F' U F2 U2 F'
SØ
{U} <apply the first half of the 5th case corner orientation algorithm: R U R' U R U2 R' as seen below>
SFØ
F2 R U R2 F R F’ U L F L’ U2 F2
SFS
F R U R' U' F2 L' U' L U F
SFSF (you can choose, I found both to be equally effective)
1  R' F R F' U2 R' F R F2 U2 F
2  F R' F' R U2 F R' F' R2 U2 R'
FF
R U B' U' R' U R B2 U B' U' R'
SF
F U2 F' U2 F' L F L'
SFF
{U} L' B L B' U2 B' U R' U R B
SS (Equal to opposite edges being switched, just rotate once)
R U R' U' R' F R2 U' R' U' R U R' F'
Opposite edge combos (2 algs)
(front and back edges)
F
F U F' U F U' R U' R' F'
SF
R U' R' F' U F R U R2 F R F'
S (see SS in Opposite twoedge combos)
Merges (5 algs)
(front and right edges  right and back edges)
SFS
{U'} R U B U' B' R'
FS
{U} F' U' L' U L F
SSF
R' U' R U R B' R' B
FSF
F' L' U' L U F
SF
{U} B U B' U' B' R B R'
Opposite twoedge combos. (8 algs)
(front and right edges  back and left edges)
FØ
R' F R U2 F' U' F' U F2 U2 F'
SØ
{U} <apply the first half of the 5th case corner orientation algorithm: R U R' U R U2 R' as seen below>
SFØ
F2 R U R2 F R F’ U L F L’ U2 F2
SFS
F R U R' U' F2 L' U' L U F
SFSF (you can choose, I found both to be equally effective)
1  R' F R F' U2 R' F R F2 U2 F
2  F R' F' R U2 F R' F' R2 U2 R'
FF
R U B' U' R' U R B2 U B' U' R'
SF
F U2 F' U2 F' L F L'
SFF
{U} L' B L B' U2 B' U R' U R B
SS (Equal to opposite edges being switched, just rotate once)
R U R' U' R' F R2 U' R' U' R U R' F'
Opposite edge combos (2 algs)
(front and back edges)
F
F U F' U F U' R U' R' F'
SF
R U' R' F' U F R U R2 F R F'
S (see SS in Opposite twoedge combos)
Merges (5 algs)
(front and right edges  right and back edges)
SFS
{U'} R U B U' B' R'
FS
{U} F' U' L' U L F
SSF
R' U' R U R B' R' B
FSF
F' L' U' L U F
SF
{U} B U B' U' B' R B R'
Based on the orientation of the LL color faces. x means it's correctly oriented. (6 algs (5 excluding reuse))
F U R' U' R2 U' R2 U2 R U2 R U R' F'
R B' R B R2 F R' F' R F' U2 F
R' U L U' R U L'
L U' R' U L' U' R (Simply a mirror of the above. Also, can be solved by using the above algorithm twice after doing a U' turn)
R U R' U R U2 R' (then mirror it) L' U' L U' L' U2 L
(The same as above, simply perform a Z' reorientation first. Or if you're talented with the down layer: D R D' R D R2 D' making 26 algs in total)
L' U' L' U R U' L U R' L (These last two moves can be replaced with a slice move, or the last three with an odd fingertrick)
Code:
_

 _
Code:
_ _
_ _
Code:
_
x
_ 
Code:
_
x
 _
Code:
_
x
_ x
Code:
x 
x 
Code:
_
x
 x
(4 algs)
Threecorner trade clockwise (the three corners are the two back corners and the front right corner)
(X) R' U R' D2 R U' R' D2 R2 (X’) (or if you don't want to reorient and can do the Front and Back layers well enough: R' F R' B2 R F' R' B2 R2)
Threecorner trade counterclockwise
(X) R2 D2 R U R' D2 R U' R (X') (literally just backwards of the first one. Without reorientation: R2 B2 R F R' B2 R F' R)
Left to right (and viceversa)
R2' U R' d' R U R' U' R U R' U' R U R' F U' F2
Cross (front right trading to back left, and front left trading to back right. Equal to trading all edge pieces to opposite sides.)
L2 R2' U L2 R2' U2 L2 R2' U L2 R2' (I recommend that this be modified with slice moves to: M2 U M2 U2 M2 U M2)
Threecorner trade clockwise (the three corners are the two back corners and the front right corner)
(X) R' U R' D2 R U' R' D2 R2 (X’) (or if you don't want to reorient and can do the Front and Back layers well enough: R' F R' B2 R F' R' B2 R2)
Threecorner trade counterclockwise
(X) R2 D2 R U R' D2 R U' R (X') (literally just backwards of the first one. Without reorientation: R2 B2 R F R' B2 R F' R)
Left to right (and viceversa)
R2' U R' d' R U R' U' R U R' U' R U R' F U' F2
Cross (front right trading to back left, and front left trading to back right. Equal to trading all edge pieces to opposite sides.)
L2 R2' U L2 R2' U2 L2 R2' U L2 R2' (I recommend that this be modified with slice moves to: M2 U M2 U2 M2 U M2)
This method isn't designed to be a professional/competition solving speed method, but is simply meant to be a method for beginnerintermediate cubers to be able to get almost 30 second times (if not faster) using only a small handful of algorithms. It also isn't designed to be a static orientation method, though it can be adapted to that if your fingers are talented enough, and that does shave many precious seconds off. This method is meant to be adapted to the needs and the skill of the cuber using it, so any use of reorientation, fingertricks, and solve recognition methods are up to the cuber.
As opposed to other methods I looked at the cases and algorithms required in other combinations. Specifically the following cases:
Common method 1: OLL(avg moves 10)+PLL(avg moves 12) = 57+21 = 78 algorithms (avg moves 22).
Common method 2: CLL(avg moves 10)+ELL(avg moves 11) = 42+29 = 71 algorithms (avg moves 21). Out of the question for my goal of few algorithms.
Common 3step/3Look method: 2Look OLL(avg moves 6+8)+PLL(avg moves 12) = 3+7+21 = 31 algorithms (avg moves 26). Good, but still too many algorithms (21) requiring very difficult recognition techniques. The recognition skill required for the final step to be effective serves as an impediment to speed and simplicity of learning and executing the method.
This method: LLEF(avg moves 8)+OCLLEPP(avg moves 10)+CPLL(avg moves 9) = 15+5+4 = 24 algorithms (avg moves 27) with only a 6 move difference from CLL+ELL, and there are only 510 cases requiring a somewhat tricky recognition stage (the edge "merges").
So at the sacrifice of 6 extra moves (let's say it takes about two seconds to do that, to be modest) and one extra (and simple) recognition pause (lets also say about two seconds), we're talking about a 4 second difference between CLL+ELL and this method. So in terms of simplicity and benefit, this is, theoretically, a very effective method to achieve fast times.
Now, while it's nothing compared to the ZZ and Roux methods (for obvious reasons), it can be adapted to be used with the ZZ F2L (if you're into frankensteining things), and because of the initial edge orientation from ZZ, the LLEF is reduced to 2 algorithms, making 11 algs in total for a 3Look last layer. In order to maintain the consistency of ZZ in not using the F and B sides, the algorithms can be traded to those of your own making should you so desire. This method, after all, isn't about the algorithms used, but simply the efficient order of operations.
Right now, I'm looking at the possibilities of a 2LLL based on this origin point. There is the obvious L4C step (combining the two corner steps into one) with 84 algs, making a 99 alg 2LLL method. Mixing any steps between edges and corners (ex: Solve edges and Orient Corners, or solve edges and permute corners) requires massive amounts of algorithms due to the possible rotations of each relative to each other (E+CO = 360 algs?, E+CP = 240? unless of course some of the case I'm thinking are nonexistent, which I both doubt and don't have the drive to go and find out). So in looking to create a 2LLL method using Edges First as a base, while it is possible to do, requires at least 99 algs for memorization and becomes an unrealistic 74 alg step up from the 25 algs for 3LLL.
But what if the F2L already oriented the edges?
Well then. We would have an E+CO of 48 algs (8 of which are already known), added to the 4 CP algs, which makes a 52 alg 2LLL with only a 40 alg learning curve. We could also perform an E+CP of 32 algs (6 of which are already memorized), added to 7 Corner orientation algs (between 25 of the current algs might need replaced with algs that respect permutation) for a 2LLL of only 39 algs, with a 26 alg learning curve. Compared to OCLL/PLL (28 algs), it could be worth it to just learn OCLL/PLL instead. But at the same time, it's still better than the 44 alg COLL/EPLL.
All in all, these are the possibilities.
Questions? Comments? Critique? Unfunny jokes?
Last edited: