The New Method / Substep / Concept Idea Thread

[patricKING]

Try alg.cubing.net
But you have to enter the moves manually.

 

[OreKehStrah]

I call it like that, because it's a mixture of the roux method and the cfop method. Basically you make the first two blocks, like in roux, for example, the blue and green blocks. Then you make all the edges white or yellow for this example, like in roux, then putting the white red and orange white edge on their right positions. That will make f2l. Then you will basically always have a yellow cross, so oll cross skip thing. You do a 2 look oll alg, (itll be like 1 look oll, as cross is already done), then pll. Is it a good method? I'm kinda new so I need your help

That is bad. Lots of new people come up with it. Don’t do that.

 

[patricKING]

The first question here: Wouldn't it be faster to just do normal cross and F2L? It feels like it is slower doing two 1x2x3 blocks than normal F2L. But really nice that you have these ideas, keep it going!
Edit: Also, try to do a solve with your method and then the CFOP method and you'll see what is the fastest for you.

 

[Cubing Forever]

An advanced version of this method, called ZBRoux exists. Here's what it looks like(inefficiently):
z' F2 U' S U2 S' U2 R2 U' R' U' R U L U' L' F' U F2 R' F' R U' L' U2 L2 U L2 U L //first 2 blocks
U M' U M //all red and orange on top and bottom
U' M' U2 M' U2 M2 // Down edges
U R2 D' R U2 R' D R U2 R U2 //ZBLL (which solves both OLL and PLL at once)
(click on that link to see the whole solve at alg.cubing.net)

 

[Akira80kv]

That is bad. Lots of new people come up with it. Don’t do that.

Ok! Thanks! Do you have any tips on how I could achieve a consistent sub 20 w/ roux? My pb is 16 secs but that was very lucky, I sometimes do 18 scs, and I average 20-23 secs.

 

[OreKehStrah]

Ok! Thanks! Do you have any tips on how I could achieve a consistent sub 20 w/ roux? My pb is 16 secs but that was very lucky, I sometimes do 18 scs, and I average 20-23 secs.

Just do lots of untimed solves to focus on finding efficient solutions, and watch example solves to learn new ways to solving blocks.

 

[SH03L4C3]

I came up with something similar back in january

 

[Existential Shrimp]

I came up with something similar back in january

was it for the method competition? (just curious)

 

[trangium]

Here's an idea for a beginner's blindfolded method. This probably won't be good for everyone, but could be okay for those who have trouble remembering their setup moves.
It works similarly to Old Pochmann, except with different swap algs. In particular, the edges swap alg swaps 2 edges and 4 centers, which allows for more freedom in setups, leading to shorter setups. The different corner alg allows parity to be handled in a simple way.

Speffz lettering is used here.

Edges Buffer: S
Edges Target: C
Allowed setups: <U, R, F, L>
Edge swap alg: M' U' M' U M' U M' U2 M' U M' U M' U' or U2 M’ U’ S R’ F’ R S’ R’ F R U’
Parity: Add R to the end of edge memo
Special case: if there are an odd number of edge letter pairs, add E2 M’ E2 M to the start of execution

Corner buffer: H
Corner Target: C
Allowed setups: <U, R, F>
Corner swap alg: R B R’ U2 r U’ r B r2 U2

Spoiler: Example solve

U' D B R' B U' D2 F' L2 D B2 L2 U' F2 L2 U D2 L2 F2 R

Edges: GU IV QP DF HN EB MR (Add R because there is parity)
Corners: BI UJ EW V

