TorbinRoux
Member
or you could just learn VLS
yeah this is basically two look vls
or you could just learn VLS
or you could just learn VLS
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?
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
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?
Exactly. But this is a 1LLL whereas COLL to EPLL is not. Also, I would argue that this has better recognition than regular ZBLL.
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.
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.