# Thread: A Collection of Algorithms

1. Ooh nice. I'm going to add it to my OLLCP table, thanks!

2. The reverse is quite nice and actually I was looking for something for this case. Thanks.
(But for the one you posted, I like (FRUR'U'F') (RUR'U'R'FRF'))

3. <3 OLL 34 <3.

R U R' U' f' U' F d M'

4. R2 F R2 U R' U' R' F' R U2 R U' R' U' R

5. R perm
R U R' U2' R' U2 L R2 U' R' U L' R' U2' R U2'

RUL. I think I am going to use it for OH.
Found it a long time ago but only thought it was worth posting now

6. Originally Posted by Tao Yu
R perm
R U R' U2' R' U2 L R2 U' R' U L' R' U2' R U2'

RUL. I think I am going to use it for OH.
Found it a long time ago but only thought it was worth posting now
Nice alg. It's already in the wiki though. "Alg.5" under R Permutation b on the PLL page.

Anyway, here's a transformation of my M layer double parity algorithm: r U2 r' U2 r' D2 r D2 r' B2 r B2 r' (19,13) which I posted on 1-9-2010 (that post no longer exists though).
r U2 r' U2 l2 r U2 r U2 l' U2 r U2 l' (20,14)

This might have been made in the past, but I didn't see it posted anywhere in public. So I hope I'm not posting an old (version) of my (19,13).

Transformation Steps:
r U2 r' U2 r' D2 r D2 r' B2 r B2 r'
= r U2 r' U2 r' x2 U2 r U2 r' x2 x' U2 r U2 r' x
= r U2 r' U2 r' x2 U2 r U2 r' x U2 r U2 r' x
= r U2 r' U2 r' (L2 l2 r2 R2) U2 r U2 r' (L' l' r R) U2 r U2 r' (L' l' r R)
= r U2 r' U2 l2 r (L2 R2) U2 r U2 l' (L' R) U2 r U2 l' (L' R)

Omitting the L and R outer layer turns to obtain the transformation,
= r U2 r' U2 l2 r U2 r U2 l' U2 r U2 l'

---------------------------------------------------------------------------------------------------------------------
Also, for those who participated in the WANTED: New Dedge Flip Algorithm! thread, everyone was telling reThinking the Cube that his "reParity" algorithm Rw U2 Lw' U2 x' Rw' U2 Lw U2 Rw' U2 Lw U2 Lw' U2 y' M2 y' was identical to my 4-cycle double parity algorithm r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2. Well, it is, as others have said for the inner layer turn portion of the algorithms.

Only for those who didn't compare those two algorithms before,
Spoiler:
"reParity"
= Rw U2 Lw' U2 x' Rw' U2 Lw U2 Rw' U2 Lw U2 Lw' U2 S2 y2

In single slice turns,
= r U2 l' U2 x' (L' R) r' U2 l U2 r' U2 l U2 l' U2 S2 y2
= r U2 l' U2 (L l r' R') (L' R) r' U2 l U2 r' U2 l U2 l' U2 S2 y2
= r U2 l' U2 l r2 U2 l U2 r' U2 l U2 l' U2 S2 y2

Note from this point, when I say "reParity", I am referring to the single slice turn version above).

To affect only the M-Layer,
= r U2 l' U2 l r2 U2 l U2 r' U2 l U2 l' U2 S2 y2 + y2 S2 U2 (l2 r2)
= r U2 l' U2 l r2 U2 l U2 r' U2 l U2 l r2
Let's call this algorithm (*).

Now, is (*) a transformation of my alg (let's just temporarily call it "cmowla") (which existed before reParity)?

Is (*) = T(cmowla)?

cmowla
= r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2
= r U2 r' x U2 x' l' x' U2 l U2 l' x x2 U2 l U2 x2 l' x U2 x' U2
= r U2 r' (x) U2 l' (x2) U2 l U2 l' (x') U2 l U2 l' (x') U2 (x') U2
= r U2 r' (L' l' r R) U2 l' (L2 l2 r2 R2) U2 l U2 l' (L l r' R') U2 l U2 l' (L l r' R') U2 (L l r' R') U2
= r U2 l' (L' R) U2 l r2 (L2 R2) U2 l U2 r' (L R') U2 l U2 r' (L R') U2 l r' (L R') U2

