The Rubik’s cube is a pretty cool and amazing toy, one that I’ve been spending a considerable amount of time playing with recently.

Methods for solving the cube vary. Beginner methods are easy to learn, but the downside is that they’re inefficient, usually taking a hundred moves or more to solve the cube. On the other hand, speedcubing methods often enable the cube to be assembled in fifty or sixty moves, but requires memorization of up to hundreds of move sequences, or *algorithms*.

The most common speedcubing method, usually called the CFOP or Fridrich method, requires memorization of about 70 different algorithms. Naturally, I didn’t want to do so much memorizing.

I learned to solve the Rubik’s cube from this site, which I think is a very good beginner tutorial. For the rest of this article, **I will assume that the reader already solves the cube using this method**, and furthermore I will use their notation and conventions. That is, this article would be a sort of extension to the tutorial.

The method provided is basically as follows:

- Solve the first two layers
**Orient**the**edges****Permute**the**corners****Orient**the**corners****Permute**the**edges**

The site gives 7 algorithms to solve the last layer (5 algorithms plus 2 mirror ones). As a result, any of steps 2-5 may require two sub-steps to do.

Here I provide 9 additional algorithms, making it possible to solve each of steps 2-5 in a single step. This makes a 4-step last layer with a total of 16 algorithms.

I will not be listing the original 7 algorithms: they are already available on the linked site.

### Orienting the edges

In this step we want to form a yellow cross, that is, all four yellow edges are oriented so that yellow is facing up.

In addition to the three cases already covered, here’s a special algorithm for the fourth case:

**R U2 R2 F R F’ U2 R’ F R F’**

### Permuting the corners

Next we make it so the corners are in the right place (although not necessarily the right orientation). The usual method for this is switching two corner pieces. However, in one case *both *corner pieces have to be swapped.

You can apply the algorithm twice, or you can use this algorithm:

**L U2 R’ U L’ U’ R L U2 L’**

### Orienting the corners

Now we want the corners to all be oriented, that is: have yellow facing up on all of them. The only algorithm here that’s really needed is the one that rotates groups of 3 pieces clockwise (or counterclockwise) 120 degrees all at once. Any case can be solved with at most a combination of two of these.

The first two cases are when exactly three of the corners are facing incorrectly. The two algorithms needed are already covered.

Next, there are two similar looking cases where all four pieces are facing incorrectly:

**R U R’ U R U’ R’ U R U2 R’**

The other case is similar, but a little bit different:** **

**R U2 R2 U’ R2 U’ R2 U2 R U2**

There is one case where two diagonal corners are oriented incorrectly:

**L B’ D2 B L’ U2 L B’ D2 B L’ U2**

Finally there are two cases where the two adjacent corners are oriented incorrectly. Here’s one:

**R’ U’ R U’ R’ U2 R2 U R’ U R U2 R’**

The other one, which is basically the reverse:

**R U2 R’ U’ R U’ R2 U2 R U R’ U R**

### Permuting the edges

The final step now is permuting the edges. There are two algorithms already, to rotate a group of three edges clockwise (or counterclockwise). The other two cases can be done in a combination of two substeps.

The first one, where edges need to be swapped oppositely:

**R2 L2 D R2 L2 U2 R2 L2 D R2 L2**

Or the other case where edges need to be swapped adjacently:

**R’ U’ R U’ R U R U’ R’ U R U R2 U’ R’ U2**

And this is it. We’re done!