Rubik's cube: Difference between revisions
(76 intermediate revisions by the same user not shown) | |||
Line 1: | Line 1: | ||
{{rubiktoc}} |
|||
This page is a stub. |
|||
== Guidelines for editing Rubik's Cube page on this wiki == |
|||
== Links == |
|||
* Use template <code>bk</code> to insert Rubik's cube moves (e.g <code><nowiki>{{bk|R U R' U'}}</nowiki></code> gives {{bk|R U R' U'}}). This ensures consistency accross pages. |
|||
;Official |
|||
:* ''Two-turn moves'' are written by appending a digit <code>2</code> to face letter, like <code>U2 F2</code>. '''Don't use the notation with exponent!''' (like <code>U²</code>), or the algorithms will be rejected by the Rubik's simulator. Using the exponent is ok to indicate that a trigger or named formula must be done twice (like <code>E2²</code>, meaning that E2 OLL must be done twice). |
|||
* [https://www.worldcubeassociation.org/ World Cube Association] |
|||
* Use templates starting with <code>bk...</code> to insert common triggers. Some of these templates are colored, and using the template guarantees that all triggers will have the same color accross pages. Note that these triggers must still be included in a <code><nowiki>bk</nowiki></code> template. |
|||
: By default template are named according to their formula (e.g. <code><nowiki>{{bk|{{bkrurpup}}}}</nowiki></code> for {{bk|{{bkrurpup}}}}). |
|||
: But some may have their own names, like the sexy moves (<code><nowiki>{{bk|{{bksxr}}}}</nowiki></code> for {{bk|{{bksxr}}}}) or sledgehammers (<code><nowiki>{{bk|{{bkshr}}}}</nowiki></code> for {{bk|{{bkshr}}}}). |
|||
* Use template <code><nowiki>{{bkft|...}}</nowiki></code> for finger tricks note (like {{bkft|Standard grip, first {{bk|U}} with I}}, or, using the official notation, {{bk|{{bkft|{TF,tF} }}U{{bkft|(I2)}}}}). |
|||
* '''Always verify the algorithm using the [https://miki.immie.org/alg.cubing.net/index.html Rubik's simulator]''' ([http://localhost/alg.cubing.net/index.html localhost]). |
|||
== Notations and acronyms == |
|||
;Guides & Wiki |
|||
=== Official notation === |
|||
* [https://www.speedsolving.com/wiki/index.php/Main_Page speedsolving.com wiki] |
|||
From [http://en.wikipedia.org/wiki/Rubik's_Cube#Move_notation Wikipedia]: |
|||
* [https://www.youtube.com/watch?v=tm9h0XYHlzQ Quel cube choisir pour le speedcubing 3x3x3] |
|||
* [https://www.youtube.com/watch?v=YWT3aNax_j8 Rubik's cube : aller plus vite avec la méthode débutant] |
|||
{|class=wikitable |
|||
;Tip Videos |
|||
|- |
|||
* [https://www.youtube.com/watch?v=z4jj9u72PVs HOW TO DO FINGER TRICKS RUBIK'S CUBE FINGER SHORTCUTS How to do finger tricks for Beginners.] |
|||
|'''F B U D L R''' |
|||
:Some cool finger tricks. Don't leave your finger from the cube most of the time. |
|||
|Front, Back, Up, Down, Left, Right (one-layer move) |
|||
* [https://www.youtube.com/watch?v=77ZKlietMAA Finger Trick Exercises And Tips] |
|||
|- |
|||
:More nice exercices to do (RUR'U', L'U'LU, RUR'F...) |
|||
|'''f b u d l r''' |
|||
* [https://www.youtube.com/watch?v=Jcv4ePMPN_U What a speedcuber sees when he solves the Rubik's cube.] |
|||
|Front, Back, Up, Down, Left, Right (two-layer move, aka. ''wide'' move). |
|||
* [https://www.youtube.com/watch?v=4P8ksdJsr5c Tutoriel : Améliorer la croix du 3x3 (méthode fridrich)] |
|||
:''Overshoot'' move: '''U' R' F R''', swap an edge on the cross: '''R' u R' u' ''' |
|||
* [https://www.youtube.com/watch?v=UDP4hX7LJ4E Tutoriel : Résoudre les F2L intuitivement] |
|||
:See [[#Tutorial]] section below |
|||
* [https://www.youtube.com/watch?v=DIUZRrs_OYo Rubik's cube : Méthode intermédiaire (fridrich simplifiée)] |
|||
:See [[#Tutorial]] section below |
|||
* [https://www.youtube.com/watch?v=TckuLOgOfIg Alternatives to cube rotation [F2L Tutorial] |
|||
:Video on how to move F2L to FR column. |
|||
:* Cube rotation: y U' L' U L. Quite slow. |
|||
:* Sledgehammer: '''F R' F' R''' (or see variants below). |
|||
:*:A bit faster, no cube rotation. Use it for inserting your last f2l pair for partial edge control of your OLL, or to avoid moving your next pair if you've spotted it using look ahead. Apparently the F' is done with the thumb, a bit before doing the R. |
|||
:* Case Number 2: F' (r U r') |
|||
:* Case Number 3: r' U' R U M' — {{blue|What about B' R B R' ?}} |
|||
:* Case Number 4: l U L' U' M' — {{blue|What about B L' B' L ?}} |
|||
* [https://www.youtube.com/watch?v=4BFVHTpW-Y0 NoahCubes Edge Control Part 1: When to Use Sledgehammer] |
|||
:When to use the sledgehammer (right-handed left variant): '''R' F R F' ''', or "RU" prime: '''U R U' R' ''' (i.e. sexy move prime). |
|||
:The goal is to end up with 4 well-oriented edges in the OLL. |
|||
* [https://www.youtube.com/watch?v=RlPfy6KLzQg NoahCubes 10 Websites Every Cuber Should Know] |
|||
: http://cubesolv.es/ (reconstruction db for WR...), speedsolving.com forum and wiki, alg.cubing.net, wca, www.qqtimer.net |
|||
* [https://www.youtube.com/watch?v=ku1DrYp1tp0 F2L - The Jessica Fridrich Method - No algorithms needed.] |
|||
: |
|||
;Solutions |
|||
* [http://www.cubewhiz.com/index.php Bob Burton's CubeWhiz] |
|||
*: [http://www.cubewhiz.com/notationnj.php Notations] |
|||
Alternate notations are '''Fw Bw Uw Dw Lw Rw'''. |
|||
;Shops |
|||
|- |
|||
* [http://www.lubixcube.com/Welcome.html Lubix Cube (USA)] |
|||
|'''M E S''' |
|||
: Sell the recommended lube lubix's lube, but oversee, so high shipping and custom cost. |
|||
|Middle (<code>l L'</code>), Equator (<code>d D'</code>), Standing (<code>f F'</code>) (middle layer move, aka slice move) |
|||
: The Lubix silicone is made of a polydimethylsiloxane polymer. Note this is the same lubricant that Rubik's sell in their ''Rubik's Speedcube Pro Pack''. |
|||
|- |
|||
* [https://www.cubikon.de/ Cubikon (Germany)] ([https://translate.google.com/translate?sl=de&tl=en&js=y&prev=_t&hl=en&ie=UTF-8&u=https%3A%2F%2Fwww.cubikon.de%2F&edit-text=&act=url google translated]) |
|||
|'''x y z''' |
|||
** Does not sell lube in tube (only spray, reputed bad) |
|||
|R, U, F (whole cube move) |
|||
** Sell Zhanchi Dayan V (10.95€) |
|||
|} |
|||
* [http://www.kingscube.com/ King's Cube (France)] |
|||
* '''R''' means 90° clockwise, '''R'''' mean 90° counter-clockwise, '''R2''' means 180° clockwise, and '''R2'''' 180° counter-clockwise. |
|||
: Sell Maru lube (not recommended, see below), Calvin's lube high viscosity and Calvin's lube medium viscosity (seems very good). |
|||
* Alternative notation for easier pronunciation uses '''T''' (for ''Top'') instead of '''U'''. This way all faces start with a consonnant. Using '''O''' for clockwise move, '''A''' for anti-clockwise, and '''I''' for 180° move, an algorithm like the sexy move becomes then <code>RoToRaTa</code>. |
|||
: Sell Zhanchi's cube, but not black ones. |
|||
* [http://www.icubik.com/ iCubik (Italy)] |
|||
* Info |
|||
** [https://www.speedsolving.com/wiki/index.php/Lubrication List of recommended and non-recommended lubricant] |
|||
** Maru lube not recommended. Dries out too quickly. ([https://www.speedsolving.com/forum/showthread.php?30182-Doubts-on-Maru-Lube]) |
|||
=== Finger tricks and grips === |
|||
;Tools |
|||
We use DeeDubb's notation as explained on [https://www.speedsolving.com/wiki/index.php/Finger_tricks Finger_tricks speedsolving.com]. |
|||
* [http://mzrg.com/rubik/tools.shtml Tools on Rubik's cube] (algorithm mirror, rotation remover) |
|||
** [http://mzrg.com/js/qcube-v2.html qcube v2] (cube simulator) |
|||
z = U p = z h / g = F / F' |
|||
r = Lw', l q = z' i / k = R / R' |
|||
t = x' j = U d / e = L / L' |
|||
y = x2 m = r' j / f = U / U' |
|||
u = Rw, r x = U' s / l = D / D' |
|||
i = R v = l w / o = B / B' |
|||
space = scramble a = y' |
|||
n / b = x / x' |
|||
;Finger notation |
|||
* [http://alg.cubing.net/ alg.cubing.net] — Great & clear cube visualizer, view your moves, simplify & mirror them. |
|||
{| class=wikitable |
|||
: On [https://github.com/cubing/alg.cubing.net GitHub]. Installed locally at http://localhost/alg.cubing.net/index.html. |
|||
|- |
|||
!Colspan=4|Finger notation |
|||
== Apps == |
|||
|- |
|||
=== Android === |
|||
|'''I'''|| Right Index |
|||
;Games |
|||
|'''i'''|| Left Index |
|||
*'''[https://play.google.com/store/apps/details?id=com.maximko.cuber Cube Rubik]''' |
|||
|- |
|||
:A rubik's cube game. A bit though to manipulate. |
|||
|'''T'''|| Right Thumb |
|||
|'''t'''|| Left Thumb |
|||
|- |
|||
|'''M'''|| Right Middle |
|||
|'''m'''|| Left Middle |
|||
|- |
|||
|'''R'''|| Right Ring |
|||
|'''r'''|| Left Ring |
|||
|- |
|||
|'''P'''|| Right Pinkie |
|||
|'''p'''|| Left Pinkie |
|||
|} |
|||
;Piece notation |
|||
;Timers |
|||
{| class=wikitable |
|||
*'''[https://play.google.com/store/apps/details?id=com.tinyorange.rubiksstopwatch&hl=en Rubik's Stopwatch]''' |
|||
|- |
|||
:A simple speedcubing timer with scrambler algorithms support. Very nice design, all on one single page. Best out there. |
|||
!colspan=2|Piece notation (corners) |
|||
|- |
|||
*[https://play.google.com/store/apps/details?id=com.jumpsquares.cubetimer SpeedCube Timer Free (Rubiks)] |
|||
|colspan=2|Each corner of the side being turned is labelled with the numbers 1-4 in a clockwise fashion. The front face starting with the corner UFL, the U face beginning with UBL, the D face with DFL, R with UFR, L with UBL, and B with UBR. |
|||
:A timer for speed cubing. Some ads and no much features. |
|||
|- |
|||
|U face|| U1 = UBL, U2 = UBR, U3 = UFR, U4 = UFL |
|||
*[https://play.google.com/store/apps/details?id=com.h3ss.speedcube SpeedCube Timer] |
|||
|- |
|||
:A timer for speed cubing. Scramble algorithm. No graph. |
|||
|F face|| F1 = UFL, F2 = UFR, F3 = DFR, F4 = DFL |
|||
|- |
|||
*[https://play.google.com/store/apps/details?id=com.speedcubertimer Speedcuber Timer] |
|||
!colspan=2|Piece notation (edges, slices) |
|||
:A timer for speed cubing. Scrambe algorithm. No graph. Compare cube brands. Too many pages. |
|||
|- |
|||
|colspan=2| |
|||
*'''[https://play.google.com/store/apps/details?id=com.Baid.basic5 Sune Timer]''' |
|||
On slice moves, the numbers correspond with the edges "behind" the corners of the side with which it turns. For example M turns with the L side, and so it's edges will have the same numbers as the corresponding corners on the L face. S with the F face. E with the D face. |
|||
:A timer for speed cubing. Scramble algorithm. Graph. Design not as good as ''Rubik's Stopwatch''. Additional resources like algo, WCA regulations. |
|||
|} |
|||
*[https://play.google.com/store/apps/details?id=com.pluscubed.plustimer plusTimer] |
|||
A simple, elegant timer with WCA scrambles for recording Rubik's cube solves. Graph and history by session (best, best AO5), scramble image, double touch inspection. |
|||
;Solvers, Algorithm database |
|||
*[https://play.google.com/store/apps/details?id=com.BodorGdev.fridrichsolver2 Rubik's Cube Fridrich Solver] |
|||
:Solver (manual input or via camera). List of solving algorithms. |
|||
Together, the finger and piece notation form the basic finger trick notation. It is written 'move(fingerPiece)'. |
|||
*[https://play.google.com/store/apps/details?id=com.lfm.mcalgodb Rubik's Cube Algo Reminder] |
|||
:A big database of all possible sequence for each category (PLL, OLL, F2L...). Support for 'favorite' flag, adding new category and new algorithms. |
|||
* Example: {{bkft|U(I2)}} means that the right index finger performed the move U by sliding the UBR cubie to UFR. |
|||
*'''[https://play.google.com/store/apps/details?id=com.badmephisto.app Badmephisto]''' |
|||
:Simply a big page with all solving algorithms, clear and well-designed. Must have. |
|||
Two-turn moves such as F2 are described using two fingers and two pieces, and can use prime to indicate direction like so: {{bkft|F2'(T3,i1)}}. |
|||
=== PC === |
|||
<ul> |
|||
<li> [https://github.com/cubing/tnoodle TNoodle]</li> |
|||
Official WCA's scrambler, showing final cube state. Include a very nice timer application. |
|||
;Grip notation |
|||
Download TNoodle: |
|||
All grip notations are written in curly brackets ({{bkft|{...} }}) and only when necessary to define a non-standard or non-intuitive grip. |
|||
<source lang=bash> |
|||
Piece specific grips are separated by a dash (e.g. {{bkft|T-F}}). |
|||
git clone https://github.com/cubing/tnoodle.git |
|||
{| class=wikitable |
|||
./tmt graph --description # To get a list of available target |
|||
</source> |
|||
;Timer |
|||
:Timer application is only available up to ''v0.8.7''. |
|||
<source lang=bash> |
|||
git checkout v0.8.7 |
|||
./tmt make dist timer |
|||
sudo cp -r timer/dist /usr/local/bin/tnoodle-timer |
|||
chromium-browser /usr/local/bin/tnoodle-timer/tnt.html # To start the javascript timer |
|||
</source> |
|||
In old version, timer is available as a .jar file. For instance: |
|||
<source lang=bash> |
|||
git checkout v0.7.14 |
|||
vi tmt |
|||
# Comment line with |
|||
# args += [ '-Werror' ] |
|||
./tmt make dist timer |
|||
java -jar timer/dist/TNoodleTimer.jar |
|||
# Then visit http://127.0.0.1:8080/tnt/ or http://127.0.1.1:8080/tnt/ (or possibly port 2014) |
|||
</source> |
|||
* Data for the javascript ''tnoodle-timer'' is stored in chromium local storage: |
|||
:On the disk |
|||
~/.config/chromium/Default/Local Storage |
|||
__0.localstorage |
|||
__0.localstorage-journal |
|||
chrome-extension_pafkbggdmjlpgkdkcbjmhmfcdpncadgh_0.localstorage |
|||
chrome-extension_pafkbggdmjlpgkdkcbjmhmfcdpncadgh_0.localstorage-journal |
|||
:Or better, in chromium, open developer tools by pressing {{kb|F12}},then |
|||
:*Export timing data — Go to ''Console'' tab, then type <code>localStorage.sessions</code> to get the content of the array, and save the results. |
|||
:*Import timing data — Go tot ''Console'' tab, then type <code>localStorage.sessions="XXX"</code> where the XXX is replaced by the result saved previously, but '''with all double-quotes escaped'''. These can be escaped for instance with |
|||
sed 's/"/\\"/g" sessions.txt > sessions-escaped.txt |
|||
:Sessions data is also available in the ''Ressources'' tab, but long values get truncated, and hence this is not suitable method for import / export. |
|||
* To install ''tnt'' in lighttpd (example on ''lacie-cloudbox''): |
|||
vi /etc/lighttpd/lighttpd.conf |
|||
:Add the lines |
|||
## Added for rubik's WCA official scrambler / timer |
|||
alias.url += ("/tnt" => "/opt/local/tnoodle-timer/tnt.html" ) |
|||
:Copy all files to {{file|/opt/local/tnoodle-timer/}} |
|||
:Then open browser at http://lacie-cloudbox/tnt/ (Firefox or chromium works best it seems, Opera only works via {{file|file:}} access) |
|||
;Other TNoodle apps: |
|||
* BLD |
|||
* scrambler |
|||
<li>[http://mzrg.com/qqtimer/ qqtimer] (the most used timer it seems) ([https://github.com/cubing/qqTimer qqTimer on GitHub])</li> |
|||
</ul> |
|||
== Notation == |
|||
* Cube rotation '''x''', same as '''R''' but whole cube |
|||
* Cube rotation '''y''', same as '''U''' but whole cube |
|||
* Cube rotation '''z''', same as '''F''' but whole cube |
|||
Acronyms: |
|||
;LH: Left-hand |
|||
;RH: Right-hand |
|||
;SH: Sledgehammer |
|||
== Sequences == |
|||
We call a ''move'' a permutation on the cube that can be done in a single movement. This can be the rotation of a face by 90° or 180°, but also rotation of a middle layer, two layers, or the whole cube. Each move has a dedicated letter, with a prime indicating the reverse movement. |
|||
A ''sequence'' is a small serie of moves that is frequently used to build up more complete algorithms. Typically these sequences are done very rapidly. Fast algorithms are those that link several sequences with an easy transition (no re-gripping, cube rotation, etc). |
|||
The ''inverse'' of a sequence is the sequence that cancel the effect of that sequence. We use ''prime'' to denote that sequence. |
|||
A ''mirror'' sequence if the L-R symmetric sequence (i.e. F changes to F', R changes to L', etc) |
|||
;Sexy move |
|||
* Direct: <code>R U R' U'</code> (prime: <code>U R U' R'</code>) |
|||
;Sledgehammer |
|||
* Right: <code>R' F R F'</code> (prime: <code>F R' F' R</code>) |
|||
* Left: <code>L F' L' F</code> (prime: <code>F' L F L'</code>) |
|||
:Note: If we do this sequence with the right-hand (after cube rotation <code>y'</code>), we get <code>y' F R' F' R</code>, which is the same as Right prime. |
|||
;Overshoot |
|||
* <code>U' R' F R</code> |
|||
== Tutorials == |
|||
=== F2L === |
|||
Source: [https://www.youtube.com/watch?v=UDP4hX7LJ4E Tutoriel : Résoudre les F2L intuitivement] |
|||
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/: <code>R U' R'</code> and case /L1/: <code>L' U L</code> (mirror) |
|||
:Pair next to each other, horizontal and left (right) of target slot. |
|||
* Case /R2/: <code>R U R'</code> and case /L2/: <code>L' U' L</code> (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 <code> </code> indicate that we reached a basic case. |
|||
* We can always replace <code>U2 R U' R'</code> with <code>U sledgeR'</code>. |
|||
* 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. |
|||
There are 3 F2L families: sticker UP, sticker FRONT, and sticker RIGHT. |
|||
==== White sticker UP ==== |
|||
* Edge on 2L: |
|||
{| width=100% |
|||
|- |
|- |
||
!colspan=4|Standard Grip |
|||
|width=10%|[[File:Rb_F2LU2Lwrong.png|100px]] |
|||
|- |
|||
|width=40%| |
|||
|{{bkft|{TF} }}||(standard grip) Right thumb on Front face |
|||
; (2L1) Case 1, edge wrong (matching corner color) |
|||
|{{bkft|{tF} }}||(standard grip) Left thumb on Front face |
|||
* 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> |
|||
|{{bkft|{TU} }}||(standard grip) Right thumb on Up face |
|||
* {{red|'''Faster'''}}, FL: left SH, or <code>y'</code>, the subcase FR above. |
|||
|{{bkft|{tU} }}||(standard grip) Left thumb on Up face |
|||
* {{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 y U' R U' R'</code> ({{blue|U' while y}}. |
|||
|{{bkft|{TD} }}||(standard grip) Right thumb on Down face |
|||
|width=10%|[[File:Rb_F2Lsexysexysexy.png|100px]] |
|||
|{{bkft|{tD} }}||(standard grip) Left thumb on Down face |
|||
|width=40%| |
|||
|- |
|||
;(2L2) Case 2, edge correct (not matching corner) |
|||
!colspan=4|Non-standard Grip |
|||
* <code>sexy sexy sexy</code>. |
|||
|- |
|||
|{{bkft|{T-F} }} |
|||
|colspan=3|Right thumb on front face, center piece |
|||
|- |
|||
|{{bkft|{T-FR,I-B1} }} |
|||
|colspan=3| Right thumb on front face, FR edge; Right index on back face, 1st corner |
|||
|} |
|} |
||
=== Acronyms === |
|||
* 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. |
|||
{| class=wikitable |
|||
:* (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> |
|||
|AUF||Adjust Upper Face — rotate up face until it is solved, or matches a desired position. |
|||
:* (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 ==== |
|||
* Edge on 2LL: |
|||
:* Case 1, edge correct ('''R1, BR'''): goal is to get a /R1/ using '''BR''' corner, <code>U' R U' R' U2 R U' R'</code>. |
|||
:* Case 2, edge wrong ('''L2, BR'''): goal is to get a /L2/ using '''BR''' corner, <code>U' R U R' U y L' U' L</code>. |
|||
* Edge on LL, non-adjacent |
|||
:* Case 1, same U color, edge BU ('''R1, BR'''): Goal is to get a /R1/ using '''BR''' corner, <code>U' R U R' U2 R U' R'</code> |
|||
:: Idem for edge LU ('''R1, BR'''): <code>U' R U2 R' U2 R U' R'</code> |
|||
:* 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: <code>y U L' U' L U' L' U' L</code> (or <code>U' R U' R' U y L' U' L</code>). |
|||
:: For edge LU, this time we directly have a /L2/ ('''L2'''): <code>y L' U' L</code> |
|||
* Edge on LL, adjacent on RU |
|||
:* Case 1, same U color ('''R1'''): we have directly a basic case /R1/, <code>U R U' R'</code>. |
|||
:* Case 2, different U color ('''L2, BR'''): so we want to get a /L2/, using '''BR''' corner: <code>U' R U2 R' U y L' U' L</code>. |
|||
* Edge on LL, adjacent on FU |
|||
:* Case 1, same U color ('''R2, FL, rot'''): we use '''FL''' corner to get a /R2/ : <code>y L' U L U2' y' R U R'</code> |
|||
:* Case 2, different U color ('''R2, FL'''): we use '''FL''' corner to get a /L2/: <code>y U L' U L U' L' U' L</code> |
|||
==== White sticker RIGHT ==== |
|||
* Edge on 2LL 2LL: |
|||
{| width=100% |
|||
|- |
|- |
||
|AUL||Adjust Upper Layer — Same as AUF. |
|||
|width=10%|[[File:Rb_F2LR2Lcorrect.png|100px]] |
|||
|- |
|||
|width=40%| |
|||
|LH||Left-hand |
|||
; Case 1, edge correct |
|||
|- |
|||
:This case can actually be inserted from any angle without cube rotation. |
|||
|RH||Right-hand |
|||
* ('''L1, FL''') mirror of above, get a /L1/ using '''FL''' corner, and '''U''' then '''L' ''' move: <code>y U L' U L U2' L' U L y'</code>. |
|||
* {{red|'''Faster, no y / y' '''}}, FR: <code>U R U R' U2 R U R'</code> |
|||
* {{red|'''Faster, no y / y' '''}}, BL: <code>U L U L' U2' L U L'</code> |
|||
* {{red|'''Faster, no y / y' '''}}, FL: <code>U L' U L U2' L' U L</code> (alt using sledge: <code>U L' U L L F' L' F,</code> {{blue|F with thumb}}) |
|||
* {{red|'''Faster, no y / y' '''}}, BR: <code>U R' U R U2' R' U R</code> |
|||
|width=10%|[[File:Rb_F2LR2Lwrong.png|100px]] |
|||
|width=40%| |
|||
; Case 2, edge wrong |
|||
* ('''R2, FL''') mirror of above, get a /R2/ case using '''FL''' corner, and '''U''' then '''L' ''' move: <code>y U L' U' L y' U' R U R'</code> |
|||
* {{red|'''Faster, no y / y' '''}}: <code>U2 R' F R F' U2 R U R'</code> |
|||
|} |
|} |
||
* 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''' <code>y' U R' U' R U' U' R' U R y</code> (alt: <code>y' U R' U' R U' y F R' F' R</code> or <code>y U L' U' L U' L F' L' F y'</code>). |
|||
::idem for edge LU ('''L1, FL'''): <code>y' U R' U2 R U' U' R' U R y</code> (alt: <code>y U L' U2 L U' L F' L' F y'</code>). |
|||
:* Case 2, different U color, edge LU ('''R2, BR'''): we need to shift our edge by a single U move: <code>U' R U R' U R U R'</code> |
|||
::For edge BU ('''R2'''): this time we directly get a /R2/: <code>R U R'</code> |
|||
== Triggers == |
|||
* Edge on LL, adjacent on RU |
|||
We call a ''move'' a permutation on the cube that can be done in a single movement. This can be the rotation of a face by 90° or 180°, but also rotation of a middle layer, two layers, or the whole cube. Each move has a dedicated letter, with a prime indicating the reverse movement. |
|||
:* Case 1, same U color ('''L2, BR, rot'''): we get a /L2/ case using '''BR''' corner and '''R U' ''' move, <code>R U' R' U2 y L' U' L y'</code> |
|||
:* Case 2, different U color ('''R2, BR'''): we get a /R2/ case using '''BR''' corner and '''U' R''' move, <code>U' R U' R' U R U R'</code> |
|||
A ''trigger'' is a small squence of moves that is frequently used to build up more complete algorithms. Typically these sequences are done very rapidly. Fast algorithms are those that link several triggers with an easy transition (no re-gripping, cube rotation, etc). The ''inverse'' of a trigger is the sequence that cancel the effect of that trigger. We use ''prime'' to denote that trigger. A ''mirror'' trigger is the M-symmetric trigger (i.e. F changes to F', R changes to L', etc) |
|||
* Edge on LL, adjacent on FU |
|||
:* Case 1, same U color ('''L1'''): we directly have a basic case /L1/, <code>L' U L</code> |
|||
:* Case 2, different U color ('''R2, FL'''): so we want to get a /R2/ case. We can with '''FL''' corner, <code>y' U R' U2 R y U' R U R'</code> (or <code>y U L' U2 L U' y' R U R'</code>) |
|||
List of triggers: |
|||
==== Some shortcuts ==== |
|||
* Corner FBR, white sticker on BOTTOM: |
|||
:Known case from beginner method. Bring matching edge on UP face, on its matching face, then |
|||
:* If matching face FRONT: <code>U R U' R' F R' F' R</code> (this move is called '''le belge''') |
|||
:* If matching face RIGHT: <code>y U' L' U L F' L F L'</code> |
|||
{| class=wikitable |
|||
For other sticker positon, we first move '''edge on its color''': |
|||
* 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. |
|||
{| width=100% |
|||
|- |
|- |
||
|1 |
|||
|width=50%| |
|||
|'''S''' |
|||
[[File:sexysexy.png|100px]] Solved with <code>sexy sexy</code> |
|||
|Sexy move |
|||
|<code>R U R' U'</code> |
|||
| |
| |
||
[[File:sexyLsexyL.png|100px]] Solved with <code>y sexyL sexyL y'</code> |
|||
(alt. <code>U2 R U' R' y L' U' L y'</code>) |
|||
|- |
|- |
||
|2 |
|||
|width=50%| |
|||
|'''Sp''' |
|||
[[File:rb_sexypsexyp_alt.png|100px]] Solved with <code>R U' R sexy'</code> ({{blue|best grip, RH: front/back, index to prepare for U}}) |
|||
|Sexy move prime |
|||
|<code>U R U' R'</code> |
|||
| |
| |
||
[[File:rb_sexyLpsexyLp_alt.png|100px]] Solved with <code>y L' U L sexyL' y'</code> |
|||
(alt. <code>R U R' U' F R' F' R</code>) |
|||
|} |
|||
Variants: |
|||
{| width=100% |
|||
|- |
|- |
||
|3 |
|||
|width=50%| |
|||
|'''LS''' |
|||
[[File:sexypsexyp.png|100px]] Solved with <code>sexy' sexy'</code> |
|||
|Left sexy move |
|||
|<code>L' U' L U</code> |
|||
| |
|||
|- |
|||
|4 |
|||
|'''LSp''' |
|||
|Left sexy move prime |
|||
|<code>U' L' U L</code> |
|||
| |
|||
|- |
|||
|5 |
|||
|'''SL''' |
|||
|sledgehammer |
|||
|<code>R' F R F'</code> |
|||
|{{blue|F' with right thumb!}} |
|||
|- |
|||
| |
|||
|'''SLp''' |
|||
|sledgehammer prime |
|||
|<code>F R' F' R</code> |
|||
| |
|||
|- |
|||
|7 |
|||
|'''LSL''' |
|||
|left sledgehammer |
|||
|<code>L F' L' F</code> |
|||
|Same as <code>y' SLp y</code>. |
|||
|- |
|||
| |
|||
|'''LSLp''' |
|||
|left sledgehammer prime |
|||
|<code>F' L F L'</code> |
|||
|Same as <code>y' SL y</code>. |
|||
|- |
|||
| |
|||
|'''O''' |
|||
|Overshoot |
|||
|<code>U' R' F R</code> |
|||
| |
|||
|- |
|||
|6 |
|||
| |
|||
| |
|||
|<code>R' U R U'</code> |
|||
| |
|||
|- |
|||
|8 |
|||
| |
|||
| |
|||
|<code>L U' L U</code> |
|||
| |
|||
|- |
|||
|9 |
|||
| |
|||
|Anti-sune |
|||
|<code>R U2 R'</code> |
|||
| |
|||
|- |
|||
|10 |
|||
| |
|||
|Sune |
|||
|<code>R U R' U</code> |
|||
| |
|||
|- |
|||
|11 |
|||
| |
|||
| |
|||
|<code>R U' R' U'</code> |
|||
| |
|||
|- |
|||
|12 |
|||
| |
|||
| |
|||
|<code>R' U' R U'</code> |
|||
| |
| |
||
[[File:sexyLpsexyLp.png|100px]] Solved with <code>y sexyL' sexyL' y'</code> |
|||
|} |
|} |
||
* Numbering from [https://www.youtube.com/watch?v=WXSs2wRC7KE this video]. |
|||
* Badmephisto (see Andy Klise [http://www.kungfoomanchu.com/home.html]) classifies triggers in three colors, from the position of prime moves: |
|||
==== More tricks ==== |
|||
:* {{red|Red}} = {{red|R U R' U'}} family (i.e. {{red|X Y X' Y'}}) |
|||
; [https://www.youtube.com/watch?v=twvaMySJUrY Tutoriel F2L avancés - Partie 1] |
|||
:* {{green|Green}} = {{green|R U R' U}} family (i.e. {{green|X Y X' Y}}) |
|||
* Déconjugaison intelligente |
|||
:* {{blue|Blue}} = {{blue|R F' R' F}} family (i.e. {{blue|X Y' X' Y}}) |
|||
* Andy Klise's guide use a different color coding: |
|||
;[https://www.youtube.com/watch?v=YKxE3582Hhw Tutoriel F2L avancés - Partie 2] |
|||
:* {{green|Green}} = {{green|R U R' U'}} family |
|||
* Avoid <code>y2</code> moves, but solve the F2L cases as is (with empty slots in the back). |
|||
:* {{blue|Blue}} = {{blue|R U R' U R U2 R'}} family |
|||
: This is true for all "base" cases, both contiguous and not. |
|||
:* {{orange|Orange}} = {{orange|R F' R' F}} family |
|||
* <code>y</code> and <code>y'</code> is ok. When choosing between both, '''favor the one that leads to <code>R</code> and <code>U</code> moves'''. |
|||
: For instance, better do <code>y' R' U R</code> than <code>y L' U L</code> to insert a base case. |
|||
== Tutorials == |
|||
;[https://www.youtube.com/watch?v=5AtwWuRPX2I Tutoriel F2L avancés - Partie 3] |
|||
* Use free slots |
|||
;[https://www.youtube.com/watch?v=QsDoRkqIewg Tutoriel F2L avancés - Partie 4] |
|||
* Goal of this part: Avoid <code>y</code> and <code>y'</code> move whenever possible. |
|||
* Introduce another ''commutator'', the '''sledgehammer''': <code>R' F R F'</code> |
|||
: <code>F'</code> move must be done with the '''right thumb'''! |
|||
See [[Rubik F2L]], [[Rubik OLL]] and [[Rubik PLL]] for dedicated tutorials. |
|||
* Case: <code>R U' R y L' U2' L y'</code>, white sticker UP, FR corner. |
|||
: Subcase FR. Use sledgehammer <code>U' R' F R F' R U' R'</code> |
|||
: Subcase FL. Use left sledgehammer, or <code>y'</code> then subcase FR above. |
|||
: Subcase BL. Use <code>L U' L' y' L' U2 L</code>. Or sledgehammer also possible, but with re-grip (B with right hand index). |
|||
: Subcase BR. Usual solution is <code>R' U R' F R F' R</code>, but <code>R' U R y U' R U' R'</code> (U' while y) is also ok. |
|||
* Case: <code>U y L' U' L U' y' R U R'</code> |
|||
: Avoid cube rotation with sledgehammer: <code>U2 R' F R F' U2 R U R'</code> |
|||
* Case: <code>U y L' U L U2' L' U L y'</code> |
|||
: Can be inserted from any angle. Either pick contiguous base case or separated. |
|||
: If corner in FR or BL: <code>U R U R' U2 R U R'</code> or <code>U L U L' U2' L U L'</code>. |
|||
: If corner in FL or BR: <code>U L' U L U2' L' U L</code> (alt using sledge: <code>U L' U L L F' L' F</code>, F with thumb) or <code>U R' U R U2' R' U R</code> |
|||
* 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: |
|||
:* <code>R U' R' U' R U' R' U R U R'</code> ({{blue|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) |
|||
:* <code>U' R' F R F' R U R'</code> (with a sledgehammer) |
|||
=== Fridrich simplified === |
=== Fridrich simplified === |
||
Line 406: | Line 259: | ||
For 2-look PLL, like for the 2-OLL, we first do the cross, then the corners. For the cross, turn the U face until 1 edge is good, and place it at F slot, and look how the other edges must be permuted. |
For 2-look PLL, like for the 2-OLL, we first do the cross, then the corners. For the cross, turn the U face until 1 edge is good, and place it at F slot, and look how the other edges must be permuted. |
||
* All edges are ok: congratulations ;-) |
* All edges are ok: congratulations ;-) |
||
* clockwise: <code>R' U R' U' R' U' R' U R U R2'</code> ( |
* clockwise: <code>R' U R' U' R' U' R' U R U R2'</code> ({{blue|1=<code>R' U R' U'</code> with right index under BRD corner, then <code>R' U' R' U</code> with right index next to FRD corner}}) |
||
* anti-clockwise: <code>R2' U' R' U' R U R U R U' R</code> |
* anti-clockwise: <code>R2' U' R' U' R U R U R U' R</code> ({{blue|1=right thumb on B face, right index on FRD corner, ready for 1st U, then <code>R U' R</code> with RH, U' with right thumb }}) |
||
* 2 edge ok: do either of algorithm above, and retry. |
* 2 edge ok: do either of algorithm above, and retry. |
||
Then look at the corners. If one corner is good, turn the cube such that it is at FL slot, and look how the other corners must be permuted |
Then look at the corners. If one corner is good, turn the cube such that it is at FL slot, and look how the other corners must be permuted |
||
* 1 good corner (FL), clockwise: <code>x R' U R' D2 R U' R' D2 R2</code> or <code>l' U R' D2 R U' R' D2 R2</code> (using <code>x R'</code> → <code>l'</code>) |
* 1 good corner (FL), clockwise: <code>x R' U R' D2 R U' R' D2 R2</code> or <code>l' U R' D2 R U' R' D2 R2</code> (using <code>x R'</code> → <code>l'</code>). My old fingertrick was {{blue|left thumb on F center, left index/middle/ring fingers on back, right thumb on U face, right index under RBD corner. First U done with right index, then D2 done with left ring+middle or left little+ring, then U' done with right thumb, like for the sledgehammer}}. This fingertrick is not adviced, instead train on using the {{blue|left index to do the U' move}} [https://www.youtube.com/watch?v=-YrtxKcg7m0]. |
||
* 1 good corner (FL), anti-clockwise: <code>x R2' D2 R U R' D2 R U' R</code> <code>l' R' D2 R U R' D2 R U' R</code> ({{blue|best grip: left thumb on D face, right thumb on F face, left ring finger to prepare the D2 / D2, right index to prepare the U}}. |
* 1 good corner (FL), anti-clockwise: <code>x R2' D2 R U R' D2 R U' R</code> <code>l' R' D2 R U R' D2 R U' R</code> ({{blue|best grip: left thumb on D face, right thumb on F face, left ring finger to prepare the D2 / D2, right index to prepare the U}}. |
||
* no good corner: do either of algorithm above, then you will have a good corner |
* no good corner: do either of algorithm above, then you will have a good corner |
||
Line 417: | Line 270: | ||
== Algorithms == |
== Algorithms == |
||
;PLL - swap 2 edges |
;PLL - swap 2 edges |
||
* |
* {{rubik|R U R' U R U2 R' U}} |
||
;Sexy moves and reverse, mixed with {{rubik|F}} face |
|||
* {{rubik|f {{bksxr}} f'}} is reversed by {{rubik|f {{bksxrp}} f'}} but also by {{rubik|U² F {{bksxr}} F'}}. This is true for any number of sexy moves {{bksxr}} we do. |
|||
== Cross == |
|||
* Be color neutral. |
|||
* Do {{rubik|d}} move to avoid cube rotation might help. |
|||
== Finger Tricks == |
== Finger Tricks == |
||
Line 423: | Line 283: | ||
:Use the ring and major finger. To work well, hold the cube with index and thumb such that ring and major hits the left (or right) side of the D face almost vertically. For instance, using the left hand, the index must hold both the LBU corner and LB edge, and possibly a bit the center back face and BU edge. See [https://www.youtube.com/watch?v=LtJ2u3s_-zA this video]. |
:Use the ring and major finger. To work well, hold the cube with index and thumb such that ring and major hits the left (or right) side of the D face almost vertically. For instance, using the left hand, the index must hold both the LBU corner and LB edge, and possibly a bit the center back face and BU edge. See [https://www.youtube.com/watch?v=LtJ2u3s_-zA this video]. |
||
* '''Left sledgehammer''' |
|||
== Solution == |
|||
:The left sledgehammer is {{rubik|L F' L' F}}. In the right sledgehammer, the {{rubik|F}} is done with the thumb. Here it is best to do is as {{rubik|r U' r' F}}, using the LH only for the {{rubik|U'}}. Also the {{rubik|r}} can be done by pushing with the right ring finger at the bottom of the cube to avoid the re-grip (see [https://www.youtube.com/watch?v=63jenxhu9Mg&t=09m55s VC 9:55]). |
|||
== Look-ahread == |
|||
;Effect of two sexy moves ({{rubik|{{bksxr}} {{bksxr}}}} or {{rubik|{{bksxl}} {{bksxl}}}}) |
|||
* Corners don't move but are rotated: 3 corners on the U faces and 1 corner on the D face. |
|||
* Edges keep their ''parity'' but moves: 2 edges on the U face and 1 edge on the F face. |
|||
== My progress == |
|||
;Short-term plan |
|||
* F2L: Practice and apply algo marked with ''TRAINME''. |
|||
* Use x-cross for F2L cases with correct edge or correct corner when faster. |
|||
;Long-term plan |
|||
* Learn OLL (57 cases) |
|||
* Learn 2-edge PLL identification. |
|||
* Learn OLL-2-PLL identification. |
|||
* Learn partial edge control to avoid dot-OLL cases. |
|||
* Learn COLL |
|||
;To Do |
|||
* View and integrate Victor Colin's video on multi-slotting |
|||
* View / integrate video Badmephisto on OLL resolution (+partial edge control) |
|||
* View / integrate video Badmephisto on F2L. |
|||
=== Personal best === |
|||
{| class=wikitable |
|||
|- |
|||
| Time || Date || Pict || Comment |
|||
|- |
|||
| 13.20 |
|||
|2020-11-13 |
|||
|[[File:IMG-20201113-WA0000.jpg|200px]] |
|||
|With OLL skip on the GAN356i (old cube station app). |
|||
|- |
|||
| 14.83 |
|||
|2020-09-01 |
|||
|[[File:IMG-20200901-WA0000.jpg|200px]] |
|||
|On the GAN356i (old cube station app). |
|||
|- |
|||
| 15.12 |
|||
|2018-04-23 |
|||
|[[File:IMG-20180423-WA0000.jpg|200px]] |
|||
|On Prisma Puzzle Timer. |
|||
|- |
|||
| 15.83 |
|||
|2018-03-21 |
|||
|[[File:IMG-20180321-WA0001.jpg|200px]] |
|||
|On Prisma Puzzle Timer. |
|||
|} |
|||
=== Questions === |
|||
If I could meet a rubik expert: |
|||
* How practice F2L look-ahead? Should we first well visualize the F2L case, how to insert it, then do it? But how do we follow the position of the side color, since we might do cube rotation? Do we have to also explicitly keep track of which slot is already filled, etc? |
|||
=== Example of cross resolution === |
|||
* Below, an example of setup move. |
|||
<pre> |
|||
Scramble: |
|||
B2 R2 L2 F2 U' B2 L2 D R2 L2 U R' B' R D2 L U' R L B' D U' |
|||
yellow top, green front: |
|||
We use notations from https://github.com/chrishunt/rubiks-cube: |
|||
U' L2 F' L' D B L' D |
|||
* R, means turn Right face clockwise |
|||
-- Setup move for green |
|||
* '''R'''' or '''r''', means turn Right face counter-clockwise |
|||
-------- We set blue and orange. Now red is ready, with green to follow nicely |
|||
* R2, means turn Right face twice. |
|||
------ We set red and green. |
|||
-- Adjust bottom layer |
|||
</pre> |
Latest revision as of 00:46, 29 December 2022
Rubik's pages on this wiki |
---|
Guidelines for editing Rubik's Cube page on this wiki
- Use template
bk
to insert Rubik's cube moves (e.g{{bk|R U R' U'}}
gives R U R' U'). This ensures consistency accross pages.
- Two-turn moves are written by appending a digit
2
to face letter, likeU2 F2
. Don't use the notation with exponent! (likeU²
), or the algorithms will be rejected by the Rubik's simulator. Using the exponent is ok to indicate that a trigger or named formula must be done twice (likeE2²
, meaning that E2 OLL must be done twice).
- Two-turn moves are written by appending a digit
- Use templates starting with
bk...
to insert common triggers. Some of these templates are colored, and using the template guarantees that all triggers will have the same color accross pages. Note that these triggers must still be included in abk
template.
- By default template are named according to their formula (e.g.
{{bk|{{bkrurpup}}}}
for Template:Bkrurpup). - But some may have their own names, like the sexy moves (
{{bk|{{bksxr}}}}
for (R U R' U')) or sledgehammers ({{bk|{{bkshr}}}}
for (R' F R F')).
- Use template
{{bkft|...}}
for finger tricks note (like Standard grip, first U with I, or, using the official notation, {TF,tF} U(I2)). - Always verify the algorithm using the Rubik's simulator (localhost).
Notations and acronyms
Official notation
From Wikipedia:
F B U D L R | Front, Back, Up, Down, Left, Right (one-layer move) |
f b u d l r | Front, Back, Up, Down, Left, Right (two-layer move, aka. wide move).
Alternate notations are Fw Bw Uw Dw Lw Rw. |
M E S | Middle (l L' ), Equator (d D' ), Standing (f F' ) (middle layer move, aka slice move)
|
x y z | R, U, F (whole cube move) |
- R means 90° clockwise, R' mean 90° counter-clockwise, R2 means 180° clockwise, and R2' 180° counter-clockwise.
- Alternative notation for easier pronunciation uses T (for Top) instead of U. This way all faces start with a consonnant. Using O for clockwise move, A for anti-clockwise, and I for 180° move, an algorithm like the sexy move becomes then
RoToRaTa
.
Finger tricks and grips
We use DeeDubb's notation as explained on Finger_tricks speedsolving.com.
- Finger notation
Finger notation | |||
---|---|---|---|
I | Right Index | i | Left Index |
T | Right Thumb | t | Left Thumb |
M | Right Middle | m | Left Middle |
R | Right Ring | r | Left Ring |
P | Right Pinkie | p | Left Pinkie |
- Piece notation
Piece notation (corners) | |
---|---|
Each corner of the side being turned is labelled with the numbers 1-4 in a clockwise fashion. The front face starting with the corner UFL, the U face beginning with UBL, the D face with DFL, R with UFR, L with UBL, and B with UBR. | |
U face | U1 = UBL, U2 = UBR, U3 = UFR, U4 = UFL |
F face | F1 = UFL, F2 = UFR, F3 = DFR, F4 = DFL |
Piece notation (edges, slices) | |
On slice moves, the numbers correspond with the edges "behind" the corners of the side with which it turns. For example M turns with the L side, and so it's edges will have the same numbers as the corresponding corners on the L face. S with the F face. E with the D face. |
Together, the finger and piece notation form the basic finger trick notation. It is written 'move(fingerPiece)'.
- Example: U(I2) means that the right index finger performed the move U by sliding the UBR cubie to UFR.
Two-turn moves such as F2 are described using two fingers and two pieces, and can use prime to indicate direction like so: F2'(T3,i1).
- Grip notation
All grip notations are written in curly brackets ({...} ) and only when necessary to define a non-standard or non-intuitive grip. Piece specific grips are separated by a dash (e.g. T-F).
Standard Grip | |||
---|---|---|---|
{TF} | (standard grip) Right thumb on Front face | {tF} | (standard grip) Left thumb on Front face |
{TU} | (standard grip) Right thumb on Up face | {tU} | (standard grip) Left thumb on Up face |
{TD} | (standard grip) Right thumb on Down face | {tD} | (standard grip) Left thumb on Down face |
Non-standard Grip | |||
{T-F} | Right thumb on front face, center piece | ||
{T-FR,I-B1} | Right thumb on front face, FR edge; Right index on back face, 1st corner |
Acronyms
AUF | Adjust Upper Face — rotate up face until it is solved, or matches a desired position. |
AUL | Adjust Upper Layer — Same as AUF. |
LH | Left-hand |
RH | Right-hand |
Triggers
We call a move a permutation on the cube that can be done in a single movement. This can be the rotation of a face by 90° or 180°, but also rotation of a middle layer, two layers, or the whole cube. Each move has a dedicated letter, with a prime indicating the reverse movement.
A trigger is a small squence of moves that is frequently used to build up more complete algorithms. Typically these sequences are done very rapidly. Fast algorithms are those that link several triggers with an easy transition (no re-gripping, cube rotation, etc). The inverse of a trigger is the sequence that cancel the effect of that trigger. We use prime to denote that trigger. A mirror trigger is the M-symmetric trigger (i.e. F changes to F', R changes to L', etc)
List of triggers:
1 | S | Sexy move | R U R' U'
|
|
2 | Sp | Sexy move prime | U R U' R'
|
|
3 | LS | Left sexy move | L' U' L U
|
|
4 | LSp | Left sexy move prime | U' L' U L
|
|
5 | SL | sledgehammer | R' F R F'
|
F' with right thumb! |
SLp | sledgehammer prime | F R' F' R
|
||
7 | LSL | left sledgehammer | L F' L' F
|
Same as y' SLp y .
|
LSLp | left sledgehammer prime | F' L F L'
|
Same as y' SL y .
| |
O | Overshoot | U' R' F R
|
||
6 | R' U R U'
|
|||
8 | L U' L U
|
|||
9 | Anti-sune | R U2 R'
|
||
10 | Sune | R U R' U
|
||
11 | R U' R' U'
|
|||
12 | R' U' R U'
|
- Numbering from this video.
- Badmephisto (see Andy Klise [1]) classifies triggers in three colors, from the position of prime moves:
- Red = R U R' U' family (i.e. X Y X' Y')
- Green = R U R' U family (i.e. X Y X' Y)
- Blue = R F' R' F family (i.e. X Y' X' Y)
- Andy Klise's guide use a different color coding:
- Green = R U R' U' family
- Blue = R U R' U R U2 R' family
- Orange = R F' R' F family
Tutorials
See Rubik F2L, Rubik OLL and Rubik PLL for dedicated tutorials.
Fridrich simplified
Source: Rubik's cube : Méthode intermédiaire (fridrich simplifiée)
4 steps:
- Cross
- F2L
- 2-look OLL
- 2-look PLL
For F2L, see tutorial above.
For 2-look OLL, first do the cross:
- Line shape:
F sexy F'
(F' with the thumb) - L shape:
f sexy f'
(f' with the thumb) - no shape: do 1st then 2nd algorithm
Then we do one of the 7 OLL "cross" algorithms. The cases are denoted by the position of yellow sticker for each corner, starting from FL, the FR, BR and BL corner. So UFRB means the yellow sticker facing upward for the left-front corner, facing front for the right-front corner, facing right for the right-back corner, and facing back for the left-back corner.
- UFRB:
R U R' U R U2 R'
- FRUL:
R U2 R' U' R U' R'
(inverse of UFRB) - FFUU:
R2 D R' U2 R D' R' U2 R'
(D and D' ideally by pulling then pushing with left-hand finger) - LRUU:
x' R U R' D R U' R' D'
(idem) (x' R
→l
, sol U R' D R U' R' D'
) (or variant UFBR:l' U' L U R U' r' F
) - URUB:
x' R U' R' D R U R' D'
(idem) (x' R
→l
, sol U' R' D R U R' D'
) - FFBB:
F sexy sexy sexy F'
- LFBL:
R U2 R2' U' R2 U' R2 U2 R
For 2-look PLL, like for the 2-OLL, we first do the cross, then the corners. For the cross, turn the U face until 1 edge is good, and place it at F slot, and look how the other edges must be permuted.
- All edges are ok: congratulations ;-)
- clockwise:
R' U R' U' R' U' R' U R U R2'
(R' U R' U'
with right index under BRD corner, thenR' U' R' U
with right index next to FRD corner) - anti-clockwise:
R2' U' R' U' R U R U R U' R
(right thumb on B face, right index on FRD corner, ready for 1st U, thenR U' R
with RH, U' with right thumb) - 2 edge ok: do either of algorithm above, and retry.
Then look at the corners. If one corner is good, turn the cube such that it is at FL slot, and look how the other corners must be permuted
- 1 good corner (FL), clockwise:
x R' U R' D2 R U' R' D2 R2
orl' U R' D2 R U' R' D2 R2
(usingx R'
→l'
). My old fingertrick was left thumb on F center, left index/middle/ring fingers on back, right thumb on U face, right index under RBD corner. First U done with right index, then D2 done with left ring+middle or left little+ring, then U' done with right thumb, like for the sledgehammer. This fingertrick is not adviced, instead train on using the left index to do the U' move [2]. - 1 good corner (FL), anti-clockwise:
x R2' D2 R U R' D2 R U' R
l' R' D2 R U R' D2 R U' R
(best grip: left thumb on D face, right thumb on F face, left ring finger to prepare the D2 / D2, right index to prepare the U. - no good corner: do either of algorithm above, then you will have a good corner
Algorithms
- PLL - swap 2 edges
- R U R' U R U2 R' U
- Sexy moves and reverse, mixed with F face
- f (R U R' U') f' is reversed by f (U R U' R') f' but also by U² F (R U R' U') F'. This is true for any number of sexy moves (R U R' U') we do.
Cross
- Be color neutral.
- Do d move to avoid cube rotation might help.
Finger Tricks
- D2 move
- Use the ring and major finger. To work well, hold the cube with index and thumb such that ring and major hits the left (or right) side of the D face almost vertically. For instance, using the left hand, the index must hold both the LBU corner and LB edge, and possibly a bit the center back face and BU edge. See this video.
- Left sledgehammer
- The left sledgehammer is L F' L' F. In the right sledgehammer, the F is done with the thumb. Here it is best to do is as r U' r' F, using the LH only for the U'. Also the r can be done by pushing with the right ring finger at the bottom of the cube to avoid the re-grip (see VC 9:55).
Look-ahread
- Effect of two sexy moves ((R U R' U') (R U R' U') or (L' U' L U) (L' U' L U))
- Corners don't move but are rotated: 3 corners on the U faces and 1 corner on the D face.
- Edges keep their parity but moves: 2 edges on the U face and 1 edge on the F face.
My progress
- Short-term plan
- F2L: Practice and apply algo marked with TRAINME.
- Use x-cross for F2L cases with correct edge or correct corner when faster.
- Long-term plan
- Learn OLL (57 cases)
- Learn 2-edge PLL identification.
- Learn OLL-2-PLL identification.
- Learn partial edge control to avoid dot-OLL cases.
- Learn COLL
- To Do
- View and integrate Victor Colin's video on multi-slotting
- View / integrate video Badmephisto on OLL resolution (+partial edge control)
- View / integrate video Badmephisto on F2L.
Personal best
Questions
If I could meet a rubik expert:
- How practice F2L look-ahead? Should we first well visualize the F2L case, how to insert it, then do it? But how do we follow the position of the side color, since we might do cube rotation? Do we have to also explicitly keep track of which slot is already filled, etc?
Example of cross resolution
- Below, an example of setup move.
Scramble: B2 R2 L2 F2 U' B2 L2 D R2 L2 U R' B' R D2 L U' R L B' D U' yellow top, green front: U' L2 F' L' D B L' D -- Setup move for green -------- We set blue and orange. Now red is ready, with green to follow nicely ------ We set red and green. -- Adjust bottom layer