Rubik F2L: Difference between revisions

From miki
Jump to navigation Jump to search
(Template for new classification)
(Merging cases for Sticker UP)
Line 47: Line 47:
|width=100px align=center|[[File:rbf2l_edgeok1.png|100px]]
|width=100px align=center|[[File:rbf2l_edgeok1.png|100px]]
|width=40%|
|width=40%|
<code>sexy sexy sexy</code>
|
|
This is different from case <tt>15<tt> because corner and edge color mismatch.
|-
|-
|width=2em|<tt>05</tt>
|width=2em|<tt>05</tt>
Line 114: Line 116:
|width=100px align=center|[[File:rbf2l_corneruu1.png|100px]]
|width=100px align=center|[[File:rbf2l_corneruu1.png|100px]]
|width=40%|
|width=40%|
* <code>R U2' R' y U2 (L' U L)</code>
* {{red|'''Faster'''}}, FR: <code>U' R' F R F' R U' R'</code>
* {{red|'''Faster'''}}, FL:
* {{red|'''Faster'''}}, BL: <code>L U' L' y' L' U2 L</code> ({{blue|B with RH index}}).
* {{red|'''Faster'''}}, BR: <code>R' U R' F R F' R</code>
|
|
* Get the pair out, then reinsert (alt. <code>R U2' R' U' F R' F' R'</code>)
* {{red|'''Faster'''}}, FR: <code>U' R' F R F' R U' R'</code>
* {{red|'''Faster'''}}, FL: left SH, or <code>y'</code>, the subcase FR above.
* {{red|'''Faster'''}}, BL: Victor's formula.
* {{red|'''Faster'''}}, BR: This is usual code. Victor uses <code>R' U R d' R U' R'</code> ({{blue|d' = U' y}}.
|-
|-
|width=2em|<tt>16</tt>
|width=2em|<tt>16</tt>
|width=100px align=center|[[File:rbf2l_corneruu2.png|100px]]
|width=100px align=center|[[File:rbf2l_corneruu2.png|100px]]
|width=40%|
|width=40%|
<code>y L' U2 L U (L' U' L) y'</code>
|
|
('''L2, FL, rot''') create a /L2/ case by using '''BL''' corner with '''y L' ''' move, and U2.
|-
|-
|width=2em|<tt>17</tt>
|width=2em|<tt>17</tt>
|width=100px align=center|[[File:rbf2l_corneruu3.png|100px]]
|width=100px align=center|[[File:rbf2l_corneruu3.png|100px]]
|width=40%|
|width=40%|
<code>y U L' U L U y' R U R' (R' F R F')</code>
|
|
('''LLLU1, FL''') idem, fall-back using '''BL''' corner (with '''y U''' then '''L' ''').
|-
|-
|width=2em|<tt>18</tt>
|width=2em|<tt>18</tt>
|width=100px align=center|[[File:rbf2l_corneruu4.png|100px]]
|width=100px align=center|[[File:rbf2l_corneruu4.png|100px]]
|width=40%|
|width=40%|
<code>y U' L' U2 L L F' L' F y'</code>
|
|
Get a basic base by (i) bring edge to its color, (ii) raise empty slot, (iii) bring corner above the edge, then (iv) turn back slot. There are three other identical cases.
|-
|-
|width=2em|<tt>19</tt>
|width=2em|<tt>19</tt>
|width=100px align=center|[[File:rbf2l_corneruu5.png|100px]]
|width=100px align=center|[[File:rbf2l_corneruu5.png|100px]]
|width=40%|
|width=40%|
<code>U2 R U R' R' F R F'</code>
|
|
|-
|-
Line 139: Line 158:
|width=100px align=center|[[File:rbf2l_corneruu6.png|100px]]
|width=100px align=center|[[File:rbf2l_corneruu6.png|100px]]
|width=40%|
|width=40%|
<code>R U2' R' U' (R U R')</code>
|
|
('''R2, BR, rot''') create a /R2/ case by using '''BR''' corner with '''R''' move, and '''U2'''.
|-
|-
|width=2em|<tt>21</tt>
|width=2em|<tt>21</tt>
|width=100px align=center|[[File:rbf2l_corneruu7.png|100px]]
|width=100px align=center|[[File:rbf2l_corneruu7.png|100px]]
|width=40%|
|width=40%|
<code>U' R U' R' U' y L' U' L (L F' L' F)</code>
|
|
('''LLBU2, BR''') fall-back to case <tt>22</tt> using '''BR''' corner with '''U' ''' then '''R''', .
|-
|-
|width=2em|<tt>22</tt>
|width=2em|<tt>22</tt>
|width=100px align=center|[[File:rbf2l_corneruu8.png|100px]]
|width=100px align=center|[[File:rbf2l_corneruu8.png|100px]]
|width=40%|
|width=40%|
<code>U R U2' R' R' F R F'</code>
|
|
|-
|-
Line 154: Line 178:
|width=100px align=center|[[File:rbf2l_corneruu9.png|100px]]
|width=100px align=center|[[File:rbf2l_corneruu9.png|100px]]
|width=40%|
|width=40%|
<code>y U2' L' U' L L F' L' F y'</code>
|
|
|}
|}
Line 254: Line 279:
|
|
|}
|}

