Random Nameless Columns First-like Method

[Erzz]

I just had this random idea for a Columns First method. I got bored so generated algorithms for it. It's just for fun, it isn't good for speed. At least, I don't think so.
Still no idea what to call it. Post ideas if you have them.
General Idea:
1) Four F2L pairs, no cross edges
2) Fix centers if needed (M and S turns, intuitive)
3) CxLL, as long as it doesn't affect the E slice or D corners you can use it.
4) Orientate the edges.
5) Separate the edges into their correct slices.
6) Solve the M slice.
7) Do a y/y' and solve the new M slice.

Step One​

Step One is intuitive. If you really need to, you can use your Fridrich algorithms. For the first few pairs you can insert them with just R or F if they are paired. You can also use the M slice without worrying about messing up the cross.
A better way to do it would be to do it Roux-style with block building, leaving out the DL and DR edges.

I shouldn't need to say anything about step 2.

Step Three​

There are many different alg sets you can use here. CMLL, COLL, modified CLL, etc. Whichever method you use, there will be 42 algorithms.
You can check the wiki for algorithms, or this thread, or this site, or this video, as well as many others.
You could also just use OLL algorithms to flip the corners, then A perms / T perms / Y perms / etc to solve the corners.

The columns are done now.

Step Four​

This can be done intuitively, or you can use algorithms. I do it intuitively, so I didn't generate algorithms for this step. You can look at some Roux tutorials for ideas on how to do this.
I did find this algorithm accidentally though:
M d D M U M' S
It flips all the non-E edges. Might be useful, might be better ones out there.
If you're doing this intuitively, try to do step five at the same time, or at least avoid bad cases.

Step Five​

The M and S slice should only have edges in them that have stickers the same colour as the centers of that slice. So if you start with white on D, and the M slice has White/Blue/Green/Yellow, then the White/Blue, White/Green, Yellow/Blue, and Yellow/Green edges should be in the M slice.

There seems to be 13 cases for this step. For recognition, just find all the pieces that don't belong in each slice. If there is one from each slice in the same layer, there is an adjacent swap. If there is just one from a slice in a layer, there is also one from the other slice in the other layer. That's when you need the algorithms that say UF<->DF and such.

If you don't want to learn 13 algorithms, just learn the Adj on U one and the UB<->DB one.

(<-> just means "these two edges are being switched")

Algorithms

Spoiler

