Difference between revisions of "EG Method"

From Speedsolving.com Wiki
m (Not so stubish anymore so no more {{Stub}})
m (→‎External links: speedcubingtips.eu's EG Tutorial in French added)
(30 intermediate revisions by 12 users not shown)
Line 7: Line 7:
 
|variants=[[CLL]]
 
|variants=[[CLL]]
 
|steps=2
 
|steps=2
|algs=120
+
|algs=128 (including PBL)
 
|moves=12.35
 
|moves=12.35
 
|purpose=<sup></sup>
 
|purpose=<sup></sup>
 
* [[Speedsolving]]
 
* [[Speedsolving]]
 
}}
 
}}
The '''EG method''' (Erik-Gunnar), so far only used for the [[2x2x2 cube]], only has two [[step]]s: solve one [[face]], and then finish the entire cube in one algorithm. Without reflections, it requires 120 non-[[PBL]] algorithms. There are 3 bottom layer cases that each require the same amount of algorithms as [[CLL]]. Those that know CLL already know 1/3rd of EG, the EG 2 cases. The other two groups of cases have a T permutation on bottom EG 1, and a Y permutation on bottom EG 0.
+
The '''EG method''' (Erik-Gunnar), so far only used for the [[2x2x2 cube]], only has two [[step]]s: solve one [[face]], and then finish the entire cube in one algorithm. Without reflections, it requires 128 algorithms. There are 3 bottom layer cases that each require the same amount of algorithms as [[CLL]]. Those that know CLL already know 1/3rd of EG. The other two groups of cases have a T permutation on bottom (EG 1), and a Y permutation on bottom (EG 2).
  
 
{| border="0"  
 
{| border="0"  
| valign="top"|[[Image:2x2 EG 2.jpg|160px|thumb|EG 2 (CLL) first layer]]
+
| valign="top"|[[Image:2x2 EG 2.jpg|160px|thumb|CLL first layer]]
 
| valign="top"|[[Image:2x2 EG 1.jpg|160px|thumb|EG 1 first layer]]
 
| valign="top"|[[Image:2x2 EG 1.jpg|160px|thumb|EG 1 first layer]]
| valign="top"|[[Image:2x2 EG 0.jpg|160px|thumb|EG 0 first layer]]
+
| valign="top"|[[Image:2x2 EG 0.jpg|160px|thumb|EG 2 first layer]]
 
|}
 
|}
'''EG''' is by far the best method for solving the cube in one look, many scrambles have an easy first layer so it often easy to see the whole solve in the inspection, this is the strongest reason for learning EG, most other times you are better of using [[CLL]]. This because of the many cases, it takes a great lot of practice to learn to do all fast (in EG 1 it is not only the case and alg, you also have to remember on wich side you need to put the FL pair before the alg) but the worst problem with EG is the AUF's you get in EG 1 (that occures 4:6 times). You need to AUF first before and then after the alg and it is not possible to pre AUF like it is in CLL because of the need of the first AUF (you got to have LL aligned propely to the pair in the first layer to swap the correct FL pieces). CLL has got a more complicated first layer on average but you regain it in the end.
+
'''EG''' is by far the best method for solving the cube in one look, many scrambles have an easy first layer so it is often easy to see the whole solve in the inspection, this is the strongest reason for learning EG, most other times you are better off using [[CLL]]. This because of the many cases, it takes a great lot of practice to learn to do all fast (in EG 1 it is not only the case and alg, you also have to remember on which side you need to put the FL pair before the alg) but the worst problem with EG is the AUF's you get in EG 1 (that occures 4:6 times). You need to AUF first before and then after the alg and it is not possible to pre AUF like it is in CLL because of the need of the first AUF (you got to have LL aligned propely to the pair in the first layer to swap the correct FL pieces). CLL has got a more complicated first layer on average but you regain it in the end.
  
 
The best is probably to learn EG but use CLL for all cases where you cannot see the whole solve in the inspection.
 
The best is probably to learn EG but use CLL for all cases where you cannot see the whole solve in the inspection.
  
==EG 0 or not?==
+
==LEG-1==
Some cubers have only learnt EG 2 and EG 1 case: you can cancel the last moves of making a face with 'R2 F2 R2' (0+0 PBL) if you see that you will have a EG 0 case, giving you a EG 2 algorithm (CLL). For this reason, there is no internet published list of the EG 0 cases, (or not a compleate one but the [[CxLL]] pages here in this wiki lists some of them and more are getting added so it will soon be compleate).
+
{{Method Infobox
 +
|name=LEG-1 (2x2x2)
 +
|image=
 +
|proposers=[[Christopher Olson]]
 +
|year=2014
 +
|anames
 +
|variants=[[EG-1]]
 +
|steps=2
 +
|algs=42 (including [[PBL]])
 +
|moves=
 +
|purpose=<sup></sup>
 +
* [[Speedsolving]]
 +
}}
 +
 
 +
LEG-1 Is just like an EG-1 except you hold the bar on left, not on the back. That saves you a rotation after bulding a face so you can go straight into your alg. Though some of the algs for LEG-1 are not as good as EG-1, so its recommended to learn full EG first and then learn LEG-1.
 +
 
 +
