# (Need help) List of all ZZ variants

#### Shiv3r

##### Member
I know the wiki does not have all the ZZ variants, and so I want to compile a list of all of them here. If you have any you want me to add, please comment below on which ones I missed, including which section they go in.
(At the time of this posting, the first 2 sections are just copy pasted from the SS wiki page for ZZ method.)
• OCLL/PLL The LL is completed by first orienting the corners (OCLL), and then permuting corners and edges (PLL). This is the second least algorithm intensive 2-look method for solving the last layer, following ZZ-reduction.
• OCELL/CPLL This is similar to using COLL/EPLL, but more of the algorithms can be 2-gen. First the LL corners are oriented and LL edges are permuted in one step, then the cube is completed with CPLL in the final step.
• ZZ-a: ZBLL is used to complete the last layer in a single step, also known as 1LLL (one-look last layer). There are 494 cases, solvable by 177 algorithms, in an average of ~12.08 moves.
• COLL/EPLL, or ZZ-VH(sometimes mistakenly called ZZ-a). The first step, COLL, orients and permutes the LL corners while preserving LL edge orientation(42 algorithms). The second step, EPLL, permutes the LL edges(4 algorithms). Often used in OH solving because all EPLL's can be solved 2-gen.
• NMLL completes the last layer when matching or non-matching blocks are used. The first step separates the colors belonging to the left and right layer. The second finishes permutation.

• ZZ-b: During F2L, the solver employs a technique called Phasing to correctly permute two opposite LL edges. Before the last corner-edge pair is placed, the solver uses one of several algorithms depending on how the edges are positioned. The last layer is then completed with one look using ZZLL.
• ZZ-WV: Before the last corner-edge pair is placed, the solver correctly orients all the corners by using 1 of 27 algorithms. After the first two layers, the solver is left with a PLL case, since both edges and corners are oriented.
• ZZ-c: The last layer corners are oriented during insertion of the last F2L block. This system is similar to using Winter Variation, but can be applied to any last block situation and uses many more algorithms. Conceptually, the comparison of ZZ-c with ZZ-WV is similar to the comparison of ZBLS with VH.
• ZZ-blah The last layer corners are disoriented during insertion of the last slot allowing the last layer to be solved using the Pi and H subsets of ZBLL.
• MGLS-Z During the F2L last slot, only the edge is placed. LL corner orientation and the final F2L corner are then solved in one step using CLS. Finally the solve is completed with PLL.
• EJLS Similar to MGLS-Z, but using less algorithms. During the F2L last slot the edge and corner are connected and placed, but the corner is not necessarily oriented. A subset of CLS is then used to orient the last slot corner along with the LL corners. PLL to finish.
• ZZ-d: Just before the completion of the left-hand F2L block, the solver permutes the remaining corners to put the cube into an <R, U> group. This makes the rest of the solve 2-gen, which is even faster than 3-gen. Only a maximum of 2 additional moves are required to correctly permute the corners. The process is called, CPLS. However, the solver must determine the permutation of all the unsolved corners to execute this step; this is a slow process, which makes ZZ-d inappropriate for speed solving. 2GLL to finish.
• ZZ-Orbit: A variation of ZZ-d, the solver will permute all the corners during insertion of last F2L's pair. Recognition is not so straight forward, but much faster than that of ZZ-d. Once performed, a 2-gen subset of ZZLL, consisting of 71 algs, can be used for 1-look last layer. This has many similarities to CPLS/2GLL, but was developed independently. Thread:[1] Guide:[2]
• ZZ-e: Similar to ZZ-d and ZZ-Orbit. After solving left block, the solver swaps remaining corners to put the cube into an <R, U> group. The process is called, 'Semi-Permunitation'. This makes the rest of the solve 2-gen, which is even faster than 3-gen. However, the solver must determine the permutation of all the unsolved corners to execute this step; this is a slow process, which makes ZZ-e inappropriate for speed solving, even more than ZZ-d. 2GLL to finish.
• ZZ-reduction During F2L, the solver employs a technique called Phasing to correctly permute two opposite LL edges. Then a 2-look orientation/permutation approach is used, with the phased edges preserved in the orientation step, resulting in a reduction of PLL cases down to 9 compared to 21 in full PLL. This is the least algorithm intensive 2-look method for solving the last layer of any 2LLLmethod, needing 7 + 9 = 16 total algorithms.
• ZZ-z: Similar to ZZ-d, ZZ-e, and ZZ-orbit, this variant relies on permuting the corners so that the solve can be done 2-gen after the 3rd step. This variant also has fewer algorithms than any other variant. First, the solver creates an EOLine, left block, CP, 1x2x2 block on BDR, LPELL, 2GLL.
• ZZ-CT: This variant solves EO and all but one F2L slot, then inserts the last edge and orients corners in one algorithm, then solves the rest (PLL and one corner), again in one algorithm.
Methods I know of but aren't on the wiki:
• ZZ-porky v1(or ZZ-porky1): after solving first block, place the DRF & DRB corners correctly, without regards to orientation.. then execute an algorithm to solve corner Permutation so that the rest of the solve can be done 2-gen.
• ZZ-porky1 variant: ZZ-Rainbow: after EOline, place the DRF and DRB corners in place and get the FB pieces in the L and U layers. Then either solve the first block<LU> or do a z rotation and then solving it RU. after first block you have already done the setup moves for ZZ-porky v1, and so execute the ZZ-porky algorithm, then solve the rest of the cube 2-gen.
• ZZ-porky V2(or ZZ-porky2): after solving the first square of ZZF2L, place the DRB and DRF corners and AUF the last first block corner to UBL. then execute an algorithm to permute the corners. then insert the last first block pair using only <LU> moves, then solve the rest of the cube with only <RU> moves.
• CPLS+2GLL: after solving ZZF2L-1 slot, insert the edge. then insert the final corner while solving CP, then finish with 2GLL.
• ZZ-snake pattern(ZZ-SP): after solving the first ZZF2L block on L, solve a 1x2x3 block on the top of the cube with <RU>, then rotate with a z' and solve the LL.
• ZZ-top: during EOline, orient only the cross edges and F2L edges. After ZZF2L you will end up with the same last layer as CFOP, so you can just do OLL/PLL.
• ZZ-LSE or ZZ-4c: a variant I proposed a while back. Instead of solving EO and a line comprising of DF and DB, solve EO and then place the edges that go to UL and UR at DF and DR. After ZZF2L, you can then do COLL and then go directly into Roux LSE step 4c, which often is more efficient than EPLL.
• ZZ-DF: solve EO but only place the DB edge. this allows for significant freer blockbuilding than normal ZZF2L.
Anything I missed? please tell me.