Adj = L<->B
Z = L<->B, R<->F
Square brackets are for AUF/ADF.
--
Adj on U
[U' D] R' U' R U R U R U' R'
--
Adj on U, UF<->DF
M U2 M' U' M' U2 M' U M2
M2 U' M U2 M U M U2 M'
--
Adj on U, UR<->DR
[U' D'] M2 U M' D2 M U M' U2 M'
[U D'] M U2 M' U M' U2 M' U' M2
--
Adj on D
[U'] M2 D M' U2 M D' M2
--
Adj on D, UF<->DF
[U2] M2 D M' U2 M D M' D2 M'
--
Adj on D, UR<->DR
[U2 D'] R2 U' M U2 M2 U2 M U R2
[U2 D'] R2 U' M' U2 M2 U2 M' U R2
[U' D'] M2 D' M' D2 M' D' M U2 M'
[U' D'] M2 D' M' U2 M D' M' D2 M'
bleh...
--
Both Adj
[U'] M U2 S U S' M'
[U2 D'] M U' D' M' U' M (U' D) M'
--
Both Adj, UR<->DR
[U' D'] M' S' U S D2 M
[U D] M (U' D) M' U M U D M'
--
Both Adj, UF<->DF
S U2 M D' M' S'
M2 U' M U2 M (U' D) M' U2 M
--
Z on U, Adj on D
[D2] M2 U M2 U M U2 M' D' M' U2 M
--
Z on D, Adj on U
No "good" alg yet... Use one of these for now
[U2 D] M U2 M U M U2 M D' M2 D' M2
[U2 D] M D2 M' U M' D2 M D' M2 D' M2
[U2] M2 D' M2 D' M' D2 M U M D2 M'
--
Double Z
M2 U' M2 U' D M2 D M2
--
UB<->DB
M' U' M2 U2 M2 U' M
M' U M2 U2 M2 U M

Fix the columns after doing these.

Step Six​

The case names come from 4c here.
Since both slices are unsolved, there can be 2 edges switched anywhere in each of those cases. Since there are 4 sides to a slice, there are 16 (4 cases * 4 switches) more cases that can come up. Unfortunately they aren't as short as the normal cases.

They are separated by where the switch is. So if you look under "Half-a-Dot", then under "F:", those will solve the Half-a-Dot case when UF and DF are switched.

If everything is solved except for the switch, put the switch on U and rotate, then do one of these algorithms on the other slice.

Algorithms

Spoiler

Half-a-Dot:
U/D:
H perm. If D you skip the first M2.
F:
U M2 U2 M2 U' M U2 M'
U' M2 U2 M2 U M U2 M'
M' U2 M U M2 U2 M2 U'
M' U2 M U' M2 U2 M2 U
B:
Same as F but switch direction of the Ms.
--
Dot: (I'm not sure if you can actually get this with this method)
U:
Same as D, but end with M2.
D:
U M U2 M2 U2 M' U'
U M' U2 M2 U2 M U'
U' M U2 M2 U2 M' U
U' M' U2 M2 U2 M U
F:
M U2 M U M2 U2 M2 U'
M U2 M U' M2 U2 M2 U
B:
Same as F but with M'.
--
Fuu~:
U:
M U M2 U2 M2 U M
M U' M2 U2 M2 U' M
D:
U M2 U2 M2 U' M U2 M'
U' M2 U2 M2 U M U2 M'
M' U2 M U M2 U2 M2 U'
M' U2 M U' M2 U2 M2 U
F:
U M2 U2 M2 U M U2 M U2
U2 M' U2 M' U M2 U2 M2 U
U2 M' U2 M' U' M2 U2 M2 U'
U' M2 U2 M2 U' M U2 M U2
B:
U2 M U M2 U2 M2 U M U2
U2 M U' M2 U2 M2 U' M U2
--
Worse than Fuu~:
U:
M' U M2 U2 M2 U M'
M' U' M2 U2 M2 U' M'
D:
U M2 U2 M2 U' M U2 M
U' M2 U2 M2 U M U2 M
M' U2 M' U M2 U2 M2 U'
M' U2 M' U' M2 U2 M2 U
F:
U2 M' U M2 U2 M2 U M' U2
U2 M' U' M2 U2 M2 U' M' U2
B:
U2 M U2 M U M2 U2 M2 U
U2 M U2 M U' M2 U2 M2 U'
--

Step Seven​

Step seven is just the cases from 4c here.
After this the cube should be solved. If not, I probably didn't explain well enough.

Move count should definitely be below 70, I think. 75 algorithms or so.

PS: Stachu's aCube GUI is very useful. I might re-generate these algorithms after aCube 4 comes out.

 

[y235]

Step Seven​

Step six is just the cases from 4c here.

...

 

[5BLD]

It's abit like just Roux but you insert edges later. And have some difficult edge orientation...
It even ends exactly like Roux.

 

[Erzz]

...

Oh wow, how did I miss that. Fixed.

It's abit like just Roux but you insert edges later. And have some difficult edge orientation...
It even ends exactly like Roux.

I had originally been doing corners first, then each slice individually after EO and separation. But that was way too many algs so switched to columns. It was all based on that last step of Roux from the beginning though.

 

[5BLD]

Ah right... But either way, it's an interesting method. I've always been a fan of columns methods, although they are inefficient...

 

[Jorghi]

If you want efficient then do fridrich with a line instead of cross.

 

[5BLD]

If you want efficient then do fridrich with a line instead of cross.

No. That's supa dupa inefficient. Imagine inserting the cross edges with M U M or S U S variants. May as well do the whole cross.
Whilst in ZZ, there's a line, and edges oriented. That lets you have that ergonomy, and that RUL set. It also saves me from learning full OLL

If you are thinking of doing CFOP with more freedom, maybe start with a block like 2x2x2 or 2x2x3? Like FreeFOP.

 

[Jorghi]

Lol 42 F2L cases is enough for recognition, and when you have the cross finding edges is easier from top view. And you only need to lookahead/recognise 2 pieces. Efficient blockbuilding sometimes makes you look for 2+ which theoretically will take longer.
And blockbuilding is still usually solved in 4 looks(ZZ).
Its more efficient but it depends how fast you can even solve EOline.

efficiency vs. simplicity.

 

[Kirjava]

Recog for step5 is surprisingly good. Also, you shouldn't need to learn algs for it.

Wow, this is fun. I've been blending the steps from 2 - 3 and 4 - 6 though. No difficultly with CN.

So many lucky cases to force wtf.

number of times: 12/12
best time: 22.76
worst time: 44.09

current avg5: 28.09 (σ = 3.65)
best avg5: 26.58 (σ = 1.54)

current avg12: 30.08 (σ = 4.05)
best avg12: 30.08 (σ = 4.05)

19.87 single ftw

ok, doubleturn conjugation is powerful for <M,S> solving.

lots of edits here

 

[5BLD]

Lol 42 F2L cases is enough for recognition, and when you have the cross finding edges is easier from top view. And you only need to lookahead/recognise 2 pieces. Efficient blockbuilding sometimes makes you look for 2+ which theoretically will take longer.
And blockbuilding is still usually solved in 4 looks(ZZ).
Its more efficient but it depends how fast you can even solve EOline.

efficiency vs. simplicity.

Mm... Well... Now if I'm not mistaken you are talking about normal CFOP now...

Blockbuilding... In blockbuilding we blend steps of making blocks anyway...

And hold on...

Efficient blockbuilding will sometimes make you look for 2+ which theoretically will take longer

Eh? Looking for more pieces is good; and we get used to it. And know where the pieces are; thus reducing hesitations. If you say in f2l you only look for two pieces a slot... Then it'll be slow because you keep having to 'look'. The idea is looking ahead, which voids the above quote.

Efficiency vs simplicity yes. But you need a balance. You have stated the two extremes... Looking for only two pieces, and excessive efficiency. In reality, we always try to get a balance no matter what method we use.


@kirjava
Hm... I might actually give it ago... Sounds interesting to use.

 

[Cool Frog]

I played with columns first for a while, (was planning on learning all L5E cases (LOL))

Need to try this out some time. (I love how efficient you can make the first 4 columns))

 

[Kirjava]

number of times: 12/12
best time: 19.68
worst time: 35.56

current avg5: 22.18 (σ = 1.48)
best avg5: 22.18 (σ = 1.48)

current avg12: 23.40 (σ = 2.61)

 

[5BLD]

number of times: 11/12
best time: 19.80
worst time: 40.18

current avg5: 26.90 (σ = 3.02)
best avg5: 26.90 (σ = 3.02)

current avg12: 31.44 (σ = 5.29)
best avg12: 31.44 (σ = 5.29)

It's an interesting method actually. I suggest calling it the RNCF method... for obvious reasons.

 

[Athefre]

Nice to have someone trying to create serious and logical ideas.