The New Method / Substep / Concept Idea Thread

Aerma said:
So, a sort of Roux/Petrus/ZZ-CT hybrid:
1) Solve Roux block on left and 2x2x1 block on right (in RB)
2) TSLE/CTTLL (Corner TTLL)
3) EODB
4) L5E (all M/U, you could just use insertion canceling into EPLL every time)
Click to expand...

I don't quite see, why EODB and L5E should be used (lookahead to the DB edge isn't that hard)
My suggestion is either normal LSE(fast enough, can be done in 1.7 seconds)
or EOdFdB and EPLL since that could be done using just M and U moves
the TSLE+Corner only TTLL sooks quite interesting when mixed with TCMLL

Reed Merrill said:
What would it be like if you did EODB and L5E using wide r turns instead? I ask because that sounds nice for me (I'm not too good at M moves) but I also don't know if that would be for step 2.
Click to expand...

Nah, r+R insead of M changes corners and the Steps almost certaily need to be done algorithmic which isn't worth it at all
 
ok, how about a Roux/ZZ-Orbit hybrid haha:
1) CPBlock
2) Second block minus FRD corner
3) insert last corner while making sure every LL corner is misoriented
4) EODFDB
5) Last layer (just the 2GLL cases for H and Pi)

for second block you could also just do minus one pair and connect it before inserting it with the alg.
 