E2 M' E2 M // Odd number of edge letter pairs (7 is odd)
L' F (M' U' M' U M' U M' U2 M' U M' U M' U') F' L // G
F2 (M' U' M' U M' U M' U2 M' U M' U M' U') F2 // U
F R U (M' U' M' U M' U M' U2 M' U M' U M' U') U' R' F' // I
R2 U (M' U' M' U M' U M' U2 M' U M' U M' U') U' R2 // V
U R' F' (M' U' M' U M' U M' U2 M' U M' U M' U') F R U' // Q
F' (M' U' M' U M' U M' U2 M' U M' U M' U') F // P
U' (M' U' M' U M' U M' U2 M' U M' U M' U') U // D
F (M' U' M' U M' U M' U2 M' U M' U M' U') F' // F
L2 F (M' U' M' U M' U M' U2 M' U M' U M' U') F' L2 // H
R2 F' (M' U' M' U M' U M' U2 M' U M' U M' U') F R2 // N
L F (M' U' M' U M' U M' U2 M' U M' U M' U') F' L' // E
U (M' U' M' U M' U M' U2 M' U M' U M' U') U' // B
R' F' (M' U' M' U M' U M' U2 M' U M' U M' U') F R // M
L U' (M' U' M' U M' U M' U2 M' U M' U M' U') U L' // R

U (R B R' U2 r U' r B r2 U2) U' // B
F2 R (R B R' U2 r U' r B r2 U2) R' F2 // I
F2 (R B R' U2 r U' r B r2 U2) F2 // U
F R (R B R' U2 r U' r B r2 U2) R' F' // J
U R' (R B R' U2 r U' r B r2 U2) R U' // E
R2 (R B R' U2 r U' r B r2 U2) R2 // W
R2 U (R B R' U2 r U' r B r2 U2) U' R2 // V

View at alg.cubing.net

 

[PapaSmurf]

That's pretty cool, (although potentially kinda hard to visualise for beginners). The first edge alg needs a bit of reworking, but otherwise I actually really like it. The main disadvantage is that M2/M are both better and are also suitable for beginners, which is kinda annoying, but hey.

 

[MethodNeutral]

Just had this thought this morning and wanted to see if this has been thought of before, I tried looking on the speedsolving wiki but I couldn't find anything for it.

Essentially my idea is EJLS (link) but for full OLL. The idea is when solving F2L in CFOP, if a pair happens to be in the correct slot and the edge is flipped correctly (but the corner is twisted), then simply continue solving F2L. Then execute one of ~116 (?) algs which untwists the corner and orients the last layer.

The 116 number looks a bit daunting, but half of them would be mirrors since the corner can be twisted one of two ways. So it'd really be about 58 algs, but that's just my own guess for the number of cases.

Another interesting idea could be to learn the algs which solve OLL while correcting an F2L pair with a flipped edge.

I should clarify, both of these should be considered as alg sets which are not meant to be used in every solve. Like COLL in the context of CFOP, this isn't something a solver should go out of their way to use, but if the opportunity presents itself (e.g. a pre-made pseudo-pair), then it would come in handy to have these algorithms.

 

[AlgoCuber]

Theses have most likely been proposed before but here are my ideas for skewb:

Intermediate:
First face
EG + A center
L5C

Intermediate-Advanced:
First face
EG
L6C

Advanced:
3 face corners
Last 5 corners
L6C

 

[Z1hc]

I have some 2x2 methods that may be new. Here they are:
2x2 method 1:
Step1: create a layer except don’t solve the last piece (Down Front Right corner.).
Step 2: solve the front right up corner.
Step 3: permute the last 4 corners so they look like 4 corner twists (or less).
Step 4: solve the 4 twisted (or less) corners with one algorithm.

2x2 method 2:
First solve down left front and down left back corner.
Step 2: solve up right front and up right back corner.
Step 3: permute the last 4 corners.
step 4: orient the last 4 corners.
/\ the last 2 steps can be rearranged and might be easier that way.

 

[Jamal_69]

hey! so I've had this idea for a while now so here goes! I essentially wanted to create an actually viable way of doing roux on megaminx and I think I've found it... sorta. this may have been proposed before Idk. this method is sort of a variant of balínt I guess and also I'm kinda stuck on how to do step 5 so some help would be appreciated
step 1: F2L. just like with most megaminx methods you start off with the first two layers. you can do this however you want but I do it by blockbuilding since I'm a roux user.
step 2: first block. the first block is made up of a balínt block and the two pairs adjacent to it. nothing much more to say here.
step 3: second block. same thing as first block. make sure there's a balínt block slot in the front between the first and second block and two balínt block slots and a pair slot in the back in between them.
step 4: solve the two balínt blocks in the back. very straight forward. by the end of this step there will be one s2l slot and one balínt block slot left of the s2l.
step 5: roux style EO. this is the step I'm having trouble on so I would love some help on it. it's basically doing roux style EO with R' L F' L' R I know what the move does but can't figure out recognition for it. ZZ-Spike recognition doesn't work for this method as far as I know.
step 6: finish s2l. last balínt block slot and s2l slot
step 7: last layer. just like ZZ-Spike since all edges are oriented. so that's the method. I hope somebody can find a way to do EO.

 

[Waffles]

I don’t know if anyone has ever thought of this idea before (they probably have) and I’m not here to think about optimisation. I know it’s unlikely anyone will use it, and even if they do, they will notice some flaws in the method.

Anyway, it’s a substep of CFOP (my main method) where you do 3 piece cross, then leave the final piece unsolved. Then you do F2L having the final piece of the cross unsolved so you can do M moves to make F2L slightly easier. Then you can do some kind of edge orientation/solving the last cross piece as 1st look OLL, then COLL and the final edges.

Now, this is assuming you know COLL and would have to learn a few algorithms (which I can’t be bothered to make them).

Potential Problems: if you use a lot of ZB or WV or other last-slot related things. Obviously this would rely on having good M’/M fingertricks and being good at turning in general. It might be hard to recognise LCEO algorithms depending on the case. I assume there won’t be many algorithms for it.

As you can tell, this was quite rushed and I haven’t tested out or anything and no-one is going to use it but I just thought I’d put it out there anyway.


Steps:
3Cross
MF2L
LCEO
COLL
PLL

I hope this inspired you in some way

 

[ruffleduck]

I don’t know if anyone has ever thought of this idea before (they probably have) and I’m not here to think about optimisation. I know it’s unlikely anyone will use it, and even if they do, they will notice some flaws in the method.

Anyway, it’s a substep of CFOP (my main method) where you do 3 piece cross, then leave the final piece unsolved. Then you do F2L having the final piece of the cross unsolved so you can do M moves to make F2L slightly easier. Then you can do some kind of edge orientation/solving the last cross piece as 1st look OLL, then COLL and the final edges.

Now, this is assuming you know COLL and would have to learn a few algorithms (which I can’t be bothered to make them).

Potential Problems: if you use a lot of ZB or WV or other last-slot related things. Obviously this would rely on having good M’/M fingertricks and being good at turning in general. It might be hard to recognise LCEO algorithms depending on the case. I assume there won’t be many algorithms for it.

As you can tell, this was quite rushed and I haven’t tested out or anything and no-one is going to use it but I just thought I’d put it out there anyway.


Steps:
3Cross
MF2L
LCEO
COLL
PLL

I hope this inspired you in some way

This is just a worse version of Hawaiian Kociemba. It's worse because in Hawaiian Kociemba you orient F2L edges to make the rest of the solve more efficient and easier.

 

[the dnf master]

idk if this has been came up with before but for the case solved with R U2 R' U' R U R'(or its mirror), if the edge is misoriented, you can just do the big cube flipping alg, or sledghammer followed by R U' R', or mirrored, and it pairs it up and also flips the edge, which saves a rotation.

 

[MethodNeutral]

For a long time I've been interested in a CP reduction which can be solved by <L,U> followed by <R,U> moves.

To explain it in a different way, take a solved cube and scramble it with <R,U>. Then scramble it with <L,U>. This cube is now in the reduction state I'm interested in. This is nice because the solution is simply to solve the left F2L block (cross + 2 pairs) using LU, then solve the right F2L block in a similar fashion and then 2GLL.

However, reaching a state like this is far from easy to do in inspection, so I came up with a different method idea which uses the same concept. I am referring to this method as LURoux, a pun on the fact that this uses LU->RU reduction.

1. Reduce only the corners of the cube to the above-described LU->RU state (solvable by LU followed by RU).
2. Solve left F2L block in the style of Roux second block.
3. Solve the right F2L block in the style of Roux second block.
4. Solve edge orientation and place DF/DB edges (EODFDB).
5. 2GLL

Essentially, this is ZBRoux but with just 2-gen cases thanks to the initial reduction step.

Step 1 is much easier when we don't have to worry about edge orientation, and for now the method I am using is the same as the first step in the YruRU method. In the future, I am hoping this can be streamlined even further since it is technically even less restrictive than reducing the cube to 2-gen (the DL corners won't necessarily have to be solved at the end of this step, although having them solved makes recognition much easier).

Pros:

• Ergonomic turning throughout the solve
• Repeated steps (Two steps are similar to Roux SB, which means the solver gets more practice executing these steps)
• Reduced algorithm count compared to ZBRoux (84 for 2GLL)
• While solving EODFDB, lookahead to 2GLL is very easy as the corners case is visible throughout this part of the solve

Cons:

• Pieces for the first block can become stuck in the second block after solving CP (solvable with R2 S R2 S' or a similar commutator)
• CP recognition will take practice
• Higher movecount than ZBRoux (I'm not quite sure how to calculate movecount exactly)

I can post an example solve, although it will not be indicative of how an actual solve would look as the first step is still very undeveloped (as I mentioned earlier, I am just copying the first step of YruRU).

Comparing this method to Roux:

• Worse first block due to restricted moveset of <L,l,U>
• Identical second block
• EODFDB is comparable to EOLR

LURoux has an extra initial step, and then we are comparing 2GLL with Roux's CMLL and step 4c. As a result, I think Roux is objectively better than this method for speedsolving, so I wouldn't recommend using if you're interested in speed. Otherwise, it's a very fun method.

Let me know what you think, and if you have any advice for the LURoux reduction step!

Edit:
Rather than doing LURU reduction via the first step of YruRU, in inspection you can simply find two corners which are permuted correctly since orientation will not matter. I don't know how to calculate the likelihood of this happening, but anecdotally it is very high. It seems like at most, a scramble will require one move to place two adjacent corners next to each other.

Once two adjacent corners are next to each other, they can be treated as the DL corners for YruRU-style reduction. Once the key flip is determined between the other corners, it can be solved via a simple trigger like F R F' / F R' F' / F' U F / F' U' F. From there, the LURU reduction is solved.

In my post, I forgot to mention the solving of the L center in the method. This is done after CP (LURU reduction), as the <L,l,U,u> moveset is available. S slices are also available, but I don't find them as ergonomic. In either case, this is yet another con of the method in the context of speedsolving.

 

[MethodNeutral]

A bit of an update on LURoux: I've developed a better way of performing the reduction step, so here is an outline. I will be using this scramble from cstimer: D2 R2 U B2 R2 D R2 D2 U L2 U F U F2 R' D' B F D

I scrambled with white top green front, and I solve with white on D. So perform the scramble with your D-layer face on U in order to follow along.

0. Find two adjacent D-layer corners which are already adjacent to each other. They do not need to be oriented, nor do they need to be solved relative to each other. For example, on the scramble perform an x rotation and the two corners in DL belong adjacent to each other, but they are not solved relative to each other (this will take familiarity with the color scheme to recognize, although in this case it is obvious as they happen to be oriented).

0.a. If there are no adjacent D-layer corners which can be found next to each other, perform CP as done in the YruRU method. (note: Orientation of DL corners doesn't matter in LURoux, so we are slightly less restricted than we would be in YruRU).

Note that now, assuming we didn't branch into 0.a, the DL corners are either solved or swapped. This will be important later.

1. Determine CP using whatever method you are familiar with. I like to use a modified version of what is taught in the YruRU tutorial (link above).

Now, there is either a key swap of pieces to be performed, or CP is solved.

There are four cases to be considered now:
2.a. DL corners solved, CP solved
2.b. DL corners solved, CP requires a swap
2.c. DL corners swapped, CP solved
2.d. DL corners swapped, CP requires a swap

2.a. Nothing to do here (yay!)

2.b. The key swap can be performed with a simple algorithm such as F' U F or F R F'

2.c. This case is annoying, I handle it with F' U F R (this will be explained later)

2.d. Use 2-gen (R,U) to put the key swap at DR

In case 2.b, the algs I use are F R F' (swaps UB corners), F R' F or F' U F (swaps UR corners), and F' U' F (swaps UF corners).

In case 2.c, we actually create a swap (F' U F) and then solve it as if it's case 2.d (R).

In the scramble we received, I traced CP to find that a swap is needed between the corner at UFL and the corner at DBR, which is equivalent to swapping the two corners at FR positions. As a result, an R' will position these corners at DR to solve the LURoux reduction.

So the solution for this scramble would be something like this:

Scramble: D2 R2 U B2 R2 D R2 D2 U L2 U F U F2 R' D' B F D

Inspection: x
CP: R'
Piece sorting: No moves necessary
First block:
Square: M2 U L' U' L' U2 l U l'
Pair: L' U2 L U' L' U L
Second block:
Square: R2 U R U2 r' U' R2
Pair: U M' R' U r
EODFDB: M' U M U2 M' U' M' U' M2 U2 M' U2 M'
2GLL: U R U' R' U2 R U R' U2 R U R' U2 R U2 R'

If anyone is interested, I can show the solution to other scrambles which cover the other possible CP cases (2.a/2.b/2.c). I'm also happy to explain my method for tracing CP if that interests anyone.

 

[mastmtr]

New heavily algorithm based method

1: Make two opposite crosses intuitively
2: Use an algorithm that separates the corners into their layers
3: Cmll on both faces and extra algorithms to solve impossible cases
4: Last 4 edges in the e slice

Probably has lower movecount than cfop and very algorithmic so the turn speed could be very high