# Void Parity Resolution/Algs



## Lucas Garron (Sep 5, 2008)

The "Void Parity" is the issue that occurs when solving anything equivalent to a 3x3x3, particularly a void cube, where you have odd total parity with your current assignment of centers.
Layer methods hit this (i.e. you can recognize the parity) at PLL, and I think with CF or Roux, you can try to avoid it.

It's well-known that a reassigning centers with a quarter-slice twist + resolving pieces will resolve this. My approach used to be something like an M-fix with a 4-flip and two 3-cycles.
But for speedsolving, you'd want something efficient. Tomas once asked us for a fix in #rubik, and so I got kinda interested.

The most practical is to find a fix that preserves OLL (which can be applied before PLL). It's not hard to imagine that the best fixes are URrML-ish and preserve CPLL, which is also good for CF and Roux, depending on how you do it (and what kind of mistakes you make).

After a while, I found l U r' U M U' M' r U' R' U M U'.
Then, qqwref found the very nice M' U M' U M' U' M' U' M' U2' M' U' M'.

So, does anyone have any other algs, or better approaches?


----------



## blah (Sep 5, 2008)

Y'know what? I used to have a number of these algs, back when I first proposed my "new" 5x5x5 BLD method, but then I never went back to solving a 5x5x5 BLD again, so I think I may have deleted that file (can't find it right now)


----------



## cuBerBruce (Sep 5, 2008)

I've been using the following to swap UF and UR: (M' U')4 (R2 d' M' d2 M' d' R2) (F2 M' F2 M2).
Essentially a 4-flip, an Allan (U-Perm), and an M-layer 3-cycle + M move. But qqwref's alg (which swaps UR and UB after adding a missing U' on the end  ) is shorter.
For swapping UFL and UBR, I've been using (R' U L' U2 R U' L)2 U' F R F' (M' U')4 F R' F' B2 M B2 M2.
Not great algs, but I didn't have to memorize anything new.


----------



## Meep (Sep 5, 2008)

My approach to that was to simply do M', then insert the two cross pieces again via the M layer, then orient any edges that were misoriented from doing that.

Ex. M' + U' M' U M U M U2 (M' + M <-- These cancel out) U M U M U2 M' U M' U M' U'

A really inefficient intuitive approach. =\


----------



## coinman (Sep 5, 2008)

M' U M' U' M U' M U2 M' R U R U' M' U R U' r'
edit: joey again


----------



## cuBerBruce (Sep 6, 2008)

coinman said:


> M' U M' U' M U' M U2 M' R U R U' M' U R U' r'
> edit: joey again


joey, your alg seems to move a lot of pieces. Did you make a mistake?

BTW, there is this old thread that is somewhat related to this one.

http://www.speedsolving.com/forum/showthread.php?t=2516

(And joey, your alg in that thread doesn't work for me either. Are there people who actually post algs without using an alg checker first?  )


----------



## Lucas Garron (Sep 6, 2008)

joey's alg is M' U M' U' M U' M U2 (M' R) U R' U' M' U R U' r'. Missed a '.

(And thanks, I know about that thread. I made this thread specifically to discuss approaches to centerless speedsolving, though. )


----------



## Derrick Eide17 (Sep 6, 2008)

i came up with a really good one for the first opposite swap awhile ago but totally forgot it 

Nice alg for 2nd one though from Michael!


----------



## Ethan Rosen (Sep 6, 2008)

On the last layer make it so all you have is two edges opposite each other on the layer that need to be swapped. Then do cube rotations so those two pieces are BR and FR. Do E' L2 E L2 E'. The problem with this is that it then leaves you with four edges to orient.


----------



## Stefan (Sep 6, 2008)