Sorry for double posting, but this is unrelated to my last one.
I think it would be really nice and helpful if there was a better way to memorize algorithms than the conventional way of remembering triggers and tracking F2L pairs around the cube because lets face it, it's really difficult to learn a large quantity of them using this method.
I've created a sort-of method for this, or at least the many 2GLL cases where the alg is just a sune/antisune from either the front or the back, doing some U move, then doing another sune/antisune to finish. This is in every H 2GLL case minus one, for example.
Basically, I gave all of those algorithms I already knew a name that I could remember and that I could use in a sentence. So sune is death (because death comes soon), anti sune is not-death or not dying, a sune from the back is duck and an antisune from the back is evil duck. Then the standard alg for an H case (R U2 R' U' R U R' U' R U R') is super sune, so say doing it from the back is super duck.
Then you would decide on a name for the case on the cube that you can easily remember, for example the ZBLL you can solve with (R' U2 R U R' U R U R U R' U R U2 R') is President, or the case you solve with ((U) R U R' U R U2 R' U' R' U2 R U R' U R) is Prince. Then you would use this information to make a sentence/story to remember the alg. For example, for the President case I would remember: "President is evil duck so you die"
President is the case name, evil duck is antisune from the back right, you is just a U move, and die is a sune.
This sounds weird I know, but it works (at least for me). I don't know how this would work for algs that aren't just combinations of other easier algs like sune, however.
If you're the type of person that can remember names and sentences like this well (maybe if you're good at BLD), then this might be helpful for learning these cases. If anyone has ideas for learning algs with that aren't just combinations of smaller algs with this method, I'd love to hear them!
And sure, you may not be able to do the alg very quickly this way, but over time you won't have to think about the sentence and muscle memory will take over
 
Last edited:
Aerma said:
Sorry for double posting, but this is unrelated to my last one.
I think it would be really nice and helpful if there was a better way to memorize algorithms than the conventional way of remembering triggers and tracking F2L pairs around the cube because lets face it, it's really difficult to learn a large quantity of them using this method.
I've created a sort-of method for this, or at least the many 2GLL cases where the alg is just a sune/antisune from either the front or the back, doing some U move, then doing another sune/antisune to finish. This is in every H 2GLL case minus one, for example.
Basically, I gave all of those algorithms I already knew a name that I could remember and that I could use in a sentence. So sune is death (because death comes soon), anti sune is not-death or not dying, a sune from the back is duck and an antisune from the back is evil duck. Then the standard alg for an H case (R U2 R' U' R U R' U' R U R') is super sune, so say doing it from the back is super duck.
Then you would decide on a name for the case on the cube that you can easily remember, for example the ZBLL you can solve with (R' U2 R U R' U R U R U R' U R U2 R') is President, or the case you solve with ((U) R U R' U R U2 R' U' R' U2 R U R' U R) is Prince. Then you would use this information to make a sentence/story to remember the alg. For example, for the President case I would remember: "President is evil duck so you die"
President is the case name, evil duck is antisune from the back right, you is just a U move, and die is a sune.
This sounds weird I know, but it works (at least for me). I don't know how this would work for algs that aren't just combinations of other easier algs like sune, however.
If you're the type of person that can remember names and sentences like this well (maybe if you're good at BLD), then this might be helpful for learning these cases. If anyone has ideas for learning algs with that aren't just combinations of smaller algs with this method, I'd love to hear them!
And sure, you may not be able to do the alg very quickly this way, but over time you won't have to think about the sentence and muscle memory will take over
Click to expand...
I disagree with the claim that it's hard to memorize a large amount of algs by tracking F2L pairs and remembering triggers. I memorized all of ZBLL with this method, and it has always worked very well for me.

However, I will admit that different people learn differently, and I imagine many people will find mnemonics helpful for alg learning.

I think the key to effectively using mnemonics for learning algs is to not try and encode everything. You don't need to encode every single move of the alg into the mnemonic, because your mind will fill in many of the gaps for you. If you train your algs a ton on an alg trainer, you'll be surprised how much you remember - your memory is likely better than you think.

When was learning ZBLL, for example, I'd almost never learn the second half of algs because I was usually able to figure it out intuitively.

So for memorizing algs that aren't combinations of other algs, it should be enough to just create a mnemonic for the trigger it starts with, create a mnemonic that reminds you of the middle (but not necessarily very specific), and then you can figure out the end intutively. And if you train your algs a lot on a trainer or doing solves, your mind will fill in the rest.
 
Last edited:
Okay I made a method a couple days ago and it seems to be pretty decent. It's kind of a ripoff of Thistlethwaite but that's not what I was going for, plus the solve feels a lot different. It was actually based more on Guimond and SSC.

1. orient all edges
2. blockbuild f2l-1slot so that UD colors are on bottom and E layer edges are in E layer. No need to permute the pieces correctly yet
3. fill in the last slot with the last edge and orient all corners, this can be done with TSLE or supplemented with WV or OLL
4. use R2, L2, F2, B2, U, and D moves to blockbuild the f2l for real. Usually I make a line of one color on the bottom with 2 corners and an edge then expand it into a roux first block, then petrus 2x2x3 then add in last line. This is also the step where UD colors get separated into their own layers.
5. pll

Example scramble : L2 D L2 U2 B2 F2 U' B2 R2 B2 U L F R2 B' U' L B' R' F'
EO: R (D' U) (B' F) U F' // this actually ended up making a cross on the bottom
F2L-1: L2 U L U2 R U' R U R // somehow filled in last slot leaving OLL instead of TSLE
last slot/OLL: R U2 R' U' R U' R' // this could have cancelled with the last R
F2L: E' F2 U r2 U r2 U' r2 U' R2 U2 R2 U2 R2 U' R2 // I have a feeling this step can be optimized
PLL (Gd): U' f R f' R2 u' R U' R2 u R2
 
pinky pie LELOP (new method)
1)L+E½
create a cp line (no eo) and place 2 equator edges above the line (oriented correctly)
2)E½+flco <R,U,M,r>
place the other 2 equator edges while orienting the first layer corner pieces (the ones that actually belong on first layer)
3)L+PP setup <R2,r2,M,U,u,E>
build a 1x1x3 block in the bottom right, solve the equator, and place the UL and UR edges (oriented) in DF and DB
4)oll (keep cp) (57 algs)
solve oll with an algorithm that keeps cp solved
5)PP<U,M2> --> <M,U2>
permutate the DF-DB edges into the top, then permutate the middle slice

scramble: R2 F2 D' L2 R2 D2 B2 R2 U L B' L' U F2 L2 F' D' L' F2 D2
1) z U2 R U2 u' S2 (5 stm 4 atm)
2) r R2 U R' U2 R' (6 stm 5 atm)
3) E r R (3 stm 2 atm)
4) U R' U' F' U F R F R U R' U' F' (13 qtm) (found at http://birdflu.lar5.com)
5) U M2 U M' (4 stm)
43 qtm 35 htm 31 stm 28 atm
i am very surprised this went so well. this is just a lot of luck. took 7 minutes to find. found by hand.
 
