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.

1. Solve the MIDDLE layer. About 8-9 moves, pretty easy and intuitive. This is where I get the M

2. Orient all corners. There is probably like 200 algs for this so maybe it could be split in 2 steps but say 11-17 moves. This is the CO.

3 and 4. Orient then permute all edges with 2 algorithms. I think you only need 7 algs for orientation. Probably about 21 moves. This is E

5. Permute all corners maybe 13 moves. CP

Probably a lot to learn, but who knows. I had a far fetched but plausible idea for advanced cubes to do middle layer then an alg for putting all peices in the right layer AND Orienting edges then just doing ZBLL on both sides.

Edit: that wouldn't work because you would have parity or something.

Woah, cool graph! I didn't see Diaper, ZBLBL, or SF2L so that makes me happy to know that I understood enough methods to avoid repeating myself. Though I expected to see BLL there (and I did) because it was what seemed to me the most natural progression when I figured it out.

I've gotta come up with something different yet just as efficient if not more so than other methods. That's my goal.

It is interesting, but not practical for speed. I made a try with commutators. If someone improves that method, could result into something interesting for solving for fun, but I don't know if it will be useful for FMC or speed.

What would be the alg count for ELL including both parities? 116?

Other than things like bad recognition and high alg count, this seems like it's at least worth some thought for 4x4. Yau/CFCE with the E including solution to either or both parities would guarantee a 2 look last layer.

What about OLL including OLL parity and PLL including PLL parity? Is it as simple as being twice the number of OLLs and PLLs?

I considered this worth some thought a few weeks ago and only just found this post. I started making algs but never finished the cases because I'm lazy.

Edit: I messed this up earlier, I'm a little tired I guess. I only looked at ELL when there's OLL parity, which is a total of 48 cases. I never finished making algs, might tidy up what I have and post at some point.

...or you could use Petrus (or Roux). The number of algs for step 4 could be quite high unless you split it into two steps, considering that there are still 7 unsolved edge slots. Additionally, one of the nicest things about L6E (the fact that it can be done just <M,U>) is lost. I can't see this catching on, except, as previously mentioned, perhaps a bit for FMC.

Not a method or subset or anything, but out of curiosity, has anyone ever tried 3x3 speedsolving where the solved position is any that has all of the pieces permuted with orientation disregarded? I tried it and it seems kind of fun, but I think it would become so easy after a while that single times would become outlandishly fast and luck would play way too big a role.

Not a method or subset or anything, but out of curiosity, has anyone ever tried 3x3 speedsolving where the solved position is any that has all of the pieces permuted with orientation disregarded? I tried it and it seems kind of fun, but I think it would become so easy after a while that single times would become outlandishly fast and luck would play way too big a role.

Recently I did something similar: I tried to "solve" the cube into the superflip position from a scrambled position. It's fun how you have to treat all the edges with their other orientation!

People usually solve 2x2x2 blocks with the BRD corner because you can see more of the cube throughout the rest of the solve and it helps with lookahead. Also, when did you solve the DR edge?

For step 4, you can easily insert these edges intuitively if you had the M layer free. I think it may be better to start off with a 1x2x3 block on the left like in Roux, then solve the ULB and DRB corners, then use an algorithm for the last 4 corners, then solve 3 edges in the right ide by inserting them, and then do LSE.

Now from this, you could make an improvement from doing CLL normally on the LL because you can AUF the last layer. There would be the same number of cases doing CLL how you proposed, but instead of doing an AUF, you would have to rotate the cube around a corner.