*M' (D' R2 D) (U M' U' M) (D' R2 D)*
The M' changes parity, the (conjugated) 5-edges-cycle repairs the damage.

Now with ACube and this input: FD ? -? ? BD DR -? DL FR FL BR BL ? ? ? ? DRF DFL DLB DBR
13 qtm: *M' U' B D B U S' U' F' R' B'*
9 stm, 12 htm: *M' U B2 U2 M' U M U B2*


----------



## Stefan (Sep 9, 2008)

I came up with a quite elegant approach now, not sure whether your algs use it, but at least you didn't explicitly talk about it. With one alg implementing this approach I got a 1.66 execution last night after some practice. What best times did you get with what algs?

I'll show my approach/alg later, but because I find it so elegant, I want to give you guys the opportunity to discover it as well (or maybe even another one). I'm sure if you see it, you'll wonder why you didn't think of it immediately.


----------



## Kenneth (Sep 9, 2008)

Lucas Garron said:


> So, does anyone have any other algs, or better approaches?



Solve all but the last edges, if the case is a parity do M or M' and parity is gone and edges are solveable.

EDIT: Use Roux, look for parity before edge permutation and do as I wrote above...

Hmmm, on a second, then you have to redo orientation and orient four edges...

To do it before orientation makes recognition much harder but after some testing I found it seems possible to find out about parity counting how many edges that are at uneven positions = if an edge is adjacent to its place (U) it is uneven, if it is opposite (M = U + U = U2) it is even and if it is M2 = even = M + M, a M + U is uneven and so on...

If it is a even number of uneven edges then it is parity. Using that is a little slow =/ (but wery useful for void cube FMC =)

Like to try a void but don't know where to get one???

Remove the centre stickers


----------



## Stefan (Sep 9, 2008)

To clarify and not be confused with Kenneth's suggestion: What I meant was still for the CFOP method, applying an alg between OLL and PLL. With "approach" I meant a certain way to build algs, i.e., algs based on a certain idea.


----------



## Kenneth (Sep 9, 2008)

Kenneth said:


> EDIT: Use Roux, look for parity before edge permutation and do as I wrote above...
> 
> Hmmm, on a second, then you have to redo orientation and orient four edges...
> 
> ...



That was not useful...

The first approach works, the parity alg to use is:

M U' B2 U2 M' U' M U' B2 ... first M solves parity, the rest orients the four edges of the M-slice.

Edit: hehe, same as Stefans... promise I did not look at the algs above until now I just used setups and the usual Roux "OLL" = M' U M ("OLL" to avoid Stefans "It is not OLL" else I had written only OLL  )



Kenneth said:


> Like to try a void but don't know where to get one???
> 
> Remove the centre stickers



Made one, it works fine... first I thought the Rubik's logo on one of the centres would ruin it but it makes the same, you can even leave the stickers on that and the opposite side.

Edit: 25.34, but no parity = boring record, I want to do it with parity =)

Used columns first (solve pairs + CLL), place three D edges, orient, parity, permute.


----------



## Kenneth (Sep 9, 2008)

Not a parity but this was fun:

M2 U M2 U' M2
M2 U' M2 U M2

Does Z-PLL in 5 turns.

That made me wonder how many algs that are shorter for the void cube than for the normal 3x3x3. How many turns are the hardest scramble and so on...


----------



## Stefan (Sep 9, 2008)

Ok, here's my idea (the other reason I didn't post it earlier was lack of time).

Observations:
- We want to "change permutation parity", most obvious way is to do an inner slice turn.
- We allow permutation of LL edges.

Idea: Combine those two observations. Setup the four edges in one inner slice (with proper orientation), turn it, undo the setup.

Obvious one resulting in nice pattern on normal 3x3 (btw I think a riddle from Per at RWC2005):
*(F L B F R F') E (F R' F' B' L' F')*

Here's one in 12htm/14qtm: *(R' F D2 r U) M' (U' r' D2 F' R)*

After that, I thought about going backwards. So instead of setting the four edges up into the M slice, I set them up there and tried to find a nice way to "solve the cross" from there. Because I have more experience with that. I found (U' R2' F r U') and built this alg from it which is the one with the 1.66 seconds mentioned above:
*(B r' U' x') (R2 U R' r U' R2' F r U' x)*


----------



## Kenneth (Sep 9, 2008)

I wanna change the name for the puzzle, "Level 1 Menger Sponge" is much cooler 

Started to try to do parity after I solved all but 5 edges, before orientation. then I simply AUF and do a quick "BLD memo" to see if it is parity, it works but is a bit slow. With practice it may be better.

Probably also a wery nice way to practice edge memo... The void is good for such things, like F2L practice, it is much harder to see where to put the pair without the cross as a guide. Try it boys and gals you are only six stickers away from a Menger


----------



## Kenneth (Sep 9, 2008)

M2 U M U' M2 ... solves parity and orient four LL edges 
M U2 M' U M' U M U' M ... parity + opposite EOLL
M' U M U' M U' M U M' ... p + adjacent EOLL

These algs is a start for a 2xELL that always solves LL edges and parity, it is a total of 59 cases, probably the best approach you can have, no extra step, just more algs.

2xPLL works the same, learn it and you can use it for 4x4x4 = no more PLL paritys =)


----------



## Kenneth (Sep 10, 2008)

Like to solve parity on this?







It's a Level 3 Menger Sponge, exactly 8,000 pieces 

I use the image for my profile page at Svekub. Made it in a program I wrote myself, including the 3D image generator (use a separate Z table for the shadows as it was the lights view of the scene and do a 2-phase render, one for shadows, then the image, this one I cheated and made two exactly the same but diffrent direction of light and then I merged the images in PS).

Maybe not on topic but I like to show off


----------



## Ron (Sep 10, 2008)

Cube Explorer can easily find optimal solutions for this.
On a solved cube in Cube Explorer do:
1) moves U + D'
2) color the edge pieces in middle layer correctly (after this cube is solved except for 4 centers)
3) make all stickers in upper layer yellow with stripes (using CTRL+click)
4) click add and solve, error message will come and after removing the error message the outside of upper layer has become gray
5) click add and solve again

