• Welcome to the Speedsolving.com, home of the web's largest puzzle community!
    You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

    Registration is fast, simple and absolutely free so please, join our community of 40,000+ people from around the world today!

    If you are already a member, simply login to hide this message and begin participating in the community!

Z1hc

Member
Joined
Apr 30, 2021
Messages
8
Location
309 Ben brown ln Woodburn or
Here’s a method idea but for 2x2

Step 1: Make a V on the bottom so just FRD is unsolved.

Step 2: Solve BLU corner and orient the missing FRD corner of the bottom layer. Around 10 algorithms for this step.

Step 3: Solve the oriented FRD corner and everything else in one algorithm. Should be 216 algorithms.
 

LukasCubes

Member
Joined
Aug 10, 2020
Messages
806
Location
Idk
YouTube
Visit Channel
Here’s a method idea but for 2x2

Step 1: Make a V on the bottom so just FRD is unsolved.

Step 2: Solve BLU corner and orient the missing FRD corner of the bottom layer. Around 10 algorithms for this step.

Step 3: Solve the oriented FRD corner and everything else in one algorithm. Should be 216 algorithms.
nice i like where this method is going. It is a subset of 1LLS which is 614 algs and a subset of VR which is 3684 algs.
 

Z1hc

Member
Joined
Apr 30, 2021
Messages
8
Location
309 Ben brown ln Woodburn or
Thought of a method:
First step: EO and the line on the bottom like in zz.
Second step: Blockbuild but instead of solving normally you can solve it so you need to do an R,R’ or R2 to get it solved at the the end. Kind of like NMCLL. You do that for both sides.
last layer: I forgot what it was called but I’ll come and edit this later if I find it again. But you have to do 1 or 2 algorithms to put the Two side colors on the side. Here’s what I mean: L U’ R2 U R U’ R’ U L’ U’ R U R’ U’ R2 U. The two side colors are opposite so it’s easier to solve the cube.

last step just do L and R moves.
 

OreKehStrah

Member
Joined
May 24, 2019
Messages
686
How many algs are there for 1LLL with phasing? Would it be 4x OLLCP? That might be feasible.
I'm not gonna lie, I've been toying with the idea of letting learning phased 1LLL be my end-game alg set to learn after ZB, and a few other ZZ/Petrus alg sets
 

Athefre

Member
Joined
Jul 25, 2006
Messages
1,128
Yeah, it's NMLL. And that is actually why NMLL was developed. Non-matching blocks seemed interesting to use in ZZ, but there wasn't an easy to recognize LL method for non-matching blocks. So the idea was to find the L/R stickers since those stay consistent even when the left and right blocks don't match.

NMLL isn't the best LL method for speedsolving, but it is really interesting I think.
 

Thom S.

Member
Joined
Sep 26, 2017
Messages
491
Yeah, it's NMLL. And that is actually why NMLL was developed. Non-matching blocks seemed interesting to use in ZZ, but there wasn't an easy to recognize LL method for non-matching blocks. So the idea was to find the L/R stickers since those stay consistent even when the left and right blocks don't match.

NMLL isn't the best LL method for speedsolving, but it is really interesting I think.
I actually used NMLL semi-regularly for a Month. Problem is, when you do one colour every time, you look at OLL and PLL only by one Colour. When you go to things like COLL, CMLL and OLLCP, you learn to look at the relationships that colours have (matching, adjacent, opposite) in order to recognise the case. When you do NMLL(with any of the big three) you can't go by that alone, you need to learn how every case needs the pieces to be moved.
So eventually you do thousands of solves and drills to learn a whole new recognition system and you save 7 moves on good cases.
My Opinion but I did seriously use it for CFOP, Roux (the most), ZZ and Petrus in order to have this conclusion.
 

Athefre

Member
Joined
Jul 25, 2006
Messages
1,128
I actually used NMLL semi-regularly for a Month. Problem is, when you do one colour every time, you look at OLL and PLL only by one Colour. When you go to things like COLL, CMLL and OLLCP, you learn to look at the relationships that colours have (matching, adjacent, opposite) in order to recognise the case. When you do NMLL(with any of the big three) you can't go by that alone, you need to learn how every case needs the pieces to be moved.
So eventually you do thousands of solves and drills to learn a whole new recognition system and you save 7 moves on good cases.
My Opinion but I did seriously use it for CFOP, Roux (the most), ZZ and Petrus in order to have this conclusion.
Do you have an example?

