Speed Cubing

55
Speedcubing /ˈspiːdkjuːbɪŋ/ -noun 1. The art and sport of solving a Rubik's Cube in least time possible. Welcome to the obsession. My current speedcubing method for Rubik's Cube is the Fridrich method with the following extra techniques: Extended cross and other block approaches to F2L when possible. F2L cross on bottom or left. Frequent use of empty slots and miscellaneous tricks. Multiple algorithms for corner-edge pairs to minimize pause and regripping. Avoiding 4 wrong LL edges when fixing the fourth slot (but only when it flows nicely from the rest of the F2L) The nicer patterns from COLL when all LL edges are correctly oriented PLL recognition by blocks of continuous colors With this method I set multiple world records between 2004 and 2006 in both single solve and average of 5 for 3x3x3 speedcubing. Menu How should I learn the Fridrich Method? Fridrich and Beyond Other Speedcubing Methods Memorizing Algorithms How should I learn the Fridrich Method? You just bought a Rubik's Cube and can't wait to start learning the Fridrich Method? Not so fast. The Fridrich Method is quite advanced and is meant for cubers near 30 seconds who want to average under 20. Since the full Fridrich method requires a large number of algorithms, it is best to learn it in several steps.

Transcript of Speed Cubing

Page 1: Speed Cubing

Speedcubing/ˈspiːdkjuːbɪŋ/-noun1. The art and sport of solving a Rubik's Cube in least time possible.

Welcome to the obsession. My current speedcubing method for Rubik's Cube is the Fridrich method with the following extra techniques:

Extended cross and other block approaches to F2L when possible. F2L cross on bottom or left. Frequent use of empty slots and miscellaneous tricks. Multiple algorithms for corner-edge pairs to minimize pause and regripping. Avoiding 4 wrong LL edges when fixing the fourth slot (but only when it flows nicely from

the rest of the F2L) The nicer patterns from COLL when all LL edges are correctly oriented PLL recognition by blocks of continuous colors

With this method I set multiple world records between 2004 and 2006 in both single solve and average of 5 for 3x3x3 speedcubing.

Menu

How should I learn the Fridrich Method?Fridrich and BeyondOther Speedcubing MethodsMemorizing Algorithms

How should I learn the Fridrich Method?

You just bought a Rubik's Cube and can't wait to start learning the Fridrich Method? Not so fast. The Fridrich Method is quite advanced  and is meant for cubers near 30 seconds who want to average under 20. Since the full Fridrich method requires a large number of algorithms, it is best to learn it in several steps.

Step 0: Preliminaries

Before anything, you should select a color scheme and learn the notation.

Step 1: Simple Layer-by-LayerLearn Leyan's Beginner Solution. The Fridrich Method is based on the Layer-by-Layer (LBL) approach, which solves the three layers of the cube in order: first, middle, then last.

Page 2: Speed Cubing

Although full Fridrich actually combines the first two layers, the simple LBL method in Leyan's guide will get you started in the right direction.

Make sure to keep the cross on either bottom or left during the first two layers. Since this method requires about 110 moves, only 2 turns per second is needed to get a sub-minute average.

I realize that Jasmine's beginner page is the standard among layer-by-layer beginner's method guides. I recommend Leyan's over Jasmine's because Leyan teaches to do the first two layers with the cross on bottom. Later on, this will make looking ahead much easier and will be crucial for those sub-20 times.

"Algorithms" needed: 11 total. Of these, only 4 are for the last layer. The rest are short and mostly intuitive "algorithms."Moves on Average: ~110 moves on averagePossible average:~35 secondsGoal for Average before Advancing: 60 sec, which comes out to a little less than 2 tps (turns per second)

Step 2: 4-step last layer (2-step OLL and 2-step PLL)

The method described in Leyan's guide often solves each of the four steps of last layer (edge orientation, corner orientation, corner permutation, and edge permutation) using more than one algorithm. Our goal in this step is to combine these sub-steps so that each of the four steps, in the same order, is now solved with just one algorithm. The list of required algorithms, which is a subset of full OLL and PLL, are given on this page.

Algorithms needed: 16 last layer algorithms (3 edge orientation, 7 corner orientation, 2 corner permutation, 4 edge permutation)Moves on Average: ~85 movesPossible average: ~25 secondsGoal for Average before Advancing: 40 sec (~2 tps)

Once you have memorized the algorithms, consult Getting Faster with an Easy Method for tips on how to get down to 40 seconds.

Step 3: Fridrich for the Lazy Cuber

This is almost full Fridrich. Work on the following substeps simultaneously:

3a: 3-step last layer 3b: Standard F2L

Page 3: Speed Cubing

(Full PLL)

Combine the 2-step PLL into one by learning the complete PLL.

Algorithms needed: 31 last layer algorithms (the same 10 orientation algorithms from Step 2 and 15 new permutation algorithms for a total of 21 PLL)

The method described in Leyan's guide solves the first two layers by first solving the corners and then the edges. F2L allows us to solve a corner and an edge at the same time, thus combining some of the steps within the first two layers and reducing the number of algorithms applied from a maximum of 8 to 4. Learn the standard F2L and the basic techniques described on the F2L page.

Algorithms needed: 41 F2L "algorithms," many of which are intuitive and short (only the first 3 or 4 moves are essential).

Although memorizing algorithms is of course important, at this stage looking ahead is much more crucial to getting faster times. Once you are comfortable with the algorithms, start praticing to look ahead. After learning both Steps 3a and 3b:

Moves on Average: about 63 movesPossible average: 15 secondsGoal for Average before Advancing: 25 sec (about 2.5 tps)

Step 4: Full Fridrich (Full OLL)

As in Step 3(1), we combine the two-step OLL into one by learning the complete OLL. This step is simultaneously the least important and the one that requires the most memorization. For cubers who are already very good at two-step OLL, learning these algorithms might only improve their time by 2 seconds or so. Of course, it is a necessary step for becoming a world-class cuber.

As you are learning OLL, continue to practice looking ahead. To achieve a sub-20 average, a good goal is 3 tps.

Algorithms needed: 78 last layer algorithms (47 new orientation algorithms)Moves on Average: 56 movesPossible average: 11 seconds ??

Of course, it's not necessary to strictly follow this outline. Many people start learning OLL earlier, and it's perfectly possible to mix the OLL algorithms you do know with two-step OLL for cases you don't. Several cubers have learned the entire Fridrich method in less than three months. Even with the high level of speedcubing in the last year years, because of the

Page 4: Speed Cubing

increased availability of optimized algorithms and videos it's still possible to become a world-class speedcuber in less than one year.

Memorizing Algorithms

Yes, the Fridrich Method does require you to memorize a large number of algorithms. Yes, it's difficult to memorize and keep memorized the algorithms for many OLL cases that happen only rarely. There are, however, things that can make the process less painful.

Relate patterns to one other, by shape, mirroring, inverses, finger tricks, etc. Breaking an algorithm down into smaller substeps or two other patterns is also useful. For example, #12 on my list is #45 twice with a y in the middle. While learning the algorithms, always keep a print-out page handy for reference. Feel free to edit mine by putting in your own algorithms.

One good technique for memorization is to find key shapes or blocks of colors while excuting an algorithm. For example, in doing RUR'URU2R', look at the block formed by the FRD corner and the FR edge. As you excute the algorithm, this block moves up to the top layer and is rotated clockwise 90 degree at a time before being placed back by a 180 degree turn and into the starting position. It becomes much harder to find these things for a longer algorithm, but knowing something peculiar about an algorithm help you reconstruct it as you go.