Here are some optimal solutions between OLL and PLL:
R D B' L' D2 F' U' R F D2 L B' (12f*)
R B' D2 L' F' U' D R F D2 L B' (12f*)
R B' L' D2 F' U' R F D2 L D B' (12f*)
R B' L' D2 F' U' D R D2 F L B' (12f*)
R' F D2 L B U' D L' F' D2 R' B (12f*)
R' F D2 L B U' L' D2 F' R' D B (12f*)
R' F L D2 B U' D L' D2 F' R' B (12f*)
R' D F D2 L B U' L' D2 F' R' B (12f*)
F R' D2 B' L' U' D F L D2 B R' (12f*)
F R' B' D2 L' U' F L D2 B D R' (12f*)
F R' B' D2 L' U' D F D2 L B R' (12f*)
F D R' B' D2 L' U' F L D2 B R' (12f*)
F' D L D2 B R U' B' D2 L' F' R (12f*)
F' L D2 B R U' D B' L' D2 F' R (12f*)
F' L D2 B R U' B' D2 L' F' D R (12f*)
F' L B D2 R U' D B' D2 L' F' R (12f*)
L F' R' D2 B' U' D L D2 B R F' (12f*)
L F' R' D2 B' U' L B D2 R D F' (12f*)
L F' D2 R' B' U' D L B D2 R F' (12f*)
L D F' R' D2 B' U' L B D2 R F' (12f*)
L' D B D2 R F U' R' D2 B' L' F (12f*)
L' B R D2 F U' D R' D2 B' L' F (12f*)
L' B D2 R F U' R' D2 B' L' D F (12f*)
L' B D2 R F U' D R' B' D2 L' F (12f*)
B D L' F' D2 R' U' B R D2 F L' (12f*)
B L' F' D2 R' U' D B D2 R F L' (12f*)
B L' F' D2 R' U' B R D2 F D L' (12f*)
B L' D2 F' R' U' D B R D2 F L' (12f*)
B' R F D2 L U' D F' D2 R' B' L (12f*)
B' R D2 F L U' F' D2 R' B' D L (12f*)
B' R D2 F L U' D F' R' D2 B' L (12f*)
B' D R D2 F L U' F' D2 R' B' L (12f*)

You may want to try other center positions. Maybe there are shorter solutions for those cases.

Have fun,

Ron


----------



## Kenneth (Sep 13, 2008)

Use Roux, do not orient last edges, just place UR and UL (oriented of course) and then do the M-slice, both orientation and permutation and you will newer have any parity.

Same goes for CF if the M-slice is done as the last step (or E or S-slice, same thing).


----------



## clement (Sep 13, 2008)

There are only 2 possible positions for the centers (and symmetries). The other one gives 13 moves solutions.


----------



## Stefan (Sep 13, 2008)

I see *four* non-equivalent possibilities:
- centers off by E turn (2 ways)
- centers off by M or S turn (4 ways)
- U center swapped with D center (2 ways)
- U center swapped with adjacent center (4 ways)

And here are ftm-optimal algs for these cases found with Cube Explorer:
- R D B' L' D2 F' U' R F D2 L B' (12f*)
- U R2 L' U' B R L' D' B R2 L B' (12f*)
- U R L' B' U D' L2 B2 R' F B' D B2 (13f*)
- U D' R B2 R2 U D' B R L' U2 D' R2 (13f*)


----------



## clement (Sep 13, 2008)

Yes, I agree.
I was focusing only on centers, and not where would be the last layer.
So for me 1/ and 2/ are equivalent, so are 3/ and 4/

EDIT : H Perm : M2 U F2 M2 F2 U' M2 (10f)


----------