== White sticker UP ==
* Edge on 2L:
{| width=100%
|-
|width=10%|[[File:Rb_F2LU2Lwrong.png|100px]]
|width=40%|
; (2L1) Case 1, edge wrong (matching corner color)
* Get the pair out, then reinsert <code>R U2' R' y U2 (L' U L)</code> (alt. <code>R U2' R' U' F R' F' R'</code>)
* {{red|'''Faster'''}}, FR: <code>U' R' F R F' R U' R'</code>
* {{red|'''Faster'''}}, FL: left SH, or <code>y'</code>, the subcase FR above.
* {{red|'''Faster'''}}, BL: Victor uses <code>L U' L' y' L' U2 L</code> ({{blue|B with RH index}}).
* {{red|'''Faster'''}}, BR: usual is <code>R' U R' F R F' R</code>, Victor uses <code>R' U R d' R U' R'</code> ({{blue|d' = U' y}}.
|width=10%|[[File:Rb_F2Lsexysexysexy.png|100px]]
|width=40%|
;(2L2) Case 2, edge correct (not matching corner)
* <code>sexy sexy sexy</code>.
|}

* Edge on LL, not touching: we get a basic base by (i) bring edge to its color, (ii) raise empty slot, (iii) bring corner above the edge, then (iv) turn back slot. All cases below are identical.
:* (LLBU1) Edge on BU, case 1: <code>U R U2' R' R' F R F'</code>
:* (LLBU2) Edge on BU, case 2: <code>y U2' L' U' L L F' L' F</code>
:* (LLLU1) Edge on LU, case 1: <code>U2 R U R' R' F R F'</code>
:* (LLLU2) Edge on LU, case 2: <code>y U' L' U2 L L F' L' F</code>
* Edge on LL, touching:
:* (LLRU1) Edge on RU, side color not matching ('''R2, BR, rot'''): create a /R2/ case by using '''BR''' corner with '''R''' move, and '''U2''', <code>R U2' R' U' (R U R')</code>.
:* (LLRU2) Edge on RU, side color matching ('''LLBU2, BR'''): fall-back to case (LLBU1) using '''BR''' corner with '''U' ''' then '''R''', <code>U' R U' R' U' y L' U' L (L F' L' F)</code>.
:* (LLFU1) Edge on FU, side color not matching ('''L2, FL, rot'''): create a /L2/ case by using '''BL''' corner with '''y L' ''' move, and U2, <code>y L' U2 L U (L' U' L) y'</code>.
:* (LLFU2) Edge on FU, side color matching ('''LLLU1, FL'''): idem, fall-back using '''BL''' corner (with '''y U''' then '''L' '''), <code>y U L' U L U y' R U R' (R' F R F')</code>.


== White sticker FRONT ==
== White sticker FRONT ==

Revision as of 11:30, 24 December 2014

Intro

This page is dedicated to solving the first two layers of the Rubik's cube, after making the cross on the D face.

Links:

The principle is to always fall back in one of the 4 basic cases. A basic case is one that requires only 3 moves to solve:

  • Case /R1/: R U' R' and case /L1/: L' U L (mirror)