Another basic method is to "chunk" each algorithm into smaller pieces that can be excuted in one move. Each chunk should be easy enough to memorize, and then all you need to do is to piece them together to reconstruct the entire algorithm. Chunks can be any finger trick like RUR', R'UR, or B'R'U.

Mnemonics can be useful for getting an algorithm to at least stick in your mind before getting it internalized with muscle memory. Some people associate each move to a sound so that an algorithm becomes a "word." While they can be helpful, these systems should only be thought of as training wheels. Speedcubers need to be able to react instantaneously to any learned case, so the memory needs to be in the muscle more than as letters or sounds. Also, splitting up the moves by sound usually gives a different result than the grouping based on finger tricks.

Here's an analogy I like: mnemonics for a foreign language. I often use creative connections to learn new words, and that fine for taking vocabulary tests in class. But it's not as useful in conversation, where I have to come up with words very quickly and put them together in a natural manner--kind of like finger tricks in speedcubing.

Of course, there's always repetition. This could be simplified with the help of a training program like the last layer trainer.

Page 5: Speed Cubing

Other Speedcubing Methods (to be edited)

Although most top speedcubers use a Fridrich-based method, there are a handful of cubers who use very different methods. Sub-15 average has been shown to be possible with each of the methods in this section.

Besides Jessica Fridrich, there are two other cubers who competed in the 1982 World Championship in Hungary and has come back to compete after 2004. Each of them invented their own method.

Razoux Shultz Method (CLL/ELL)

After completing the first two layers, this method finishes off the last layer in two steps, as in Fridrich, but using CLL, which permutes and orients the corners, followed by ELL, which permutes and orients the edges while preserving the corners. Since the Fridrich F2L is usually used for the first two layers, this approach is used not as an entirely separate method but as an alternative to Fridrich last layer. In this context, it is usually simply called CLL/ELL.

Petrus Method

Invented by Lars Petrus, this method relies less on algorithms and more on building blocks; the first step, for example, is to build a 2x2x2 block. At the same time that this is more intuitive than Fridrich F2L, it usually takes longer to master all the various block building techniques.

Waterman MethodMarc Waterman invented this advanced corners-first method during the first cube crazy. For many years, his 17 second average remained one of the fastest in the world using any method. Watermaan has not competed since the 80's. A description of this method can be found at Rubikscube.info.

Roux MethodGilles Roux invented this method in 2003 partly in reaction to the growing popularity of the Fridrich Method, which relies on a large number of algorithms. Extending the block approach of the Petrus Method even further, this method starts off with a pair of 1x2x3 blocks.

Page 6: Speed Cubing

Beyond Fridrich(to be edited)

(hmm note the recurring idea of combining steps by adding more algorithms)

When I entered the world of speedcubing in 2002, sub-20 average was the holy grail achieved only by a handful of speedcubers around the world. Over the next few years, this barrier dropped to 17, 15, 14, and 13--times that many believed neared the limit of the Fridrich method. While Fridrich has remained mainstream, cubers have developped a number of new system in search for faster methods. Among these, what seemed the most logical extension of Fridrich was Zborowski-Bruchem method, or ZB, which combined another step in the last layer by dramatically increasing the number of algorithms.

Although several cubers attempted to learn ZB, or at least ZBF2L (the ZB version of F2L), as far as I know there is no one as of yet who has memorized the full method. What's more, I, like many, now doubt that ZB would improve the solving time significantly. Although the number of moves used in ZB is very appealing, with such a large number of algorithms, it would take a tremendous amount of time to optimize and master every single pattern to the extent that top cubers have done for the Fridrich method. Now with the fastest cubers recording sub-12 averages with Fridrich, there is no longer any motivation to learn ZB.

So where will speedcubing go? What's the true limit of Fridrich, and is there another method that can surpass Fridrich? These are the questions we're still trying to answer.

Page 7: Speed Cubing

NotationThis site uses the standard notation with the exception of the double-layer suffix "w" adopted from the JSCC notation.

The six layers and three slices of the cube are indicated by the following capital letters:

Layers

U (Up) D (Down) R (Right) L (Left) F (Front) B (Back)

Slices

M (Middle) E (Equator) S (Side)

A layer and its adjacent slice together are denoted by the letter for the layer followed by "w":

Double Layers

Uw (Up double) Dw (Down double) Rw (Right double) Lw (Left double) Fw (Front double) Bw (Back double)