Last edited:
Abram Lookadoo said:
pinky pie LELOP (new method)
1)L+E½
create a cp line (no eo) and place 2 equator edges above the line (oriented correctly)
2)E½+flco <R,U,M,r>
place the other 2 equator edges while orienting the first layer corner pieces (the ones that actually belong on first layer)
3)L+PP setup <R2,r2,M,U,u,E>
build a 1x1x3 block in the bottom right, solve the equator, and place the UL and UR edges (oriented) in DF and DB
4)oll (keep cp) (57 algs)
solve oll with an algorithm that keeps cp solved
5)PP<U,M2> --> <M,U2>
permutate the DF-DB edges into the top, then permutate the middle slice
Click to expand...
Example solve please?
 
Abram Lookadoo said:
pinky pie LELOP (new method)
1)L+E½
create a cp line (no eo) and place 2 equator edges above the line (oriented correctly)
2)E½+flco <R,U,M,r>
place the other 2 equator edges while orienting the first layer corner pieces (the ones that actually belong on first layer)
3)L+PP setup <R2,r2,M,U,u,E>
build a 1x1x3 block in the bottom right, solve the equator, and place the UL and UR edges (oriented) in DF and DB
4)oll (keep cp) (57 algs)
solve oll with an algorithm that keeps cp solved
5)PP<U,M2> --> <M,U2>
permutate the DF-DB edges into the top, then permutate the middle slice

scramble: R2 F2 D' L2 R2 D2 B2 R2 U L B' L' U F2 L2 F' D' L' F2 D2
1) z U2 R U2 u' S2 (5 stm 4 atm)
2) r R2 U R' U2 R' (6 stm 5 atm)
3) E r R (3 stm 2 atm)
4) U R' U' F' U F R F R U R' U' F' (13 qtm) (found at http://birdflu.lar5.com)
5) U M2 U M' (4 stm)
43 qtm 35 htm 31 stm 28 atm
i am very surprised this went so well. this is just a lot of luck. took 7 minutes to find. found by hand.
Click to expand...
Isn't this basically doing eo and cp in the beginning of roux?
 
@Abram Lookadoo Rude and unnecessary comments. He's just looking at the method objectively (like we SHOULD be looking at proposals on this thread); all you needed to do was explain you don't do EO at the beginning.

What if for L7E we did an equivalent of EOLR that solves FRUL, and solve the rest of the cube with L5E?
 
Just had what I think is a really cool idea: L6E Commutator Reduction.
1) Solve 3 edges intuitively ~4 moves
2) Solve remaining edges with a commutator ~9 moves
Step one could be completely intuitive, or something like E2L; movecounts are pretty much guesses; not sure about comm count, but it's probably not too high, with reflections/AUF's/AMS's (yes I just invented adjust M slice) probably less that EOLR.
EDIT: Intuitive is not ~4 moves.
 
Last edited:
Hi, this is my first post on the forum so please excuse any mistakes!

This isn't a 3x3 method, but a skewb method, and due to the large variety of skewb methods this may have been suggested before:

1) (Intuitively) solve a "line" consisting of two fully solved corner pieces and a solved center piece in between them. The corner pieces are both on the same face as the center piece and are diagonally opposite each other on that face. This is equivalent to 3/5 of a face, and can often be solved in 3 moves or less.

2) There are 2 corners that when you turn them, they do not disturb the line. Step 2 is to solve these 2 corners as well as the 5 centers that they wield.

3) Last 4 Corners. I'd imagine this would be algorithmic but I have absolutely no idea where to start with this/if it's been genned before.

This of course would not be superior to Skewb EG in any way, but could be a considerable intermediate-speed method with few algorithms.

This method is reminiscent of 2GR on 3x3, where the "line" could be imagined as the 2x2x3 block, due to the quick 2-gen solution of Step 2.

A more advanced method to build off this might be more similar to 2GR, solving CPLine and merging steps 2 and 3.

EDIT: Now that I think about it, a Skewb missing the 4 free corners is analogous to a Pyraminx, and therefore steps 1 and 2 might be able to be turned into a Pyraminx method, and a Pyraminx method might be applicable to replace steps 1 and 2.
 
Last edited:
I have an idea for new 3x3 method.
The steps:
S1: make Vblock (seem like FB+1x2x2 next to FB)
S2: Solve last F2L pair.
S3: Orient and Permute 4 U corners
S4:
a) Orient all edges
b) Reduce cube to G4={R2, L2, B2, U2, F2, D2}
c) Solve remaining cube with G4.
Number of alg: 42
Movecount: 49
 