==EG 2 or not?==
 +
Some cubers have only learnt CLL and EG1 because you can cancel the last moves of making a face with 'R2 F2 R2' (0+0 PBL) if you see that you will have a EG 2 case, giving you a CLL case.
  
Another method that has been used for EG 0 is to inverse solve LL using normal CLL, say you got EG 0 and [[CxLL H D]], then you can use the CLL for [[CxLL H U]] that will "solve" LL to diagonal permut and then add the permutation for [[PBL]] 0+0 in the end. In some cases, like this, the alg ends in R2 so the only extra turn you need to add is the F2, like this; orginal CLL ''R2 U2 R U2 R2'' makes ''R2 U2 R U2 '''F2''' R2'' to solve the inverse CLL and 0+0 PBL. All CLL's has got a inverse CLL, to look at the pairs just set up one case and do the 0+0 PBL (R2 F2 R2) and you will have the inverse instead. It is also possible to insert a single F2 PBL in the middle of a CLL alg if pieces are in correct position but this will not always solve the inverse case but some diffrent one, this shows that; null alg R U2 R - R' U2 R, with insert R U2 R '''F2''' R' U2 R' (you have to test it on a cube to see the effect of the insert).
+
Another method that has been used for EG 2 is to inverse solve LL using normal CLL, say you have EG 0 and [[CxLL H D]], then you can use the CLL for [[CxLL H U]] that will "solve" LL to diagonal permut and then add the permutation for [[PBL]] 0+0 in the end. In some cases, like this, the alg ends in R2 so the only extra turn you need to add is the F2, like this; orginal CLL ''R2 U2 R U2 R2'' makes ''R2 U2 R U2 '''F2''' R2'' to solve the inverse CLL and 0+0 PBL. All CLL's have an inverse CLL, to look at the pairs just set up one case and do the 0+0 PBL (R2 F2 R2) and you will have the inverse instead. It is also possible to insert a single F2 PBL in the middle of a CLL alg if pieces are in correct position but this will not always solve the inverse case but some diffrent one, this shows that; null alg R U2 R - R' U2 R', with insert R U2 R '''F2''' R' U2 R' (you have to test it on a cube to see the effect of the insert).
  
Those who learn EG and chooses to 'cheat' in the EG 0 part should be aware of the fact that the EG 0 cases are often easy to solve, if you add the permutation in the last part of the first layer you also add turns, naturally, but you may also get a longer alg for the CLL than you would have gotten for the EG 0 case, you will loose double those times. On average you can improve a good bit by learning also the last part of the method.
+
Those who learn EG and chooses to 'cheat' in the EG 2 part should be aware of the fact that the EG 2 cases are often easy to solve, if you add the permutation in the last part of the first layer you also add turns, naturally, but you may also get a longer alg for the CLL than you would have gotten for the EG 2 case, you will loose double those times. On average you can improve a good bit by learning also the last part of the method.
  
 
==EG for 3x3?==
 
==EG for 3x3?==
It is possible to use EG for the [[3x3x3 cube]] as a [[columns first]] method but with a diffrent set of algorithms. The idea is to orient four pairs without minding relative order and then sort the pairs and solve CLL using a EG algorithm, one that preserves the pairs, "Pairs EG" or [[PEG]]. But this has only been tested as a experimental method so far.
+
It is possible to use EG for the [[3x3x3 cube]] as a [[columns first]] method but with a different set of algorithms. The idea is to orient four pairs without minding relative order and then sort the pairs and solve CLL using a EG algorithm, one that preserves the pairs, "Pairs EG" or [[PEG]]. But this has only been tested as a experimental method so far.
  
 
=== See also ===
 
=== See also ===
 
* [[CLL]]
 
* [[CLL]]
* [[2x2x2 Methods]]
+
* [[2x2x2 methods]]
  
== External Links ==
+
== External links ==
 
* [http://erikku.er.funpic.org/rubik/EGIndex.html Erik Akkersdijk's Tutorial]
 
* [http://erikku.er.funpic.org/rubik/EGIndex.html Erik Akkersdijk's Tutorial]
* [http://dtwoner.110mb.com/index.php?p=1_42_EG1 Algs for the EG1 set]
+
* [https://www.speedcubingtips.eu/methodes-de-resolution/methode-eg/ speedcubingtips.eu's EG Tutorial in French]
 +
* [http://dtwoner.110mb.com/index.php?p=1_42_EG1 Algs for the EG1 set] (by David Woner)
 +
* [http://www.speedcubing101.com/eg-1.html More algs for EG1] (by Anthony Brooks)
 
* Speedsolving.com: [http://www.speedsolving.com/forum/showthread.php?t=5184  EG(D?) 2x2 method- 12.35 move avg.]
 
* Speedsolving.com: [http://www.speedsolving.com/forum/showthread.php?t=5184  EG(D?) 2x2 method- 12.35 move avg.]
 +
* Speedsolving.com: [http://www.speedsolving.com/forum/showthread.php?t=18486 Good EG + CLL Algorithms]
 +
* [https://docs.google.com/leaf?id=0B1HP6i5J4mf9ZTY3NTY5OTQtMzdkNC00OTBjLTgyOTgtZGZmYjgzNDgzNDY1&hl=en_US EG2 Algorithms Word Doc]
 +
* [http://cyotheking.squarespace.com/ Christopher Olson's Page w/ EG Algs]
 +
* [https://www.speedcubingtips.eu/cll-corners-of-the-last-layer-2x2x2/ speedcubingtips.eu's CLL algs]
 +
* [https://www.speedcubingtips.eu/eg-1/ speedcubingtips.eu's EG-1 algs]
 +
* [https://www.speedcubingtips.eu/eg-2/ speedcubingtips.eu's EG-2 algs]
 +
* [http://algdb.net Algorithm database containing all of the EG algs]
  
  
[[Category:Methods]]
+
[[Category:2x2x2]]
[[Category:2x2x2 Methods]]
+
[[Category:2x2x2 speedsolving methods]]
[[Category:2x2x2 Speedsolving Methods]]
+
[[Category:2x2x2 methods]]
 +
[[Category:2x2x2 substeps]]

Revision as of 10:01, 6 August 2019

EG method
Eg method.gif
Information about the method
Proposer(s): Erik Akkersdijk
Gunnar Krig
Proposed: 2006
Alt Names: none
Variants: CLL
No. Steps: 2
No. Algs: 128 (including PBL)
Avg Moves: 12.35
Purpose(s):

The EG method (Erik-Gunnar), so far only used for the 2x2x2 cube, only has two steps: solve one face, and then finish the entire cube in one algorithm. Without reflections, it requires 128 algorithms. There are 3 bottom layer cases that each require the same amount of algorithms as CLL. Those that know CLL already know 1/3rd of EG. The other two groups of cases have a T permutation on bottom (EG 1), and a Y permutation on bottom (EG 2).

CLL first layer
EG 1 first layer
EG 2 first layer

EG is by far the best method for solving the cube in one look, many scrambles have an easy first layer so it is often easy to see the whole solve in the inspection, this is the strongest reason for learning EG, most other times you are better off using CLL. This because of the many cases, it takes a great lot of practice to learn to do all fast (in EG 1 it is not only the case and alg, you also have to remember on which side you need to put the FL pair before the alg) but the worst problem with EG is the AUF's you get in EG 1 (that occures 4:6 times). You need to AUF first before and then after the alg and it is not possible to pre AUF like it is in CLL because of the need of the first AUF (you got to have LL aligned propely to the pair in the first layer to swap the correct FL pieces). CLL has got a more complicated first layer on average but you regain it in the end.

The best is probably to learn EG but use CLL for all cases where you cannot see the whole solve in the inspection.

LEG-1

LEG-1 (2x2x2) method
Information about the method
Proposer(s): Christopher Olson
Proposed: 2014
Alt Names: none
Variants: EG-1
No. Steps: 2
No. Algs: 42 (including PBL)
Avg Moves:
Purpose(s):


LEG-1 Is just like an EG-1 except you hold the bar on left, not on the back. That saves you a rotation after bulding a face so you can go straight into your alg. Though some of the algs for LEG-1 are not as good as EG-1, so its recommended to learn full EG first and then learn LEG-1.

EG 2 or not?

Some cubers have only learnt CLL and EG1 because you can cancel the last moves of making a face with 'R2 F2 R2' (0+0 PBL) if you see that you will have a EG 2 case, giving you a CLL case.

Another method that has been used for EG 2 is to inverse solve LL using normal CLL, say you have EG 0 and CxLL H D, then you can use the CLL for CxLL H U that will "solve" LL to diagonal permut and then add the permutation for PBL 0+0 in the end. In some cases, like this, the alg ends in R2 so the only extra turn you need to add is the F2, like this; orginal CLL R2 U2 R U2 R2 makes R2 U2 R U2 F2 R2 to solve the inverse CLL and 0+0 PBL. All CLL's have an inverse CLL, to look at the pairs just set up one case and do the 0+0 PBL (R2 F2 R2) and you will have the inverse instead. It is also possible to insert a single F2 PBL in the middle of a CLL alg if pieces are in correct position but this will not always solve the inverse case but some diffrent one, this shows that; null alg R U2 R - R' U2 R', with insert R U2 R F2 R' U2 R' (you have to test it on a cube to see the effect of the insert).

Those who learn EG and chooses to 'cheat' in the EG 2 part should be aware of the fact that the EG 2 cases are often easy to solve, if you add the permutation in the last part of the first layer you also add turns, naturally, but you may also get a longer alg for the CLL than you would have gotten for the EG 2 case, you will loose double those times. On average you can improve a good bit by learning also the last part of the method.

EG for 3x3?

It is possible to use EG for the 3x3x3 cube as a columns first method but with a different set of algorithms. The idea is to orient four pairs without minding relative order and then sort the pairs and solve CLL using a EG algorithm, one that preserves the pairs, "Pairs EG" or PEG. But this has only been tested as a experimental method so far.

See also

External links