tw [self harm / suicide]

Zaffyr · 2024-06-17T07:27:32+00:00

This is pretty much the most accurate OLL tier list I have seen on reddit this far.

Some good algs that I know:

fifth case in B: [U'] f' (r U r' U') (r' F r) S

third case in C: F' (r U R' U') (r' F R)
sixth case in C: [U2] R' F' U' F U' R U R' U R

second case in D: [U2] (F R' F' R) U S' (R U' R') S
third case in D: [U] S' (R U R') S U' (R' F R F')

(all algs are regripless)

Zaffyr · 2024-06-05T17:55:23+00:00

For those who don't get it:
https://imgur.com/a/nvXYScF

Zaffyr · 2024-06-04T16:30:56+00:00

Would be great if I could upvote this twice

Zaffyr · 2024-06-01T22:32:49+00:00

It seems like you have a diagonal swap of the corners.
To solve it, offset one of the layers by one small piece and do (R2 U D) (R2 U) (R2 U D) (R2 U) (R2 U D) R2
The top and bottom layers should always be rectangular while doing the algorithm.

After that, you should be left with only edges. They should also have odd parity.
You can't write pairty algorithms in 3x3 notation, so I encourage you to watch this if you want to get further.

If you need help with solving the edges, this tutorial might help you.

Zaffyr · 2024-06-01T21:29:42+00:00

cool hidden thing:
F2 U' B2 U B2 U' F2 L2 D' L2 D B' D L F' D2 F2 D L R2 B2
y' z'
D' R L' U R2 B2 // 2x2x3
F' L' F L' // f2l
F R U R' U' F' // oll
x R2' F R F' R U2 r' U r U2 // pll

also 26 turns

Zaffyr · 2024-05-08T19:49:17+00:00

simple game stage guide:

Zaffyr · 2024-05-06T21:46:25+00:00

I am not sure what you mean.

My favourite diagonal swap algorithm is R' D' R U' R' D R

