The BLD "Example Solve" Game!

Member
Scramble: D' R2 U' L2 U B2 R2 B2 F2 D2 B2 L' D R' D' R B' D2 U2 R' D'

Conjugate, insertion, interchange

Corners
VN: y R U' L2 U R' U' L2 U y'
WH: R2 L' D' L U2 L' D L U2 R2
Last corner is solved on its own using OP to solve parity

Edges
DB: U M' U2 M U (UB piece is placed on UL)
IA: D M' U R2 U' M U R2 U' D' (UL piece is placed on UB)
VR: D R E2 R' D' R E2 R'
NP: R' U M' U' R2 U M U' R' Undo exchange (R2) + undo setup (R) in the end become R'
FS: x F L F' M F L' F' M' x'
GT: x R L' U L E' L' U' L E R' x'

Last Corner
F' D R U' R' U' R U R' F' R U R' U' R' F R D' F (Solves last corner, swaps UB and UL)

alg.cubing.net

Next: B2 F2 U F2 R2 U' R2 D' B2 U2 R U L2 B' F2 L2 F D F' R' D2

Wouldn't it make sense to move this to the example solves forum? Also, bump Ollie

Member
Next: B2 F2 U F2 R2 U' R2 D' B2 U2 R U L2 B' F2 L2 F D F' R' D2