#### TDM

##### Member
Well there's this, but I'm not sure it's any good (though if you're going for completeness then include it if you want). Looking back now I should have suggested the edges to be unphased to give better algs.

There's also COLL+, where (after standard F2L) you solve COLL plus one edge which gives you an EPLL skip or a U perm. Two algs per case, one main alg and one to unphase edges where you'd otherwise get H/Z.

Porky v1/v2 come under ZZ-d/ZZ-e respectively.

You definitely weren't the first to propose ZZ-LSE.

Unrelated: lol, who wrote the ZZ-SP WiFi article? It was invented years ago and didn't have such a stupid name. Also, "Unlike the standard ZZ Method, you only perform half of F2L" is completely false because you solve exactly the same blocks as ZZ only you're more restricted so it's less efficient and slower.

Last edited:

#### mDiPalma

##### Member
for LL there's also fish & chips

for LS/LL there's also LPELL+L4C and Speed-Heise+L3C

and Q-M's method for non-vanilla zz

edit i would also kill zz-e, and move zz-orbit to Missing Link Approaches

#### Y2k1

##### Member
ZZ-SV

There's also COLL+, where (after standard F2L) you solve COLL plus one edge which gives you an EPLL skip or a U perm. Two algs per case, one main alg and one to unphase edges where you'd otherwise get H/Z.
That sounds interesting. Can you link it here?

#### TDM

##### Member
That sounds interesting. Can you link it here?
I can't find anything, I'm sure I've heard about it somewhere before. Weird. Perhaps it has a different name.

Either way it's hardly a new method (only just a way to reduce bad cases) so it arguably shouldn't get a name of its own. Though the same argument could be said for ZZ-rainbow and possibly even ZZ-b.

If you want information, that post is honestly all you need to know. Learn two algs per case and learn to recognise when you would get phased edges with your preferred one. If you're going to get phased edges, use the alternative alg. Unless you're going to get a skip, of course.

I'd been considering extending it to CFOP/CFCE for a while, where you ensure one edge is solved but edges are unphased, giving you a 3-cycle ELL (or a skip since you can probably predict that). It's only four algs per CLL but recognition is terrible, so I gave up on it. However it's very easy for ZZ.

#### Y2k1

##### Member
I can't find anything, I'm sure I've heard about it somewhere before. Weird. Perhaps it has a different name.

Either way it's hardly a new method (only just a way to reduce bad cases) so it arguably shouldn't get a name of its own. Though the same argument could be said for ZZ-rainbow and possibly even ZZ-b.

If you want information, that post is honestly all you need to know. Learn two algs per case and learn to recognise when you would get phased edges with your preferred one. If you're going to get phased edges, use the alternative alg. Unless you're going to get a skip, of course.

I'd been considering extending it to CFOP/CFCE for a while, where you ensure one edge is solved but edges are unphased, giving you a 3-cycle ELL (or a skip since you can probably predict that). It's only four algs per CLL but recognition is terrible, so I gave up on it. However it's very easy for ZZ.
Thanks, I was just curios to see where someone proposed it but np.

#### 1973486

##### Member
Unrelated: lol, who wrote the ZZ-SP wiki? It was invented years ago and didn't have such a stupid name. Also, "Unlike the standard ZZ Method, you only perform half of F2L" is completely false because you solve exactly the same blocks as ZZ only you're more restricted so it's less efficient and slower.