Removing the L and R outer layer turns to create the transformation,
T(cmowla) = r U2 l' U2 l r2 U2 l U2 r' U2 l U2 r' U2 l r' U2

And (*) + (l' r) U2 (l r') U2
= r U2 l' U2 l r2 U2 l U2 r' U2 l U2 l r2 + (l' r) U2 (l r') U2
= r U2 l' U2 l r2 U2 l U2 r' U2 l U2 (l r') r' (l' r) U2 (l r') U2
= r U2 l' U2 l r2 U2 l U2 r' U2 l U2 r' U2 l r' U2 = T(cmowla)

So (*)
= T(cmowla) - (l' r) U2 (l r') U2
= T(cmowla) + ((l' r) U2 (l r') U2)'
= T(cmowla) + U2 (l' r) U2 (l r')

Since (*) = reparity + y2 S2 U2 (l2 r2), then reparity
= (*) - y2 S2 U2 (l2 r2)
= (*) + (l2 r2) U2 S2 y2

Therefore, (reParity)
= (*) + (l2 r2) U2 S2 y2
= [T(cmowla) + U2 (l' r) U2 (l r')] + (l2 r2) U2 S2 y2
= T(cmowla) + U2 (l' r) U2 (l' r) U2 S2 y2

and it turns out that T(reParity)
= cmowla + U2 (l' r) U2 (l' r) U2 S2 y2
= r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2 + U2 (l' r) U2 (l' r) U2 S2 y2
= r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 (l' r) U2 (l' r) U2 S2 y2
However, the first 13 turns of "reParity" are completely identical to r U2 r' U2 l2 r U2 r U2 l' U2 r U2 l' (20,14) (the transformation of my (19,13), which I posted even earlier than r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2...a total of 6 days before reThinking the Cube posted his "reParity").

Just add cube rotations to the beginning and end of the algorithm in wide turns.
(y2 x') Rw U2 Rw' U2 x Lw' U2 Rw U2 Lw' U2 Rw U2 Lw' (x' y2)

Just simplify:
y2 Lw U2 Rw' U2 x Lw' U2 Rw U2 Lw' U2 Rw U2 Rw' y2
Rw U2 Lw' U2 x' Rw' U2 Lw U2 Rw' U2 Lw U2 Lw'
Versus:
Rw U2 Lw' U2 x' Rw' U2 Lw U2 Rw' U2 Lw U2 Lw' U2 y' M2 y'

I can't believe no one compared his algorithm to my (19,13) M layer double parity algorithm. They're identical!

**Note to mods**
I didn't want to bump that old thread back up again to just mention this. However, if you all want me to move the second part of this post into a new post in that thread, just let me know.

7. I still prefer F R U R' U' F2 L' U' L Dw R

8. I'll chip in: F R' F' R U2 R U' R' U' R' F R2 U R' U' F'.

a. Rw' U' R U r U' R' U R2 U R' U' r U R U' Lw Uw2 Rw' U' Rw Dw2 Rw' U Rw' F'
b. Rw' U' R U r U' R' U R2 U R' U' r U r' F' Rw U Rw' U' Rw' F Rw2 U' Rw' U'
c. Rw' U' R U r U' R' U R2 U R' U' r U r' U' Rw' F Rw2 U' Rw' U' Rw U Rw' F'

Useful for 444 and 666 (and 888 etc)

10. Originally Posted by Robert-Y

a. Rw' U' R U r U' R' U R2 U R' U' r U R U' Lw Uw2 Rw' U' Rw Dw2 Rw' U Rw' F'
b. Rw' U' R U r U' R' U R2 U R' U' r U r' F' Rw U Rw' U' Rw' F Rw2 U' Rw' U'
c. Rw' U' R U r U' R' U R2 U R' U' r U r' U' Rw' F Rw2 U' Rw' U' Rw U Rw' F'

Useful for 444 and 666 (and 888 etc)
Decomposition(a) = [Rw: [r': [R2: [r', U' R U] ] [U R' U', r] ] [y2: [Rw: [Dw2, Rw' U' Rw] ] [Rw': (F')] ] ] (29,26)

Decomposition(b) = [Rw: [r': [R2: [r', U' R U] ] [U R' U', r] ] [U Rw': [F' Rw U, Rw'] [Rw U' Rw': (U')] ] ] (28,26)

Decomposition(c) = [Rw: [r': [R2: [r', U' R U] ] [U R' U', r] ] [Rw' F: [F' Rw U, Rw'] [Rw U' Rw': (U')] ] ] (28,26)

Using the parity algorithm [U': [Lw U Lw' U', Rw] [U Rw: (U)] ] instead (just for my curiosity),

Rw U R' U' r' U R U' R2 U' R U r' U' R' Lw U Lw' U' Rw U Lw U' Lw' Rw' U Rw U (29,28)

If Robert(b) is shifted, only one set up move needs to be added to make an opposite case.
F Rw' F Rw2 U' Rw' U' Rw' U' R U r U' R' U R2 U R' U' r U r' F' Rw U Rw' U' F' (30,28)

And just to let those who don't know, these 2-corner swap algorithms only exchange 2 X-center pieces on the 4x4x4 (or center pieces on the nxnxn even cube).

Here are the shortest algorithms I have found. As you will see, assuming that the solutions below are optimal, Robert's algorithms are only a few more moves than the optimal ones for this category of algorithms.
Spoiler:

[1]
L Bw2 Dw2 Bw U Bw' Dw2 Bw U' F2 b L' d2 L F' U' F L' d2 L F' U S z' (29,23)

= [L Bw2: [Dw2, Bw U Bw'] [Bw2: L] ] [B' F: [F L' d2 L F', U'] ]
=
L Bw2
Dw2 Bw U Bw' Dw2 Bw U' Bw'
Bw2 L Bw2
Bw2 L'
B' F
F L' d2 L F' U' F L' d2 L F' U
F' B
[2]
Fw' L2 Uw F' U R U' F r2 F' U R' U' F r2 Fw Uw' L Uw Fw' Uw' L Fw L (27,24)
= [Fw' L2 Uw: [F' U R U' F, r2] [Uw' L: [L', Uw Fw Uw'] [L Fw: L] ] ]
=
Fw' L2 Uw
F' U R U' F r2 F' U R' U' F r2
Uw' L
L' Uw Fw Uw' L Uw Fw' Uw'
L Fw L Fw' L'
L' Uw
Uw' L2 Fw
[3]
Fw' L2 Uw r2 F' U R U' F r2 F' U R' U' F Fw Uw' L Uw Fw' Uw' L Fw L (27,24)
= [Fw' L2 Uw: [r2, F' U R U' F] [Uw' L: [L', Uw Fw Uw'] [L Fw: L] ] ]
=
Fw' L2 Uw
r2 F' U R U' F r2 F' U R' U' F
Uw' L
L' Uw Fw Uw' L Uw Fw' Uw'
L Fw L Fw' L'
L' Uw
Uw' L2 Fw

Opposite

[1]
F r2 F' U R' U' F r2 Fw Uw' L Uw Fw' Uw' L Fw L Fw' L2 Uw F' U R U' (27,24)
= [U R' U' F: [F' U R U' F, r2] [Uw' L: [L', Uw Fw Uw'] [L Fw: L] ] ]
=
U R' U' F
F' U R U' F r2 F' U R' U' F r2
Uw' L
L' Uw Fw Uw' L Uw Fw' Uw'
L Fw L Fw' L'
L' Uw
F' U R U'