Also, I have had the idea I just described in my head for a while (I'll still let you claim it if you want), but I was thinking you could do RoFL CLL to improve the movecount a bit.

Recently I did something similar: I tried to "solve" the cube into the superflip position from a scrambled position. It's fun how you have to treat all the edges with their other orientation!

I have a friend who does that in blindsolving. He will memorize good edges instead of bad if there are less good than bad. At the end of the solve, he just does the superflip. Pretty neat.

Hi I just want to show a video of an example solve of my 4x4 method called the B4 method. The B4 name is short for Belt method for 4x4. Also sorry for some parts of the solve to be out of frame. The scramble I used was R B2 F' u2 B' f2 u f2 R' r2 f' L2 r2 F' L' U u L2 u2 U B U2 f2 D L2 R' B2 L' F U B r U' u f' F r2 R2 u B'. This method could be potentially use for speed solving if we all look at better algs for the this method. This method consists of 8 steps:
Step 1: solve 2 opposite centers
Step 2: solve 2 more opposite centers
Step 3: solve the edges that connect the 4 solved centers together
Step 4: Solve the remaining 2 centers
Step 5: orient the corners. In this step there is a parity where you get on unoriented corner in the U and D layer but in the solve I did I got lucky by not getting it.
Step 6: place corners into the correct layer
Step 7: position the corners into the correct spot
Step 8: solve remaining edges

You could swap steps 2 and 3 so that you solve the belt edges similarly to Yau's first 3 cross edges. Should be more efficient and if you place them before solving the rest of the centres, then making the other centres can also be done as fast as Yau, except using slice moves instead of wide moves.

You could swap steps 2 and 3 so that you solve the belt edges similarly to Yau's first 3 cross edges. Should be more efficient and if you place them before solving the rest of the centres, then making the other centres can also be done as fast as Yau, except using slice moves instead of wide moves.

I personally am curious as to what your trying to show us. It looks like square 1 scramble, but I really have no idea as I don't have one.
------------------------------------------------------------------------------------------------------------------------------
Here's an idea I came up with and have been using for the last couple of days.

Method
- Make a block on the left the same as in the Roux method
- Solve any M layer edge and AML (Adjust M Layer) so that the edge is in the DB or DF position (preferably DB for lookahead)
- Build a 1x2x2 block on the right side. This block does not need to match up with the left block or the M layer edge
- Extend the 1x2x2 block on the right side into a 1x2x3
- Place another M layer edge and AML so that all pieces in the F2L are solved
- Do a NMLL of your choice

There is a NMLL algorithm set out there (you can find it on the wiki), but it only covers cases with all edges oriented.

One option for the LL is CPEOLL and 2GLL. The biggest drawback for this would be the recognition. The EO in CPEOLL can be recognized by first finding the orientation of the UL and UR edges by finding the L and R edge colors followed by looking at the remaining two edges to see if they have the U center color on top. 2GLL can be recognized by the orientation case of the corners using the L and R colors and pairing that with the placement of the L and R stickers on the edges.

I have come up with another NMLL. The biggest drawback to this is its algorithm count. It is inspired by the one on the wiki. Its algorithm counts would be 82 for the first step and 30 (maybe less if I check for mirrors) for the second. The first step is the same as the normal NMLL, except you force one of the UL and UR edges to be oriented while the other in misoriented. For each normal case you have 2 algorithms. One will either flip both the UL and the UR edges or leave them both oriented how they are. The other will flip one of the UL or UR edges but not the other. You then can finish with a step similar to the regular NMLL, but it will flip the misoriented Ur or UL edge and an M layer edge. You should know which M layer edge your algorithm flips and AML so that your misoriented edge is in the correct place.

Personally, I think poor recognition is worse than more algs, so I'd go with the second option listed here. I played around with a lot of things, but these were the only 2 LL systems that seemed viable. Enjoy!

Oh, and btw, what should I call this? NMM which stands for Non-Matching Method? Or just simply Method as I have done in this post?

Whether you call it a T perm or not, the adjacent swap alg I use is R' U R' F2 R F' R' F2 R2. Is R' U R' F2 R F' U R' F2 R F' R really "much slower" than that? I'll take that over CP recognition any day.

Well, I was thinking, and a very interesting method came to mind. It reduces the cube to <R, U, F2>, and solves the cube from there. Because it begins very similar to Petrus, I'd like to call it Pet rock. Here's the idea.

1- Solve the 2x2x2 block in the BDL corner.
2- Orient the edges relative to <R, U, L, D>. The freedom of having a third side to turn without restriction should make this simpler to perform.
3- Extend from the original the 2x2x2 block to a 2x2x3 on the F side. This is done only using <R, U, F2>. With practice, this could become very efficient.
4- Extend from the original 2x2x2 block to a 2x2x3 on the R side. This in combination with step 3 should leave an F2L slot and all the edges oriented. (Use only <R, U> moves)
5- Insert the last F2L edge/corner pair (the orientation of the corner doesn't matter, allowing faster execution). (Use only <R, U> moves. 25 cases. Avg moves 7.5, rare worst case 12)
6- Perform CLS (24 algs (CLS: I/CLS: I(mirror)/OCLL). This orients the rest of the corners and leaves the edges oriented, skipping OLL)
7- Perform PLL. Done!

Because of the nature of the method, I don't have any way of discovering the avg move count besides actually performing it myself multiple times, so I have no idea how efficient it is yet, but what I do know is that it is very intuitive until steps 6 and 7. The total alg count is 55.

The combination of CLS and PLL has an avg move count of 22.3 (compared to the OLL/PLL avg move count of 21.5). Now the question is what the average moves are for steps 1-5. From what I've tested already, it seems not to be much more than what is already common for Cross+F2L or Petrus->F2L, though I'd like to test more, and see the possible situations.

It really depends on if steps 2-4 require less moves on average than 3 F2L slots. If I were good at block building, I could probably find out. Step 2 should be quick, though steps 3 and 4 will likely take more. Anyone already know or willing to give it a go?

Well, I was thinking, and a very interesting method came to mind. It reduces the cube to <R, U, F2>, and solves the cube from there. Because it begins very similar to Petrus, I'd like to call it Pet rock. Here's the idea.

1- Solve the 2x2x2 block in the BDL corner.
2- Orient the edges relative to <R, U, L, D>. The freedom of having a third side to turn without restriction should make this simpler to perform.
3- Extend from the original the 2x2x2 block to a 2x2x3 on the F side. This is done only using <R, U, F2>. With practice, this could become very efficient.
4- Extend from the original 2x2x2 block to a 2x2x3 on the R side. This in combination with step 3 should leave an F2L slot and all the edges oriented. (Use only <R, U> moves)
5- Insert the last F2L edge/corner pair (the orientation of the corner doesn't matter, allowing faster execution). (Use only <R, U> moves. 25 cases. Avg moves 7.5, rare worst case 12)
6- Perform CLS (24 algs (CLS: I/CLS: I(mirror)/OCLL). This orients the rest of the corners and leaves the edges oriented, skipping OLL)
7- Perform PLL. Done!