## Ton (Oct 18, 2008)

Got a void cube today , this is my contribution, again with cube explorer (I adapted LR' to M moves)

(U') M' U B2 U2 M' U M U B2 (13f) swaps with (U') its swaps UF with UR 

I execute it like

M' U x' U2 x U2 M' U M d L2 

of course 

M' U' x' U2 x U2 M' U' M d' R2 is also possible 

Only 9 move , the U' is only needed when the corners are already in position

Turns quite oke


----------



## Radcuber (Jul 30, 2010)

I might seem like an idiot saying this but: I still don't get it.


----------



## JasonDL13 (Sep 25, 2014)

*My void cube parity alg*

This algorithm fits my hands because I like M and U' turns. Mirroring the algorithm and changing the last part might help it for you.

This will swap UB with UF and the centers D to F to U to B to D.

M2 U M U' //Move centers
M' U' M U' M U' M U' M' U' M' U' M' U' M' U' //Move cancellation (M2 and M to M') and orient edges
M2 U' M' U2 M U' M2 // U Perm (R2 U R U R' U' R' U' R' U R') Move the edges

The mirror: M2 U' M U M' U M U M U M U M' U M' U M' U M' U M2 U M' U M U M2

EDIT: This post was moved here, so the 4 year bump isn't my fault ;P


----------



## Lucas Garron (Sep 25, 2014)

I'm still a fan of Michael's void cube PLL parity because it's short and easy to remember (I still remember it 6 years later without any special effort to keep it fresh!): M' U M' U M' U' M' U' M' U2 M' U' M'


----------



## Berkmann18 (Jan 23, 2015)

Stefan: you forgot L z for the 13 qtm algo and an U for the 9qtm one.
Those ones are the best I ever tried though


----------



## qqwref (Jan 23, 2015)

There's also ben1996123's alg: (R2 S R2 U')3


----------



## Eduard Khil (Jan 26, 2015)

Lol just by using roux, when you see a parity, just put the parity pair on top, do M U M' U2 M' U2 M' U M' and then solve as normal...


----------



## qqwref (Jan 26, 2015)

I assume you mean M U M' U2 M' U2 *M* U M'? Either way you're just doing a slice and fixing orientation, which any Roux solver should be able to do in their sleep without an alg.


----------



## Berd (Jan 26, 2015)

qqwref said:


> I assume you mean M U M' U2 M' U2 *M* U M'? Either way you're just doing a slice and fixing orientation, which any Roux solver should be able to do in their sleep without an alg.


Shots fired.


----------



## Xcuber222 (Dec 29, 2015)

Here are some algorithms I've calculated that only use the M slice move
and are 10-12 Moves long For Switching Opposite edges:

*R2 F' M F R2 F' L2 B' M B R' L' D

R2 B R' L' D M D' L2 U' R2 U M U'

F U2 F M F' D2 F2 M F' M' F' E2 B'

F U2 F M F' U2 F2 M' F' M' F M2 F

F U2 F2 M F' M2 F' U2 B2 M' F' M' B2

F U2 F2 M F' M2 F' U2 F2 M F' M F2

F U2 M D2 F M2 F' U2 M D2 F M F2

F U2 M U2 F M F2 D2 F M2 F' D2 M

F D2 M D2 F M F2 D2 F' M2 F D2 M *

These also work for adjacent edges Just make an L on top one edge above the R-face and One above the B-face, and hold with white on top.
What these algorithms basically do is move the center pieces around and re-position edges.
These algorithms are optimized for The Beginners Speed Solving Method.

Hope This Helps.


----------



## Spencer131 (Jan 2, 2017)

I haven't encountered parity with roux at all... I've only done like 5 solves so is this just luck?


----------



## shadowslice e (Jan 2, 2017)

Spencer131 said:


> I haven't encountered parity with roux at all... I've only done like 5 solves so is this just luck?


If you're using a void cube, you only have a 1/2 chance of getting parity so the odds of not getting parity in 5 solves is 1/2^5=1/32 which is reasonably likely (also, it's not only roux which can get parity on a void cube- any method can)


----------



## Spencer131 (Jan 3, 2017)

I think I figured out the fastest way to solve parity for roux users. Since its hard to spot parity until step 4c, I figured out an algorithm that preserves everything up until step 4c so you don't have to redo the whole lse.

U' M' U2 M' U2 M U' M' U2 M U2 M' U M2 U
I think its 15 moves stm btw.


----------



## Teoidus (Jan 3, 2017)

Why not just:

BLD trace from whatever orientation you plan your FB into to determine whether you'll get parity

If even, pretend there's a white center sticker on U and start your LSE accordingly

If odd, pretend there's a white center sticker on F and start your LSE accordingly

Like CSP but with Roux and void cubes


----------



## AlphaSheep (Jan 4, 2017)

Teoidus said:


> Why not just:
> 
> BLD trace from whatever orientation you plan your FB into to determine whether you'll get parity
> 
> ...


Since edge orientation is irrelevant, I think you can trace this really quickly. With practice, probably around a second. It feels like a long pause, but it's better than an awkward alg that takes 2 seconds minimum.


----------



## Solvador Cubi (Jan 5, 2017)

I recently got a void cube and discovered all the interesting LL edge perm cases.

Thanks to folks on here and some youtube videos... here are the algs I've settled on so far:

Adjacent
(UB <--> UR) : *(M' U)2 (M' U')3 U' (M' U')2*
(UF <--> UR) : *M U' F2 U2 M U' M' U' F2 U*

Opposite
(UF <--> UB) : *(M' U2)2 B U B' (M' U)4 B U' B' M' *(looking for a better one, though)

A shorter Z-Perm
(UF <--> UL & UB <--> UR) : *M2 U' M2 U M2* 

edges counter clockwise : *(R2 S R2 U')3*
edges clockwise : *(L2 S' L2 U)3
*
I have also seen where I can get my edges into a zig zag pattern where they need to move in a way such as:
UF > UR > UL > UB > UF


thoughts?


----------



## AlphaSheep (Jan 6, 2017)

Solvador Cubi said:


> I have also seen where I can get my edges into a zig zag pattern where they need to move in a way such as:
> UF > UR > UL > UB > UF


These are called W perms, and there are two possible cases - Wa and Wb. I never remember which is which.

One trick I like is to set up the four edges onto the M slice so you can cycle them in a single move. For example: F' L F R2 D' moves all four edges onto the M slice. You can then cycle them and fix parity in one move, then undo the setup moves. So the two cases are
F' L F R2 D' (M') D R2 F' L' F
F' L F R2 D' (M) D R2 F' L' F

An alg that's better suited to speed solving that I've never gotten round to learning is
M U' M' U2 F2 U' M2 U2 M U' F2
And then just replace all the U' moves with U moves to get the other case.


----------



## Solvador Cubi (Jan 7, 2017)

Awesome! thanks AlphaSheep. Those are nice and helpful. 

I've also seen some of those other cases already have names too, like the counter- and clockwise pair are "O-Perms".
do any of the others? e.g. the two 2-edge swaps? I'm thinking !-Perm and /-Perm  thoughts? 

I was thinking about updating the Void Cube page on the wiki: https://www.speedsolving.com/wiki/index.php/Void_cube
With at least a little more description and some LL algs.

Reading the current text there helped me realize that 2 corners can be swapped too! 
Are there any known algs to correct that case?


----------



## TDM (Jan 7, 2017)

AlphaSheep said:


> These are called W perms, and there are two possible cases - Wa and Wb. I never remember which is which.
> 
> One trick I like is to set up the four edges onto the M slice so you can cycle them in a single move. For example: F' L F R2 D' moves all four edges onto the M slice. You can then cycle them and fix parity in one move, then undo the setup moves. So the two cases are
> F' L F R2 D' (M') D R2 F' L' F
> ...


Isn't there only one case? The second alg solves the same case from a U2.


----------



## Solvador Cubi (Jan 13, 2017)

This is what I'm seeing:

to move edges in this direction: F > L > R > B > F
Then this is the alg: *M U' M' U2 F2 U' M2 U2 M U' F2*

to move edges in this direction: F > R > L > B > F
do a *U'* then the above alg.

Does that sound right to anyone else?


----------



## Solvador Cubi (Jan 18, 2017)

Does anyone know of an algorithm to solve the void cube corner parity where you would need to Swap 2 Opposite (diagonal) Corners

It seems like a decent way is the combination of an E Perm + O Perm
but is there anything known that is shorter?







thanks.


----------



## Teoidus (Jan 18, 2017)

I think that the best way for CFOP users to solve void cubes is to use CFCE. ELL + parity algorithms will be far more friendly compared to these diag swap algs


----------



## Solvador Cubi (Jan 19, 2017)

I agree with you Teoidus about changing up one's method a bit to avoid those situations.
I'm a CFOP 4LLL solver (with EPLL last) so I wouldn't normally need that diag swap alg.

If someone finished F2L and was presented with that case (unlikely, but still possible) then knowing one alg (preferably 16 htm or less) would be nice.

I'm also just trying to compile a complete list of Void Cube LL scenarios and algs.


----------



## Martin Orav (Oct 29, 2017)

I'm not sure if this has been posted in this thread before, but I used the alg M2 U/U' M/M' U'/U M2, that I figured out myself in like 5 minutes one time I was bored and couldn't find a good parity alg for a void cube. It preserves F2L, COLL and CPLL, and flips all the LL edges. I learned the OLL case 47 to make that part faster. The OLL 47 is also really easy to recognise so it makes the OLL a bit faster in general, but that's not the topic to talk about here.

Today, I was bored, and since I learned intermediate LSE like a week or so ago, I was thinking that what if I just did an M' or an M move and then did LSE EO and then fixed the DF and DB edges. After trying out different ways to do do it I found this alg M' U M U2 M' U2 M' U' M U' M U2 M' (U'). It's 13 moves STM so pretty good considering the fact that its a 2-swap. If you used EOLR, by looking at DF and DB edges as UL and UR edges you might get a better alg.

Since there was already a 2-swap in the first post in this thread, it doesn't help much, but it's an alternate alg.

If there was an <M, U> subgroup optimal solver it would be really good, because if you use RL and FB mirrors along with inversing pretty much every sequence of MU moves can be very fingertrickable. There might be one in cube explorer, but I don't have a computer so I can't check.

This way we could also generate all the parity EPLLs (or ELLs, although using edge control and CLL on 3x3 with parity EPLLs might be better (idk)) since they will be fingertrickable, as said above. If someone can tell me how to use cube explorer on an apple computer, I'll try it since my mother has a computer, but it's apple.

Now if you are a Roux solver, you can just use the EOLR case, that you get, when you do an M/M' move after the first EO+LR or recognise it before LR. That might be faster, but I'm not sure. Also, I'm not sure if this would work, but by not doing just M', but deciding whether to do M or M' you might be able to skip dots. Not sure if this would work though. Again, with an <M, U> subgroup optimal solver we could generate parity M slice cases, which is probably the best for Void cube speedsolving with Roux.


Edit: now I read through the thread, and I saw an idea that's probably better for Roux (solve UL & UR, after CMLL, solve M slice in one alg). No parity ever. The amount of cases is really low as well, it's 27, including the skip, (for void cube) (can someone confirm, please) and the recog doesn't seem too bad either.


----------



## Solvador Cubi (Dec 19, 2017)

I wanted to follow up on this thread with an answer to my own question from a few months ago. 

The best alg I "found" (using online solvers, actually) to swap 2 diagonal corners is:
* M' F' M F2 U2 F' M U2 F U2 B' U2 B (L2 F') 2*

I also put all my Void Cube notes together in this one page info-graphic:
http://solvexio.cf/app/#/Void_Page

It organizes 10 parity fixing algs for solves using CFOP or CFCE methods.


-= Solvador Cubi


----------



## 1001010101001 (Dec 21, 2017)

Use roux logic.


----------



## Electro Web (Feb 25, 2019)

Solvador Cubi said:


> Opposite
> (UF <--> UB) : *(M' U2)2 B U B' (M' U)4 B U' B' M' *(looking for a better one, though)



I too had been looking for a better algorithm, and after looking and looking I couldn't seem to find one that could be easy to remember, so after a long time of looking I decided to take matters into my own hands and I made my own algorithm, that combines the knowledge I've gained from solving the 4x4 parity and the knowledge I've gained from solving the void cube parity and this was the algorithm I came up with:

Opposite
(UF <--> UB): *(U R U' R') U' (M' U)2 (M' U')3 U' (M' U') (r U R' U')*


----------



## Solvador Cubi (Feb 26, 2019)

Thanks Electro Web,

I have now tried out your alg too. While it's a few moves longer, it does avoid the Back moves, so that's nice.

From the time when I posted my alg until now, I have since learned some LMCF and Roux.
So using that knowledge, these are now the shortest ones I can come up with...


17-Move Opposite U Edge Swap (UF <--> UB): 
*U r' U M U' M2 R U' R' U M U' R M' u2 M u2
U' M U2 M' U' R' F R U' M' U R' F' R' U2 M U2 M'*

or this is one with 19 moves, but seems a bit smoother to execute:
*M' U' M (U2 M' U2 M') U' M' (U2 M' U2 M') U M2 U' M' U2 M*


-= Solvador Cubi


----------

