The New Method / Substep / Concept Idea Thread

[TorbinRoux]

or you could just learn VLS

yeah this is basically two look vls

 

[shadowslice e]

or you could just learn VLS

Acually they would be better off learning MGLS cause it seems like they want a lower alg count.

 

[Calode]

Not my idea.

Friend of mine proposed an ell + cp substep. We're thinking cfop wv + ellcp would be an interesting cfop variation. We're trying to figure out how many algs there would be. We're supposing 6 (solved, opp, 4 adj swaps) * 29 (# of ells) but unsure. To solve ell + cp (co is solved), how many cases would that be?

 

[Cale S]

Not my idea.

Friend of mine proposed an ell + cp substep. We're thinking cfop wv + ellcp would be an interesting cfop variation. We're trying to figure out how many algs there would be. We're supposing 6 (solved, opp, 4 adj swaps) * 29 (# of ells) but unsure. To solve ell + cp (co is solved), how many cases would that be?

https://www.speedsolving.com/wiki/index.php/COALL

 

[Calode]

https://www.speedsolving.com/wiki/index.php/COALL

All, cool. Thanks.

 

[xyzzy]

Last layer CO can always be done with two Sunes, which gave me this idea for a two-look ZBLL that also turned out to have a low alg count. For the first look one of the Sune COLLs is used to permute the corners and orient the corners into a Sune state, and for the second look one of the Sune 2GLLs is used to permute the edges and solve CO. It's probably not a novel idea, but I've never seen it mentioned anywhere.

The total number of algs needed is just 17 (not counting mirrors), which is slightly lower than the 20 needed for OCLL/PLL, and most of these 17 algs can be done two-gen. It's not really a useful 2LLL method on its own since recognition and some of the algs aren't very nice, but it could be used as a stepping stone towards either full COLL or full 2GLL.

Scramble (random ZBLL): F2 U2 D' B2 D' R2 U R B2 D2 R' D2 R2 B2 R D2 R2 F2
CP: U' L' U R U' L U R'
EP: L' U' L U' L' U2 L

 

[4Chan]

Last layer CO can always be done with two Sunes, which gave me this idea for a two-look ZBLL that also turned out to have a low alg count. For the first look one of the Sune COLLs is used to permute the corners and orient the corners into a Sune state, and for the second look one of the Sune 2GLLs is used to permute the edges and solve CO. It's probably not a novel idea, but I've never seen it mentioned anywhere.

The total number of algs needed is just 17 (not counting mirrors), which is slightly lower than the 20 needed for OCLL/PLL, and most of these 17 algs can be done two-gen. It's not really a useful 2LLL method on its own since recognition and some of the algs aren't very nice, but it could be used as a stepping stone towards either full COLL or full 2GLL.

Scramble (random ZBLL): F2 U2 D' B2 D' R2 U R B2 D2 R' D2 R2 B2 R D2 R2 F2
CP: U' L' U R U' L U R'
EP: L' U' L U' L' U2 L

Bro, that's pretty darn cool.

 

[Sion]

Working on a New Hybrid

Hey. I finally decided on a particular hybrid as my main method of choice. It consists of:

-F2B
-SMLE (Solving Middle Layer Edges; this is so the first two layers are solved)
-OLL
-PLL

I am a newbie and can only solve this method at a slow pace to get used to it. So I'm asking the more experienced cubers to try to test this method out and conclude if it is a method worthwhile learning, since I am working at it now. Thank you again for your support

Please post your times and average along with a comment

 

[shadowslice e]

This method is known about but the general consensus is that it is not as good as either CFOP or Roux cause it is less efficient and has more steps.

 

[Sion]

I don't mean to be objective, but how is that exactly?

 

[GuRoux]

i think it is good, but i belive you should try this out too:

F2B
SMLE
CLL
ELL

while you solve SMLE, you can see what CLL case you have, therefore you skip a recognition pause.

 

[Sion]

Thanks. By the way, you're outstandingly amazing at roux!

 

[TDM]

This is probably one of the most proposed "new" methods.

It's definitely slower than Roux. It's far less efficient, harder to fingertrick and has more difficult lookahead.

Compared to CFOP, this method of solving F2L is, again, fairly slow. Although initially the F2B is faster than F2L, solving DF+DB can be very slow and does use a lot of moves. The lookahead and ability to influence LL is limited, though as Kavin suggested finishing with CLL/ELL does give good lookahead into a probably faster LL system.

