Welcome to the Speedsolving.com, home of the web's largest puzzle community! You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

U' R F2 R' U R D R2 U' R2 D' F2 R'
R F2 D R2 U R2 D' R' U' R F2 R' U
U' R F2 R' U R U F2 U' F2 U' F2 R'
R Y-PERM R'
R' U' R F' R' U R U F U' F' U' F
x D' R U (l R) B U R' U' R' F' R2 U R

FD - UL - RU - y' [M'] U R2 U' [M] U R2 U' y
FD - RU - UL - y' U R2 U' [M'] U R2 U' [M] y
FD - UR - LU - y' [M] U' R2 U [M'] U' R2 U y
FD - LU - UR - y' U' R2 U [M] U' R2 U [M'] y

I know Ollie has asked me a couple of times about awkward isolated cycles across 2 faces at the end of a solve. Was messing around earlier with other things in mind and ended up with these instead. Not every case yet and there may be better options, but it's a start. Organised by number of wrong x-centres on each face and given for F/U. 5x5 btw, but can easily be applied on other big cubes.

X-centres:
2)
adj-adj: [2L', U 2R U2 2R' U]
opp-adj: [U 2R U2 2R' U, 2L']
opp-opp: (couldn't find any tricks so far)

3)
2L' U (2R U2 2R' U) (2L U2 2L' U) 2R U' 2L U' 2R' U'

4)
2L' U (2R U2 2R' U) (2L U2 2L' U) (2R U2 2R' U) 2L U2
= [2L' U: {(2R U2 2R' U) (2L U2 2L' U)}2]

Spoiler

All found by building on 8-move comms using insertions, so no other piece types are affected, and the other ways of looking at them such as the [5,1] comm were found afterwards. I actually found the 4 case by inserting an 8-move comm into the 3 case and cancelling 8 moves o_o

Edit: +-centres:
2)
adj-adj: U 2R U' 3R U 2-3r' U' 2R U 3R U' 2-3r'
opp-adj: 2-3r U 3R' U' 2R' U 2-3r U' 3R' U 2R' U'
opp-opp: [3R, [U: 2R 4R]]

3)
U' 2-4r U 3R' U' 2L 2R' U 2-3r U' 3R' U 2R'

4)
U' 2-4r U 3R' U' 2L 2R' U 2-4r U' 3R' U 2L 2R'

Edit 2: just for fun, probably bad (swaps all centres on U/F)
2L' U 3R (2R U2 2R' U) (2L * U2 2L' U) (2R U2 2R') 2R' U 2L U2
*[[U: 2R 2L'], 3R']
= 2L' U 2-3r U2 2R' U 2L U 2R 2L' U' 3R' U 2L 2R' U' 3R U2 2L' U 2R U2 2-3r' U 2L U2

I am planning to post some parity sets that I know in here. They take a while to type. I'll start with

Fixed edges UF-UB for all corner cases from the URB buffer:

URB-UFR F-perm
URB-FRU [U’RUR’:L-perm]
URB-RUF [R’U2R2U:T-perm]
URB-ULF Nb-perm
URB-LFU [R’U':T-perm]
URB-FUL [L’U:T-perm]
URB-UBL [U:T-perm]
URB-BLU UR’U (J-perm) U2RU’R’U2R (this is basically a cancellation of the Nb-perm)
URB-LUB r'Ur' U2 lU'l' U2 rLU' x
URB-DBR [U2R2U':T-perm]
URB-BRD R'U'RUR' (L-perm) RU'R'UR -there is a cancellation depending on the L-perm that you use and is a setup to URB-FRU
URB-RDB [R': F-PERM}
URB-DRF [y'U'R2U':T-perm]
URB-RFD [R'DR: F-perm] -there is a cancellation
URB-FDR [U2RU':T-perm]
URB-DFL [L2U:T-perm]
URB-FLD [yRD'R':T-perm] - This is a tricky cancellation I execute it as y R (UD') R'U'R'FR2U'R'U'RUR'F'RDR'
URB-LDF [L'R'U':T-perm]
URB-DLB [y'UL2U: T-perm]
URB-LBD [L2R'U': T-perm]
URB-BLD [R'U:T-perm]

To help with notation, the parity cases are written as [setup moves:common algorithmn].

So, I memo edges first and solve corners first, leaving UBL (my buffer) and UBR switched when there's parity. Recently I started using PLLs to solve special parity cases, where the last 3 edge targets make an independent 2-cycle and none of them is my buffer (which is DF). For example, when the last 3 targets are UR-UL-UR and there's parity, now I see it's simply an F-perm.
I'm starting to learn some ZBLL algs to solve other cases, such as:

BR-BD-BR + UBL-UBR using ZBLL on the back: x' y R U' L' U R' U' L y' R' U' R U' R' U2 R x
that's just Niklas + Anti-Sune

BR-BL-BR + UBL-UBR using ZBLL on the back: x' R' U' R2 L U2 R' U' R U2 L' U R' U' R' U R x
adapted from here

And in this other case, where BR and BL are switched again, but the edge orientations change, it could even be solved like this (if you are lazy like me):

BR-LB-BR + UBL-UBR using OLL (T shape) and PLL (J-perm) on the back: x' y [R U R' U' R' F R F'] U [R U R' F' R U R' U' R' F R2 U' R'] U2 y' x

So... a few questions:
Is this something obvious for you guys?
Do elite BLDers actually use this kind of approach in those cases?
Is there a faster way to deal with this that I'm missing out?
Does anyone want to generate some algs for this?

Edit: I should have posted this in the Random Blindfold Cubing Discussion topic... sorry about that.

This is aimed at beginners learning TURBO. A list of basic corner/edge algs for TURBO BLD. The algorithms are aimed at learners who learn algs visually. Rather than looking at daunting lists, I've tried to present the info as concisely as possible. You can print them out as index cards to carry around as you learn.