Pair next to each other, horizontal and left (right) of target slot.
  • Case /R2/: R U R' and case /L2/: L' U' L (mirror)
Corner above target slot, edge on UB. Corner white sticker facing right (left), front sticker same as edge up sticker.


Notes:

  • Always put the corner above the slot, and solve from the right side first, then switch to left if necessary.
  • In algorithm below, whitespaces indicate that we reached a basic case.
  • We can always replace U2 R U' R' with U sledgeR'.
  • Case solve are coded for fast reference. (R2, BR) means we want to get a basic case /R2/ by bringing the corner above BR corner. (R2, BR, rot) means we aim at obtaining a /R2/ case by using the BR corner, but this time with rotation of the corner; this means that the corner is moved above the BR corner not using a U move (followed by R ... R' that would preserve orientation of the corner), but with a R moves that changes orientation of the edge. So rot indicates that the solves change the F2L family.

We follow Bob's Burton classification.

Corner correct, edge not placed

01 Rbf2l cornerok1.png
02 Rbf2l cornerok2.png
03 Rbf2l cornerok3.png

Edge correct, corner slot free

04 Rbf2l edgeok1.png

sexy sexy sexy

This is different from case 15 because corner and edge color mismatch.

05 Rbf2l edgeok2.png
06 Rbf2l edgeok3.png

Corner in first layer twisted clockwise

07 Rbf2l cornerdf1.png
08 Rbf2l cornerdf2.png
09 Rbf2l cornerdf3.png
10 Rbf2l cornerdf4.png

Corner in first layer twisted counter-clockwise

11 Rbf2l cornerdr1.png
12 Rbf2l cornerdr2.png
13 Rbf2l cornerdr3.png
14 Rbf2l cornerdr4.png

Corner in U-layer with cross-color on U-face

15 Rbf2l corneruu1.png
  • R U2' R' y U2 (L' U L)
  • Faster, FR: U' R' F R F' R U' R'
  • Faster, FL:
  • Faster, BL: L U' L' y' L' U2 L (B with RH index).
  • Faster, BR: R' U R' F R F' R
  • Get the pair out, then reinsert (alt. R U2' R' U' F R' F' R')
  • Faster, FR: U' R' F R F' R U' R'
  • Faster, FL: left SH, or y', the subcase FR above.
  • Faster, BL: Victor's formula.
  • Faster, BR: This is usual code. Victor uses R' U R d' R U' R' ({{{1}}}.
16 Rbf2l corneruu2.png

y L' U2 L U (L' U' L) y'

(L2, FL, rot) create a /L2/ case by using BL corner with y L' move, and U2.

17 Rbf2l corneruu3.png

y U L' U L U y' R U R' (R' F R F')

(LLLU1, FL) idem, fall-back using BL corner (with y U then L' ).

18 Rbf2l corneruu4.png

y U' L' U2 L L F' L' F y'

Get a basic base by (i) bring edge to its color, (ii) raise empty slot, (iii) bring corner above the edge, then (iv) turn back slot. There are three other identical cases.

19 Rbf2l corneruu5.png

U2 R U R' R' F R F'

20 Rbf2l corneruu6.png

R U2' R' U' (R U R')

(R2, BR, rot) create a /R2/ case by using BR corner with R move, and U2.

21 Rbf2l corneruu7.png

U' R U' R' U' y L' U' L (L F' L' F)

(LLBU2, BR) fall-back to case 22 using BR corner with U' then R, .

22 Rbf2l corneruu8.png

U R U2' R' R' F R F'

23 Rbf2l corneruu9.png

y U2' L' U' L L F' L' F y'

Corner in U-layer with cross-color on R-face

24 Rbf2l cornerur1.png
25 Rbf2l cornerur2.png
26 Rbf2l cornerur3.png
27 Rbf2l cornerur4.png
28 Rbf2l cornerur5.png
29 Rbf2l cornerur6.png
30 Rbf2l cornerur7.png
31 Rbf2l cornerur8.png
32 Rbf2l cornerur9.png

Corner in U-layer with cross-color on F-face

33 Rbf2l corneruf1.png
34 Rbf2l corneruf2.png
35 Rbf2l corneruf3.png
36 Rbf2l corneruf4.png
37 Rbf2l corneruf5.png
38 Rbf2l corneruf6.png
39 Rbf2l corneruf7.png
40 Rbf2l corneruf8.png
41 Rbf2l corneruf9.png

White sticker FRONT

  • Edge on 2LL:
Rb F2LF2Lcorrect.png
Case 1, edge correct
Can this case be be inserted from any angle without cube rotation?
  • (R1, BR) goal is to get a /R1/ using BR corner, U' R U' R' U2 R U' R'.
  • Faster, no y / y' , FR:
Rb F2LF2Lwrong.png
Case 2, edge wrong
  • (L2, BR) goal is to get a /L2/ using BR corner, U' R U R' U y L' U' L.
  • Faster, no y / y' , FL: y U2' L F' L' F U2' L' U' L y'
  • Edge on LL, non-adjacent
  • Case 1, same U color, edge BU (R1, BR): Goal is to get a /R1/ using BR corner, U' R U R' U2 R U' R'
Idem for edge LU (R1, BR): U' R U2 R' U2 R U' R'
  • Case 2, different U color, edge BU (L2, BR): Because U color are different, goal is to get a /L2/ case here using BR corner: y U L' U' L U' L' U' L (or U' R U' R' U y L' U' L).
For edge LU, this time we directly have a /L2/ (L2): y L' U' L
  • Edge on LL, adjacent on RU
  • Case 1, same U color (R1): we have directly a basic case /R1/, U R U' R'.
  • Case 2, different U color (L2, BR): so we want to get a /L2/, using BR corner: U' R U2 R' U y L' U' L.
  • Edge on LL, adjacent on FU
  • Case 1, same U color (R2, FL, rot): we use FL corner to get a /R2/ : y L' U L U2' y' R U R'
  • Case 2, different U color (R2, FL): we use FL corner to get a /L2/: y U L' U L U' L' U' L

White sticker RIGHT

  • Edge on 2LL 2LL:
Rb F2LR2Lcorrect.png
Case 1, edge correct
This case can actually be inserted from any angle without cube rotation.
  • (L1, FL) mirror of above, get a /L1/ using FL corner, and U then L' move: y U L' U L U2' L' U L y'.
  • Faster, no y / y' , FR: U R U R' U2 R U R'
  • Faster, no y / y' , BL: U L U L' U2' L U L'
  • Faster, no y / y' , FL: U L' U L U2' L' U L (alt using sledge: U L' U L L F' L' F, F with thumb)
  • Faster, no y / y' , BR: U R' U R U2' R' U R
Rb F2LR2Lwrong.png
Case 2, edge wrong
  • (R2, FL) mirror of above, get a /R2/ case using FL corner, and U then L' move: y U L' U' L y' U' R U R'
  • Faster, no y / y' : U2 R' F R F' U2 R U R'
  • Edge on LL, non-adjacent
  • Case 1, same U color, edge BU (L1, FL): Here the best is to solve FR then send it to BR y' U R' U' R U' U' R' U R y (alt: y' U R' U' R U' y F R' F' R or y U L' U' L U' L F' L' F y').
idem for edge LU (L1, FL): y' U R' U2 R U' U' R' U R y (alt: y U L' U2 L U' L F' L' F y').
  • Case 2, different U color, edge LU (R2, BR): we need to shift our edge by a single U move: U' R U R' U R U R'
For edge BU (R2): this time we directly get a /R2/: R U R'
  • Edge on LL, adjacent on RU
  • Case 1, same U color (L2, BR, rot): we get a /L2/ case using BR corner and R U' move, R U' R' U2 y L' U' L y'
  • Case 2, different U color (R2, BR): we get a /R2/ case using BR corner and U' R move, U' R U' R' U R U R'
  • Edge on LL, adjacent on FU
  • Case 1, same U color (L1): we directly have a basic case /L1/, L' U L
  • Case 2, different U color (R2, FL): so we want to get a /R2/ case. We can with FL corner, y' U R' U2 R y U' R U R' (or y U L' U2 L U' y' R U R')

Corner on 1L

White sticker DOWN

Rb F2LbelgeFR.png

Le Belge (front right)
  • Beginner solution U R U' R' y U' L' U L y'
  • Using inverse SH U R U' R' F R' F' R

Rb F2LbelgeFL.png

Le Belge (front left)
  • Beginner solution U' L' U L y' U R U' R' y
  • Using inverse SH U' L' U L F' L F L'
Le Belge (front right - alt)

Rb F2LbelgeRF.png

Le Belge (front left - alt)
  • Faster (no y / y') R U' R' U' R U' R' U R U R' (grip: LH F/B, index doing all U' and first U, RH U/D, index 2nd U) (R U' R' to create a known F2L case)
  • Faster (no y / y') U' R' F R F' R U R' (with a sledgehammer, 2nd U with LH index)
White sticker on FRONT / RIGHT face
  • First move edge on its color, then
    • If white sticker is on the SAME face → use a double sexy or sexyL.
    • If white sticker is on DIFFERENT face → use a TRUNCATED double sexy' or sexyL' , where first UP rotation is skipped.
  • Cases are identified by the visible colors on corner and lateral color on the edge. This is useful when solving the F2L in the wrong slot.

Sexysexy.png

col-white R-col

sexy sexy

(alt. U2 L' U L y' R U R')

SexyLsexyL.png

col-white F-col

y sexyL sexyL y'

(alt. U2 R U' R' y L' U' L y')

Rb sexypsexyp alt.png

white-col1-col2

R U' R sexy' (best grip, RH: front/back, index to prepare for U)

(alt. R U' R' R' F R F' or y L' U2 L y' R U2 R')

Rb sexyLpsexyLp alt.png

col2-col1-white

y L' U L sexyL' y'

(alt. R U R' U' F R' F' R)

More tricks

Tutoriel F2L avancés - Partie 1 (déconjugaison intelligente)
  • Déconjugaison intelligente
Tutoriel F2L avancés - Partie 2 (Insertions sous différents angles)
  • Avoid y2 moves, but solve the F2L cases as is (with empty slots in the back).
This is true for all "base" cases, both contiguous and not.
  • y and y' is ok. When choosing between both, favor the one that leads to R and U moves.
For instance, better do y' R' U R than y L' U L to insert a base case.
Tutoriel F2L avancés - Partie 3 (Utilisation des slots libres)
  • Use free slots
Tutoriel F2L avancés - Partie 4 (Eviter les rotations y et y')
  • Goal of this part: Avoid y and y' move whenever possible.
  • Introduce another commutator, the sledgehammer: R' F R F'
F' move must be done with the right thumb!
  • Case: R U' R y L' U2' L y', white sticker UP, FR corner.
Subcase FR. Use sledgehammer U' R' F R F' R U' R'
Subcase FL. Use left sledgehammer, or y' then subcase FR above.
Subcase BL. Use L U' L' y' L' U2 L. Or sledgehammer also possible, but with re-grip (B with right hand index).
Subcase BR. Usual solution is R' U R' F R F' R, but R' U R y U' R U' R' (U' while y) is also ok.
  • Case: U y L' U' L U' y' R U R'
Avoid cube rotation with sledgehammer: U2 R' F R F' U2 R U R'
  • Case: U y L' U L U2' L' U L y'
Can be inserted from any angle. Either pick contiguous base case or separated.
If corner in FR or BL: U R U R' U2 R U R' or U L U L' U2' L U L'.
If corner in FL or BR: U L' U L U2' L' U L (alt using sledge: U L' U L L F' L' F, F with thumb) or U R' U R U2' R' U R
  • Case: corner on D face
See my shortcuts above with sexy moves above.
  • Case: le Belge
When corner in FRD, and correct edge on UR, two solutions:
  • R U' R' U' R U' R' U R U R' (grip: LH F/B, index doing all U' and first U, RH U/D, index 2nd U) (R U' R' to create a known F2L case)
  • U' R' F R F' R U R' (with a sledgehammer)
Android - Fridrich Solver (Algorithms summary)
  • This app shows solutions for all F2L cases.
  • FAST: Use d and d' move instead of y' U or y U'. This happens extremely frequently, and is very useful to solve pair in any slot without turning the cube.