New Method/Concept Thread

[qqwref]

I just came up with this, build a 2x2x2 block Then build 2x2x1 blocks around it, then fix bad edges. Then you solve the rest of the cube with only R and U (or L and U depending on how you fix them. R U is more preferred though).

That's exactly the same as Petrus, just with a 2gen last layer (which is impossible by the way, you probably forgot about corner permutation). But pretty much everyone who uses Petrus nowadays does OLL PLL or COLL EPLL, so it actually is the same as Petrus.

On insertion of the final C+E Pair of ZZ F2L, solve LL edge permutation, to allow finish with non-edge permuting COLL. Setting up edge permutation can be done with 2-gen algs.

The problem I see is that it takes quite a few moves to do the edge permutation (at least 4, right? and possibly way more), and the recognition is pretty difficult because you have to look at the stickers RU, BU, LU, and RF, all of which matter (unlike PLL) because 2-cycles can happen. In addition I can't see any quick way to fix an edge 2-cycle (adjacent or opposite).

As for CLL with edges solved, it sounds like a cool concept, but I've looked at the set of algs before and in practice there are a lot of ugly cases... corner 3-cycle with the fourth corner twisted, tons of E-perm cases, that kind of thing. It's not all that nice.

 

[Cride5]

On insertion of the final C+E Pair of ZZ F2L, solve LL edge permutation, to allow finish with non-edge permuting COLL. Setting up edge permutation can be done with 2-gen algs.

The problem I see is that it takes quite a few moves to do the edge permutation (at least 4, right? and possibly way more), and the recognition is pretty difficult because you have to look at the stickers RU, BU, LU, and RF, all of which matter (unlike PLL) because 2-cycles can happen. In addition I can't see any quick way to fix an edge 2-cycle (adjacent or opposite).

As for CLL with edges solved, it sounds like a cool concept, but I've looked at the set of algs before and in practice there are a lot of ugly cases... corner 3-cycle with the fourth corner twisted, tons of E-perm cases, that kind of thing. It's not all that nice.

Although I've not checked, I have a hunch that you're probably right about the terrible move count. The fact a completed F2L with unsolved, but phased edges requires a 13-mover to solve 2-gen is a bit worrying! I'd imagine that COLL followed by EPLL is probably easier .... buuut, I guess there's no harm in having a look at the algs if you've got the time to kill

 

[PlutoCuber]

well i created a method awhile ago based on the roux and fridrich method. i posted it on youtube and people said that it was copying. I think you'd probably have to come up with something completely original.

 

[guitardude7241]

well i created a method awhile ago based on the roux and fridrich method. i posted it on youtube and people said that it was copying. I think you'd probably have to come up with something completely original.

Hybrids of already well-known and efficient methods are generally not well-accepted, unless they are more efficient than the original method(s). If it was more efficient than Roux and Fridrich, your 11 year old self would be rather lucky.
:fp

 

[ErikJ]

Ok here's an idea for petrus users: After the 2x2x3 block, orient the edges permute the corners in such a way that the corners can be solved using just <R,U> moves. Finish the F2L (so you have a 2x3x3 block), then finish the LL (EPLL+COLL). I don't know anything about the move count. I only just came up with this idea a few hours ago. I have a feeling that EJF2L is better...

Lars said that he used to flip edges and fix corners before finishing the F2L. one of the original components to his method. it's really efficient but it's not practical for speedsolving because of the time it takes to see what has to be done to the corners.

 

[Robert-Y]

@ErikJ: Oh ok thanks

Ok erm... I've got another idea, but it involves learning ELL then CLL.

If you have an OLL parity on the 4x4x4, then you could do this instead:

1. ELL (with one edge flipped)

2 a. If you can recognise the CLL case, then do the pure OLL parity algorithm.
b. If you cannot recognise the CLL case, then do the non-pure double parity algorithm.

3. CLL.

 

[Robert-Y]