Wouldn't it make sense to move this to the example solves forum? Also, bump It would actually! Plus you can write commutator notation like this, rather than label everything. [z': [R' D R, U']]
[x': [U', R' D R]]
[D', R' U2 R]
[z: [R' D' R D R' D' R, U']
[z': [U R U', M]]
[x' U: [U M U', L2]]
[y' U': [U' M U, R2]]
[M' U M, D]
R u' M' u2 M' u' R' // those rotations, geez.

Next: F B' R L' B D' R' B' F2 D2 B' D2 L' U2 R2 F L2 U2 F B U D R' F U

suushiemaniac

Member
Scramble:
F B' R L' B D' R' B' F2 D2 B' D2 L' U2 R2 F L2 U2 F B U D R' F U // scramble in solving orientation

Edges:
[M' U M , D]
[U : [R2 , U M' U']]
[Uw ; [M2 , U R' U']]
[z' ; [U' R U , M']]
[M : [U R' U' , M]]
[U' ; [F R' F' , M']] // don't like this + mirror

Corners:
[x ; [D2 , R U' R']]
[x R' : [R' D2 R , U2]] // I'd very probably keep the x rotation from the previous comm
y R U2' R' U' R U' R' L' U2 L U L' U L // classical antisune-flip

Next scramble:
B2 U L2 U2 L2 B2 R2 U2 F2 L2 U B D' R' U' R2 U' L B' D' R' D2

Last edited:

bobthegiraffemonkey

Member
F B' R L' B D' R' B' F2 D2 B' D2 L' U2 R2 F L2 U2 F B U D R' F U

[M' U M, D]
[R2': (M' U M U)2]
[M', F' L F]
[z' U2: [M, U R U']]
[z' U2: [M', U' R U]]
[U' r': [M, U R U']]

[z R': [U', R' D2 R]]
[l': [R' D2 R, U2]]
(U' R') (L' U2 L U L' U L) (R U2' R' U' R)

Was hoping for something more interesting. I don't actually use the last alg (cyclic shift of 2 sunes) but I should. I probably wouldn't spot the cancellation in 4th/5th edge cycles.

Necks: B' L2 R2 B D2 F' L2 B' F' U2 L2 R U2 B' R' U' B D L' R2 F'

Ollie

Member
Scramble:
F B' R L' B D' R' B' F2 D2 B' D2 L' U2 R2 F L2 U2 F B U D R' F U // scramble in solving orientation

Edges: [U' ; [F R' F' , M']] // don't like this + mirror

Next scramble:
B2 U L2 U2 L2 B2 R2 U2 F2 L2 U B D' R' U' R2 U' L B' D' R' D2
Awesome corners solution, here are some possible cycles for the edge case that I use: r' u' M u2 M u' r, M U M2 U2 M' U2 M' U' M', or just L' B' set up to 4-mover is decent.

bobthegiraffemonkey

Member
[U' ; [F R' F' , M']] // don't like this + mirror
Oops, ninja'd on the scramble. Btw, I would execute this as U' (F R' F' r) (R' F R F' R) (r' U), flows decently for me.

suushiemaniac

Member
Awesome corners solution, here are some possible cycles for the edge case that I use: r' u' M u2 M u' r, M U M2 U2 M' U2 M' U' M', or just L' B' set up to 4-mover is decent.
Thank you Oops, ninja'd on the scramble. Btw, I would execute this as U' (F R' F' r) (R' F R F' R) (r' U), flows decently for me.
I guess that's the initial BLDers' hype now that the thread has been bumped At least the next person gets to choose a scramble. And thanks for the alg!

A Leman

Member
Necks: B' L2 R2 B D2 F' L2 B' F' U2 L2 R U2 B' R' U' B D L' R2 F'
Edge Memo(images):
[HL EO] Hilda stabbing a sword into the ground wearing Eowyn's helmet
[YJ BD] Yajirobe falling into a bed
[RM TE] Rambo planting a tree

Corner memo: ill mu yuck ass

Corners:
U2 R2DR'U2RD'R'U2R' U2
D' U'LU R2 U'L'U R2 D
LU R'D'R U R'DR U2L'

Edges:
LUl'U'LUMU'L'ULU'L'
RU MUM'U2MUM' U'R'
R2U'R'ERUR'E'R'
M2U'MU'M'U'MU'M
U'R'U'M2URU'M2U2
DM'U2MU2D'

Parity:L2U (T perm) U'L2

Next:U' B D R D' F' L B2 R D R' U2 L2 F2 L F2 B2 D2 R D2

Last edited:

Ollie

Member
Next:U' B D R D' F' L B2 R D R' U2 L2 F2 L F2 B2 D2 R D2
z R U2 R D R' U2 R D' R2 z'
[D', R' U2 R]
l' U2 R U2 l U2 l' U2 R' U2 L U2
[R' D' R D R' D' R, U']

[M' U' M U']*2
[y' x': [U M2 U', R']]
[U' x': [M, U R U']] // noticed during memo that breaking into this cycle gives me the letter quad "WARE"
[z: [M, U L' U']]
M U2 M U M' U2 M' U'
[u': [U' L U, M2]] // I sometimes do E' R u' M2 u R' u' M2 U for the whimsy.

Next: R' L2 D2 U B L2 D2 R2 D R' L' B D R2 L' B2 L' D2 F R' U2 B' F' L U2

Member
Next: R' L2 D2 U B L2 D2 R2 D R' L' B D R2 L' B2 L' D2 F R' U2 B' F' L U2
Edges:
[L' U: [M2, B L2 B']]
[R': [U M' U', R']]
[R', U' M2 U]
M' L R2 U R U R' U' R' U' R' U R' M L' // weird thing I do when I run into 2 outer edges on opposite faces, it's setup U-Perm setup', is that silly?
[U: [B' R2 B, M2]]
[U' R U, M']
[M U2]*4
M U M U M U2 M' U M' U M' U2

Corners:
[y: [U', R D2 R']]
[x': [L2, U' R U]]
[R2: [U2, L' D' L]]
U2 R U R' F' R U R' U' R' F R2 U' R' U

alg.cubing.net

Edges were a pain, pretty surprised I didn't DNF. Love commutator notation.
Next: B R2 F2 L2 B2 D2 F R2 D2 U2 R2 U L D2 B F' D F2 L' B' L2

bobthegiraffemonkey

Member
Next: B R2 F2 L2 B2 D2 F R2 D2 U2 R2 U L D2 B F' D F2 L' B' L2
Kinda horrible, but some interesting stuff, including a parity thing I just generated for this which I'm going to learn (last alg).

[M', U L2' U']
[z' U2: [M', U' R U]]
[U': [F' R' F, M']]
[M': [U' R U, M2']]
U M U2 M U M' U2 M' U2
[z': [R, U M2' U']]
[R2': U M' U' F' r U M U' r' F]

[z' R: [D2, R U2 R']]
[U: [R' D R, U]]
[F' r U, R2']
[L D' L', U']

[U' R2' U: R' f2 r U' r' f2 R2 U R' U' F' U F2]

Member
Scramble: R2 D' F2 D2 R2 U2 L2 D L2 F2 U2 F' D' L R F U' L' R B'

// Edges
[U' R2 U, M']
[D2, F' E2 F]
[M2, B L' B']
[L': [L D' L', E']]
[U': [B L2 B', M2]]
[R' U: U2 M' U2 M]

// Corners
[R2: [F L2 F', R]]
[R U2 R', D']
[D: R U' R' U' R U R' F' R U R' U' R' F R]
Click

Next: L2 B' D2 B' U2 B' R2 B' U2 R2 U' F' R2 B' U2 R' U2 L2

leeo

Member
Next: L2 B' D2 B' U2 B' R2 B' U2 R2 U' F' R2 B' U2 R' U2 L2
method: 3-cycles TurBO variation "Solid Diagonal"
solving orientation: scramble orientation: white up green front std colors
letter system: anticlockwise major: UFRBLD order "A" thru "W" and "Y"

generator: B2 D2 L2 D2 F2 D2 R2 U F D' R F' U' R' B2 D B R' (18f*)
edge_#_corner cycles per my solving orientation and letter system: (ATJON_BYEGPq'r_Sv_#_AOLISq-u_Gj-y_Kn-w)

split into pairs off A_ edge buffer and memorize: TJ ON BY EG PQ(flip) S(flip)
similarly off _A corner buffer: OL IS(backtwist) G(backtwist) K(backtwist)
I prefer to solve the corners first.

to solve _OL corner, apply _OL 6 BO 2 YO:
code 6 move _OL to _BO (I think "setup _O"): x z
// twist the whole cube along the axis of 3-fold symmetry along ULB-DRF
// whole-cube turning ULB to BUL and DRF to RFD. Then _O becomes _B and _L
// becomes _O, BDL becomes ULF and RBU becomes BDL in two steps: _O moves
// with the whole cube to _T (BDL to LUF) and twists once anticlockwise with
// the buffer to _B (LUF to UFL); _L moves with the whole cube to _V (RBU to
// DLB) and twists once anticlockwise with the buffer to _O (DLB to BLD)
double-type move _BO to _YO (I think "setup _Y"): F2
solve _YO with the alg for _OY: x' U R' U' L' U R U' L x
return _YO to _BO (I think "restore _O"): F2
return _BO to _OL (I think "restore _L"): x' y
// whole-cube untwist along the same 3-fold axis applying a single spin-type move.

optimal generator of the result after this step:
U2 L2 F' U' L D R2 F' L' D B' D R2 D F2 D2 L2 (17f*)
(ATJON_BYEGP'r_S'v_#_AIS-u_G-y_K-w)
to solve _IS corner, apply _IS _IO _JO
move _IS to _IO (I think "setup _O"): D'
move _IO to _JO (I think "setup _J"): R'
solve _JO with the alg for _OJ: L B' R2 B L' B' R2 B
return _JO to _IO (I think "restore _I"): R
return _IO to _IS (I think "restore _S"): D

optimal generator of the result after this step:
B2 U2 B L2 D B2 U B D L' F R2 F U2 B2 R2 U2 (17f*)
(ATJON_BYEGPq'r_Sv_#_Aq-p_Gj-y_Kn-w)
// here all the corners are in place, but three are back-twisted. To solve,
// I apply a solid-diagonal twist-untwist algorithm that affects _A and _G
// (UBL and DRF).
R' Fw2 L D' F2 D L' Fw2 R U' F2 U

optimal generator of the result after this step:
F U2 R2 D U' R2 U' B' L' U2 R2 F L F2 R F' (16f*)
(ATJON_BYEGPq'r_Sv_#_Ap+q_Kn-w)
// to apply a second time, I setup move _K to _J (RDB to RFD)
( "setup _J") R
R' Fw2 L D' F2 D L' Fw2 R U' F2 U
( "restore "_K") R'

// now the corners are solved
optimal generator of the result after this step:
U' B2 D L' R B' R2 B2 R F U L R' B' R' B2 F U' (18f*)
(ATJON_BYEGPq'r_Sv_#)
to solve TJ_ edge: apply TJ_ 2 JT 2 JR UR
( "setup R_" ) TJ_ 2 JT 2 JR: F2 L2
( "setup U_" ) JR_ UR: F
solve UR_ with alg for RU_: M2 F L2 F' M2 F L2 F'
( "restore "T_" ) UR_ JR: F'
( "restore "J_" ) JR_ 2 JT 2 TJ: L2 F2

optimal generator of the result after this step:
U2 F' D L R' F' R F2 D' B R' B2 F2 L F' R (16f*)
(AON_BYEGPq'r_Sv_#)
to solve ON_ edge: ON_ 3 SR GR
( "setup R_") ON_ 3 SR: Dw // "3" is my code for a two-layer "w" type move
// 'w' and '3' look somewhat alike
( "setup G_") SR GR: D
solve GR_ with alg for RG_: D2 M' D L' D' M D L D
( "restore "O_" ): GR_ SR: D'
( "restore "N_" ): SR_ 3 ON: Dw'

optimal generator of the result after this step:
F2 L2 F2 L' D2 U L D U' F' D L' F2 L2 (14f*)
(BYEGPq'r_Sv_#)
to solve BY_ edge: BY_ PY 2 PV % // % signifies that I set up the target first
( "setup P_" % ): BY_ PY: L' // % flags a reversed setup order
( "setup V_" ): PY_ 2 PV: D2
solve PV_ with the alg for VP_: L' D M2 D' L D M2 D'
( "restore Y_" % ): PV_ 2 PY: D2
( "restore B_" ): PY_ BY: L

optimal generator of the result after this step:
B2 L' D U L' D' U B U2 L' B2 R2 F2 R2 (14f*)
(AEGPQm'b_Sv_#)
to solve EG_ edge: EG_ ES ER 2 GR
( "setup R_" ): EG_ ES ER: D' L
( "setup G_" ): ER_ 2 GR: F2
solve GR_ with the alg or RG_: D2 M' D L' D' M D L D
( "restore E_" ): GR_ 2 ER_: F2
( "restore G_" ): ER_ ES EG: L' D

optimal generator of the result after this step:
U L' U' F L U2 L' U' F' L U L U (13f*)
(APQm'b_Sv_#)
to solve PQ_ edge: PQ_ VR UR
( "setup R_" ): PQ_ VR: L'
( "setup U_" ): VR_ UR: D
solve UR_ with the alg for RU_: M2 F L2 F' M2 F L2 F'
( "restore P_" ): UR_ VR: D'
( "restore Q_" ): VR_ PQ: L

// now all of the cubies are in place, but two are flipped
optimal generator of the result after this step:
L' U' L' U L2 U2 L' R' F' L F R U2 (13f*)
(Am_Sv_#)
// here all the edges are in place, but two are flipped. To solve,
// I apply a solid-diagonal flip-flip algorithm that affects UB and FD:
( "setup F_" ): S_ F_: D
U' Fw U F U' F' / Fw' U2 F2 U F' U' F' U'
( "restore S_" ): F_ S_: D'

(#) // solved!

my turn, challenge scramble: D L2 B2 L2 U B2 U2 B' R' U2 F2 U2 B' L D' F2 L D L2

Ollie

Member
D L2 B2 L2 U B2 U2 B' R' U2 F2 U2 B' L D' F2 L D L2
x' U' F2 U R' U' R F2 R' U R x
[L2, U' R U]
[x: [U R2 U', L']]
[r: [U2, L D2 L']] // cancels into a 9-mover and 'skips' the step of twisting the UFR corner

u' L U' M' U L U' M U L2 // cancel a set-up move
x' M U R U' M' U R' U' x U
[R: [U' M2 U, R]]
y' R' U' R U R U R U' R' U'
M' U' [T-perm] U M // parity
F R' U2 R2 U R' U' R' U2 r U R U' r' F' // fix flipped edges

next: B2 U B2 U D' R L2 D R2 U R F2 U2 R' B2 D2 U' L' R U F' R' F' D R'

Tao Yu

Member
next: B2 U B2 U D' R L2 D R2 U R F2 U2 R' B2 D2 U' L' R U F' R' F' D R'
y
[R':[UM'U',R2]]
x [URU',M'] x'
[M:[U'LU,M]]
[M2,RUR'U']
x [U':[R'ER,U']] x'
x' [U2:[U'L'U,M]] x

y [R2:[RU2R',D]] y'
[R': [F'LF,R'] ]
[R2:[D2,RU2R']]
y' [U:[R'D'R,U2]] y
F' R U' R' U' R U R' F' R U R' U' R' F R F //parity

alg.cubing.net

Next: U' L2 U' B2 D B2 D R2 B2 U2 B2 F' D2 R' B D L' B' L B2 R2

Last edited:

suushiemaniac

Member
Scramble:
U' L2 U' B2 D B2 D R2 B2 U2 B2 F' D2 R' B D L' B' L B2 R2 // Scramble in solving orientation

Edges:
[M2 , Uw' L' Uw] // intentionally swapping UB and UL to resolve parity, which I would notice during corner memo.
[x' ; [M , U' L' U]] // again intentionally swapping UB and UL
[x y U : [M' , U2]]
[U : [M' , U L2 U']]
[z ; [U L' U' , M']] // breaking in to RF
[R : [R , U' M2 U]]

Corners:
[L ; [D2 , R U' R']]
[L D2 L' , U'] // you could cancel it with the previous L setup, not sure if I would actually do that
[R2' F ; R U' R' U' R U R' F' R U R' U R' F R] // last target as OP to resolve parity

Overall nice scramble Next:
L2 D2 B2 U2 L2 U F2 R2 D B2 U' R F D2 B2 D2 U L U2 B' U R'

Member
Next:
L2 D2 B2 U2 L2 U F2 R2 D B2 U' R F D2 B2 D2 U L U2 B' U R'
// Edges
[U: [M2, L U' L' U]]
[F E2 F', D2]
[x L': [L' U L, E']]
[M2, B L B']
[L' y': [U R2 U', M']]
[U2: [M, D R' D']]

// Corners
[R': [L' D L, U2]]
[U: [L', D R2 D']]
[D2: [L F L2 F' L', U']]
[R' D' R D R' D' R D, U2]

alg.cubing.net

This thing was a nightmare for no good reason, took me 4 tries to get a success (memo was right, just kept messing up the corners for some reason)

Next: B2 R F2 L' U2 F2 R D2 U2 F2 L2 D U2 B' R2 F' D2 B2 R2 U'

CuberM

Member
//Corners:
z L' D2 x' D2 R U R' D' R U' R' D' x D2 L z'
x' z D' R U R' D' R U' R' D2 z' x
R2 D' R' U R D R' U' R'
D2 Lw D' L' U' L D L' U L Lw' D2

//Edges:
Uw' R2 U M' U' R U M U' R (nothing here because it's binding into the next cycle)
L U M2 U' L U M2' U' L2 Uw
R' U R U' M2 U R' U' R M2
M U2 M U2 Uw' L' Uw M2 Uw' L Uw
x' U L2 U' M2 U L2 U' M F2 M F2 x
Last edge: U R U' M2 U R' U'

//Parity/Flipped/Twisted Stuff:
U' F2 U M2 U' F2 U' R U R' F' R U R' U' R' F R2 U' R' U' (The U' to bind into the alg to fix the corner orientation)
L' U' L U' L' U2 L R U R' U R U2 R' U (U to bind into edge flipping alg)
x M U M U M U2 M' U M' U M' U2 x'
U

Next: F U2 R2 F2 U' R' F2 D F2 U2 F' B' L2 U2 F' R2 D2 F U'

Member
Next: F U2 R2 F2 U' R' F2 D F2 U2 F' B' L2 U2 F' R2 D2 F U'
// Edges
[L2 U' M': U2 M' U2 M] // XW
[M2, R U R' U'] // AB
[z': [U' M U, R]] // HV
[M': [M', U' L' U]] // IL
[y': R' U' R U R U R U' R' U'] // AD
[U': [M, D R' D']] // JE

// Corners
[R': [L' D2 L, U2]] // QC
[D': [R U2 R', D']] // OS
[y' R': [D, R' U2 R]] // IU
[R':R U' R' U' R U R' F' R U R' U' R' F R] // M

alg.cubing.net

I generated this using a tool I wrote that you can try out here, if you have a min to check it out, please let me know what you think! (shameless plug is shameless).

Next: D2 U2 F2 U2 R2 B' R2 B' L2 B' L B' U2 F D' F' R B2 D U2 F'