But no, this is not worth using.

 

[crafto22]

Easy ZB

Hey guys, I've been playing around with this for awhile. At first it was just an idea for 2GLL without learning all the algs but I realized this could easily become full ZB without that many algs.

I'll just start off with an example solve then explain what I'm doing if it isn't already obvious.

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

x2 y R2 U' L' F2 U' B2 // Cross
L U2 L' U L U' L' // First Pair
U R' U' R U' R' U R // Second Pair
L' U2 L U2 F R' F' R // Third Pair
d [F R' F' R] U [R U2 R' U' R U R'] // ZBLS
U' [R2 U R U R' U' R' U' R' U R'] U' [R U2 R' U2 L' U R U' R' L] // ZBLL

Yes that last part was one-look.

So basically you use sledgehammer or hedgeslammer to orient edges whilst tracking the pieces to build the last pair thus giving a less efficient ZBLS, then you use an edge permutation algorithm to give you the skip case for that specific COLL. You basically just have to memorize what each skip case is. In that case, I knew that I had to have a sort of two-piece bar in the back and the edges around the oriented corner along with the ladder had to look like a Z-perm.

So this is really just a 46 algorithm version of ZB. I hope no one came up with this already.

 

[Cale S]

Hey guys, I've been playing around with this for awhile. At first it was just an idea for 2GLL without learning all the algs but I realized this could easily become full ZB without that many algs.

I'll just start off with an example solve then explain what I'm doing if it isn't already obvious.

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

x2 y R2 U' L' F2 U' B2 // Cross
L U2 L' U L U' L' // First Pair
U R' U' R U' R' U R // Second Pair
L' U2 L U2 F R' F' R // Third Pair
d [F R' F' R] U [R U2 R' U' R U R'] // ZBLS
U' [R2 U R U R' U' R' U' R' U R'] U' [R U2 R' U2 L' U R U' R' L] // ZBLL

Yes that last part was one-look.

So basically you use sledgehammer or hedgeslammer to orient edges whilst tracking the pieces to build the last pair thus giving a less efficient ZBLS, then you use an edge permutation algorithm to give you the skip case for that specific COLL. You basically just have to memorize what each skip case is. In that case, I knew that I had to have a sort of two-piece bar in the back and the edges around the oriented corner along with the ladder had to look like a Z-perm.

So this is really just a 46 algorithm version of ZB. I hope no one came up with this already.

So instead of COLL to EPLL you do EPLL to COLL but with harder recognition?

 

[crafto22]

So instead of COLL to EPLL you do EPLL to COLL but with harder recognition?

Exactly. But this is a 1LLL whereas COLL to EPLL is not. Also, I would argue that this has better recognition than regular ZBLL.

 

[gyroninja]

Exactly. But this is a 1LLL whereas COLL to EPLL is not. Also, I would argue that this has better recognition than regular ZBLL.

You know you could learn what epll is going to come after the coll for a certain zbll and it would be the same but better recognition in case your prediction was wrong. If you did the wrong epll in your method you would have to do epll coll epll.

 

[Cale S]

Exactly. But this is a 1LLL whereas COLL to EPLL is not. Also, I would argue that this has better recognition than regular ZBLL.

If you want to make your system 1LLL, you would need to know how all COLLs affect EPLL (not that difficult actually), but if you know that you could just do COLL and predict the EPLL, instead of changing the EPLL to what it would need to be to skip.

 

[crafto22]

If you want to make your system 1LLL, you would need to know how all COLLs affect EPLL (not that difficult actually), but if you know that you could just do COLL and predict the EPLL, instead of changing the EPLL to what it would need to be to skip.

Wut? This is a 1LLL. Trust me, predicting EPLL after COLL sucks worst than my initial idea, I've tried to do that before. I have already created a pretty good recognition system for the H and Pi sets of COLL, and I'm guessing the others will be just as good.

 

[crafto22]

You know you could learn what epll is going to come after the coll for a certain zbll and it would be the same but better recognition in case your prediction was wrong. If you did the wrong epll in your method you would have to do epll coll epll.

No, recognition wouldn't be better. Think about it. You'd have to figure out where each piece is going in an instant. With my method, there are predetermined locations pieces need to be in, so recognition is basically instant. You just look, see where the pieces need to be, recognize your COLL at the same time and then execute your EPLL-COLL. This system is superior to COLL-EPLL by a long shot since COLL-EPLL can't be recognized fast enough.