With the first step of my idea above, how many algorithms would you have to learn?

EDIT: Is it just... 11?

 

[JTW2007]

Okay, this is a hybrid, but don't flame me. What about:

1. 2x2x1 on left
2. 1x2x3 on right (as in Roux)
3. Expand the 2x2x1 block to 1x2x3 while solving all top layer corners
4. Finish as in Roux.

 

[somerandomkidmike]

Okay, this is a hybrid, but don't flame me. What about:

1. 2x2x1 on left
2. 1x2x3 on right (as in Roux)
3. Expand the 2x2x1 block to 1x2x3 while solving all top layer corners
4. Finish as in Roux.

It works, but it's not really faster. The recognition would be worse for this.

 

[JLarsen]

This is a method that combines full cls with Petrus.

Step 1. Solve any three edges around a corner. This is essentially a 2x2 block with a missing corner.

Step 2. Expand to a direction then avoids "bad corners". If an LL corner is trapped in the 2x2 you cannot solve it with a cls case. You must expand to a direction that makes it so that the corner in the 2x2 block, is not one that belongs in your last layer.

Step 3. Bad Edges

Step 4. Step 4

Step 5. CLS

Step 6. PLL

This has been come up with before I just thought I'd share it since it's not too well known. Keep in mind it is best to be fully CN to avoid bad corners, otherwise you have to make 2x2 blocks making *SURE* you don't contain a bad corner within, and that doesn't really save hardly as many moves. You can also merely place 2 edges next to a 2x2 block, that way 2x2x3 is just tracking 2 pieces.

 

[Robert-Y]

Another edge pairing method for the 4x4x4

Name: NOH (Nakajima-Omura-Hardwick)

How it works:

Step 1. Pair up 4 edges and place them on U layer then do z2

Step 2. Do d, replace 3 dedges, do d' to solve 3 edges (or 2 if there's a "problem"). In this step, you do not need to look on the bottom layer for edges.

Step 3. 2 pair chain solving. In this step, you can just look at the top layer for the edges.

 

[jcuber]

2x2 cross between CLL and Ortega

Make first layer (orientation only)

Solve the last layer and permutation of the first layer in 1 algorithm

I think it requires 3(?) times the amount of CLLs.

I thought about this when I realized how much easier it is to make a layer when only orientation matters.

 

[Robert-Y]

That's EG.

 

[guitardude7241]

I'm reviving this because people keep on making threads about methods. You're welcome.

 

[gamemeister27]

EDIT: I'm retarded, and got confused with my tabs and thought this thread was new, my mistake!

 

[(R)]

I'm reviving this because people keep on making threads about methods. You're welcome.

I hate you

 

[palmcubes]

i had an idea rouw but for cll first do oll to oreint edges on ll if botom edges are oriented permute corners if not do M2 and use 2 special algs that will flip them

oh and if one ontop is fliped and one on botom just bring um both up

 

[somerandomkidmike]

i had an idea rouw but for cll first do oll to oreint edges on ll if botom edges are oriented permute corners if not do M2 and use 2 special algs that will flip them

oh and if one ontop is fliped and one on botom just bring um both up

I don't understand what you're trying to say.

 

[dannyz0r]

i had an idea rouw but for cll first do oll to oreint edges on ll if botom edges are oriented permute corners if not do M2 and use 2 special algs that will flip them

oh and if one ontop is fliped and one on botom just bring um both up

I don't understand what you're trying to say.

F2B->Orient Corners->Orient Edges->Permute Corners->Don't permute edges

 

[somerandomkidmike]

i had an idea rouw but for cll first do oll to oreint edges on ll if botom edges are oriented permute corners if not do M2 and use 2 special algs that will flip them

oh and if one ontop is fliped and one on botom just bring um both up

I don't understand what you're trying to say.

F2B->Orient Corners->Orient Edges->Permute Corners->Don't permute edges

The CMLL is shorter because you don't have the edges oriented. This is not a very good idea.