# Difference between revisions of "Megaminx LL"

RedstoneTim (talk | contribs) (Add ELL and descriptions for the algorithm sets) |
RedstoneTim (talk | contribs) m (Added image and link to image editor) |
||

Line 1: | Line 1: | ||

{{Substep Infobox | {{Substep Infobox | ||

|name=Megaminx LL | |name=Megaminx LL | ||

− | |image= | + | |image=Megaminx_Last_Layer.png |

|anames=Megaminx Last Layer | |anames=Megaminx Last Layer | ||

|variants= | |variants= | ||

Line 108: | Line 108: | ||

* [https://www.speedsolving.com/threads/megaminx-oll-trainer.72913/ Megaminx OLL trainer (website)] | * [https://www.speedsolving.com/threads/megaminx-oll-trainer.72913/ Megaminx OLL trainer (website)] | ||

* [http://qblog.be/2010/02/last-layer-megaminx-solver/ 5g solver for Megaminx LL by Lars Vandenbergh (website)] | * [http://qblog.be/2010/02/last-layer-megaminx-solver/ 5g solver for Megaminx LL by Lars Vandenbergh (website)] | ||

+ | * [https://www.speedsolving.com/threads/megaminx-image-editor-released.77280/ Megaminx Image Editor (website)] | ||

=== Beginner === | === Beginner === |

## Revision as of 09:25, 13 June 2020

**Megaminx LL** or **Megaminx Last Layer** refers to the Last Layer of the Megaminx, similar to the Last Layer on 3x3x3. The Last Layer is the last step for solving the Megaminx, usually preceded by Megaminx F2L and Megaminx S2L.

## Contents

## Approaches

There are multiple approaches for solving the Last Layer, grouped into how many looks are required/algorithms need to be performed for solving all of it. (Except for Beginner, since the amount of looks needed for the Beginner's variant heavily depends on the case and in usually very high).

### Beginner

A possible approach for solving the Last Layer of the Megaminx for beginners is the following:

- Orient all edges (an edge is oriented when its sticker with the last layer color matches the center of the last layer).
- When there are two unoriented edges adjacent to each other, place one in front of you and the other one on then right. Then perform the algorithm F U R U' R' F'.
- When there are two unoriented edges that are not adjacent to each other, place one in front of you and the other one in the back right. Then perform the inverse of the above algorithm, F R U R' U' F'.
- When there are four unoriented edges, place the oriented one in the back left, perform one of the algorithms for orienting two edges and proceed by orienting the resulting two edges

- Permute all edges (put them in the correct places so they match up with both centers).
- Try to find the position with the most edges solved by performing a maximum of three U moves.
- If all edges are solved, you are done.
- If two adjacent edges are solved, perform a Sune (R U R' U R U2' R') once or twice while holding the solved edges at the front and left until all edges are solved.
- If only one edge can be aligned correctly, perform a Sune once or twice with the edge on the front until another edge gets solved and proceed with the two adjacent edges case.
- If two edges are solved that are not adjacent, match one edge up by performing either a U or U' move (this will unsolve the other edges). Now proceed with the only one edge case.

- Orient all corners (a corner is oriented when its sticker with the last layer color points in the same direction as the last layer center).
- Take one unoriented corner and perform the algorithm R' D' R D multiple times until the corner is oriented.
- Replace the now oriented corner with an unoriented one by moving the last layer.
- Repeat this until all corners are oriented. (The S2L should have restored itself by then.)

- Permute all the corners (put them in the correct places so that they become solved).
- Take one unsolved corner and perform the algorithm R' D' R.
- Turn the last layer so the corner would be solved if R' D R were performed.
- Perform the algorithm R' D R to place the corner and simultaneously take another one out.
- Repeat the last two steps until all corners are permuted. Instead of only R' D R, one has to alternate between R' D R and R' D' R' (after using R' D R, use R' D' R', then R' D R again, and so on).

### 4LLL

4LLL is the most commonly used approach to solve the last layer due to manageable algorithm count and being a direct improvement on the beginner approach. This can be seen as an intermediate approach to last layer.

- Orient the edges using one of 3 EOLL algorithms.
- Orient the corners using one of 16 OCLL algorithms.
- Permute the edges using one of 5 EPLL algorithms.
- Permute the corners using one of 32 CPLL algorithms.

### 3LLL

3LLL is a direct improvement on 4LLL, where EPLL and CPLL are combined into one step, PLL. Because of high algorithm count, this is only used by world class Megaminx solvers.

- Orient the edges using one of 3 EOLL algorithms.
- Orient the corners using one of 16 OCLL algorithms.
- Permute the edges and the corners using one of 151 PLL algorithms.

### 2LLL

2LLL is one of the most advanced ways to solve the last layer of the Megaminx in only two looks at the cost of 411 algorithms. Even at the top, barely no one uses this because of the enormous effort that has to be put into learning all algorithms, which is often better spent practicing F2L and S2L.

- Orient the edges and the corners using one of 260 OLL algorithms.
- Permute the edges and the corners using one of 151 PLL algorithms.

Another approach to 2LLL is orienting edges early, e.g. via Edge Control during last slot or methods like ZZ-Spike. Either of those allows the last layer to be solved using OCLL and PLL, which leads to an algorithm count of 167.

## Algorithm sets

### EOLL/EO

EOLL on Megaminx generally refers to orienting the edges of the last layer (while not preserving anything else). It only consists of three algorithms (F' R U R' U' F', F U R U' R' F' and L U2 F U' R U' R' F' L'), the first two of which should be familiar to everyone who knows the LBL method for 3x3x3.

### OCLL/CO

OCLL generally refers to orienting the corners while preserving edge orientation. For this step, only 16 algorithms need to be learn. Some 3x3x3 OCLL algorithms like Sune transfer to Megaminx OCLL as well, which makes this step easier to learn for most cubers.

### EPLL/EP

Permuting the edges after orienting the last layer is called EPLL. EPLL only consists of 5 algorithms, which means that this step can be learned relatively quickly.

### CPLL/CP

CPLL is the last step of the most common 4LLL variant. It finishes the solve by permuting the last five corners using one of 32 algorithms. Often, not all algorithms are learned and commutators are used instead.

### PLL

Megaminx PLL does EPLL and CPLL at once, at the cost of 151 algorithms. Because of the algorithm count, this is only used by some of the best cubers, although lots of people use partial PLL due to the fact that lots of 3x3x3 PLLs like the T permutation also work on the Megaminx.

### OLL

Megaminx OLL combines EOLL and OCLL into one step that requires 260 new algorithms to be learned. Even among world class solvers, knowing full OLL isn't common.

### ELL

Unlike 3x3x3 ELL, Megaminx ELL refers to orienting and permuting the edges ignoring the corners (similar to LLEF). It only consists of 39 algorithms, although the main issue is that the algorithms to orient the corners after this step become longer and that this is hard to extend to a 4LLL due to the very high algorithm count for solving the last four corners.

## See also

## External links

### Software

- Megaminx OLL trainer (website)
- 5g solver for Megaminx LL by Lars Vandenbergh (website)
- Megaminx Image Editor (website)

### Beginner

- Z3Cubing's beginner tutorial (video)
- J Perm's beginner tutorial (video)
- Feliks Zemdegs' beginner tutorial (video)

### 4LLL

- Feliks Zemdegs' 4LLL (video)
- Feliks Zemdegs' 4LLL (PDF)
- 4LLL algorithms (website)
- SirWaffle's 4LLL algorithms (PDF)
- Simon Westlund's EO and CO algorithms (video)
- Simon Westlund's EP and CP algorithms (video)
- Odder's Megaminx Last Layer Guide (PDF)
- Alg sheet for the last layer (PDF) (10 algorithm beginner's guide and a 20 algorithm advanced guide)
- Sarah Strong's OCLL algorithms (website)