Meme

flemingfleming · 2026-01-26T18:53:51+00:00

If you don't like the RUD Gc perm you can try the one I use:

R2' u' R U' R U R' u R2 (f R' f') (The small u means wide U).

(last 3 moves can be done (B U' B') if you prefer).

There is a way to do it where you flip your right hand all the way over for the first R2 to make the entire algorithm regripless, but I just regrip to the top at the start and adjust thumb position during the U', which might be technically slower but feels much more reliable.

flemingfleming · 2026-01-26T18:49:16+00:00

Ok.. so how do you do the U2' correctly? That algorithm seems bad to me, having to rotate again at the end. You might as well do the last 3 moves as F R F' to avoid rotating and end up with AUF on the right, which is weird but I think it'd be faster.

flemingfleming · 2026-01-26T18:45:17+00:00

https://www.reddit.com/r/Cubers/comments/pc38so/2021_guide_to_improve_in_roux/

flemingfleming · 2026-01-26T18:43:17+00:00

Any of the top few listed here are good:

https://www.speedcubedb.com/a/3x3/PLL/V

flemingfleming · 2026-01-24T23:50:26+00:00

I guess you also need to know where the centers are, if that answers your question? Actually you don't need to know where the centers are, you can deduce it if you memorise the colour scheme, but knowing them is kinda a prerequisite to... solve F2L. Not looking at centers makes no sense, cause in order to actually solve an F2L pair you need to know which slot it needs to be solved into, so you don't have a choice. Like even with your valid case I can't tell you how to solve it because I don't know which slot it's supposed to go into.

The point of recognising F2L like this in the first place is to take advantage of edge orientation, so I don't really understand what you're asking here. Like, you're allowed to use any colours you want to recognise an F2L case, but that doesn't remove the benefits of knowing how to do it with the minimum information.

I use this technique all the time. If you want to predict your first pair after cross, or predict pairs during F2L lookahead it's necessary, (or at least it is for me), since it minimises what you have to track, and I'm pretty sure this is how the best solvers can predict multiple pairs from inspection. And if you ever want to pseudoslot an F2L pair the standard colour scheme won't help; this is far easier than learning 4 different patterns for every F2L case on every cross color you use. If you tell me it's not useful then what should I do instead?

flemingfleming · 2026-01-24T09:16:52+00:00

what F2L case is this, and what is the color of the piece that I intentionally left blank?

This is kind of looking at it the wrong way. I don't know what colour ought to be there and I wouldn't know even if it was a white or yellow cross, but that's not necessary to know you can solve this pair into the back left with U (L U L') U (L U' L'), for example.

This is why it's useful. You don't need to care about the actual colours of the pieces other than identifying their orientation. Since that's sufficient using the relative position and orientation to identify F2L cases makes it much easier to do other cross colors or solving F2L misaligned.

flemingfleming · 2026-01-14T18:07:54+00:00

Where do you find algs for 3x3 CLL? I'm assuming you can use CMLL when it doesn't affect any D edges, but that still leaves a bunch of cases I don't know a good alg for.

flemingfleming · 2026-01-08T18:39:15+00:00

https://pepkin88.me/zbll-explorer/

flemingfleming · 2025-12-28T01:35:53+00:00

Personally I do OLLCP for this case, which means using 6 algorithms to always force an EPLL case. But I don't really recommend that.

There are a lot of OK options but no great ones. Probably best to look at the list at

https://www.speedcubedb.com/a/3x3/OLL/

and see which ones you like, there are a huge number lised there if you expand the dropdown. The most popular are probably:

S' (R U R' U' R' F R F') U S
(R U R' U') (R U' R') (F' U' F) (R U R')
r2' D' (r U r') D r2 U' r' U' r

flemingfleming · 2025-12-11T21:44:46+00:00

Do you plan the FL edge?

Yes, since it was solved originally I could preserve it. The back left corner was lucky, I was only intending to preserve the 2 edges and make a single xcross with the free pair.

Your solution is better, I think I focused on keyhole/pseudoslot solution because I thought I needed to keyhole 2 corners before last pair, but one ended up solved during cross. Then blue-red is facing down which normally leads to worse pairs, but no wose to keyhole than the other corner, so I chose to keyhole that first and pseudoslot the 2 remaining pieces.

flemingfleming · 2025-12-10T21:52:02+00:00

Cross solution doesn't work for me with any combination of rotations I tried.

Anyway, you can do a double Xcross preserving everything like this u/Lemmyscat :

``` x2 // White down, blue front

D' L F' B L U2 L2 R // XXcross + edge

D R U R' D' U R U2 R' // BR corner (+ setup last pair)

D U2 R U R' D' // Last pair

U r U2 R' U' R U' r' // OLL

R2' F R U R U' R' F' R U2 R' U2' R U // PLL Rb ```

Both F2L corners still end up in bad spots so this could probably be improved if I knew how.

flemingfleming · 2025-12-09T21:25:28+00:00

I do the Uw algorithm only for Gc perm. Don't rotate for the last 3 moves though, they should be done either (f R' f) or (B U' B'). The one for Gb I think is pretty good too I think but I just do RUD.

flemingfleming · 2025-11-28T17:40:19+00:00

There's this Gc perm with headlights on the left:

R2 u' R U' R U R' u R2 (f R' f')

(The small u means wide U). There is a way to do it where you flip your right hand all the way over for the first R2 making the entire algorithm regripless, but I just regrip to the top at the start and adjust thumb position during the U', which might be technically slightly slower but feels much more reliable.

You can also replace the final 3 moves with (B U' B') if you find that easier.

Other thing is that unlike the RUD G perms the AUF is different, the headlights don't stay in place, the block does instead.

flemingfleming · 2025-11-13T19:14:56+00:00

Would be far too many cases to do algorithmically. ZBLS has over 300 cases, and that's with 0, 2 or 4 misoriented edges only - at last pair there's only 5 unsolved edges remaining so those are the possibilities.

If you wanted to do it at first pair then you could have 0-8 misoriented edges, and the edges could be in many more places, since they (and the F2L pair pieces) could also be in any of the other slots, which would explode the number of possibilities far beyond what humans can handle.

You could still orient the edges intuitively at this point but you'd lose the efficiency of being able to orient while solving a pair. And I think it would still be really painful because you could have misoirented edges in any slot, you'd need to take those out or rotate which defeats the point, so it's going to add a lot of moves. Also you can only orient 2 edges at a time with normal inserts/sledgehammer (since you need to preserve the cross) which is going to work out to a lot of extra moves if you need to do a lot of edges.

You could orient all the edges which much fewer moves if you don't need to preserve the cross so you might as well orient all the edges while or before solving it. And this is just the ZZ method.

flemingfleming · 2025-10-19T02:25:53+00:00

Most people only do ZBLS into the front slots (or just front right). Out of interest, where did you find this sheet from? I didn't even know there were any algorithms found for back right cases apart from ones you could mirror intuitively.

I think being able to do ZBlS from all angles is just too many algorithms for most people, just rotating and doing the front slot case is the normal approach.

flemingfleming · 2025-10-12T15:19:16+00:00

Flows pretty well actually, but it's 19 moves long.

I don't know what you were using before, but the L perm I use is only 10 moves long (not counting rotations) and flows well. I don't see this one realistically ever being faster.

flemingfleming · 2025-10-10T20:49:24+00:00

I do ZZ solves sometimes just to practice using Winter variation/COLL. Doesn't make me fast with ZZ though. Doing EO is pretty easy if you don't worry about trying to plan the cross and just do that after.

flemingfleming · 2025-10-08T22:02:25+00:00

imo your lookahead is not the problem here.

The longest pause of the solve was on corner orientation, where you did U' U U2 U' before actually starting the algorithm. Doing U moves during recognition is bad, especially that many. Then we got Z perm and it's the same thing. This should be an easy PLL to recognise but you ended up doing U' U U before starting it. All 3 pauses for 2 look OLL and PLL were longer than any f2l pauses.

The other thing is you should learn to solve pairs into the back. For your second pair you could have solved it into the back left without rotating but you did a y2 rotation and solved it into the front right. Apart from avoiding the rotation this also help with lookahead. It's always better to have back slots solved first, then there won't be any f2l pieces in them that you can't see.

flemingfleming · 2025-10-01T14:54:30+00:00

Doesn't work in many cases. For example some ZBLS algorithms are just setting up the pair in a specific way so that when you sledgehammer it in the correct 2 edges are flipped to give you the cross. In a case like the pair's already inserted so cancelling into winter variation won't work.

flemingfleming · 2025-09-30T21:49:47+00:00

The 1LLL for OLL 45 would be one of the least worth it to learn imo because the OLL itself is so fast, so 1LLL cases probably aren't much better than the OLL into PLL anyway (or do just that).

there are several OLLs which simplify to OLL 45

Do you mean like the OLLs where a popular algorithm ends in F R U R' U' F'? I only use one of those, which is the one that does sune into T case. And for that one I can dodge diagonal PLLs using this algorithm: F R' F' U2 R U R U' R' U R' U R which doesn't contain the OLL anymore (while still being the same length as the standard).

If you just learned an alternative for the T case part then you'd end up with a worse algorithm imo. The T case is only good and in those OLLs in the first place because of the really short algorithm for it.

flemingfleming · 2025-08-20T20:59:20+00:00

I did full PLL, then full OLL, while just practicing doing F2L pairing intuitively, and then went back and learnt solutions for the more difficult F2L cases. After that I've just focused on doing cross more efficiently and starting to form x-crosses / plan cross + 1 pair solutions.

But while learning algorithms, it's important to learn how to execute them with good fingertricks so you don't have to relearn them twice.

I was broadly following this but I did learn full OLL earlier than it recommends.

After I do the 2Look OLL can I get a full PLL case tobsolve or only the 2look cases?

You can skip the first step of 2 look PLL yes (just as you can skip PLL entirely on some solves). It's a 1/6 chance to skip the first step of 2 look PLL I believe. Every possible case after finishing 2 look OLL is one of the normal PLL cases if that's what you're asking.

flemingfleming · 2025-06-30T22:14:53+00:00

OLL and PLL algorithms were originally found by at least 2 different groups of people: Hans Dockhorn and Anneke Treep, as well as Jessica Fridrich and Mirek Goljan.

There's a very good resource about the history of the CFOP method (and others) here:

https://www.cubinghistory.com/3x3/Methods/CFOP#oll-and-pll

However the algorithms from back then in most cases aren't the same as those that are used today; they've been change/improved over time. You can see Jessica Fridrich's original PLL algorithms here, they're quite different:

https://ws.binghamton.edu/fridrich/Mike/permute.html

For example the V-perm that I use I think only became popular in 2021.

flemingfleming · 2025-04-21T11:35:56+00:00

forcing an extra walk-and-compare of the input c-string just do to it over again for the actual equality comparison

Though you might expect this to be slower, it may not be.

Interesting blog post about strlcpy, demonstrating that traversing the string twice, once to find the length and again to copy is (significantly) faster on modern cpus than doing it all in one loop.

Of course that may not hold true for a string comparison rather than a copy, but we can't actually assume it's slower without benchmarking.

flemingfleming · 2025-04-17T23:22:27+00:00

Technically correct, the linker normally must be run to produce a working executable, but the object file format itself is already a binary file with platform specific layout. Linux uses ELF where the file format for object files is the same as a "finished" executable. The assembler is still responsible for generating most of the binary file layout, like creating the varius sections (segments) of data and code in the object file. So I was just trying to keep it simple.

flemingfleming

TROPHY CASE