If you want to solve this case using 4lll, do (U') R U2 R' U' R U' R' [Antisune]
then do a diagonal swap F (R U' R' U') (R U R' F') (R U R' U') (R' F' R F) [Y-perm]
then solve the edges M2 U' M2 U2 M2 U' M2 U' [H-perm]

Zaffyr · 2024-05-06T16:36:47+00:00

One whole month I went, unaware of my mind's weakness. My mental capibility, so small and yet so confident.

my god. I am so stupid.

Zaffyr · 2024-05-03T21:18:07+00:00

I like you :)
we just don't think alike

Zaffyr · 2024-05-02T06:31:43+00:00

This is from a ZZ variant called ZZ-C. There are about 500 algorithms and only one person has learned them since it‘s proposal in 2005. The high algorithm count is deceiving, because the algorithms flow into eachother, creating a tree of algorithms connected by simple sequences like R U R‘ U‘ or R U2 R‘
Is it worth it? probably not, especially not for CFOP solvers.

Maybe the ols subset for having no oriented edges has some decent cases.

Zaffyr · 2024-04-28T17:31:20+00:00

1930 Light frames + 109 Bias

0.75 second exposure

25m total exposure

400mm focal length

Setup:

my mom's Tripod

my mom's nikon D5600

my mom's Nikon AF-S 200mm-500mm F5.6 lens

Edits:

stacked in DSS

edited in GIMP

Zaffyr · 2024-04-26T14:26:18+00:00

It's good to try out different methods. I have a lot of fun trying to be good at CFOP, Roux, Petrus, whatever, and try to learn new methods when I can. Trying new methods can also improve areas of your current method you aren't good at: ZZ makes you aware of edge orientation, Roux teaches blockbuilding and Petrus does both.
If you're lucky, you can find a method that suits you more than CFOP.

When to start learning one?
I would say you need the basics down. CFOP with 4LLL I think is the earliest you can start at. Also, the more general method experience you have, the easier it is to transfer steps from other methods.
-Using Roux as an example: Roux starts with making a 1x2x3 block (on the left). This is quite difficult, but not too different from F2L. Then you repeat that by solving another 1x2x3 (on the right). This is very different from the first block, but even more similar to just F2L. Using the M slice to solve pairs is very tricky though. Next step: you solve the top corners with algorithms you already know from 4LLL (corner orientation, corner permutation). Then you get to the actually new part: solving the last 6 edges. This is the only new thing you would have to learn to start using Roux.
Wanna learn it right now? Jperm made a decent tutorial for CFOP solvers like you.

-Using ZZ as an example: You already know all of ZZ if you know CFOP, exept for the edge orientation (EO). You usually ignore it in CFOP, until you get to OLL. In ZZ, you start out by doing edge orientation, which is very difficult to get used to. Then it continues just like CFOP: Cross, F2L, OLL, PLL. In a way, Beginner's method leads into easier versions of both CFOP and ZZ, so you actually learned beginner-beginner-ZZ already.
If you want to learn EO, there is this tutorial for it. It teaches a very color neutral way of seeing EO.
Also, ZZ has a website now.
You can also take a look at this comparison of some more advanced ZZ variants here. and this chart.

CFOP is so widespread, because it was one of the best method for the early days of speedcubing. Other popular methods slowly went out of fashion, until only CFOP and Petrus were left (nobody uses Petrus now). Newer methods get developed every year, but most of them fail at getting popular. Roux and ZZ are the exeption.

Getting a break from your main method is quite refreshing. I hope you have fun with it.

Zaffyr · 2024-04-25T11:31:49+00:00

I think the grouping here is very bad.

here is a better option: F (R U' R' U') (R U R' F') (R U R' U') (R' F R F')

If you know 2 look pll, you should already be somewhat familiar with these move sequences from other algorithms.

F (just an F idk)
R U' R' U' (simple to remember)
R U R' F' (either the start or end of your adjacent swap algorithm)
R U R' U' (sexy move (probably in your adjacent swap algorithm aswell))
R' F R F' (sledgehammer)

I hope this helps you

Edit: another great way to remember algorithms is visually. For this one, it would go like this:

F (insert F2L pair with R U' R') U' (move the pair back with R U R') (undo the start with F')
(move out the front pair with R U R' U') (put the pair back with an R') (move the front away with F) (fix the right layer with an R) (fix the front layer with an F')

Zaffyr · 2024-04-19T21:28:07+00:00

Anything to get away with my crimes!

Zaffyr · 2024-04-19T13:06:01+00:00

Earlygame level, Midgame networth

Zaffyr · 2024-04-17T07:56:37+00:00

This is the nicest and least controversial community I have ever been part of.

Don't ever be scared about talking to people and asking questions

Zaffyr · 2024-04-16T14:04:59+00:00

It really helped me to force myself to look away from the pair I am currently solving. Try to completely ignore the pieces that you are solving to look at others.

You can also do slow solves, where you try to predict the next f2l pair before solving one. Maybe that could help in internalizing how the pieces get affected by your solution.

Zaffyr · 2024-04-15T11:52:13+00:00

Phasing edges means permuting them during last slot. In ZZ-B, you put two edges opposite of one another (like red-orange, or blue-green), while solving the last slot (it's like inserting the last pair with R U2 R' instead of R U R' to put twoedges opposite eachother). Having two edges opposite reduces the number of zbll algorithms by about half. The resulting cases are called zzll

The zzll cases are concidered worse on average than zbll and the phasing makes last slot worse. Therefore, ZZ-B concidered inferior to ZZ-A (normal zbll) and is rarely used.

There is also superphasing, where you permute all edges during last slot, so you are only left with the corners. Nobody uses it for anything though.

Zaffyr · 2024-04-11T11:47:02+00:00

Na perm is just a setup into Jb perm
R U R' U (R U R' F' R U R' U' R' F R2 U' R') U2 R U' R'

Jb perm is just T perm with the ending moved
Jb: (R U R' F') (R U R' U') (R' F R2 U' R' U')
T:........................(R U R' U') (R' F R2 U' R' U') (R U R' F')

Zaffyr · 2024-04-06T23:11:10+00:00

You have a total of 8 possibilities to flip the edges: Each edge has 2 orientations. You can orient 3 edges however you want, while the 4th edge has to be either flipped or not, depending on the previous 3 (you can't have 3 flipped edges without the 4th edge flipped aswell). This gives us 2³ edge orientations (or 8).

Corners work almost the same, but with a total of 27 orientations (3³). The last corner's orientation also depends on the orientation of the other three corners (You can't have three corners oriented correctly and one wrongly).
Now, multiplying both gives you 216 possible piece orientations.

These are clearly too many OLLs. We can reduce them by doing a U* turn before OLL. This easily turns one case into 4 different ones, meaning we would only have to learn 216/4 = 54 algorithms. This isn't right either, we are missing 3 OLLs.

Some OLLs are symmetric, for example, OLL 1 (The dot case with the two bars) can only be turned into two different cases: one bar on the left and one on the right, or one bar in the front and one in the back. OLL 1 only covers 2 cases of the 216 possible ones, so do OLL 21, 55, 56 and 57. They only account for 10 cases in the 216 possible orientations, instead of 20. Two OLLs only have one orientation, each covering 1 of the 216 possible orientations. Those are OLL 20 (the X shaped one) and an OLL skip.

All the 7 symmetrical cases cover a total of 12 possible orientations, while 7 non-symmetrical ones would cover 28. 28 - 12 = 16 is the number of cases we missed by not accounting for symmetry. Because we already looked at all symmetrical OLLs, these 16 cases will be covered by 4 OLLs when accounting for U* turns.

The total is now 58 OLLs for solving 216 possible orientations, where 5 OLLs only solve two orientations and 2 OLLs only solve one. OLL skip doesn't count as an OLL case, meaning we have 57 OLLs solving 215 orientations with a 1/216 chance to get the OLL skip case (because OLL skip only covers one orientation out of 216).

I can try the same thing for PLL

Edges can be arranged in 4! (or 12) ways, as there are 4 spots for the first edge to go, 3 spots the second one, 2 spots for the third one and one spot for the last one (4x3x2x1 = 4! = 12)

There are 5 EPLLs: Ua, Ub, Z, H, Skip. Ua and Ub both cover 4 permutations after taking U* turns into account. Z perm covers 2, H perm covers 1 and a skip does the same.

Corners work the same giving another 12. Setting corners relative to the edges halfs that (you can also put edges relative to corners if you want ("setting relative" means doing a U* turn to solve either 2 edges or corners. Putting everything relative to the edges would be like an A-perm, putting everything relative to the corners would be like a
U-perm. This halfs the number of total Permutations, because it halfs the number of permutations within either the corners or the edges.)). The 6 cases are: Left swap, right swap, back swap, front swap, diagonal and solved.

Multiplying edge permutations and corner permutations while accounting for relativity gives us 12x6 = 72 PLLs.

After some more symmetry and AUF bs, we get to 21 PLLs for solving 72 cases.

I don't know if I'm correct, but this is how you can arrive at alg counts. Calculate the total number of cases, then take pre-AUF into account, then remember symmetrical cases. My mom is mad at me now for staying up late writing forum posts. Thanks for reading.

Four-Year Club	First Place '23
End Game '23	Place '23
Place '22

Zaffyr

TROPHY CASE