aceofspades98
Member
Its not a bad idea. It doesn't involve any more thinking than a cfop solve with practice. And could be very useful for f2l.
-
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 New Method / Substep / Concept Idea Thread
- Thread starter elrog
- Start date
Its not a bad idea. It doesn't involve any more thinking than a cfop solve with practice. And could be very useful for f2l.
cuBerBruce
Member
Swapping DF and DB with "PLL" adds about one move (optimal face turn metric) on average over regular PLL. There is no "skip" case and the worst case of 16 moves instead of 15.
I also note that if using one alg for each case, you will half the time need a pre-AUF (90-degree turn) to line up the last layer properly with the pieces to swap on D, in addition to also needing a post-AUF a majority of the time. Regular PLL just requires one AUF, which can be done either before or after the alg.
Move distribution comparison is given below:
Code:
moves Standard DF-DB swap
PLL + PLL
----- ----- -----
0f*: 1 0
1f*: 3 0
5f*: 0 1
6f*: 0 5
7f*: 0 2
9f*: 18 0
10f*: 82 2
11f*: 16 30
12f*: 40 74
13f*: 84 100
14f*: 40 63
15f*: 4 8
16f*: 0 3
avg.: 11.64 12.63elrog
Member
As I was messing around with different ideas, I happened across this.
Rather than using CLS + PLL, you can save on alg count by just orienting the corners and permuting the last layer + 1 corner.
CLS + PLL = 104 + 21 = 125
CO + PLL+1 = 15 + (72+21) = 108
PLL+1 corner could be recognized from 2 sides just like PLL, while CO is easier a little recognition than CLS.
I also found that Using ELS with key holing is still efficient while keeping a low alg count making it better than ZBLS.
Rather than using CLS + PLL, you can save on alg count by just orienting the corners and permuting the last layer + 1 corner.
CLS + PLL = 104 + 21 = 125
CO + PLL+1 = 15 + (72+21) = 108
PLL+1 corner could be recognized from 2 sides just like PLL, while CO is easier a little recognition than CLS.
I also found that Using ELS with key holing is still efficient while keeping a low alg count making it better than ZBLS.
elrog
Member
When solving edges on the 4x4, I place the edge oriented correctly while I swap it for another edge. This makes EO complete when I finish the edges. I solve the last 2 edges into correct orientation usually with a 3-cycle commutator. I'm sure others have thought of this, but does anyone do it?
Another Idea I've had is to just not pair the last 2 edges and save them for the very last part of the solve so you solve both parities and pair the last 2 edges in one step.
Another Idea I've had is to just not pair the last 2 edges and save them for the very last part of the solve so you solve both parities and pair the last 2 edges in one step.
BaMiao
Member
But then the edge you're swapping in isn't necessarily oriented well for pairing up the next edge. You'd just end up wasting moves trying to set up the next pair.
aceofspades98
Member
Ever heard of Z4?
elrog
Member
You can put the edge in in a different place in the middle layer to have it oriented correctly. The only problem is you can't do multi edge pairs at the same time.
I have actually, I just didn't know what it was. It is just what I was thinking of though.
elrog
Member
We Have VHF2L for CFOP. Why not also have it for Roux? Rather than having 8 algs for the pair connected, 8 for it unconnected, and then the mirrors of them, it would take 32 algs for the pair connected and 32 for it unconnected.
In R U R' and U' F' U F the pair is only a M move away. If you get the centers off though, the edge in the pair would be counted as a bad edge though completely ruining the systems recognition.
If anyone has any solutions to this, you could eliminate half the cases.
Also, if you get the mirror of a case, you'll just have to do a D move to keep from messing up the S layer. The only problem with this is cube rotations. I gues you could get completely different algs, but that's doubleing the alg count if you don't count mirrors as separate algs.
Another cool Idea is to do VHF2L with Phasing. This would take 24 algorithms for the pair connected, 24 for unconnected, and all the mirrors.
EDIT: You could also do this without the corner possibly shortening the alg. It'd be like doing Phasing with ELS.
In R U R' and U' F' U F the pair is only a M move away. If you get the centers off though, the edge in the pair would be counted as a bad edge though completely ruining the systems recognition.
If anyone has any solutions to this, you could eliminate half the cases.
Also, if you get the mirror of a case, you'll just have to do a D move to keep from messing up the S layer. The only problem with this is cube rotations. I gues you could get completely different algs, but that's doubleing the alg count if you don't count mirrors as separate algs.
Another cool Idea is to do VHF2L with Phasing. This would take 24 algorithms for the pair connected, 24 for unconnected, and all the mirrors.
EDIT: You could also do this without the corner possibly shortening the alg. It'd be like doing Phasing with ELS.
Last edited:
kunparekh18
Member
Well Roux is all about minimal algorithms so I don't think most Rouxers would learn this. Cool idea though
elrog
Member
New Speedsolving Method (Navi)
I liked the way that porkynator named his algorithms for his version of ZZ-d after Pokemon. I decided to go with a random name as well and name this method after the fairy in the Zelda games. I also put a lot of thinking time into the creation of this method, so please don't dismiss it as you normally would dismiss any random method. I wasn't going to post something I didn't think could be fast.
My "theory" behind this method is to exploit the small algorithm sets the same way that OCLL/PLL is so much better than ZBLL. This method utilizes a total of 86 (21 mirrors) algorithms including algorithms used throughout the F2L. A few of the algorithms can be done intuitively. The largest single algorithm set is 33 (9+24) algorithms, so recall shouldn't be a problem. You can learn subsets of the algorithms and still be able to solve the cube, which helps people learn the method. I'd say this method is not the easiest method to learn, but its not too difficult. With practice, the first step and possibly the second can be planned out during inspection.
Here is a step by step description of the method.
- Pictures that go along with the explanations were created using VisualCube.
Here are some example solves.
- Scrambles for this section were generated using qqtimer.
Algorithms for each step can be found here.
Here's an explanation of how to solve the cube using less algorithms for beginners to the method.
You can find out what the acronyms stand for here.
Thanks to Cride5 for creating VisualCube, and to Lucas Garron for creating alg.garron.us and making it so easy to use on the forums.
If you find anymore algorithms that are good or better than these, or if one of these doesn't work, please notify me.
I do plan to eventually make algorithms for solving with the first block on the left throughout the solve, and algorithms to orient the corners before phasing in case you prefer to do the Orph cases rather than the standard phasing. You may also just decide to do this when you get a phasing case that an F move shows up.
I liked the way that porkynator named his algorithms for his version of ZZ-d after Pokemon. I decided to go with a random name as well and name this method after the fairy in the Zelda games. I also put a lot of thinking time into the creation of this method, so please don't dismiss it as you normally would dismiss any random method. I wasn't going to post something I didn't think could be fast.
My "theory" behind this method is to exploit the small algorithm sets the same way that OCLL/PLL is so much better than ZBLL. This method utilizes a total of 86 (21 mirrors) algorithms including algorithms used throughout the F2L. A few of the algorithms can be done intuitively. The largest single algorithm set is 33 (9+24) algorithms, so recall shouldn't be a problem. You can learn subsets of the algorithms and still be able to solve the cube, which helps people learn the method. I'd say this method is not the easiest method to learn, but its not too difficult. With practice, the first step and possibly the second can be planned out during inspection.
Here is a step by step description of the method.
- Pictures that go along with the explanations were created using VisualCube.
Step 1: D-Block
Solve a 1x2x3 block on the D face and position it so that the R slice is free. This could also be done on the left side with the U-layer free. If you use the left side, your first two layers would be the left 2 layers.
Step 2: 2EE
Solve two adjacent E-layer edges using U, Uw, R, and possibly E moves and position them to create a 2x2x3 block or a pseudo 2x2x3. You may also influence the next step by orienting the last D-layer edge, or matching it with one of its corners. You may do this influencing during step one if you see the chance.
Step 3: D-Pair
Solve the missing D-layer edge and one of the missing D-layer corners. Keep in mind that you will want to have the still unsolved corner slot in the FRD position for orientation and permutation algorithms. Assuming you don't favor doing the BRD corner first, which you should, you have a 25% chance of having to do a y rotation to get the unsolved corner in the FRD position. Don't go out of your way too much to avoid a rotation though, because F moves are arguably worse. You can also try to avoid bad E-layer edge positions.
Step 4: EELS
Keyhole one of the missing E-layer edges in using ELS to orient top layer edges. You count the last E-layer edge as good or bad depending on the one in its place or depending on if you have an even/odd number of bad/good edges. This step uses 21 algs (8 mirrors). Some of these can be done intuitively.
You may run into some situations that you cannot simply do an ELS algorithm. This is either because both E-layer edges are oriented incorrectly in their correct position, or the 2 unsolved E-layer edges are in each others correct positions. If you run into the first case, just orient as many of the edges as you can while solving one of the E-layer edges and use one of 3 (1 of this will be your ELS algorithm for that case) algorithms in step 5 that deal with this situation. If you end up with the second case, you can simply move one of the edges into the top layer and influence the ELS case you'll get afterwards, or you can use an algorithm for that specific case which is included in the Extra algorithms listed with the ELS algorithms.
Step 5: LEEP
Keyhole in the last E-layer edge and phase the U-layer edges (make opposite edges opposite of each other). This step takes 9 (3 mirrors) algorithms. 6 are used when the edge is in the top layer, 1 is used when the last E-edge is solved, and the 3 mentioned in step 4 also must be counted (Remember that one of these will be your ELS alg for that case). All of these can be done intuitively except for the 3 mentioned in step 4.
Step 6: O5C
Orient the last 5 corners. This step can be recognized by the orientation of the top 4 corners (looking at the bottom corner isn't necessary), but there are some cases where you have to look at the left or back side of the cube. If you do look at the corner in the slot only for these cases, looking at the left or back side is never necessary. This step takes 23 algs. 7 are OCLLs and it takes 8 more algs and their mirrors.
Step 7: PLL+C
Place the D layer corner and permute the top layer. This takes 33 algorithms. 9 are PLLs (2 mirrors), and 24 (6 mirrors.) are without the last D corner in place.
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
I chose to build the F2L this way because it saves moves, yet still sustains good look ahead and a decent move-set. You may build the F2L minus one slot with edges oriented any way you want, but this is what I think the most efficient way is for speed (balancing move count with TPS). You can solve the 1x2x3 block on the left to do an easier x rotation instead of a y rotation after step 3, but the transition to the last layer requires rotation(s) unless you learn the algorithms from this angle.
With all other speedsolving methods I know of, cubers learn extra algorithms to help out in certain cases. I have generated what I believe are the most useful extra algorithms to learn. With this method, it would be recommended, but not necessary, to learn 17 (4 mirrors) extra algorithms. 8 (1 mirror) of these algorithms orient the top layer edges while phasing just in case you end up with your edges already solved in the E layer. You should already know 3 of the 8 if you know ELS. 6 (there are 12 cases, but 6 of them are not worth it) of the algorithms orient the edges while swapping one of the E layer edges to the other remaining E slot. Note that you may end up with the last E-layer edge being placed misoriented, but you should already know algorithms for this from step 5. The last 6 (3 mirrors) algorithms place the last E edge while phasing and preserving the orientation of the comers in case they end up oriented.
Pros - Low average movecount for a speedsolving method. No large algorithm sets. Can be broken down easily making it suitable for beginners to learn.
Cons - Uses F moves in the F2L. Occasionally requires a rotation.
Solve a 1x2x3 block on the D face and position it so that the R slice is free. This could also be done on the left side with the U-layer free. If you use the left side, your first two layers would be the left 2 layers.
Step 2: 2EE
Solve two adjacent E-layer edges using U, Uw, R, and possibly E moves and position them to create a 2x2x3 block or a pseudo 2x2x3. You may also influence the next step by orienting the last D-layer edge, or matching it with one of its corners. You may do this influencing during step one if you see the chance.
Step 3: D-Pair
Solve the missing D-layer edge and one of the missing D-layer corners. Keep in mind that you will want to have the still unsolved corner slot in the FRD position for orientation and permutation algorithms. Assuming you don't favor doing the BRD corner first, which you should, you have a 25% chance of having to do a y rotation to get the unsolved corner in the FRD position. Don't go out of your way too much to avoid a rotation though, because F moves are arguably worse. You can also try to avoid bad E-layer edge positions.
Step 4: EELS
Keyhole one of the missing E-layer edges in using ELS to orient top layer edges. You count the last E-layer edge as good or bad depending on the one in its place or depending on if you have an even/odd number of bad/good edges. This step uses 21 algs (8 mirrors). Some of these can be done intuitively.
You may run into some situations that you cannot simply do an ELS algorithm. This is either because both E-layer edges are oriented incorrectly in their correct position, or the 2 unsolved E-layer edges are in each others correct positions. If you run into the first case, just orient as many of the edges as you can while solving one of the E-layer edges and use one of 3 (1 of this will be your ELS algorithm for that case) algorithms in step 5 that deal with this situation. If you end up with the second case, you can simply move one of the edges into the top layer and influence the ELS case you'll get afterwards, or you can use an algorithm for that specific case which is included in the Extra algorithms listed with the ELS algorithms.
Step 5: LEEP
Keyhole in the last E-layer edge and phase the U-layer edges (make opposite edges opposite of each other). This step takes 9 (3 mirrors) algorithms. 6 are used when the edge is in the top layer, 1 is used when the last E-edge is solved, and the 3 mentioned in step 4 also must be counted (Remember that one of these will be your ELS alg for that case). All of these can be done intuitively except for the 3 mentioned in step 4.
Step 6: O5C
Orient the last 5 corners. This step can be recognized by the orientation of the top 4 corners (looking at the bottom corner isn't necessary), but there are some cases where you have to look at the left or back side of the cube. If you do look at the corner in the slot only for these cases, looking at the left or back side is never necessary. This step takes 23 algs. 7 are OCLLs and it takes 8 more algs and their mirrors.
Step 7: PLL+C
Place the D layer corner and permute the top layer. This takes 33 algorithms. 9 are PLLs (2 mirrors), and 24 (6 mirrors.) are without the last D corner in place.
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
I chose to build the F2L this way because it saves moves, yet still sustains good look ahead and a decent move-set. You may build the F2L minus one slot with edges oriented any way you want, but this is what I think the most efficient way is for speed (balancing move count with TPS). You can solve the 1x2x3 block on the left to do an easier x rotation instead of a y rotation after step 3, but the transition to the last layer requires rotation(s) unless you learn the algorithms from this angle.
With all other speedsolving methods I know of, cubers learn extra algorithms to help out in certain cases. I have generated what I believe are the most useful extra algorithms to learn. With this method, it would be recommended, but not necessary, to learn 17 (4 mirrors) extra algorithms. 8 (1 mirror) of these algorithms orient the top layer edges while phasing just in case you end up with your edges already solved in the E layer. You should already know 3 of the 8 if you know ELS. 6 (there are 12 cases, but 6 of them are not worth it) of the algorithms orient the edges while swapping one of the E layer edges to the other remaining E slot. Note that you may end up with the last E-layer edge being placed misoriented, but you should already know algorithms for this from step 5. The last 6 (3 mirrors) algorithms place the last E edge while phasing and preserving the orientation of the comers in case they end up oriented.
Pros - Low average movecount for a speedsolving method. No large algorithm sets. Can be broken down easily making it suitable for beginners to learn.
Cons - Uses F moves in the F2L. Occasionally requires a rotation.
Here are some example solves.
- Scrambles for this section were generated using qqtimer.
Example solve 1:
Example solve 2:
Example solve 3:
Example solve 4:
Example solve 5:
Scramble: L2 U2 R2 U2 F' D2 F L2 B' F D F2 L' B2 D2 U' L' D F'
(y) D2' L2' F2' u2 B' // D-Block
U R u' R' u2 // 2EE
R' U R' U' R U' R // D-Pair
u R U2 R' u' // EELS
F' U2 F // LEEP
(u U x) R' U R D' R' U' R D (x')// O5C
(U2) (R U' R' U) R U' R2' F2 R2 U' R' U' R U R' F2 (U2)// PLL+C
(y) D2' L2' F2' u2 B' // D-Block
U R u' R' u2 // 2EE
R' U R' U' R U' R // D-Pair
u R U2 R' u' // EELS
F' U2 F // LEEP
(u U x) R' U R D' R' U' R D (x')// O5C
(U2) (R U' R' U) R U' R2' F2 R2 U' R' U' R U R' F2 (U2)// PLL+C
Scramble: U2 F2 U2 B L2 U2 B' L2 B L2 F' U L R B2 U' B2 U' B2 L2
(y) F2 B' D L' F L' // D-Block
R U R u' R U2 R' u2 // 2EE
U R2 U R2 // D-Pair
R' F R F' u // EELS
F' U F u2 // LEEP
R' U L U' R U L' // O5C
(U' y') R U R2' U R U' R2 U' R' F R2 U R2' U' F' (U')// PLL+C
(y) F2 B' D L' F L' // D-Block
R U R u' R U2 R' u2 // 2EE
U R2 U R2 // D-Pair
R' F R F' u // EELS
F' U F u2 // LEEP
R' U L U' R U L' // O5C
(U' y') R U R2' U R U' R2 U' R' F R2 U R2' U' F' (U')// PLL+C
Scramble: L D' R L2 D R2 L B D B D2 F R2 D2 B2 U2 B R2 B' L2
// D-Block
// 2EE
// D-Pair
// EELS
// LEEP
// Orientation of Corners
// PLL+C
// D-Block
// 2EE
// D-Pair
// EELS
// LEEP
// Orientation of Corners
// PLL+C
Scramble: L2 F2 U2 R2 F' L2 B' D2 B R2 F R U B' D' L B' R' U' L2 B2
// D-Block
// 2EE
// D-Pair
// EELS
// LEEP
// O5C
// PLL+C
// D-Block
// 2EE
// D-Pair
// EELS
// LEEP
// O5C
// PLL+C
Scramble: F2 R2 D2 L2 D' L2 D' B2 U B2 U2 R B2 R2 D' F L2 D U2 L2
// D-Block
// 2EE
// D-Pair
// EELS
// LEEP
// O5C
// PLL+C
// D-Block
// 2EE
// D-Pair
// EELS
// LEEP
// O5C
// PLL+C
Algorithms for each step can be found here.
Normally people would use that have something like (y R' U R) instead of (F' U F) if they were a CFOP solver, but you can't effectively do (y) rotations with this method because you have a corner unsolved in the bottom that needs to stay in a certain position. So don't learn the algorithms that way. This doesn't matter for the last step though, because you'll solve the cube anyway.
Here are the 21 (8 mirrors) ELS algorithms along with 12 extra algorithms for cases with the E layer edges placed in the slot where the other E layer edge goes.
- I got pictures for each ELS case from Lucas Garron's MGLS-ELS Algs page.
- I created images for the Extra algorithms in this section using VisualCube.
Here are the 10 (one algorithm will be an ELS algorithm and 3 are mirrors) algorithms for Step 5 along with 14 other algorithms. 8 of these 14 are used in cases when you end up having the E-layer solved and the other 6 (3 mirrors) algorithms are used for cases when everything ends up being oriented correctly.
- I created pictures for the algorithms in this section using VisualCube.
Here are the 23 (8 mirrors) Orientation algorithms. I found most by hand, so they're not optimal.
- I created pictures for the algorithms in this section using VisualCube.
Here are the 33 (8 mirrors) Permutation Algorithms. 9 (2 mirrors) are PLLs, while the other 24 (6 mirrors) are PLLs plus one corner (PLL+C).
- I created pictures for the algorithms in this section using VisualCube.
Here are the 21 (8 mirrors) ELS algorithms along with 12 extra algorithms for cases with the E layer edges placed in the slot where the other E layer edge goes.
- I got pictures for each ELS case from Lucas Garron's MGLS-ELS Algs page.
- I created images for the Extra algorithms in this section using VisualCube.
Case 1:
Case 2:
Case 3:
Case 4:
Case 5:
Case 6:
Case 7:
Case 8:
Case 9:
Case 10:
Case 11:
Case 12:
Case 13:
Case 14:
Case 15:
Case 16:
Case 17:
Case 18:
Case 19:
Case 20:
Case 21:
I did not show which edge is the other E-Layer edge because it's permutation doesn't matter while its orientation does.
I have not been able to find good algorithms for cases 2, 3, 6, 8, 9, and 12. If I (or anyone else) finds decent algorithms, I will add them. I would recommend that you convert these cases into whatever ELS case works best for you (assuming it is easily reachable from the current state).
Case 1: Case 2:
Case 3:
Case 4:
Case 5:
Case 6:
Case 7:
Case 8:
Case 9:
Case 10:
Case 11:
Case 12:
I have not been able to find good algorithms for cases 2, 3, 6, 8, 9, and 12. If I (or anyone else) finds decent algorithms, I will add them. I would recommend that you convert these cases into whatever ELS case works best for you (assuming it is easily reachable from the current state).
Case 1: Case 2:
Here are the 10 (one algorithm will be an ELS algorithm and 3 are mirrors) algorithms for Step 5 along with 14 other algorithms. 8 of these 14 are used in cases when you end up having the E-layer solved and the other 6 (3 mirrors) algorithms are used for cases when everything ends up being oriented correctly.
- I created pictures for the algorithms in this section using VisualCube.
Please note that you only need the get opposite U-layer edges opposite of each other. You do not need to fully solve the U-layer edges. Because of this, opposite colors are counted as the same color.
Case 1: Case 2: Case 3: Case 4: Case 5: Case 6: Case 7: Case 8: Case 9: Case 10:
Case 1: Case 2: Case 3: Case 4: Case 5: Case 6: Case 7: Case 8: Case 9: Case 10:
The unsolved corner should be in the FRD position.
Please note that you will know 3 (or 4 if you know the mirror case) of these if you know ELS.
Case 1: Case 2: Case 3: Case 4: Case 5: Case 6: Case 7: Case 8:
Please note that you will know 3 (or 4 if you know the mirror case) of these if you know ELS.
Case 1: Case 2: Case 3: Case 4: Case 5: Case 6: Case 7: Case 8:
This is meant to be used for cases when you corners end up being oriented before phasing. These algorithm preserve corner permutation as well as orientation, so this gives you a hint at what your PLL+C algorithm will be.
Please note that you only need the get opposite U-layer edges opposite of each other. You do not need to fully solve the U-layer edges. Because of this, opposite colors are counted as the same color.
Case 1: Case 2: Case 3: Case 4: Case 5: Case 6:
Please note that you only need the get opposite U-layer edges opposite of each other. You do not need to fully solve the U-layer edges. Because of this, opposite colors are counted as the same color.
Case 1: Case 2: Case 3: Case 4: Case 5: Case 6:
Here are the 23 (8 mirrors) Orientation algorithms. I found most by hand, so they're not optimal.
- I created pictures for the algorithms in this section using VisualCube.
The unsolved corner which is not shown should be the FRD corner (excluding OCLL cases of course).
You can influence the permutation algorithm you will end up with by AUFing differently for cases that have symmetry in the U-layers corner orientation. A good example of this would be cases 22 and 23.
Case 1: Case 2: Case 3:
Case 4:
Case 5:
Case 6:
Case 7:
Case 8:
Case 9:
Case 10:
Case 11:
Case 12:
Case 13:
Case 14:
Case 15:
Case 16:
Case 17:
Case 18:
Case 19:
Case 20:
Case 21:
Case 22:
Case 23:
You can influence the permutation algorithm you will end up with by AUFing differently for cases that have symmetry in the U-layers corner orientation. A good example of this would be cases 22 and 23.
Case 1: Case 2: Case 3:
Here are the 33 (8 mirrors) Permutation Algorithms. 9 (2 mirrors) are PLLs, while the other 24 (6 mirrors) are PLLs plus one corner (PLL+C).
- I created pictures for the algorithms in this section using VisualCube.
Case 1:
Case 2:
Case 3:
Case 4:
Case 5:
Case 6:
Case 7:
Case 8:
Case 9:
The unsolved corner which is not shown should be in the FRD position.
If an algorithm has a (x) or (z) rotation at the beggining, but does not undo the rotation at the end so you can AUF, it is indicating that you perform the AUF from that orientation of the cube.
Case 1: Case 2: Case 3: Case 4: Case 5:
Case 6:
Case 7:
Case 8:
Case 9:
Case 10:
Case 11:
Case 12:
Case 13:
Case 14:
Case 15:
(U y') R2 U' R2 U R2 U2' R2 U' R2 U R2
(y')(R' U R' U' R U R) U2 (R' U' R' U R U' R)
R2' F2 U' R L F2' R' L' U F2 R2
Case 16:
Case 17:
Case 18:
Case 19:
Case 20:
Case 21:
Case 22:
Case 23:
Case 24:
If an algorithm has a (x) or (z) rotation at the beggining, but does not undo the rotation at the end so you can AUF, it is indicating that you perform the AUF from that orientation of the cube.
Case 1: Case 2: Case 3: Case 4: Case 5:
(U y') R2 U' R2 U R2 U2' R2 U' R2 U R2
(y')(R' U R' U' R U R) U2 (R' U' R' U R U' R)
R2' F2 U' R L F2' R' L' U F2 R2
Here's an explanation of how to solve the cube using less algorithms for beginners to the method.
This section if not finished yet.
Before you begin learning Navi, you should know the beginners method and know how to keyhole. If your having trouble getting started, here is a blockbuilding tutorial:
Donovan's Roux Tutorial (Part 1/5) Left Block
The video is meant for the Roux method, so he shows you how to build the block on the left side. You need to do it on the bottom, but its pretty much the same thing. You should be able to make it to step 4 from here.
Rather than doing ELS for step 4, your going to do keyholing. Here is a keyholing tutorial:
How to do Keyhole Method for Beginners
Keep in mind that you will keyhole in the last edge and leave the last corner blank, rather than solving the corner and then using an algorithm for the last edge as show in the video.
If you understand the concepts very well, you can try intuitively doing ELS. If you manage to do this, have a look at the Experienced Speedsolvers section and come back here to continue this path if you can't do the Experienced path yet. If that is just to far out of your reach at the moment, just keyhole in the remaining 2 edges.
You should then orient the edges using 3 algorithms that you probably learned in the beginners method. If you did not learn them, learn the first 3 cases listed under "ELS Algorithms" in this post. They are pretty much the same thing as the edge orientation algorithms used in the most common beginners method.
Now, you should phase the edges (get the opposite top layer edges opposite of each other) using the first algorithm listed under "Step 5 Algorithms" in this post.
Now you should learn the 7 OCLL algorithms if you do not know them already. They are the first 7 algorithms listed under "Orientation Algorithms" in this post. If you do know them already, check if they retain the phasing and learn the OCLL algorithms in this post for the cases that don't, if any. Using these 7 algorithms, you should always be able to do one of them and end up with no more than one corner in the top layer misoriented. You will then have one of the two Ape Corner orientation algorithms (or everything might already be oriented), which you can learn from this post.
You now need to learn any one of the PLL+C algorithms to place the last D layer corner. I used (x) (R' U R U')3 (x'). Now you should learn both of the A-perm and one of the N-perm PLLs to solve the top layer corners. And finally, learn the Z-perm, and H-perm to solve the cube if it is not already.
Learning more algorithms can drastically decrease your times by eliminating the number of times you have to do algorithms. Don't be scared away by the number of algorithms, because learning algorithms is not hard, it just takes time. You should learn algorithms gradually at a consistent pace. If you want to learn more, You should start by learning the rest of the 7 PLLs listed in this post. Following those, you should learn more ELS algorithms or try learning to do ELS intuitively. You should start using ELS to place the last E-layer Edge when you get a case you know so you don't have to orient the edges afterwards. After you learn all of ELS, learn the "Step 5 Algorithms" and start using ELS on the second to last E-layer Edge. These should be followed by the rest of the orientation algorithms and then the rest of the PLL+C algorithms.
Before you begin learning Navi, you should know the beginners method and know how to keyhole. If your having trouble getting started, here is a blockbuilding tutorial:
Donovan's Roux Tutorial (Part 1/5) Left Block
The video is meant for the Roux method, so he shows you how to build the block on the left side. You need to do it on the bottom, but its pretty much the same thing. You should be able to make it to step 4 from here.
Rather than doing ELS for step 4, your going to do keyholing. Here is a keyholing tutorial:
How to do Keyhole Method for Beginners
Keep in mind that you will keyhole in the last edge and leave the last corner blank, rather than solving the corner and then using an algorithm for the last edge as show in the video.
If you understand the concepts very well, you can try intuitively doing ELS. If you manage to do this, have a look at the Experienced Speedsolvers section and come back here to continue this path if you can't do the Experienced path yet. If that is just to far out of your reach at the moment, just keyhole in the remaining 2 edges.
You should then orient the edges using 3 algorithms that you probably learned in the beginners method. If you did not learn them, learn the first 3 cases listed under "ELS Algorithms" in this post. They are pretty much the same thing as the edge orientation algorithms used in the most common beginners method.
Now, you should phase the edges (get the opposite top layer edges opposite of each other) using the first algorithm listed under "Step 5 Algorithms" in this post.
Now you should learn the 7 OCLL algorithms if you do not know them already. They are the first 7 algorithms listed under "Orientation Algorithms" in this post. If you do know them already, check if they retain the phasing and learn the OCLL algorithms in this post for the cases that don't, if any. Using these 7 algorithms, you should always be able to do one of them and end up with no more than one corner in the top layer misoriented. You will then have one of the two Ape Corner orientation algorithms (or everything might already be oriented), which you can learn from this post.
You now need to learn any one of the PLL+C algorithms to place the last D layer corner. I used (x) (R' U R U')3 (x'). Now you should learn both of the A-perm and one of the N-perm PLLs to solve the top layer corners. And finally, learn the Z-perm, and H-perm to solve the cube if it is not already.
Learning more algorithms can drastically decrease your times by eliminating the number of times you have to do algorithms. Don't be scared away by the number of algorithms, because learning algorithms is not hard, it just takes time. You should learn algorithms gradually at a consistent pace. If you want to learn more, You should start by learning the rest of the 7 PLLs listed in this post. Following those, you should learn more ELS algorithms or try learning to do ELS intuitively. You should start using ELS to place the last E-layer Edge when you get a case you know so you don't have to orient the edges afterwards. After you learn all of ELS, learn the "Step 5 Algorithms" and start using ELS on the second to last E-layer Edge. These should be followed by the rest of the orientation algorithms and then the rest of the PLL+C algorithms.
You should be able to get to step 4 with no problems. You should be able to do ELS intuitively and just go back to refine cases later, just as you would do for F2L. You should also be able to phase intuitively, as this is very easy. You probably already know OCLL, so you should just do that to create an Ape case, and just learn both of those. You might want to check if your OCLL algorithms disturb the phasing or not, and if they do, learn the OCLL algorithms in this post for those cases. You can then learn a single PLL+C to do to insert the D corner {I began using (x) (R' U R U')3 (X') } and finish the solve with PLL. You may then gradually learn the rest of the Orientation algorithms and PLL+C algorithms, and maybe eventually, the extras.
You can find out what the acronyms stand for here.
Navi: The name of the method; didn't you read the title?
D-Block: The 1x2x3 block on the D-layer that you build in step 1.
2EE: Two E-layer Edges that are placed in step 2.
D-Pair: The last D edge paired with a D corner that you place in step 3.
EELS: Early ELS (Edge of the Last Slot) which is really no different than ELS except for where it is done in the solve. This is used in step 4.
LEEP: Last E edge and phasing which is done in step 5.
O5C: Orient the last 5 corners which is done in step 6.
PLL+C: PLL (Permute Last Layer) plus a corner as done in step 7.
NK: No keyhole. This just describes the situation where this alg set is used. This is what I named it because you can't keyhole an edge in if they are both in the E layer already.
EOP: Edge orientation and phasing which is pretty self explanatory.
Orph: Orientated phasing. I didn't capitalize the P because I didn't like how it looked
.
The ELS algorithms which are left have the edge that is in the slot oriented so that the top color is on the left, and the right is the same thing, just on the right.
The O5C algorithms which are left have the DRF corner with the top color on front, while the right ones have the corner in DRF with the top color on the right.
I named the individual cases mostly at random, so don't ask why it looks like an ape.
D-Block: The 1x2x3 block on the D-layer that you build in step 1.
2EE: Two E-layer Edges that are placed in step 2.
D-Pair: The last D edge paired with a D corner that you place in step 3.
EELS: Early ELS (Edge of the Last Slot) which is really no different than ELS except for where it is done in the solve. This is used in step 4.
LEEP: Last E edge and phasing which is done in step 5.
O5C: Orient the last 5 corners which is done in step 6.
PLL+C: PLL (Permute Last Layer) plus a corner as done in step 7.
NK: No keyhole. This just describes the situation where this alg set is used. This is what I named it because you can't keyhole an edge in if they are both in the E layer already.
EOP: Edge orientation and phasing which is pretty self explanatory.
Orph: Orientated phasing. I didn't capitalize the P because I didn't like how it looked
.The ELS algorithms which are left have the edge that is in the slot oriented so that the top color is on the left, and the right is the same thing, just on the right.
The O5C algorithms which are left have the DRF corner with the top color on front, while the right ones have the corner in DRF with the top color on the right.
I named the individual cases mostly at random, so don't ask why it looks like an ape.
If you find anymore algorithms that are good or better than these, or if one of these doesn't work, please notify me.
I do plan to eventually make algorithms for solving with the first block on the left throughout the solve, and algorithms to orient the corners before phasing in case you prefer to do the Orph cases rather than the standard phasing. You may also just decide to do this when you get a phasing case that an F move shows up.
Last edited:
ottozing
Platinum Member
- Joined
- Aug 13, 2011
- Messages
- 3,303
- Location
- Canberra, Australia
- WCA
- 2012MCNE01
- YouTube
- Visit Channel
Would it be any more or less advantagoud to do the 1x2x3 on the left and solve the 2x2x3 with R r U M in your opinion? The block ends up in the same spot and the move groups are generally better for the second half of the 2x2x3 (Yours might have better moves for the 1x2x3, idk).
Ranzha
Friendly, Neighbourhoodly
- Joined
- Jul 24, 2009
- Messages
- 2,551
- Location
- Reno, Nevada, United States
- WCA
- 2009HARN01
- YouTube
- Visit Channel
Better variant:
Petblock, EOsquare, phasing, ZZLL.
Or you could just use ZZ.
Petblock, EOsquare, phasing, ZZLL.
Or you could just use ZZ.
aceofspades98
Member
Interesting. I would like to see this done in competition.
TheNextFeliks
Member
Or you could use petrus.
But seriously, it's okay.
But seriously, it's okay.
mark49152
Premium Member
What are the pros and cons relative to established methods? Without some analysis of that, it looks like just another random compilation of steps labelled a method.
Wasn't it you who created the "new methods" sticky megathread? Would be good to hear why this proposal is too special to be posted there
Wasn't it you who created the "new methods" sticky megathread? Would be good to hear why this proposal is too special to be posted there
aceofspades98
Member
This method isn't that bad. Has about the same potential as most methods these days.
elrog
Member
It seems to me that the speedsolving community doesn't like to accept things without algs. Porkynator come up with a system with algs already generated and people liked it. I've never seen the community like an unfinished project yet though, so I'll work on getting algs. It may take a while with Cube Solver though.
Originally posted by me - "I'm making this thread for all of those ideas you have that are interesting, yet are not fully developed."
I am actually serious about this idea. It has much more potential than anything else I've posted. The only "not fully developed" part is the algorithms. However, I'm fine with it being moved here if that's where the mods think it should be.
To ottozing: I thought about that, but doing U, Uw, E, and R is easier for me personally, while also transitioning to the last layer better. When doing CFOP I actually like doing cross on the left for F2L, but It makes for a bad transition to the LL. Anyone is welcome to do it if they want though.
To Ranzha V.Emodrach: If that method would be any good at all, people would be doing it by now because its so similar to methods out there already. Large alg sets like ZZLL just don't work. Recall and recog both worsen. It also becomes hard to remember all the algs let alone master each one individually. Also, Petrus blockbuilding isn't great for speed because you have to find 3 pieces to be able to add onto your block. Moving 3 pieces around intuitively just isn't as fast as moving 2 at a time like in F2L. The style of blockbuilding I am doing isn't really that similar to petrus. the only similarity is you can call it blockbuilding. (sorry if I come across as unwilling to accept other ideas, but I just have thought about nearly all of the options people keep posting before and have already dismissed them)
To Chavak: Well, the algs are not generated yet. And I only average around 30 with my very Heise influenced CFOP. I do think this could be just as good as other methods out there though.
To mark49152: The more methods out there that are good, the more option you have. More options isn't a bad thing is it?
Originally posted by me - "I'm making this thread for all of those ideas you have that are interesting, yet are not fully developed."
I am actually serious about this idea. It has much more potential than anything else I've posted. The only "not fully developed" part is the algorithms. However, I'm fine with it being moved here if that's where the mods think it should be.
To ottozing: I thought about that, but doing U, Uw, E, and R is easier for me personally, while also transitioning to the last layer better. When doing CFOP I actually like doing cross on the left for F2L, but It makes for a bad transition to the LL. Anyone is welcome to do it if they want though.
To Ranzha V.Emodrach: If that method would be any good at all, people would be doing it by now because its so similar to methods out there already. Large alg sets like ZZLL just don't work. Recall and recog both worsen. It also becomes hard to remember all the algs let alone master each one individually. Also, Petrus blockbuilding isn't great for speed because you have to find 3 pieces to be able to add onto your block. Moving 3 pieces around intuitively just isn't as fast as moving 2 at a time like in F2L. The style of blockbuilding I am doing isn't really that similar to petrus. the only similarity is you can call it blockbuilding. (sorry if I come across as unwilling to accept other ideas, but I just have thought about nearly all of the options people keep posting before and have already dismissed them)
To Chavak: Well, the algs are not generated yet. And I only average around 30 with my very Heise influenced CFOP. I do think this could be just as good as other methods out there though.
To mark49152: The more methods out there that are good, the more option you have. More options isn't a bad thing is it?
mark49152
Premium Member
No of course not, but as far as I can see, you haven't said why you think this is a good/better option. What advantages does it have? What problem does it solve? I'm not complaining, just interested.
elrog
Member
Well, one advantage of more options is you can find a method more suited to you. It can also just make it harder to choose though. I didn't think there was really any problem that needs solving though.
I think this is a good option because there's no large/unlearn able alg sets, look ahead isn't bad, movecount is not bad either, the moveset is decent, and cube rotations are not needed. Basically anything you'd say about any other good method.
I think this is a good option because there's no large/unlearn able alg sets, look ahead isn't bad, movecount is not bad either, the moveset is decent, and cube rotations are not needed. Basically anything you'd say about any other good method.
Similar threads
- Deleted member 27249
- Puzzle Theory
- Deleted member 27249
- Puzzle Video Gallery