Interesting idea I just had to incorporate 42 style corner solving into other methods:

What if for EO based methods (Petrus, ZZ, CFOP with edge control) we build to F2L-1, either solve LC or use COLL conjugates to solve the corners, and end in L5E?

You get to use your same COLL algs and L5E is entirely 2-gen. At the most basic level you get 15 L5E algs (including EPLL) but this can go higher if you allow for the other E slice edge to be there.
 
Thermex said:
Great idea to cut down on the number of algs; in fact I'll probably use this while I'm learning full L7E, but it's not the most efficient. Been working on L7E really hard for the last couple of days so I'll present those algs this weekend. With rotational symmetry and AUFs there are exactly 125 unique cases, many of which are just one of the baseline cases with a couple of M or U moves tacked on to the end.

Sounds interesting; I have no idea how you're gonna do this but GL :) btw I've actually been making the L7E algs on a seperate sheet that's much better organized than the one you had, so I'll show that to you tonight. Recently I've also come up with a BOPE L8E method and a mega-efficient squan method that's based off of HD, so I'll show you guys those tomorrow.
Click to expand...
Can you show that square-1 method?
 
ZZ variant (ZZ-r?)
1: SEOLine: EOLine on S slice. Solve EOLine as usual but the solved edges are DL and DR
2: F2L: Solve the 4 F2L pairs
3: CxLL: Corners of the last layer while preserving the solved blocks and EO
4: LSE

EDIT: Here's two more another variants!
1) EOLine
2) F2L-1
3) 2x2x1 block in UBL
4) L4C/L3E (last 4 corners then last 3 edges)

1) SEOLine
2) F2L-1 cross edge (preferably DF
3) COLL
4) L5E (insertion cancelling into EPLL with only M/U)
 
Last edited:
Ok, I thought about this adaptation of ZBRoux to ZZ-CT (nothing too serious tho) which is a hybrid that is most probably better than ZZ but worse than Roux
1. First Block
2. Square on the SB down back place
3. EO + DFDB (the fact that we have 7 Edges means we can only have 0, 2, 4 or 6 cases like in roux and with the one extra slot we can transform almost everything to an Arrow)
4.TSLE
5. TTLL

Pros:
Roux FB and SB with is more efficient and economical(the 'rapid' change of L/R moves in ZZ is arguebly worse) than ZZF2L
EO in Roux/this Method is faster-can be recognised almost instantly which means Inspection is used for "something actually helpful for solving"
TSLE and TTLL algorithms have a incredibly high percentage of being 2 Gen which means your LL is often really fast

Contras:
The RU 2Gen of TSLE and TTLL is not as fast as MU for Roux
Potentially high movecount


Edit: I have an example solve(sramble with your prefered color on bottom:

Scramble: D B2 D F" B L D' R F' R F2 B2 L' D2 R2 U2 B2 U2 B2 L'
y' D' R' U2 R U' M U //Square first block -7
x R' U' R U R' U' R U R' U' R2 M U M' U' R2 //Square second block - 16
U M' F' M' //Finish First Block - 4
R U2 R' U //Setup to Arrow - 4
M U' M U2 M U2 M' //EO dfdb - 7
U R U2 R D R' U R D' R2 //TSLE - 10
U R' F R F' R' F R F' R' F R F' //TTLL - 13
U' //AUF - 1
61 Moves with STM, 70 with HTM, 78 with QTM
 
Last edited:
Insanely hard method idea
Cross
Columns
ELL
It could probably be fast and it has an optional MU finish, but the columns step is insanely hard to do well after the second column. Somebody try making it viable and I might try it. (sub-14 with CFOP rn)
 
You must log in or register to reply here.

Similar threads

D
The physics of Rubik's Cube to Substep Method Platform
2
Replies
33
Views
1,786
Christopher Mowla
Christopher Mowla
D
Incomplete Substep Method LL Megaminx
Replies
2
Views
299
Deleted member 27249
D
Dane man
Calculating Method/Substep Efficiency
2
Replies
27
Views
8,640
brododragon
brododragon
M
What method is this?
2
Replies
24
Views
6,121
~Adam~
~Adam~
AK51
2.51 world record used 33 moves, it shall be 28 moves using AK-cubie method
Replies
0
Views
224
AK51
AK51
Back
Top