It can be one of the best if not the best. Remember those variants I proposed in the method development discord server?
Yeah, those are definitely cool. It would be nice to get everything into a doc for those variants so we can really compare.
 

tsmosher

Member
Joined
Aug 30, 2020
Messages
509
  • Step 1. Roux SB + 1 (any L.edge) - 8 moves
Yes, Roux SB first!

Any oriented L.edge is positioned in DL.

The DR edge here can be any oriented U/D non-L.edge (i.e., any U/D edge except DL or UL), giving you a lot more flexibility in how you build this block.

To be clear, you can use DL or UL as well, but this limits you down to only 1 possible FB to build in the next step (down from the usual 4 possibilities).

  • Step 2. Roux FB - 15 moves
Insert two F2L pairs on the left, completing a (possibly non-matching) FB.

You have 2 options for your first F2L pair that will complete a square in dBR or dFR. This square can then be "swiveled" back and forth with L/L', giving you 2 options for the final F2L pair you insert.

  • Step 3. NMCMLL/NMCDRLL - 11 moves
I struggle with the name for this step. (While thinking up a name, it occurred to me that there is no name for a set of CLL algorithms which have no regard for EO but only affect the U layer.)

The algs used here can disturb DB, DF, or DR. (DL will always be solved and should be preserved.)

The algs here needn't preserve EO. (In fact, the centers do not even have to be aligned yet.)

NMCMLL recognition is used here. (This recognition works well when the M slice centers are "off" as they often will be.)

  • Step 4. L6E/L7E - 14 to 17 moves
Here is where it gets good.
  • Step 4a. 2 Opp EO - 9 moves
I hate the name of this step, but I do like keeping names consistent. (This is the name used by shadowslice in his proposal of 42.)

First, perform EOLR/EOBF/EOdM. (In other words, resolve EO whilst influencing UL/UR, UB/UF, or DB/DF into DB/DF.)

EO alignment would be decided by the alignment of your (righthand) Roux SB. By the end of this sub-step, U/D centers would need to be on U/D or vice versa.