You can check the history but I don't know the identity of the user who created it.

Also pls don't call an article a wiki it makes me cri

TDM

#### AlphaSheep

##### Member
Only one that I can think of that's missing
ZZ-lol (line on left): During EOline, solve EO and the LF and LB edges to reduce the rest of the cube to <R, U, D>

#### obelisk477

##### Member
I can't find anything, I'm sure I've heard about it somewhere before. Weird. Perhaps it has a different name.

Either way it's hardly a new method (only just a way to reduce bad cases) so it arguably shouldn't get a name of its own. Though the same argument could be said for ZZ-rainbow and possibly even ZZ-b.

If you want information, that post is honestly all you need to know. Learn two algs per case and learn to recognise when you would get phased edges with your preferred one. If you're going to get phased edges, use the alternative alg. Unless you're going to get a skip, of course.

I'd been considering extending it to CFOP/CFCE for a while, where you ensure one edge is solved but edges are unphased, giving you a 3-cycle ELL (or a skip since you can probably predict that). It's only four algs per CLL but recognition is terrible, so I gave up on it. However it's very easy for ZZ.

I proposed a COLL variant once (I think I called it COLL+ actually, or maybe COLL+1) where you just memorize the ZBLL recog for your standard COLL, and if you get any other ZBLL for that COLL case, you just execute another COLL alg for that case. It increases your chance of EPLL skip to 1/6 as opposed to 1/12

TDM

#### AlphaSheep

##### Member
Another one I remembered is the one where you build a 1x1x3 line on LL during LS, which needs only 17 ZBLLs to solve LL. Preserving the line is not easy to do intuitively and wastes a ton of moves though. I think everyone trying to come up with new variants must think of this at some point.

Anyway, on the topic of variants, do most ZZ solvers really actually use just one variant, or do they mainly use a mixture?

I use a mixture. I use WV into PLL for the short obvious cases (I guess about 15% of the time). If it's not an easy WV, then I'll insert the pair. I also use a few different inserts if the LS corner is already inserted (I believe this is BLE).

If the OCLL is a Sune or Antisune, I'll do OCLL+PLL unless I see a 2x2 square and phased edges, in which case I'll do a pure 3 twist, Niklas, or that other 3 cycle.

Otherwise I'll use COLL+EPLL, unless I manage to recognise the ZBLL (around 20% of the time because I only use ZBLLs that have super obvious blocks or patterns that stand out while recognising COLL).

#### TDM

##### Member
I proposed a COLL variant once (I think I called it COLL+ actually, or maybe COLL+1) where you just memorize the ZBLL recog for your standard COLL, and if you get any other ZBLL for that COLL case, you just execute another COLL alg for that case. It increases your chance of EPLL skip to 1/6 as opposed to 1/12
Interesting, that may have been what I was remembering (though Google is still not giving anything - I don't think it likes + signs). Do you think the better recognition of your method makes up for the higher probability of H/Z perms?

#### obelisk477

##### Member
Interesting, that may have been what I was remembering (though Google is still not giving anything - I don't think it likes + signs). Do you think the better recognition of your method makes up for the higher probability of H/Z perms?

I think so, and even more so because while Z perms are annoying, I don't see what the big deal with H perms is. That's probably my favorite EPLL.

#### TDM

##### Member
I think so, and even more so because while Z perms are annoying, I don't see what the big deal with H perms is. That's probably my favorite EPLL.
Oh, okay. I still prefer U to H although the extra recog time probably isn't worth it for the tiny amount saved.

#### Shiv3r

##### Member
Oh, okay. I still prefer U to H although the extra recog time probably isn't worth it for the tiny amount saved.
I'm bored. I think maybe some time today I will generate COLL+ algorithms, meaning I will take the first of each COLL on algDB and figure out which set it goes to.

#### TDM

##### Member
I'm bored. I think maybe some time today I will generate COLL+ algorithms, meaning I will take the first of each COLL on algDB and figure out which set it goes to.
?? You just take any of them which solve different phasing. No need to generate or even make a list of them.

#### Shiv3r

##### Member
?? You just take any of them which solve different phasing. No need to generate or even make a list of them.
I feel like it. my idea is just say "okay if you get phasing do the COLL alg on algdb.net, if you get no phasing do a different alg."

#### TDM

##### Member
This thread just reminded me, ZZ-1 (it doesn't have a proper name, but this is the name I use), is where you solve like a square-1. EOLine on L, reduce to <R2, U, D>, and then finish it with any square-1 method (e.g. I used to use CO->CP->EO->EP+parity, or sometimes I blockbuilt a layer and did PLL with <R2, U, D>).

##### Member
This thread just reminded me, ZZ-1 (it doesn't have a proper name, but this is the name I use), is where you solve like a square-1. EOLine on L, reduce to <R2, U, D>, and then finish it with any square-1 method (e.g. I used to use CO->CP->EO->EP+parity, or sometimes I blockbuilt a layer and did PLL with <R2, U, D>).
Looks kinda like SSC to me.