The colors are shown only for clarity. For example, "R" is the layer on the right (relative to the cube's orientation) regardless of the current state of the cube or the position of the centers.

The notation for each move is constructed as follows:

(Double) layer or slice name

One of the fifteen listed above

+

Number of turns

(none) = Quarter turn (90 degrees)2 = Half turn (180 degrees)

+

Direction of turn

(none) = Clockwise' = Counter-clockwise

Page 8: Speed Cubing

Beginner Solution to the Rubik's Cube

My speedcubing records | Rubik's 25th Anniversary

Translations: Italian | German | Spanish | Dutch

introduction | structure of the cube | cube notationsolution | first layer | cross | FL corners | middle layer | last layer

LL edge orientation | LL corner permutation | LL corner orientation | LL edge permutation | next steps

 PDF version of beginner cube solution (requires Adobe Acrobat)

 Introduction

There are many different methods for solving the Rubik's cube. They can be divided into two broad categories: layer methods and corners first methods (and there are sub-categories within these broad categories). The method I use for speedsolving is a layer based method. More specifically, the method I currently use is: cross, F2L, 3-look LL (I know some of the OLLs, so sometimes I can do a 2-look LL). If you are a newbie cuber then this description may not mean much to you, so I should add that it's the 'Advanced Solution' I described in the Next Stepssection at the end of this page.

Many years ago when I wrote this webpage there were many great websites that explained advanced and expert methods for solving the cube (check out my Rubiks links page), however, there were very few that explained beginner methods. This is the reason I wrote this page. It's not meant to be a totally comprehensive explanation, it's really just some notes I threw together for some friends I was teaching. I thought it might be useful for others, so I've turned it into a webpage.

This beginner method requires memorising only a few algorithms, and when done efficiently can achieve solves of 60 seconds or faster. I know people who can solve in 20-30s with a method like this. I haven't been able to solve so fast with a beginner method, so don't be too distressed if you can't either. On the other hand, if you can do 30s solves with this method, then you are too good for this method and you should be learning an Advanced or Expert method!

Aside from minimal memorisation, another benefit of this method is that it is very scalable. More algorithms may be added later to develop it into an advanced method, or if you're really keen, an expert method. This means you don't need to scrap it and start again to move to an expert method. Everything you learn here will be useful for more advanced methods.

 Structure of the cube

We all know that 3x3x3=27, however, rather than thinking about the cube as 27 little "cubies", think about it as 6 fixed centres (that can rotate on their own axis) with 8 corners and 12 edges which rotate around it. As the centres are fixed, the centre colour defines the colour for the face. It's important to remember this otherwise you'll end up trying to do illogical (mechanically impossible!) things like wondering why you can't work out how to put a corner piece in an edge position, or assuming that you're looking at the blue face merely because 8 of the 9 cubies on it are blue (if the centre is white then it's the white face).

 Terminology

When describing the solution for the 2nd and 3rd layers, standard cube notation will be used. Here's what you need to know to read it:

F = front face B = back face R = right face L = left face U = up face D = down face

Page 9: Speed Cubing

In addition to a letter, each move may be accompanied by an apostrophe or the number two:

A letter by itself means turn that face 90 degrees clockwise (eg. F). A letter followed by an apostrophe means turn that face 90 degrees anti-clockwise (eg. F'). A letter followed by the number 2 means turn that face 180 degrees (direction is irrelevant), (eg. F2).

So R U' L2 is shorthand for "turn the right face 90 degrees clockwise, then turn the up face 90 degrees anti-clockwise, then turn the left face 180 degrees". When thinking whether to turn clockwise/anti-clockwise, imagine that you are looking directly at the particular face you are turning.

For each algorithm, the notation is written with the assumption that the core of the cube remains fixed throughout the whole algorithm, and the faces just turn around it. This means that you also need to know how to position the cube to start the algorithm.

For pictures and further detail about cube notation, have a look at Jon Morris' cube notation page. 

The Solution

 The First Layer

The first layer is solved in two stages:

1. Form the cross2. Insert the 4 first layer corners (each corner is inserted individually)

I believe that the first layer should be done intuitively. You need to understand it and solve it without learning algorithms. Until you can do this, I wouldn't bother attempting the rest of the cube! So, spend some time playing with the cube and familiarising yourself with how to move the pieces around the cube.

Now, here are some tips to get you started.

 The Cross

I prefer to start with the white cross because I find white easier to quickly identify on a completely scrambled cube, however, you can use any colour.

There are 4 edge pieces with white (ie. the 4 arms of the cross) which have specific positions. You can't put any white edge piece in an arm of the cross because the other colour on the edge cubie must match up with it's centre on the middle layer.

Here is a pic of what a correctly formed cross looks like (grey denotes cubies that are irrelevant to the cross). Note that thewhite/red edge cubie matches up with

the white centre and thered centre. Ditto re the white/blue cubie.

Here's a pic on an incorrectly formed cross. Looking at the whiteface we do indeed see a white cross, however

the white/red edge cubie does not match up with the red centre. Ditto re thewhite/blue cubie. This is bad!

For a detailed explanation of the cross, check out Dan Harris' Solving the Cross page.

Page 10: Speed Cubing

 The First Layer Corners

Once you have completed the cross, completing the first layer requires inserting each of the 4 corners in separately. The first thing to do is examine your cube and locate all of the top layer edge pieces - they will be sitting in either the first layer or the last layer. Inserting the first layer corners should be done intuitively, not by learning algorithms. To get you started, here's a step-by-step example of one way to insert a first layer corner.

Step 1

The blue/red/white corner is sitting in the bottom layer (theblue part is facing the bottom so we can't see it in

this picture). Turn the blue face 90 degrees

anti-clockwise.

Step 2

Now your cube should look like this. Move the D face 90 degrees anti-clockwise

to line up theblue/white edge with

theblue/white/red corner.

Step 3

Now that the blue/white edge and

the blue/white/red corner have been lined up, re-form thewhite cross by turning the blueface 90 degrees

clockwise.

Step 4

Now the blue/white/red corner

is in its correct place.

Here are some tips for inserting the top layer corners:

Start with a first layer corner that is sitting in the last layer. If there are multiple first layer corners in the last layer (there usually will be), start with one that does not have

the white part of the corner on the face opposite the white face. Or, if you were using a different colour for the cross ('colour X'), start with a corner that does not have the 'colour X' part of the corner on the face opposite the 'colour X' face.

When working with a first layer corner piece that is in the first layer (but in the wrong first layer corner position), you will need to get it out of the first layer into the last layer, then insert it into the correct first layer corner position. The same principle applies if a first layer corner piece is in the correct first layer corner position but needs to be flipped around. You need to get it out of the first layer (ie. into the last layer), and then re-insert it into the first layer the correct way around.

This is what the first layer should look like when finished.

 The Middle Layer

The middle layer consists of one stage:

1. Insert the 4 middle layer edges (each edge is inserted individually).

You only need to learn one algorithm (plus the mirror algorithm) for the second layer. There are many more algs, but let's just learn the essential one first.

First, locate a middle layer edge that is currently sitting in the last layer. I'm going to use the blue/red edge for this example.

Page 11: Speed Cubing

This blue edge cubie in the last layer is the blue/red edge cubie.

In this picture, U=white, L=red and F=blue. We can't see the other three faces, but obviously the R face is the one opposite the L face, the D face is opposite the U face and the B face is opposite the F face.

Now, position the blue/red edge piece so that the colour on the side of the cube (blue in this case) lines up with it's centre. Now perform the following algorithm: D L D' L' D' F' D F

If the blue/red edge piece was flipped the other way so that the blue was on the bottom rather than the red, you would position the cubie under the red centre and perform the following alg: D' F' D F D L D' L'. This is the mirror of the previous algorithm. The axis of symmetry lies diagonally across the white face, and along the line which divides the blue face and the red face.

What if the edge piece is not in the last layer?

The instructions above assume that the middle layer edge piece you are inserting is sitting somewhere in the last layer.

If some middle edges are in the last layer and some are in the middle layer in the wrong spot, always start working with the edge pieces that are in the last layer. After you've done this, sometimes (but not too often) you'll be left with a middle layer edge piece that's in the middle layer but in the wrong spot. In this situation, you can use the same middle layer algorithms from above (D L D' L' D' F' D F or D' F' D F D L D' L') to insert another edge piece into the middle layer edge position, thereby knocking the middle layer edge piece out of its spot and into the last layer. Once you've done this, the middle layer edge piece is in the last layer and you can deal with it in the usual way.

There is a short-cut to this problem, but as this is a beginner solution with minimal memorisation, I haven't included it here. If you really want to learn it, take a look at Case Dd2 on Dan Harris' site.

The red/blue middle layer edge piece is in the middle

layer but not oriented correctly. It needs to be

moved to the last layer, then put back into the middle layer in the right way.

 The Last Layer

The last layer ("LL") is done in 4 steps:

1. Orient the edges (2 algs) - i.e. form a cross on the D face.2. Permute the corners (1 alg) - i.e. get the corners in the correct position in 3D space (don't worry if they still

need to be rotated).3. Orient the corners (1 alg + mirror alg) - i.e. flip the corners.4. Permute the edges (1 alg) - i.e. swap the edges around. The cube should now be solved! :)

All last layer algorithms are performed with the cross (i.e. the first layer - white side in this example) on the bottom.

 Orienting the LL Edges

Once you have completed the first two layers ("F2L"), hold the cube so that the white side is on the bottom. The white side will be on the bottom for the remainder of the solution. This means that the white side is the D side for all last layer algorithms.

On my cube, white is opposite yellow, therefore yellow is the U face for all last layer algorithms on my cube. Note that your cube may have a different colour opposite white (e.g. blue). Now have a look at your last layer, and in

Page 12: Speed Cubing

particular, look at the last layer face - there are 4 possible patterns of LL edges that you may see.

State 1 State 2 State 3 State 4

Unlike with the initial cross (where all the edges must match up with the white centre and with the centres on the middle layer), here all you need to worry about is getting all the last layer edges matching up with the last layer centre. It doesn't matter if the other colour on the LL edge piece does not match up with the colour on the middle layer centre. Also, ignore the LL corners too. It doesn't matter what they are doing at the moment. Now, let's consider each of these LL edge states separately.

State 1

All the edges are already oriented correctly. Move on to permuting the corners.

State 2

We are going to re-orient our faces for this algorithm. The face you are looking directly at in this picture is now the U face (it was the D face for when you were doing the second layer edges). Perform the following algorithm: F U R U' R' F'

State 3

As with State 2, the face you are looking directly at in this picture is now the U face. Perform the following algorithm: F R U R' U' F'

State 4

State 4 is really a combination of States 2 and 3, so all you need to do is perform the algorithm for either State 2 or State 3. Once you've done this, you'll see that your LL edges now look like State 2 or State 3, so just perform the appropriate algorithm and you will have a cross on the LL.

 Permuting the LL Corners

The two possible states are:

two adjacent LL corners need to be swapped; or

Page 13: Speed Cubing

two diagonal LL corners need to be swapped.

These are the only two possible states. If you cannot identify one of these two states with your LL corners then one or more of the following must be true:

You have not finished the F2L. Someone has ripped out a corner of your cube and put it in the wrong way. Someone has ripped off some of your stickers and put them back in the wrong place. You are not looking hard enough. ;)

Swapping adjacent corners

Hold the cube with the white side on the bottom, and the two corners to be swapped are in the front right top and the back right top positions. Perform the following algorithm: L U' R' U L' U' R U2. To see an animated version of this algorithm, see the first algorithm on Lars Petrus'Step 5 page. On Lars' site, the algorithm is being executed from a slightly different angle (the two corners being swapped are front-top-right and front-top-left), but it is the same exact algorithm.

Swapping diagonal corners

Swapping diagonal corners can be done by executing the adjacent corner swap algorithm twice. Perform it once to swap any two LL corners. Re-examine you cube and you'll see that now there are just two LL corners that need to be swapped. Position it correctly for the final LL adjacent corner swap and perform the LL adjacent corner swap algorithm.

 Orienting the LL Corners

There are 8 possible orientation states for the LL corners. One is where all 4 corners are correctly oriented. The other 7 look like this.

State 1 State 2State 3

State 4

State 5State 6

State 7

State 1. Twisting three corners anti-clockwise

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

State 2. Twisting three corners clockwise

R U R' U R U2 R' U2 To see an animated version of this algorithm, look at Lars Petrus' Sune algorithm.

States 3-7

Once you know the algorithms for States 1 and 2, you can solve any LL orientation State. The remaining States can be oriented using a maximum of 2 algorithms. You will need to do one of the following (i) the State 1 algorithm

Page 14: Speed Cubing

twice, (ii) the State 2 algorithm twice, (iii) the State 1 algorithm, then the State 2 algorithm, or (iv) the State 2 algorithm, then the State 1 algorithm.

In a previous edition of this solution, I had said that I'm not going to tell you exactly how to combine the State 1 and State 2 algorithms to solve States 3-7. My reason for this was because it is important that you try to understand how the State 1 and the State 2 algorithms work, and that once you do understand them you will be able to work out how to use them to solve all the States. I still believe this, however, I received emails from a few people who were having trouble with States 3-7, so I decided to write some extra tips. I still suggest that you try to work out States 3-7 by yourself, but if you are really stuck, have a look here: Orienting the Last Layer Corners: further tips.

 Permuting the LL Edges

There are 5 possible permutation states for the LL edges. One is where all 4 edges are correctly permuted. The other 4 look like this.

State 1

R2 U F B' R2 F' B U R2

State 2

R2 U' F B' R2 F' B U' R2 This is almost identical to the algorithm for State 1. Only difference is the 2nd

move and the 2nd last move.

For an animated version of this algorithm, see the Lars Petrus' Allen algorithm. The algorithm is being executed

from a slightly different angle, but it is the same

exact algorithm.

State 3

Apply the algorithm for either State 1 or State 2.

Re-examine your cube and it will now look like State 1

or State 2.

State 4

Apply the algorithm for either State 1 or State 2. Re-

examine your cube and it will now look like State 1 or

State 2.

And that's all you really need to know to solve the Rubik's Cube! With practice, you should be able to achieve times of 60 seconds (or faster) using this method. Once your comfortable with this method and want to learn more, take a look at the following section.

 Next Steps

If this beginner method is too easy and boring for you then consider the following.

 Intermediate method

Solve each first layer corner + corresponding middle layer edge in one step. This means that after the cross you only have 4 steps (4 corner/edge pairs) to complete the F2L. With this beginner method there are 8 steps: solve each of the 4 first layer corners, then solve each of the 4 middle layer edges. I'd suggest just playing around with your cube and figuring out the F2L corner/edge pairs yourself. For some hints about solving the F2L intuitively, have a look at Doug Reed's intuitive F2L guide. If you're still stuck and just want the algorithms,

Page 15: Speed Cubing

check out Dan Harris' F2L page and Jessica Fridrich's F2L page .  

Learn the 4 specific algorithms (or rather, 3 algorithms plus one mirror algorithm) for each of the 4 different permutation states of the LL edges. My beginner solution already shows you 2 of the 4 last layer edge permutation algorithms, the other two last layer edge permutation algorithms are Case #5 and Case #17 on Dan Harris' PLL page.

 Advanced method

Learn everything from the Intermediate method. Learn the 3-look LL. This requires learning the 7 specific algorithms for the 7 different orientation states of the

LL corners, and learning the 21 PLL algorithms (permuting the last layer algorithms) so you can permute the LL edges and LL corners at the same time. A full 3-look LL uses 30 algorithms.

For more details about the advanced method, check out t Rubiks Galaxia 3-look LL, Dan Harris' site and Lars Vandenbergh's PLL page.

 Expert method

Do the F2L in 5 steps (first dot point from the Intermediate method). Learn a full 2-look LL. This requires memorising 21 PLL algorithms, plus 57 OLL algorithms (orienting the last

layer algorithms).

For more details about the expert method, check out Dan Harris' site, Joël van Noort's site and Lars Vandenbergh's site.

 Other stuff

The method I've documented here is what I believe to be a good beginner method. The problem with some beginner methods is that they are not scalable - to improve your cubing you have to un-learn much of what you know and re-learn it in a different way. This method focuses on memorising very few algorithms, but is structured in a way that allows for development into an intermediate or advanced method. Other thing I should say is that I didn't actually devise any of the last layer algorithms in this method. I merely chose a selection of existing algorithms (sourced from a variety of places including Jessica's site and Dan K's site) and organised them into a simple solution method.

 Celebrate your cubing success!

When you are confident that you can solve the cube by yourself, time yourself so you can keep track of your progress. Also, consider submitting your time to the unofficial world records.

 You are cuber number... 

... to visit this page 

Home | My speedcubing records | RWC2003 | Rubiks Links | Rubik's 25th Anniversary | 

Page 16: Speed Cubing

Page last modified Saturday 31 January 2010 by Jasmine Lee 

An Overview of the Fridrich Method

NoticeThe Fridrich Method is quite advanced. Unless you already average near 30 seconds and want to get under 20 seconds, go to the general speedcubing page instead.

Online gaming has become more and more popular. Enjoy playing with the top online casino.

Invented by Jessica Fridrich in the early 1980s, the Fridrich Method gained popularity among the second generation of speedcubers when it was published online in 1997. By far today's most popular speedcubing method, it is used by most world-class speedcubers with minor modifications.

Applets on this site use the Japanese color scheme (blue opposite white) by default. The setting can be changed here.

Cross

Solve the four edges of one layer (bottom layer shown). 

~8 moves, ~2 seconds

Page 17: Speed Cubing

F2L (First Two Layers)

Complete the first two layers by solving the four corner-edge pairs between the cross edges in four steps, one slot at a time. 41 standard patterns counting mirrors for corner-edge pairs. 

~7 x 4 = 28 moves, ~6 seconds 

Advanced F2L

OLL (Orientation of Last Layer)

Correct the orientation (flip) of all last layer pieces in one step so that every piece has the last layer color on top. 57 patterns counting mirrors and inverses. 

~9 moves, ~2 seconds 

Printable page

PLL (Permutation of Last Layer)

Correct the permutation (placement) of all last layer pieces in one step. 21 patterns counting mirrors and inverses. 

~11 moves, ~2.5 seconds 

Printable page

Orientation of Last Layer (OLL) Printable Page (select "landscape" in page set-up)

First of the two last-layer steps, OLL corrects the orientarion of all last layer pieces in one step so that all U-stickers have the U-color. Permutation is not preserved.

The images represent the last layer, with a gray square or a black side bar indicating U-stickers. Each algorithm applies with this layer as U; click on any algorithm to view it on an applet. Most of these algorithms have been taken from or are based on those by other cubers. Try other lists to find your favorite.

Page 18: Speed Cubing

Recognition

The placement of the correctly oriented last-layer pieces are easy to see, so recognition depends on being able to quickly tell between different patterns with the same top view. It helps to practice recognizing each pattern from the top and two adjacent sides.

Learning OLL

OLL has the lowest speed increase per case learned of all steps of the Fridrich method; a 25-second cuber may only gain 2 seconds by replacing an efficient two-step OLL by full OLL (47 additional algorithms). Although any serious CFOP user should learn eventually learn full OLL, it should be noted that working on better F2L look-ahead is a more efficient way to get faster.

The algorithms are organized by similarity to aid memorization. See the printable page for the original order.

2-Step OLL

Before you even begin considering full Fridrich, you should know 2-look OLL. These account for 10 out of the 57 cases.

EdgesOLL 45 (6-move T): 1/54

FRUR'U'F'

The easiest OLL

OLL 44: 1/54

FwRUR'U'Fw'

Fat (double-layer) 6-move T

Page 20: Speed Cubing

RU-R'URU'R'URU2'R'

Double Sune. Sune twice with cancellation of R'-R.

(U)RU2'R'U'RUR'U'RU'R'

Double anti-Sune

OLL 22 ("The Wheel"): 1/54

RU2'R2'U'R2U'R2'U2'R

The fingertrick here is called the Air Jeff, after my friend Jeff Black. Hold the R layer with all five

fingers, four on top and the thumb on bottom. This grip never changes. Do R, double trigger U2' with

the left index finger, R2', left trigger U', etc. The key is to alternate the direction of R2.

OLL 23 ("Headlights"): 1/54

R2DR'U2RD'R'U2R'

Video by TellerWest. Probably should use a simpler fingertrick.

(U2)R'UL'URU'L-U2'R'UR

Best for OH

OLL 24: 1/54

Page 21: Speed Cubing

RwUR'U'Rw'FRF'

(U2)Lw'U'LULwF'L'F

Mirror. Nice to know.

OLL 25 ("The Finger"...ask Bob Burton): 1/54

Lw'U'L'U-RU'LUx'

(U2)Rw'U'RU-LU'R'Ux

Mirror. Nice to know.

The 6-Move T Group

Many OLL algorithms can be grouped by similarity. You already know 45 and 44 from 2-step OLL; they are replicated here for reference. This group contains the various algorithms made by combining their mirrors and inverses.

OLL 45 (6-move T): 1/54

FRUR'U'F'

The easiest OLL

OLL 44: 1/54

FwRUR'U'Fw'

Fat (double layer) 6-move T

(U2)F-URU'R'F'

Page 22: Speed Cubing

Inverse of 6-move T

OLL 43: 1/54

F'-U'L'ULF

Mirror of 44

(U2)Fw'L'U'LUFw

Same algorithm

OLL 2: 1/54

FRUR'U'F'-FwRUR'U'Fw'

Pull F and Fw with right index. Push F' and Fw' with right thumb. Keep the thumb on F center.

Rw'U'RwR'U'RU'R'URU2'Rw'URw

Sébastien Felix's. Just as good. Better for OH.

(U)RwURw'U2'RU2'R'U2'RwU'Rw'

Jeremy Fleischman's. This and mirror both great for OH.

OLL 48: 1/54

FRUR'U'RUR'U'F'

Double 6-move T (F'-F cancelled)

OLL 47: 1/54

Page 23: Speed Cubing

R'U'xR'URU'R'URU'x'UR

For righties, safer than the mirror of 48, F'L'U'LUL'U'LUF.

Bw'-U'R'URU'R'URBw

Maybe better

(U2)Rw'F'L'ULU'L'ULU'FRw

Sébastien Felix's

OLL 3: 1/54

FwRUR'U'Fw'-U'-FRUR'U'F'

Fat 6-move T, U', 6-move T

(U2)FURU'R'F'y-FRUR'U'F'

Variation

(U')R'RwU-Rw'U2-RwU-R'UR2Rw'

Old school, but great.

(U)M-RUR'URwU2'Rw'-UM'

Easier to understand (note Sune-like part). Nice for OH.

OLL 4: 1/54

FwRUR'U'Fw'-U-FRUR'U'F'

Page 24: Speed Cubing

Fat 6-move T, U, 6-move T

R'U2x-R'URDw'-R'U'R'UR'Fy'x'

Old school, but good.

(U')M'-R'U'RU'Rw'U2'Rw-U'M'

Easier to understand. Nice for OH.

You just learned 7 new algorithms, bringing the total to 17.

The Sune Group

These algorithms are all similar to Sune (OLL 26/27 from 2-Step OLL), which are replicated at the top. It shouldn't be too hard to learn these rotated by U2.

OLL 27: 1/54

RUR'URU2'R'

Sune. Mirror of 26.

OLL 26: 1/54

R'U'RU'R'U2R / (U2)L'U'LU'L'U2L

Sune

R'ULU'RUL'

Niklas. Good when the top left 2x2 is a block.

(U)RU2'R'U'RU'R'

Anti-Sune

OLL 7: 1/54

Page 27: Speed Cubing

M-RU2'R'U'RU'R'-U'M'

M then anti-Sune. Actually more like Rw'R2U2'...

(U)RUR'U'R'FR2UR'U'F'

Jeremy Fleischman taught me this. OLL 33 (the other T) then 6-move T.

(U)R'U'Ry'-RB'R'URBR'

Older, but also pretty good.

OLL 10: 1/54

M'-R'U2'RUR'UR-UM

M' then anti-Sune. Actually more like Rw'R2'U2'...

(U')RUR'y-R'FRU'R'F'R

Older, but also pretty good.

(U')RUR'UR'FRF'RU2'R'

No rotation, but is it worth it?

OLL 11: 1/54

M-RU-R'URU2'R'-UM'

M followed by Sune. Actually more like Rw'R2U...

(U2)RwU-R'UR'FRF'RU2'Rw'

Page 28: Speed Cubing

OLL 12: 1/54

M'R'U'RU'R'U2'R-U'M

M' followed by Sune. Actually more like RwR2'U'...

(U)FRUR'U'F'-y-FRUR'U'F'

6-move T twice. Actually more like FRUR'Dw'-L'FRUR'U'F'

OLL 41: 1/54

RUR'URU2'R'-FRUR'U'F'

Sune then 6-move T

(U2)RU'R'U2'RUy-RU'R'U'F'

Old school, but actually all right from this direction

OLL 42: 1/54

R'U'RU'R'U2'R-FRUR'U'F'

Sune then 6-move T

(U)R'FRF'R'FRF'-RUR'U'RUR'

Just as good

OLL 51: 1/54

Page 29: Speed Cubing

FwRUR'U'RUR'U'Fw'

Double fat 6-move T (Fw-Fw' cancelled)

(U2)F-URU'R'URU'R'F'

That's 12 more cases! We're already at 29 OLL cases.

Remove-(Play)-Reinsert

Consider how the Sune (RUR'URU2'R') affects the FR F2L pair: RUR' removes the pair to the last layer and URU2'R' reinserts it differently, so that overall only the last layer is affected. A similar analysis applies to OLL 1 (RU2'R2'FRF'-U2'R'FRF'): RU2'R'removes the FR pair; R'FRF'U2' plays only with last layer pieces; and R'FRF' reinserts the pair. Combining different ways to remove, play, and reinsert an F2L pair gives rise to a number of good OLL algorithms, and this analysis makes them easier to memorize.

OLL 33: 1/54

RUR'U'-R'FRF'

Remove-reinsert

R'U'RU-LwU'Lw'U

Better if certain blocks are present

OLL 37: 1/54

B'RBR'-U'R'UR

Remove-reinsert. Inverse of 33.

Page 30: Speed Cubing

(U)FRU'R'U'RUR'F'

OLL 36: 1/54

R'U'RU'R'URU-RB'R'B

Remove-play-reinsert the BR pair. Starts like a Sune from the back.

(U2)L'U'LU'L'ULU-LF'L'F

Same algorithm

OLL 38: 1/54

RUR'URU'R'U'-R'FRF'

Mirror of 36

(U2)LUL'ULU'L'U'-L'BLB'

Same algorithm

OLL 57: 1/108

RUR'U'-RwR'URU'Rw'

Remove-reinsert

OLL 28: 1/54

Page 31: Speed Cubing

RwUR'U'R-Rw'URU'R'

Inverse of 57

OLL 17: 1/54

RUR'U-R'FRF'U2'-R'FRF'

Remove-reinsert as in 33, play in between.

OLL 1: 1/54

RU2'R2'FRF'-U2'R'FRF'

Remove-play-reinsert

OLL 35: 1/54

RU2'R2'FRF'-RU2'R'

Remove-play as in 1, reinsert differently.

OLL 18: 1/54

Page 32: Speed Cubing

RU2'R2'FRF'-U2'RwR'URU'Rw'

Remove-play as in 1, reinsert as in 57.

(U')RwU-R'URU2'Rw2'U'RU'R'U2'Rw

Two fat Sunes

That's 9 more algorithms, bringing the total to 36 out of 57. This is where things start to get tough.

The Rest

Although these algorithms don't fit exactly into the "move around one corner-edge pair" paradigm, many can still be analyzed in a similar way by splitting into recognizable fragments. Some of the last few are especially tricky.

OLL 46: 1/54

R'U'R'FRF'-UR

Moves the BR pair

RURB'R'B-U'R'

Better depending on blocks present

OLL 52: 1/54

R'U'RU'R'-Dw-R'URB

OLL 13: 1/54

Page 33: Speed Cubing

LF'L'-U'-LFL'-F'UF

Inverse of the non-Sune alg for 9

FURU'R2F'RURU'R'

from badmephisto

OLL 14: 1/54

R'FR-U-R'F'R-FU'F'

Inverse of the non-Sune alg for 10.

OLL 15: 1/54

L'B'L-R'U'RU-L'BL

Move the DBR-BR pair (not an F2L pair, but similar analysis applies)

(U2)LwU'Lw'LU'L'ULw'ULw

Same algorithm

OLL 16: 1/54

RBR'-LUL'U'-RB'R'

Mirror of 15

(U2)RwURw'RUR'U'RwU'Rw'

Same algorithm

Page 35: Speed Cubing

Inverse of 40

(U2)L'U'BU-LU'L'B'L

Same algorithm

OLL 19: 1/54

MU-RUR'U'Rw-R2'FRF'

Rw'U2'RU-R'URw2U2'R'U'RU'Rw'

Fat double Sunes. Easier to learn, probably just as good.

OLL 20: 1/216

MU-RUR'U'-Rw2R2'URU'Rw'

OLL 34: 1/54

RUR'Dw'-R'F'*RwURw'Ry'

(U2)FRUR'U'R'F'RwURU'Rw'

From Algobase. Note resemblance to OLL 56 first algorithm.

OLL 56: 1/108

Page 36: Speed Cubing

FRUR'U'RF'-RwUR'U'Rw'

Starts like 6-move T, ends like 19

Rw'U'RwU'R'URU'R'URRw'URw

Just as good. Better for OH.

OLL 29: 1/54

B'R'BL'-B'R2B'R'B2'L

(U')M'U'Rw'FRU2'Rw2'FRwU'Rw

(U2)R2'U'RFR'UR2U'R'F'R

The Connie OLL. A lesson in non-standard fingertricks. Start with right thumb on F so that RFR' is

done without regrip, then U with left index push usually used in OH.

(U)RwUR'U'LwL2'URU'M'

Got this one from Vincent Sheu. Also tasty.

(U)RUR'U'RU'R'F'U'FRUR'

Play with FR pair. F' with right index push = no regrip.

OLL 30: 1/54

BLB'R-BL2'BLB2'R'

Mirror of 29, first algorithm

R2UR'B'RU'R2'URBR'

The Connie OLL. Starting with the RH as if after R2', R2UR'B'RU'-R2'URBR with RH ring finger B' and

180 regrip at the dash. Also several ways to do this without regrip (all using an index push), but not as

nice as in 29.

Page 37: Speed Cubing

(U2)FR'FR2U'R'U'RUR'F2

From Algobase

OLL 49: 1/54

RB'-R2'FR2BR2'F'R

Close to RwU'-Lw2'ULw2ULw2'U'Lw.

OLL 50: 1/54

L'B-L2F'L2'B'L2-FL'

Close to Rw'U-Rw2U'Rw2'U'Rw2URw'

Rw'URw2'U'Rw2U'-Rw2URw'

Same algorithm. Maybe better fingering.

OLL 55: 1/108

RwU2R'U'R2Rw'UR'U'RwU'Rw'

David Calvo Vivas's secret algorithm. No regrip!

(U)RU2'R2'U'RU'R'U2'FRF'

Page 38: Speed Cubing

Orientation of Last Layer (OLL)1

RU2-R2'FRF'U2'-R'FRF'

2 F-RUR'U'-F'-Fw-

RUR'U'-F'w

3R'RwU-Rw'U2-RwU-

R'UR2Rw'

4

R'U2x-R'URU'y-

R'U'R'UR'F

5

Lw'U2'LUL'ULw

6

RwU2'R'U'RU'Rw'

7

RwU-R'URU2'R

w'

8

Lw'U'-LU'L'U2Lw

9

F'U'F-LF'L'-U-

LFL'

10

FUF'-R'FR-U'-

R'F'R

11

L'R2BR'BR-

B2R'BR'L

12

F-RUR'U'-F'-y-F-

RUR'U'-F'

13

LF'L'-U'-LFL'-F'UF

14

R'FR-U-R'F'R-FU'F'

15

L'B'L-R'U'RU-

L'BL

16

RBR'-LUL'U'-RB'R'

17

RUR'U-R'FRF'U2-R'FRF'

18RU2-

R2'FRF'-U2'RwR'URU'Rw'

19

MU-RUR'U'Rw-R2'FRF'

20MU-

RUR'U'-Rw2R2'UR

U'Rw'

21 RU-R'URU'R'UR-U2R'

22 RU2'-R2'U'R2U'R2'-

23 R2DR'U2RD'R'U2R

'

24 RwUR'U'Rw'FRF'

Page 39: Speed Cubing

U2R

25

Lw'U'L'U-RU'LUx'

26

L'U'LU'L'U2L

27

RUR'URU2R'

28

RwUR'U'R-Rw'URU'R'

29

B'R'B-L'-B'R2B'-R'B2L

30

BLB'-R-BL2B-LB2R'

31

L'D'w-RDw-

LU'L'B'L

32

RDw-L'D'w-

R'URBR'

33

RUR'U'-R'FRF'

34

RUR'U'(x)-D'-

R'UR-E'

35

RU2-R2'FRF'-RU2R'

36

R'U'RU'R'URU-RB'R'B

37

B'RBR'-U'R'UR

38

LUL'ULU'L'U'-

L'BLB'

39

LF'L'U'LUFU'L'

40

R'FRUR'U'F'UR

41

RU'R'U2RU(y)RU'

R'U'F'

42

L'ULU2L'U'(y')L'U

LUF

43

F'wL'U'LUFw

44

FwRUR'U'F'w

45

FRUR'U'F'

46

RU-RB'R'B-

U'R'

47

F'-L'U'LUL'U'

LU-F

48

F-RUR'U'RU

R'U'-F'

49

LwU'Lw2'ULw2ULw'2U'Lw

50Rw'URw2U'Rw2'U'R2wUR

w'

51

F-URU'R'UR

U'R'-F'

52

R'U'RU'R'-Dw-R'URB

Page 40: Speed Cubing

53

Lw'U'- LU'L'ULU'L'U2-Lw

54RwU-

R'URU'R'URU2-

Rw'

55RwU2R'U'R2Rw'UR'U'RwU'Rw

'

56F-

RUR'U'RF'-RwUR'U'R

w'

57RUR'U'-

Rw-R'URU'R

w'

Shotaro makisumismakisumi at gmail

cubefreak.net

Permutation of Last Layer (PLL) Printable page (select "landscape" in page set-up)

PLL, the last step of the Fridrich Method, permutes all last layer pieces without disturbing their orientation. While there are only 21 patterns (with mirrors and inverses), PLLs are longer on average than OLLs. Go as fast as you can. First aim for sub-2.5 (sub-10 for 4 consecutive executions) for each case.

Here you can find the algorithms I use. Do check out other cubers' lists to find your best match. Even for the same algorithm, try chunking into different substeps or changing the grips. Keep in mind that you don't need to worry about cube turns and that you need to put down the cube to stop the timer. My OH algorithms are mostly from Jeremy Fleischman, who got some of them from Dan Dzoan and Chris Dzoan.

(You might be thinking, "aren't you then allowing the method of timing to influence, if only slightly, the method?" Yes! The 100-meter dash analogy shows why this is reasonable: here, here, and here.)

My best PLL execution time (all 21 PLLs in a row): ~41. Watch Harris Chan do it in 36.83 and in Hiroyuki Take in 35.02 seconds..

Recognition and AUF

Recognition takes longer for PLL than for OLL because we often need to adjust the U face (AUF) before we can determine the case. Rather than systematically matching corners or edges, I recommend using "blocks" for recognition. Refer to your keyboard's numpad for the following description (props to Timothy Wang for the idea). Cycles describe the permutation.

Two adjacent top-layer pieces are connected if they have the same color on the same side. Each permutation has a unique pattern of connected pieces that form blocks. For example, (46)(39), the T permutation, has blocks 12 and 78. (37)(48), the Y permutation, has blocks 12 and

Page 41: Speed Cubing

69--also two 2x1 blocks, but in a different arrangement. We recognize each case by its particular pattern of blocks.

Learning the block pattern for each permutation allows us to do recognition often from two adjacent sides. For instance, if you see the block 1236 (not connected to 9), the only possible case is (79)(48), a J-perm. Sometimes, we need more information. Say you see the block 236 (not connected to either 1 or 9). There are three possible permutations: (19)(48), (179), and (197). We can distinguish between these patterns by inspecting one of the two remaining sides. Note: It is always possible to do recognition from two adjacent sides. Take the same block 236. With (19)(48), the colors of 1 and 23 and those of 9 and 63 are opposite. For the three cycle, only one set is opposite and the other is adjacent, on F or on R depending on the direction. I personally find this too cumbersome.

If there is only one block, consisting of a corner and an edge, you have a G-perm. Match this block with the first two layers to determine which of the four you have. If there is no block at all, you have the E-perm, and matching any edge (which automatically matches all the edges) shows which corner pair need to be switched.

An advantage of this recognition method is that you can sometimes see blocks coming together during OLL. When this happens, by slowing down slightly towards the end of OLL, you can predict the PLL and reduce the pause between the two last layer steps.

If you're sub-15, see Sébastien Felix's R-OLL for a much more sophisticated PLL-prediction method.

Learning PLL

Start by learning two-step PLL, which is a subset of the complete PLL. There are two algorithms for corners (n3 and n15) and four for edges (n1, n2, n5, n6). Learn n4, the reflection of n3. Of the algorithms above, n15, which is used to swap corners across a diagonal, takes the longest. For this reason, the next PLL cases to learn are the other cases with a diagonal corner swap: n7, n9, n20, n21. From there, it's all preference. The intimidating G permutations are actually not any more difficult to recognize than the other cases.

Algorithms

Only EdgesPLL n1a (U): 1/18

Page 42: Speed Cubing

R'UR'U'-R'U'-R'URUR2

zU2'RURU'R'U'R'U'RU'z'

For OH. Mirror of n2a.

PLL n2a (U): 1/18

R2U'R'U'RU-RURU'R

Inverse of n1a, first algorithm.

PLL n1b (U): 1/18

RU'RU-RURU'R'U'R2

Mirror of n1a. First-timers can ignore n1b/n2b, but they help since AUF and cube rotation are relatively

significant for easy PLLs.

PLL n2b (U): 1/18

R2U-RUR'U'-R'U'-R'UR'

Mirror

zU'RU'R'U'R'U'RURU2z'

For OH. Mirror of n1b, first algorithm.

PLL n5 (Z): 1/36

Page 43: Speed Cubing

UR'U'RU'RURU'R'URUR2U'R'U

Fast two-gen. For OH, replace first and last U with U'.

(y)R'U'RU'RURU'R'URUR2U'R'U2

U cycled to the end

U'M'UM2UM2UM'U2M2

Fast slices. Saw this credited to fanwuq. Can also cycle U'.

PLL n6 (H): 1/72

M2'UM2'U2M2'UM2'

Several possible M2' fingerings: the Bob Burton double trigger (left-hand ring middle), Rw2(R'M') with.

Or R2'Rw2U'L2Lw2'U2R2'Rw2U'L2Lw2'.

R2U2'RU2'R2U2'R2U2'RU2'R2

For OH. Reduction to R2U2'R2U2'R2U2'.

Adjacent Corners (Except Gs)PLL n4 (Acw): 1/18

xR'UR'DDRU'R'DDR2x'

The Rowe Hessler Acw. No regrip, DD as left ring twice.

(y)x'R2DDR'U'RDDR'UR'x

(y')RUR'F'*RwUR'-U'Rw'FR2U'R'

Thick J

PLL n3 (Accw): 1/18

Page 44: Speed Cubing

xR2'DDRUR'DDRU'Rx'

The Rowe Hessler Accw.

PLL n8 (T): 1/18

RU*R'U'R'FR2-U'R'U'RUR'F'*

Left thumb on F throughout

(y2)U2'RU*R'U'R'FR2U'R'U-F'L'UL

Left-handed T.

RUR'U'R2z'RU'zU'R'U'RUR2z'R'Dw

The Robert Yau OH T

PLL n10 (F): 1/18

R'U'F'*RUR'-U'R'FR2-U'R'U'RUR'UR

F en T

(y)R'U2R'Dw'-R'F'R2U'R'UR'FRU'F

F en V

(y')R'URU'R2'F'U'F-URU'x'R2U'R'U

Old F, but with less rotation

PLL n11 (Ra): 1/18

Page 45: Speed Cubing

R'U2'RU2'-R'FRUR'U'-R'F'R2U'

(y2)zRU'RURU'R'U'L'URU'LUR2Uz'

For OH

PLL n12 (Rb): 1/18

(U')RU2'R'U2-LwU'L'wU'RULwULw'R'

Mirror of n11

U'RU'R'U'RURD-R'U'RD'R'U2'R'

Maybe better. Must for OH, but as -R'U'RUw'zx'-U'R2U' after the hyphen.

PLL n13 (Ja): 1/18

RU2'R'U'RU2'-L'UR'U'L

RUR'F'*RUR'-U'R'FR2U'R'U'

T-perm like. With right-index push for F', faster than the first alg. Cycle U' to beginning for another

angle.

PLL n14 (Jb): 1/18

R'U2'RUR'U2'-LU'RUL'

Mirror of n13

Page 46: Speed Cubing

R'U2RUR'z-R2'UR'DRU'

Same, but with a funky fingering

xU2'Rw'U'RwU2'-Lw'UR'U'R2x2

Optimal.

Opposite Corners

These cases tend to be more difficult.

PLL n9 (V): 1/18

R'UR'Dw'-R'F'R2U'R'UR'FRF

By Stefan Pochmann. Keep the thumb on F center except at the hyphen, where you need to move it

from L to F.

(y)zU'RDR'URU'Rz'-R'U'LU2'RU2'R'

Great for OH.

R'Uz'RU'RU2R'U'R2U'zU'Rz'R'U'R2U

For OH.

R'UR'Dw'z-U'RU'R'-Dw2R'URUR

Old. Still good for OH.

PLL n15 (Y): 1/18

R2U'R'U(RU'x')z'-L'U'RU'R'U'LU

Also definitely (y2)L2U'L'ULU'x'z-L'U'RU'R'U'LU (same ending), maybe R2'URU'R'Ux'z-RUL'ULUR'U'.

R2U'R'URU'x'-U'R'DR'D'R'UR

Same algorithm. For OH.

Page 47: Speed Cubing

FRU'R'U'RUR'F'*RUR'U'-R'FRF'

Two OLLs.

U'x'-U'RUR'x'z'-R'U'RU2'RU'R'y-U'RUR'

Jeremy Fleischman's OH

PLL n20 (Nb): 1/72

R'UR'FRF'RU'R'F'UF-RUR'U'R

Inverse of Stefan Pochmann's (his is also nice).

U'R'UL'U2'RU'R'LUL'U2'RU'L

Variat of (R'UL'U2RU'L)*2U. For OH.

PLL n21 (Na): 1/72

U-LU'R-U2'L'ULR'U'RU2'L'UR'

Also for OH.

RUR'URUR'F'RUR'U'R'FR2U'R'U2RU'R'

Conjugated J (set-up RUR'U). 21 moves.

PLL n7 (E): 1/36

x'RU'R'DRUR'D'RUR'DRU'R'D'x

The Rowe Hessler E. Left ring for D, keep it in place, push back for D'!

x'U'RU'Rz'RU'Rwxz'-RU'RURDR'U'R

Page 48: Speed Cubing

Robert Yau OH E

(y)x'RU'RU'z'U'RUw'zx'-U'RU'R'U'zU'RDR'

Robert Yau OH E

G perms

Yeah, G perms look scary. Each one has a single 1x1x2 block. Tell them apart by looking at the location of this block relative to the two correctly permuted corners. Another recognition method is to use the side sticker of the unique edge that extends this block to a 1x2x2. For example, for n16 in the figure below, the FU and FUR stickers are opposite in color, while in n17, RU and RUB are adjacent.

The French Gs (see Sébastien Felix's PLL) all start with the two good corners on the left and use singe instead of double layer turns (but essentially the same algorithms). Some of them are worth learning, especially when the two corners on the left are in the right place (i.e. no AUF).

PLL n16 (Ga): 1/18

RUR'y'-R2Uw'RU'R'U-R'UwR2

The second regrip can be omitted, but David Gomes calls the resulting right-index push for Uw "The

Elbow" for its (lack of) accuracy.

PLL n18 (Gb): 1/18

R'U'R(UD')R2U*-R'URU'RU'R2'D(U')

French G

R'U'Ry-R2UwR'URU'RUw'R2

Mirror of n16. Best for OH. For 2H, use R2' as appropriate. The first three moves can also be done as

x'Uw'R'Uwx.

PLL n17 (Gc): 1/18

Page 49: Speed Cubing

R2'Uw'RU'RUR'-Uw-R2'FwR'Fw'

(y2)R2'F2RU2'RU2'R'FRUR'U'R'FR2

From Erik Akkersdijk.

PLL n19 (Gd): 1/18

R2Uw-R'UR'U'RUw'-(R2x')-Uw'RUw

Mirror of n17

(y'U)D'R2U*R'UR'U'RU'R2-(DU')R'UR

French G. Only from this direction and AUF

Page 50: Speed Cubing

Permutation of Last Layer (PLL)n1 (Ucw)

R'UR'U'-R'U'-

R'URUR2

n2 (Uccw)R2U'R'U'RU-RURU'

R

n3 (Accw)

xR2'DDRUR' DDRU'Rx'

n4 (Acw)xR'UR'DDR

U'R' DDR2x'

n5 (Z) UR'U'RU'RU

RU'R'U RU-

R2U'R'U

n6 (H)M2'UM2'U2M2'UM2'

n7 (E)x'RU'R'DRU

R'D' RUR'DRU'R'

D'x

n8 (T)RU*R'U'R'F

R2-U'R'U'RUR'F

'*

n9 (V)R'UR'Dw'-R'F'R2U'R'UR'FRF

n10 (F) R'U'F'*RUR'-U'R'FR

2-U'R'U'RUR'UR

n11 (Ra)R'U2RU2'-R'FRUR'U'-R'F'R2U'

n12 (Rb)RU2'R'U2-LwU'L'wU'-RULwUL'wR

'U

n13 (Ja)RU2'R'U'

RU2'-L'UR'U'L

n14 (Jb)R'U2'RUR'U2'-LU'RUL

'

n15 (Y)R2U'R'U(RU

'x')z'-L'U'RU'R'U'

LU

n16 (Ga)RUR'y'-

R2Uw'RU'R'U-R'UwR2

n17 (Gc)R2'Uw'RU

'RUR'-UwR2FwR

'Fw'

n18 (Gb) R'U'R(UD')R2

U*-R'URU'RU'R2'D(U')

n19 (Gd)R2Uw-

R'UR'U'RUw'-(R2x')-Uw'RUw

n20 (Nb)R'UR'FRF'RU' R'F'UF-RUR'U'R

n21 (Na)U-LU'R-

U2'L'ULR'U'RU2'L'U

R'

Shotaro Makisumismakisumi at gmail

cubefreak.net