Memorizing algorithms

Hi,
I restarted working on blidfold solving, I know the basics quite well but have near 0 practice.

I started memorizing algorithms 1-2 years ago with a PAO system I made for it but since I forgot it anyway, I’m starting over.

I’m not really interested in speed and would like to avoid rote memorization as in doing the 3 algorithms I need to know tens of time untill I know them.

I’m considering building myself a PAO system once more but I’d also like to know if any of you have something similar to memorize algorithms?
Something helping you memorize a long algo ( 10-20 moves ) by lookign at it once.
(Even if you can’t make the moves quickly, as long as you know the moves)

If someone’s interested, my PAO was quite simple :
for each letters : R, L, (U or T), D, F, B
I had 1 “good” and 1 “bad” of all three categories ( Person, Action, Object ).

That’s the gits of it;
If you want an example, R U R’ would look something like “Red Hood (good) Unboxes (good) a Rat(Bad)”

2 Likes

I’m working on something like that. The basic idea is that numbers are chunked into 3 hexadecimal digits. The first digit indicates what type of move(s) it will be. Like a single move, or of the form (A B A’) where A and B are single moves in STM, or of the form (A B A’ B’) where A and B are single moves in STM, etc. The second and third vary based on the first. For (A B A’), the second digit specifies what “A” is, and the third specifies what “B” is. This is all subject to change as I’m still planning a major rewrite to it.

1 Like

@Dargonesti so if you’re not really interested in speed… why don’t you just use Old Pochmann then? Basically comes down to:

• Y-perm for corners `F R U' R' U' [R U R' F'] {[R U R' U'] [R' F R F']}`
• T-perm for edges `[R U R' U'] [R' F] [R2 U' R'] U' [R U R' F']`
• R-perm for parity fix `[L U2' L' U2'] [L F'] [L' U' L U] [L F] L2' U`

I’d still supplement with J(a) and J(b) considering one of them is the same as T-perm only starting a few turns further in than the T-perm. The R-perm is only used once between corners finished and starting edges (if even necessary to fix parity).

So that makes it 5 algs in total using OP. You need to know the setup moves to get the corners/edges into the buffer position and back, but the real thing that needs memorization during BLD is the sequence (I’d use speffz) of swaps you need to perform.

Anyways, what are the algorithms you are trying to learn exactly? Do you cluster them like in the above example with the brackets around common triggers?

I use the Yo notation to memorise algorithms. It is very useful to learn really big algsets like ZBLL and 5-style.

In Yo notation, each face and slice turn is encoded as a unique letter, so U=a, U’=b and U2=c and so on.