The New Method / Substep / Concept Idea Thread

[crafto22]

Yesterday I made a face first 3x3 method and I posted it on r/Cubers. It got a surprisingly good response considering how much they hate seeing new method posts, so now i'm posting it on here.

Step 1: Make a face with one corner missing

This is pretty simple. Just blockbuild. This is just like making a layer but you do not need to permute the pieces.

Where are the rest of the steps...?

 

[Neuro]

Ok found the Reddit post:
https://www.reddit.com/r/Cubers/comments/5ujsn7/i_just_made_a_face_first_3x3_method_and_its_cool/

Might have potential, but OLLCP has a ridiculous amount of algs and inserting LS+ bottom layer CP seems a bit counterproductive.

I'd probably keep the face, but solve the corners so you can insert LS with VH (orient LL edges) and do COLL after. But at that point it's basically a blockbuilding version of SSC (which isn't necessarily a bad thing)

EDIT: This variant gives a really fun solve, but I don't see it being used well for speed. Scraping this one for the time being

 

[ShyGuy1265]

Where are the rest of the steps...?

Sorry, I tested the spoiler boxes with one step (I didn't do it right) and I edited the rest in. I didn't think anyone would get to it that fast.

 

[Teoidus]

Since it doesn't seem like your primary goal is speed I think it might be more fun to continue the face-building concept as far as you can while still being a reasonable method. Like maybe after the first face you can try and build an adjacent face or something.

 

[crafto22]

Sorry, I tested the spoiler boxes with one step (I didn't do it right) and I edited the rest in. I didn't think anyone would get to it that fast.

Oh okay no worries. I feel like the first and second step can definitely be combined using non-matching F2L. One could simply solve cross without caring for EP and then solve F2L without worrying about CP either. That could work.

 

[Neuro]

Maybe do some advanced blockbuilding to make NM F2L? Like Petrus/MCELL or variants?

EDIT: Got a 65 move solve (Petrus variant). Keep in mind I'm not a great blockbuilder and was influencing bottom layer CP while doing so. Recog is hard, wouldn't reccomend. I'll test crafto's variant and my old variant and get back soon

 

[crafto22]

So I was playing around with ECE and ZZ-CT and sorta came up with this hybrid method that could be pretty good.

1. Solve EO and 2 E-slice edges on L
Estimated average moves: 6

2. Solve a 1x1x3 under the solved E-slice edges, forming a pseudo Roux block
Estimated average moves: 7

3. Solve the remaining E-slice edges whilst orienting one D layer corner
Estimated average moves: 6

4. Orient all the corners using one of 16 algs
Estimated average moves: 5

5. Expand the pseudo Roux block to a pseudo 2x2x3
Estimated average moves: 4

6. Solve F2L minus one corner
Estimated average moves: 4

7. Solve the cube with TTLL
Estimated average moves: 12

Projected average move count: ~44 STM

 

[Neuro]

So here's an idea I came up with: Neuro Last Slot- A block based method that uses only 85 algs for full 1LLL

Used in conjunction with ZZ, one gets to a point where it is essentially tripod (FB done, built to F2L-1, and 2x2x1 built in *UBL*) and uses one of 35 algs to insert the last slot while preserving the top block.

**I build left block first, wrote out of preference

I'm fairly certain that all of the NLS algs can be done 2 gen, but they may get too long. Currently the average movecount for NLS is about 9.5 moves. NLS recog is fairly straightforward, and at the moment I have it broken down by where the last F2L edge is and then looking at orientation/location of F2L corner.

By preserving the block, you get a 50 alg 1LLL (no PI or H ZBLL's and S/AS reduce to 6 algs per set; while the remaining ZBLL sets go to 11 algs each, and the remaining 5 are PLL's). Recog for 1LLL shouldn't be too hard if one is somewhat familiar with ZBLL.

Depending on how good one is at ZZF2L, they may be able to plan F2L-1 and top block together directly after first block. Also useful in lucky solves or for those just getting into ZBLL.

Here's an 49 move example solve (Not sure as to the average movecount, but I suspect it's in the same range as ZZ-CT)
https://alg.cubing.net/?setup=U2_B2.../NLS R2_U_F_U-_F2_D_R2_D-_R2_F_U-_R2_U2//ZBLL

Also attached current NLS algs. Generate in cube explorer

 

[crafto22]

Here's an example solve of the method I proposed in my previous post:

Scramble: F R2 D' L2 R2 D' L2 U F2 U' F2 L2 B R D F' D U L D

y' r F' M' B L2 D' L' // EO + E-slice edges (7/7)
U' R2 U' R U' R2 D2 // 1x1x3 (7/14)
M2 U R' // remaining E-slice edges + one D-layer corner (3/17)
U' M2 // pseudo 2x2x3 (2/19)
U' R' U' R U2 R' U' R' // CO (8/27)
U' R2 U2 R2 U R2 // F2L minus one corner (6/33)
U2 R U2 R' U' R' U2 R2 U R2 U R // TTLL (12/45)
(U' D2) // ADF = Total moves: 46

 

[efattah]

Hi guys,

I am making extraordinary progress speeding up my LMCF times by incorporating the new L6E algorithms. Sadly I have some life stuff coming up and I will have to take a short break from cubing so this will be my last post for a while. I am attaching here my latest (incomplete) algorithm sheets in case someone wants to continue pursuing this method while I am taking a break.

1. LMCF L6E algorithms and E2L triplet algorithms (these new triplet algorithms allow way more frequent triplets):
2. LMCF Waterman document, compiling the Waterman algorithms for solving the last two ledges/redges while orienting midges

As a comment to those who want to get started in LMCF. Like CFOP there are many 'variants' depending on how many algorithms you want to learn. You can start with as little as 11 algorithms and move up to over 500 if you learn the full method with all reflections; with greatly diminishing returns as you learn more algorithms. The basic set is:
- Either CLL, CMLL or EG1 to solve the corners (assume you already know one of these, preferably full EG of course)
- Just THREE E2L algorithms are required (plus reflections)
1. DF into UR, UR goes into UL: U M' U'
2. DF into UR, UR goes into UL: M U M U2 M'
3. DF into UR, UL holds the edge piece of that side but flipped: U' M U2 M2 U'
- Eight L5E algorithms (you can compensate for not knowing reflections by doing U2's and D2's)
[Learn the set solving DF into UL while orienting midges = 8 cases)

When using basic LMCF E2L try to solve the DF into UR with the above three case pairs; if there is no such case, move the opposite L/R side to displace whatever edge piece is there (when solving your next edge) and use the displaced edge as your next edge, preserving lookahead. This basic low-algorithm variant is very fast to learn, has slightly higher movecount but still easily capable of sub-10.

LMCF + Roux would be a very fast double method. You'd be surprised how many scrambles have full corner faces pre-solved, in which case 1-look is trivial for the corners and you can lookahead to the edges themselves.

 

[Neuro]

48 move NLS solve:
https://alg.cubing.net/?setup=U2_F2...y-_D-_L-_D_F2_R_U_R-_F2_L2_U-_L-_U_L2_U//ZBLL

Obviously movecount will be different in real solves but it's showing promise so far

 

[crafto22]

48 move NLS solve:
https://alg.cubing.net/?setup=U2_F2...y-_D-_L-_D_F2_R_U_R-_F2_L2_U-_L-_U_L2_U//ZBLL

Obviously movecount will be different in real solves but it's showing promise so far

48 moves is certainly nothing exceptional, and considering your optimizing the solve (move count would surely be higher in a speedsolve) I don't see how this shows much promise. If you're going to start the solve with ZZ, I'm certain you would agree that finishing with TSLE/TTLL or some other form of ZZ last layer would work just as well, and recognition and the move count would perhaps be better. Speaking of recognition, ZBLL recog is pretty hard, so why not just go the easy route and finish with something with easy recog?

 

[Neuro]

48 moves is certainly nothing exceptional, and considering your optimizing the solve (move count would surely be higher in a speedsolve) I don't see how this shows much promise. If you're going to start the solve with ZZ, I'm certain you would agree that finishing with TSLE/TTLL or some other form of ZZ last layer would work just as well, and recognition and the move count would perhaps be better. Speaking of recognition, ZBLL recog is pretty hard, so why not just go the easy route and finish with something with easy recog?

It's mostly meant for people interested in ZBLL but don't know where to start or for lucky solves. It's also for people who despise learning algorithms, and to teach new concepts to intermediate solvers.

Although I will continue to use ZZ-CT as my main variant, I don't think this should be dismissed. It can be used as an effective transitioning tool into ZBLL while dropping the 1LLL algs by 9 times from traditional ZBLL, and it can be used in lucky solves. In regards to movecount other variants are better, but it's certainly not a hindrance. Personally I will learn it in order to give me an advantage in nice situations.

I do realize that ZZ-CT would be better in overall speed/moves, but one still has to learn over 100 algs in order to use it in it's entirety. With NLS, most of the cases can be done intuitively, so one won't even need to learn the full 35 patterns. The LL recog is 1 look with very little algs, 50 with 5 likely already being known to be exact.

While I recommend ZZ-CT over NLS for most people, I do think it is is useful for people looking to advance into ZBLL and in lucky solves. It teaches beginners basic ZBLL recog with only fairly easy cases while not severely hindering their current solving times.

45 move NLS solve not optimized. Somewhat lucky, but shows method's power.
(Did the first thing I saw on alg.cubing so basically a speedsolve)
https://alg.cubing.net/?setup=D2_R2_B2_L-_U2_B2_R2_F2_R-_B2_F2_D_F_L-_D-_L-_U-_B_R_D2_L&alg=y_D2_R_F-_R2_B-_U-_B//EO_line U2_L_U_R2_L_U-_L-//FB U2_R2_U_R2//F2L-1 U2_R_U-_R-_U2_R_U_R-_U//TB R2_U-_L_U-_R2_U_L-_U2_R2_U-_R2//NLS y2_R_U-_L-_U_R-_U-_L//ZBLL
I'll do say 25 solves with it over the break and get back with stats
*may consider making this my main variant if movecount is low*

 

[Sion]

Hawaii 4-0 Method

This is a Big cubes method I came up with completely intuitively with very little help. It is currently my main 4x4 method, and I hope I can translate it to even bigger nxn puzzles in the future.

1: Solve a 1x1x3 Column.
2: Build a 1x3x3 block using the 1x1x3 column.
3: Solve the D layer center and solve another 1x3x3 block with the original 1x1x3 column, making a 3x3x3 block.
4: Extend the 3x3x3 block into a 3x3x4 block.
5: Build two columns in front of the 3x3x4 block.
6: Reduce the remaining edges into 5 edge pairs (last layer and DF position edge)
8: Solve the remaining edges.
9: Solve the last two centers with one algorithm.

Might do examples later.

 

[SenorJuan]

Interesting. Tell us about parity, please.

 

[Sion]

Parity is traditionally with step eight, although you could put it as a final step later in the solve.

 

[One Wheel]

I got as far as step 5. Not going to replace Yau for me, I'm afraid.

 

[efattah]

I had a semi-lucky 9.99 second LMCF solve from the Race-to-Sub 15 thread. I happened to video the series and I have posted the video of and reconstruction of the solve:

9.99 LMCF solve reconstruction
Scramble: B2 U2 B2 D' R2 B2 D R2 U2 B2 D' L U B F' L' D2 R D U

x' y' U2 R' [D U] // create green face and AUF in prep for EG1
F' U R U' R' U F R U R' // EG1 Sune case
U2 M U2 M' // solve blue-white edge piece on U layer
x y r U' M' U // rotate, solve green-yellow edge piece and displace blue-yellow edge piece
x L' U M' U' // solve blue-yellow edge and displace blue-orange
r U M U' // E2L pair, blue-orange and green-white
L' R2 U' M' U // solve last E2L pair and gamble on a midge orientation skip
U2 M' U2 // midge orientation skip, permute midges

38 STM, 9.99 seconds
3.80 STPS

 

[Shiv3r]

Hawaii 4-0 Method

This is a Big cubes method I came up with completely intuitively with very little help. It is currently my main 4x4 method, and I hope I can translate it to even bigger nxn puzzles in the future.

1: Solve a 1x1x3 Column.
2: Build a 1x3x3 block using the 1x1x3 column.
3: Solve the D layer center and solve another 1x3x3 block with the original 1x1x3 column, making a 3x3x3 block.
4: Extend the 3x3x3 block into a 3x3x4 block.
5: Build two columns in front of the 3x3x4 block.
6: Reduce the remaining edges into 5 edge pairs (last layer and DF position edge)
8: Solve the remaining edges.
9: Solve the last two centers with one algorithm.

Might do examples later.

It looks a lot like OBLBL to be honest, however I like the Idea or the columns.

Here's an alternative I would suggest:
after the 3x3x4 block and the 2 columns, solve the last 2 centers completely with <l, r, U>. then proceed to do CLL and then L5E(last 5 edges or Lewis 5 edges). one reason I like L5E is I myself am very good at it since I use it in my main method, and I can do it almost pauselessly.

just wondering, what is your average? I use Lewis and currently average around 1:02 or so, and that includes the very same L5E step.

EDIT: if I get around to it I will do an example solve with both variations, and Im calling mine the HK variant because it is basically HK-petrus variant on 4x4.

 

[Sion]

It looks a lot like OBLBL to be honest, however I like the Idea or the columns.

Here's an alternative I would suggest:
after the 3x3x4 block and the 2 columns, solve the last 2 centers completely with <l, r, U>. then proceed to do CLL and then L5E(last 5 edges or Lewis 5 edges). one reason I like L5E is I myself am very good at it since I use it in my main method, and I can do it almost pauselessly.

just wondering, what is your average? I use Lewis and currently average around 1:02 or so, and that includes the very same L5E step.

EDIT: if I get around to it I will do an example solve with both variations, and Im calling mine the HK variant because it is basically HK-petrus variant on 4x4.

i can go for aroun 4 minutes, but this is probably because I started to take 4x4 seriously only a couple days ago.

I'm pretty confident a world class solver could get sub 40 with this because of how intuitive it is, and block efficency.