Next, perform the AMFs/AUFs necessary to solve DB/DF, UL/UR, or UB/UF. (i.e., Cancel into M2 + U/U' as in the end of Roux step 4b.)

UB/UF would be solved into their proper positions, but their triplets would be moved to ul/ur for now with U/U'.

DB/DF should not require any AMFs/AUFs unless they are solved in their opposite positions (fixed by cancelling into M2 U2 M2).

This leaves us with the M slice edges and DR. (Or, in the case of EOdM, the U layer edges and DR.)

  • Step 4b. L4EP/L5EP - 5 to 8 moves
There are 3-4 possibilities for how to finish here:

If you have a proper Roux SB (i.e., DR is in DR), finish with EPLL (4 cases) if DB/DF are solved or L4EP (4 cases) if 2 U edges are solved. (L4EP is also commonly referred to as "Roux step 4c".) In this case, your solve would simply be a funky version of Roux.

If you do not have a proper Roux SB (i.e., DR is not solved):

If you solved DB/DF in (the previous) step 4a, finish with the L5EP-DR algorithm set (EPLL + 12 additional cases).

If you solved UL/UR or UB/UF in (the previous) step 4a, perform an x2/[r2] rotation, and finish with the RLSE-UO algorithm set (L4EP + 24 additional cases).

RLSE-UO recognition is identical because UL will be always be solved after rotating. Recognition is made slightly harder due to non-matching blocks though.

Note: if you don't mind the algs being <MD> (instead of <MU>) and the recognition being different (read: probably harder), you can avoid this x2/[r2] rotation entirely and solve L5EP using <MD> algs.

  • Un-transform (AUF/ADF/ALF) - 2 moves
Total: 50 to 53 moves (+ x2/[r2] possibly)



Admittedly, ergonomics of this method are not ideal. Perhaps you could build everything as in Roux (with DL in Roux FB being flexible) then do a d2/y2/[u2] after F2B. However, in my opinion, this extra move/rotation seems unnecessary when you consider the fact that inserting 2 F2L pairs on the left would be completely ordinary in CFOP or ZZ.



Another CP-first idea I've toyed with but not listed here.

(Any slice move can be used at any point during the solve.)
  • CP line (<RrUuFf>) - 5 moves
  • 3QB (<RrUu>) - 7 moves
  • EOdM (<RrU>), preserving belt edges - 11 moves
  • F2L pair with last belt edge (<RU> only), completing belt - 7.5 moves
  • CLS (<RU> only), solving L5C - 10 moves
  • L5EP-DR - 8 moves
Total: ~49 moves STM

You will want to look ahead and find the last belt edge (probably also DB and/or DF) during 3QB to make EOdM one-lookable.

Also, orienting one additional edge (e.g., into DB as prescribed in YruRU) during 3QB would greatly reduce the case count for EOdM.

Some CLS algs would need reworking to conform to the <RU> move set.

Everything else should be pretty straightforward.



Roast me!
 
Last edited:

LukasCubes

Member
Joined
Aug 10, 2020
Messages
806
Location
Idk
YouTube
Visit Channel
I dont see much 2x2 in this

How about, this
1: Solve 2 Adjacent Corners and put them in DL kinda like a Mehta FB (~1.5 Moves)
2: Solve the last 2 corners of the first layer randomly using only R and U moves. (~2.5 Moves)
3: L6C in 1 look. (~9 Moves)


Pros:
1. Easy to 1 look because steps 1 and 2 can be done simutaniously
2. Low Movecount (same as EG)
3. Common to see entire step 1 skips
4. 5 Moves maximum is all it takes to get to the last step
5. Some algs are shorter (4-6 Moves with some algs)
6. All cases easy to recognize. CLL, Any TCLL, For Bottom 2, only 6 cases.

Cons:
Alot of algs
R and U moves arent the best moves on 2x2
3 steps instead of 2 like in CLL, EG, TCLL, VR, 1LLS, etc.

The movecounts are not counting cases with skips. Steps 1 and 2 are not rare to have skips on.

for L6C, there are 687 algs and are divided into 16 subsets (15 with 43 algs and 1 with 42 algs)

1. 42 CLL
2. 43 LEG-1
3. 43 TCLL+
4. 43 TCLL-
5. 43 BTCLL+
6. 43 BTCLL-
7. 43 TLEG+
8. 43 TLEG-
9. 43 tCLL
10. 43 tLEG-1
11. 43uCLL
12. 43 uLEG-1
13. 43 tuCLL
14. 43 tuLEG-1
15. 43 utCLL
16. 43 utLEG-1

some of these sets have bad names but some are good names.

after learning all algs, if you get lucky, you can user gods number method on here. This is just a start tho.
 

PapaSmurf

Member
Joined
Jan 4, 2018
Messages
979
WCA
2016TUDO02
YouTube
Visit Channel
  • Step 1. Roux SB + 1 (any L.edge) - 8 moves
Yes, Roux SB first!

Any oriented L.edge is positioned in DL.

The DR edge here can be any oriented U/D non-L.edge (i.e., any U/D edge except DL or UL), giving you a lot more flexibility in how you build this block.

To be clear, you can use DL or UL as well, but this limits you down to only 1 possible FB to build in the next step (down from the usual 4 possibilities).

  • Step 2. Roux FB - 15 moves
Insert two F2L pairs on the left, completing a (possibly non-matching) FB.

You have 2 options for your first F2L pair that will complete a square in dBR or dFR. This square can then be "swiveled" back and forth with L/L', giving you 2 options for the final F2L pair you insert.

  • Step 3. NMCMLL/NMCDRLL - 11 moves
I struggle with the name for this step. (While thinking up a name, it occurred to me that there is no name for a set of CLL algorithms which have no regard for EO but only affect the U layer.)

The algs used here can disturb DB, DF, or DR. (DL will always be solved and should be preserved.)

The algs here needn't preserve EO. (In fact, the centers do not even have to be aligned yet.)

NMCMLL recognition is used here. (This recognition works well when the M slice centers are "off" as they often will be.)

  • Step 4. L6E/L7E - 14 to 17 moves
Here is where it gets good.
  • Step 4a. 2 Opp EO - 9 moves
I hate the name of this step, but I do like keeping names consistent. (This is the name used by shadowslice in his proposal of 42.)

First, perform EOLR/EOBF/EOdM. (In other words, resolve EO whilst influencing UL/UR, UB/UF, or DB/DF into DB/DF.)

EO alignment would be decided by the alignment of your (righthand) Roux SB. By the end of this sub-step, U/D centers would need to be on U/D or vice versa.

Next, perform the AMFs/AUFs necessary to solve DB/DF, UL/UR, or UB/UF. (i.e., Cancel into M2 + U/U' as in the end of Roux step 4b.)

UB/UF would be solved into their proper positions, but their triplets would be moved to ul/ur for now with U/U'.

DB/DF should not require any AMFs/AUFs unless they are solved in their opposite positions (fixed by cancelling into M2 U2 M2).

This leaves us with the M slice edges and DR. (Or, in the case of EOdM, the U layer edges and DR.)

  • Step 4b. L4EP/L5EP - 5 to 8 moves
There are 3-4 possibilities for how to finish here:

If you have a proper Roux SB (i.e., DR is in DR), finish with EPLL (4 cases) if DB/DF are solved or L4EP (4 cases) if 2 U edges are solved. (L4EP is also commonly referred to as "Roux step 4c".) In this case, your solve would simply be a funky version of Roux.

If you do not have a proper Roux SB (i.e., DR is not solved):

If you solved DB/DF in (the previous) step 4a, finish with the L5EP-DR algorithm set (EPLL + 12 additional cases).

If you solved UL/UR or UB/UF in (the previous) step 4a, perform an x2/[r2] rotation, and finish with the RLSE-UO algorithm set (L4EP + 24 additional cases).

RLSE-UO recognition is identical because UL will be always be solved after rotating. Recognition is made slightly harder due to non-matching blocks though.

Note: if you don't mind the algs being <MD> (instead of <MU>) and the recognition being different (read: probably harder), you can avoid this x2/[r2] rotation entirely and solve L5EP using <MD> algs.

  • Un-transform (AUF/ADF/ALF) - 2 moves
Total: 50 to 53 moves (+ x2/[r2] possibly)



Admittedly, ergonomics of this method are not ideal. Perhaps you could build everything as in Roux (with DL in Roux FB being flexible) then do a d2/y2/[u2] after F2B. However, in my opinion, this extra move/rotation seems unnecessary when you consider the fact that inserting 2 F2L pairs on the left would be completely ordinary in CFOP or ZZ.



Another CP-first idea I've toyed with but not listed here.

(Any slice move can be used at any point during the solve.)
  • CP line (<RrUuFf>) - 5 moves
  • 3QB (<RrUu>) - 7 moves
  • EOdM (<RrU>), preserving belt edges - 11 moves
  • F2L pair with last belt edge (<RU> only), completing belt - 7.5 moves
  • CLS (<RU> only), solving L5C - 10 moves
  • L5EP-DR - 8 moves
Total: ~49 moves STM

You will want to look ahead and find the last belt edge (probably also DB and/or DF) during 3QB to make EOdM one-lookable.

Also, orienting one additional edge (e.g., into DB as prescribed in YruRU) during 3QB would greatly reduce the case count for EOdM.

Some CLS algs would need reworking to conform to the <RU> move set.

Everything else should be pretty straightforward.



Roast me!
This is essentially Roux in a different order, but adding in an extra edge for the sake of it. It's definitely not an improvement and is probably a hinderance as LSE and SB are already not that bad. It's less efficient than Roux too.
 

tsmosher

Member
Joined
Aug 30, 2020
Messages
509
This is essentially Roux in a different order, but adding in an extra edge for the sake of it. It's definitely not an improvement and is probably a hinderance as LSE and SB are already not that bad. It's less efficient than Roux too.
I add the extra edge personally if it is hard to insert the proper DL edge. (e.g., It is located in FL or BL and would take 3+ moves to relocate.) This method was just me thinking of a way to make the edge I don't care about be the DR edge (for ergonomics and for certain alg sets such as CDRLL) instead of the DL edge.

I also like how you can plan the entire intuitive part of the solve in inspection if you are color neutral. FB+1 is essentially just a triplet, half belt, and an oriented Redge. (8-9 moves. EOCross or EO222 are harder than that.) F2L, CLL, and L7E can then be entirely algorithmic.

This is very much Roux though- with more freedom in how you build FB and SB.

Fair points though. Thanks for checking it out!
 

CubetyCubes

Member
Joined
Oct 7, 2021
Messages
12
Location
The Earth
A new method! The EPCL method! (Pronounced ep-cle not ee-pee-see-el). EPCL is a type of columns first method designed to be weird but unique. It was supposed to be similar to Roux and ZZ but it ended up being similar to SSC(Shadowslice Snow Columns) instead. Also, this is more of a fun method rather than a speedsolving method because it’s pretty inefficient and stuff.
Number Of Algs: 58-60
I will add the stats when the method gets more developed.
The major 4 steps are:
EOCross (Edge Orientation cross)
Pairs
COLL (Corners of Last Layer)
L8E (Last 8 Edges)

Orientate all the edges in the cube and make an unpermutated cross instead of a normal cross to lower movecount. A mixed cross is just a cross at the bottom but the center and edge colours don’t have to match. Just ZZ’s eoline without with a mixed cross.

Make 4 corner edge pairs (f2l pairs) and solve them. This, like ZZ, is efficient because you don’t have to use F or B moves, making it rotation less. An option is to have the corners unoriented when you so, the pairs, then you solve the corners with one out of two algorithms. If you do this, remember that, if the corner and the pairs have one of the same colors (eg, white red blue corner paired with a green red edge), then make sure none of the colors match. If none of the colors match (eg, white red blue corner pair with green orange edge), make sure the opposite colors(blue/green, red/orange, white/yellow) are matching.

Just use the COLL algs and the d corner algs if unoriente..

Solve the remaining 8 edges by first, solving parity if needed(use M2 U2 M2), and then solving them with an algorithm (EZD Algs).

Algorithms:
L8E (EZD Algs)
H both layers: M2 U2 M2 y M2 U2 M2
Z Top H Bottom: M2 D' R2 (U D') M2 (U' D) L2 U M2
Ua Top H Bottom: (U) M2 D M' D M2 U' M2 D M D M2
Ub Top H Bottom: R2 (U' D) M2 D M' U2 M' U' M2 D2 L2
H Top Z Bottom: M2 U' L2 (U D') M2 (U' D) l2 U M2
Both Layer Z: M2 D' M2 (U D) M2 U' M2
Ua Top Z Bottom: M2 D M' U2 M' (U D') M2 U M2
Ub Top Z Bottom: M2 D' M' U2 M' (U' D) M2 U' M2
H Top Ua Bottom: (D) M2 U M' U M2 D' M2 U M U M2
Z Top Ua Bottom: M2 U M' D2 M' (U' D) M2 D M2
Ua Both Layers: M' (U' D) M2 D2 M' U' M' (U' D) M (U')
Ub top Ua Bottom: L2 (U' D) r2 U M2 U' l2 (U' D) L2H top Ub Bottom: M2 U2 M2 D' M2 U M' U2 M U' M2
Z Top Ub Bottom: M2 D' M2 (U D') M D2 M U' M2
Ua Top Ub Bottom: L2 (U' D) R2 U M2 U' L2 (U' D) L2
Ub both layers: M' (U' D) M2 U2 M' D M' (U' D) M (D)

D Layer Corner Algs (there’s a selection)
Adjacent Swap Alg list
R2 U F2 U' D' F2 D R2 (8stm*)
R2 U' R2 U2 F2 D' F2 D (8stm*)
R2 U' R2 D2 B2 D' B2 D' (8stm*)
R2 D R2 U' D' R2 U R2 (8stm*)
R2 D R2 D2 F2 U F2 D (8stm*)
R2 D' F2 U D F2 U' R2 (8stm*)
D B2 U' B2 U2 R2 D' R2 (8stm*)
D' F2 U' F2 D2 R2 D' R2 (8stm*)
D' F2 D F2 U2 R2 U R2 (8stm*)

Diagonal Swap Alg list
R2 F U2 M2 U2 F r2 (7stm*)
R2 F D2 M2 D2 F r2 (7stm*)
R2 F' U2 M2 U2 F' r2 (7stm*)
R2 F' D2 M2 D2 F' r2 (7stm*)
R2 B R2 E2 R2 B R2 (7stm*)
R2 B' R2 E2 R2 B' R2 (7stm*)
F2 R U2 S2 U2 R B2 f2 (7stm*)
F2 R D2 S2 D2 R B2 f2 (7stm*)

If you have any ideas or suggestions let me know!
Also if this method already exists then let me know.
 
Last edited:

xyzzy

Member
Joined
Dec 24, 2015
Messages
2,440
What do you do if the pair edges are trapped in DF or DB? (DL and DR are also problematic, albeit a bit less so.)

Also you can probably find better CLL algs if you're only preserving pairs and EO, eg. F R2 U' R2 U R2 U R2 F'.
 
Top