# Twisting Puzzles

3x3xN Cubic Puzzles - Hints & Algorithms

## Introduction

The approach described on this page is based on the method for the 3x3x4 fully functional puzzle. There are minimal differences to account for the slightly different arrangement of layers. On this page, the diagrams and algorithms will refer to the Cubic 3x3x5. The approach works with a 3x3x7 and should also work with any larger odd-numbered values of N.

The first 4 steps are the same on the 3x3x7 - start with the thin layers nearest the middle. Then you use Steps 6 - 8 for the next two thin layers. Then sort out the middle layer and any parity problems. The outer layers can be solved using the algorithms from Steps 6 - 8 again.

## Notation

Notation is the same as for the 3x3x3 cube. The image indicates the additional terms that are used in the algorithms.

## Step 1 - Reconfigure The Puzzle

We can't do a great deal with the u and d layers when the top and bottom corners and edges are not oriented. Our first job is to orient the top and bottom layer pieces so that we can get at the inner thin layers. You don't actually need to solve these layers, although you may find it no slower to do just orienting the pieces. I tend to place the corners correctly and then not worry about where the edges are, just that they are correctly oriented.

When the top and bottom layers are oriented, we can now move the inner thin layers freely.

## Step 2 - Move u & d Edges Into Their Layers

I use the following algorithm on so many puzzles. Look at the image - assume that the middle layer pieces are where they would be when the puzzle is solved. The two edges are not oriented correctly - this is because they are in the wrong layers. The algorithm shown will sort that out.

**R2 d' R2 d' R2 d2 R2**

## Step 3 - Permute u & d Layer Edges In Their Layers

When the u and d layers have all of their edges, you may still need to swap a few of them around. You can swap two adjacent edges by placing them on the right face of the u layer and then using the algorithm shown below. You can turn the puzzle over and do this with the other layer. For diagonal swaps, you will need to do the algorithm twice.

**R2 d' R2 F2 d' R2 u R2 u' F2 u**

## Step 4 - Permute u & d Centres

The main algorithm for swapping centres between layers is simple and can be used repeatedly to solve the inner part of the puzzle. Place the two centres that you want to swap at Ru and Ld and then use the following algorithm.

**R2 d2 F2 d2 F2 d2 F2 R2**

That really is all you need. You can just keep swapping and swapping until the middle section is complete.

## Step 5 - Solve The Middle Layer

At this point, you can solve the middle layer. Start by placing the face centres where they belong and then use the appropriate algorithms from the table,

Aim | Algorithm |
---|---|

To swap FL-BL & FR-BR | R2 E2 R2 E2 |

To cycle FL-FR-BR clockwise | E R2 E' R2 |

To cycle FL-FR-BR anti-clockwise | E' R2 E R2 |

To untwist FR-BR | E R' E R' E R2 E' R' E' R' E' R2 |

To untwist FL-BR | F2 E R' E R' E R2 E' R' E' R' E' R2 F2 |

This is the stage where you may notice a parity problem. If you can place the middle layer pieces correctly, without disturbing the solved u and d layers, then you have no parity. If you find that, no matter how you combine the algorithms from the table, the middle layer pieces just won't go (you end up needing to swap two adjacent edges), then you have parity. This can be fixed. Parity is caused by the number of swaps that take place. It's not about specific pieces. The main reason it arises is that having some identical pieces means that you can solve sections of the puzzle without making sure that the number of swaps is correct for the parity of the puzzle.

To correct the parity, first line up the inner thin layers. Do a **d2** turn and then use **R2 d2 F2 d2 F2 d2 F2 R2**, to swap two identical colour centres. Then have another go at the middle layer.

You can test this parity fix by using it to set up parity. To correct it again, try swapping different centres with the same colour - the fix still works. See - the number of swaps, not the pieces.

You should end this step with the following parts of the puzzle in position.

## Step 6 - Bring Outer Layer Corners Into Their Layers

Although you might have started this solution by placing those outer corners, they may have gone astray when you were focusing on the inner layers. The following diagrams show some, but not all, of the scenarios that can arise. The algorithms are simple and, by repeating them, one of these scenarios is sure to come up. The diagrams of the bottom face show what you would see if you tilt the top of the cube away from you.

**R2 U2 R2**

**R2 U' R2**

## Step 7 - Bring Edges Into Their Correct Layers

The algorithm we used in step 3 will disturb the inner layers if we try to use it at this stage. If you do use it, it's normally quite straightforward to correct the disruption to the inner layers. Now that the inner layers are solved, we have effectively reduced the puzzle to a 3x3x3 cube. We have, rather strangely though, got a situation where the middle layer has been solved first. The parity of the 3x3x3 cube means that it is not possible to swap only two edges or corners without disrupting other pieces - so you will need to look at swapping 3 or 4 edges at a time.

Aim | Algorithm |
---|---|

Swap FU-FD & RU-RD | (F2 R2) x 3 |

Swap FU-RU-FD | R2 U2 D L2 F2 R2 U' E2 R2 F2 |

For E2, turn all 3 inner layers (two turns, either direction). This second algorithm can be useful when you have one edge in u and one in d to swap. Place the dodgy edges at RU and FD.

## Step 8 - Permute Edges Within Their Layers

This is the PLL stage of the standard 3x3x3 cube.

Aim | Algorithm |
---|---|

Swap Adjacent Pairs (F-R & L-B) | F2 U F2 U' F2 L2 F2 U' L2 U F2 L2 |

Swap Opposite Pairs (F-B & R-L) | M2 U M2 U2 M2 U M2 |

Clockwise 3 Cycle (F-L-R) | M2 U R2 F2 L2 D2 L2 F2 R2 U M2 |

Anti-Clockwise 3 Cycle (F-R-L) | M2 U' R2 F2 L2 D2 L2 F2 R2 U' M2 |

Swap UF-UR & DF-DR | F2 U R2 F2 R2 U2 F2 R2 F2 U F2 |

Swap UF-UB & DF-DB | U2 M2 D2 M2 |

The last two are the most useful for anyone that already has their own edge-swapping PLL algorithms. They deal with the problem of not being able to swap a single pair of edges by doing this on both the U and D layers.