A few K4 questions

[LearningCode]

The steps for the K4 are as follows:
1) Two Opposite Centers
2) 1x3x4 Block
3) Centers in the M ring
4) First Layer
5) F3L
6) Corners
7) ELL

However, I got lazy and do it this way:
1) Two Opposite Centers
2) 1x3x4 Block
3) Make 3 more Edges*
4) Centers in the M ring (Without destroying Edges made in Step3)
5) 3x3x4 Block
6) F3L (While influencing last layer edges to have a 3-cycle)
7) Solve remaining U-layer edges using intuitive commutators
8) OLL
9) PLL

* The 3 edges are as follows:
1) One Edge has to be the 4th edge from the First Layer.
The 1x3x4 block has 3 edges from the First Layer, building this 4th edge will let us complete the first layer easily later on.

2) The other two edges have to extend the 1x3x4 block into a 3x3x4 block later on.



It (Obviously) has more steps and is, therefore, slower.
However, I do like to think that "Making 3 more edges" (Step-3) saves time later on for the F3L.
And influencing the Last layer while doing the F3L saves me time and tiring memorization because I can use intuitive commutators to solve the remaining edges.

So..
What are your thoughts?
Go for the proper K4 or just stick with my lazy-man's method? o.0

[EDIT]
I 'store' the 3 more edges that I make in Step-3 in the 'U-layer'
Like, if my 1x3x4 block has white as it's base, the other 3edges will be at yellow and form its own temporary 1x3x4 block.
(So that it won't be broken apart when I move on the Step-4)

 

[Kenneth]

Paring up and then orient and permute the LL edges is not the best. If you just solve the corners and then 'pair' the edges into their correct positions using the comutators you will save moves.

The edges have no orientation really, just permutation = you cannot have it wrongly oriented in it's correct position.

 

[LearningCode]

.
So I just change steps 7 - 9?
Guess I'll learn all the CLL and ELL algorithms ><

 

[deepSubDiver]

.
So I just change steps 7 - 9?
Guess I'll learn all the CLL and ELL algorithms ><

There is nothing to learn. ELL is pretty much intuitive (except for some useful parity cases). CLL can be skipped by solving CP just before the F3L and then applying the appropriate 2Gen-OLL. This works pretty well for me and doesn't require much new algorithms.

 

[LearningCode]

Umm..
I didn't understand that ><

"CLL can be skipped by solving CP just before the F3L"

When I start on the F3L, 2 edges* are solved, 2 edges* are still 'scrambled'
If I solve CP then work on the F3L, inserting and solving the 2 scrambled edges will always scramble CP O_O

* The edges that belong to the 2nd and 3rd layer.

 

[deepSubDiver]

CP will stay since you can use commutators during F3L that only manipulate the edges.

 

[LearningCode]

Hmm..
That might be more work for me, though..
I'll try ^^

[EDIT]
I just tried it.
Got a case where I would need two 3-(edge? wings? What do you call them?)-cycles to get the correct permutation =/
Well, one 3-cycle and an edge parity, actually, Am I doing anything wrong? o.0

 

[Kenneth]

No, you get the paritys = 2-cycle or a 4-cycle. Read the parentesis in deeps first post again =)

To fix it you need one alg, any that does parity will do. But if you like to direct solve the parity = solve two dedges and do the last two in one go, parity and all it is more cases. 10 if you leave two opposite dedges, more if you leave adjacent (you get mirror cases and cannot just do y2 as for the opposites in some of them).

This is a decently short parity alg, a pure 2-cycle : L Rw2 (U2 l U2 r' U2 r U2) x' (U2 r U2) Rw

The first L you can leave to the end if you like, I do it first because I like the ending I get then.

Another option is this '2-gen', that makes a 4-cycle : (Rw' U2 r2 U2 Rw) (U2 r U2) (Rw U2 r2 U2 Rw')

The mirror alg or the inverse of this does the cycle in the other direction.

Edit: hehe, lololol, the algs I pasted was from my 3x3x4 page, all U2 was notated as U (on the 3x3x4 fliped sideways you can only do U2, not U or U' so it is only one possible U-move, you only need to notate the side). Fixed it now =)