#### m0nkiem0nkie

##### Member

- Joined
- Jan 29, 2020

- Messages
- 5

I myself have been privileged to be part of the 1st generation Rubik’s Cube rage back in the 80’s and have recently found a renewed interest in this puzzle; most particularly in 3BLD.

While I originally used the M2/OP-method, probably like many I became mentally stuck in-between the repetitive OP-corners method and facing the unsurpassable task of learning 378 3-style corner algorithms.

Thanks to this tutorial: http://twistypuzzles.ru/forum/index.php?topic=994.0 combined with Google translate I started to understand the EKA corners-method. However, the tutorial uses FDR as the helper piece, whereas I wanted to keep the UBL-RDF combo, to maintain use of the good old OP-corner alg. (in case of parity, for instance).

Understandably, most algorithms found on the Internet are full of speedy, but sometimes long algorithms containing only R-, D- and U-moves, to maintain regripless movements.

However, being a recreational cuber with an appreciation for simplicity and elegance, my goal was to collect sets of similar algorithms which could be grouped together, thereby making it easy to remember, turning it into an “easy-EKA”-method.

As a result, here is a set of algorithms I compiled from various sources and wish to share, using the UBL-RDF combo:

__[F L2 F', R%]__

RBD -> [F L2 F', R] -> (F L2 F') R (F L2 F') R'

RFU -> [F L2 F', R'] -> (F L2 F') R' (F L2 F') R

RBU -> [F L2 F', R2] -> (F L2 F') R2 (F L2 F') R2

__[R' D' R, U%]__

UFR -> [R' D' R, U2] -> (R' D' R) U2 (R' D R) U2

UBR -> [U: [R' D' R, U]] -> U: (R' D' R) U (R' D R) :U2

UFL -> [U': [R' D' R, U']] -> U': (R' D' R) U' (R' D R) :U2

__[F' U2 F, D%]__

FDL -> [F' U2 F, D] -> (F' U2 F) D (F' U2 F) D'

BDR -> [F' U2 F, D'] -> (F' U2 F) D' (F' U2 F) D

LBD -> [F' U2 F, D2] -> (F' U2 F) D2 (F' U2 F) D2

__(R2 U R2 U' R2)__

DBR -> [x: [R2 U R2 U' R2, D2]] -> x: (R2 U R2 U' R2) D2 (R2 U R2 U' R2) D2 :x'

LFU -> [x' y': [D2, R2 U R2 U' R2]] -> x' y': D2 (R2 U R2 U' R2) D2 (R2 U R2 U' R2) :y x

__Misc. pure Commutators__

BDL -> [L, B' R2 B] -> L (B' R2 B) L' (B' R2 B)

FLU -> [U' R U, L] -> (U' R U) L (U' R' U) L'

DFL -> [D R D', L2] -> (D R D') L2 (D R' D') L2

__Misc. with Conjugates__

DBL -> [D: [L2 , U R' U']] -> D: L2 (U R' U') L2 (U R U') : D'

LDF -> [L: [R U' R', D2]] -> L: (R U' R') D2 (R U R') D2 :L'

FRU -> [U': [D' L D, R2]] -> U': (D' L D) R2 (D' L' D) R2 :U

BRU -> [L2: [L B2 L', F]] -> Rw': U2 (L' D L) U2 (L' D' L) :Rw

As can be seen, similar algorithms have been grouped together, to ease the way to memorize these 18 algorithms.

*Note: I am aware that for instance for BDR there is the [D, R' U R]-alg., yet for now I prefer the above as the particular logic of that group made memorizing those 3 [F' U2 F, D%]-alg’s much easier.*

For those that are still a bit confused about the EKA corners-method:

- As this is a 3-style method, group targets in letter pairs.
- Setup the location of the first letter to the helper position (RDF); same as the OP-method.
- The setup move(s) may relocate the position of the second letter. It is the (relocated) position of this second letter that determines which of the 18 algorithms to use.*
- Perform algorithm, undo setup and voilà, you just solved 2 corners with only 1 algorithm!

**Tip: I place one of my fingers on the initial position of the second letter to physically follow its final position while performing the setup of the first letter to RDF.*

All in all, for those who, like me, wanted to join the fun of using 3-style on corners, but have no intention to learn all 378 corner algorithms, this may work out for you. At least it did for me.

Of course, the above list is just my current personal preference. Who knows, there may be even more easy-EKA alg-groups to be discovered.

Have fun!