If you use the Beginners' Method to solve the Rubik's cube, and solve the equator layer (the layer between the U-layer and D-layer), it can happen that one of the edges is flipped, like this:

Flipped edge in Equator layer

Screenshot generated using Cube Explorer

A way to solve this is to replace the flipped edge by a random block and then put the edge at its right place. However, I would prefer a shorter way to do this. It does not matter what happens to the top layer.

How can I do this?

  • $\begingroup$ The way I do it is solve 8/9 of the bottom, leaving a corner, then the middle layer, and finally flip the corner into place. Bypasses this possibility. $\endgroup$
    – Kevin
    Commented May 16, 2014 at 16:53
  • $\begingroup$ I would suggest starting to look ahead, you know you will want all the top (as you show) edges to have the correct flip, this would be an ideal point at which to combine the efforts. Maybe this should go in an answer... $\endgroup$ Commented Jun 14, 2016 at 14:53
  • $\begingroup$ I've made a Beginner's Method Tutorial video, which also includes that case. I personally put a random buffer-piece in and then solve it, the thing you want to prevent (hence this comment instead of an answer). So with that edge at the front-right with the unsolved layer at the bottom, I use: R' D R D F D' F' D R' D R D F D' F' $\endgroup$ Commented Jun 14, 2016 at 19:07

9 Answers 9


An intuitive solution is to remove both the corner and edge, splitting them up, then move them back in an intelligent way. This can be done with:

R U R' U' R U' R'

then by solving again.

Or, you could just memorize an algorithm. A couple easy solutions:

(R2 U2) (F R2 F') (U2 R' U R')
(R' F R F') (R U' R' U) (R U' R' U2) (R U' R')

It's also a good idea to actively avoid being stuck in this situation whenever possible.


Just face the cube as your image and do the following....

R U R' U U R U U R' U F' U' F
  • $\begingroup$ Thanks for your answer. It might help to elaborate a little on the answer, and explain why your answer works. Also, refrain from extra text which doesn't contribute to the answer. $\endgroup$ Commented Jun 14, 2016 at 16:56

With your orientation:

R Ui Ri U R Ui Ri U R U U Ri Fi U U F

Breaking it down:

R Ui Ri U R Ui Ri U R

If you watch the piece this takes the two of them, splits them rotates them, and aligns them reorientated on the top layer.

U U Ri Fi U U F

This takes the two pieces, rotates them to the back, pulls the right side back in place, flips the front for the two pieces, and then rotates them in and flips it down.


Just figured it out,



I would suggest starting to look ahead (which you might do earlier than this, but could do here), you know you will want all the top (as you show) edges to have the correct flip, this would be an ideal point at which to start combining your efforts - your method most likely does the corners next, but it is most likely that the manoeuvres you already use do not flip the edges*.

The fact that this edge is flipped and $7$ are not (the ones you've solved) means either $1$ or $3$ of the other $4$ (on the top) are flipped.

If only $1$ edge is flipped on U ($3$ yellows are facing up in your diagram) you could use a "flavour" of a single $9$ face-turn manoeuvre to both flip the edge you are solving and that one:

Flipped U Edge    Sequence
      B           R2 U2 F  R2 F' U2 R' U  R'
      F           R  U' R  U2 F  R2 F' U2 R2
      R           F' U  F' U2 R' F2 R  U2 F2
      L           F2 U2 R' F2 R  U2 F  U' F

If $3$ edges are flipped on U ($1$ yellow is facing up in your diagram) you could use a "flavour" of a single $11$ face-turn manoeuvre to both flip the edge you are solving and those three:

Correct U Edge    Sequence
      B           F' U  F  U' R  U2 B  U' B' U  R'
      F           R  U' B  U  B' U2 R' U  F' U' F
      L           R  U' R' U  F' U2 L' U  L  U' F
      R           F' U  L' U' L  U2 F  U' R  U  R'

* If you're manoeuvres to swap two corners and twist three corners on your final layer do flip edges, you could use these and their reflections instead:

Swap 2 corners:   R  U' L' U  R' U' L
Twist 3 corners:  L' U' L  U' L' U2 L

The four optimal solutions in HTM and STM are:

(F2 U2) (R' F2 R) (U2 F U' F) . (13q, 9f*, 9s*)

(F' U F' U2) (R' F2 R) (U2 F2) . (13q, 9f*, 9s*)

(R U' R U2) (F R2 F') (U2 R2) . (13q, 9f*, 9s*)

(R2 U2) (F R2 F') (U2 R' U R') . (13q, 9f*, 9s*)

Note. This is in fact only one formula, but the others are the inverse and mirror image along the FR-plane. This answer was given by Emrakul.

There are 84 optimal solutions in QTM, some of which are

F' (U R' U' R') (F R F') (U R F) (11q*, 11f, 11s)

(R U' R') B' (R' U' R2 U R') B . (11q*, 10f, 10s)

(F' U F) L (F U F2 U' F) L' . (11q*, 10f, 10s)

Note. Consider flipping the FL-edge. The last two algs become also 3-gen in :

(F U' F') R' (F' U' F2 U F') R . (11q*, 10f, 10s), and its inverse

R' (F U' F2 U F) R (F U F') . (11q*, 10f, 10s)

Found with https://www.cubing.net/ACube.js/


Here's a good algorithm taken from the Moyu pamphlet:

R U2 R' U R U2 R' U F' U' F


I am a beginner and still learning the beginner's method. I was stuck in this situation and could not understand the accepted answer in a go. So documenting what I did to solve it. Disclaimer: it is not at all fast but is simple to understand for beginners.

Do what you do to move an edge from top layer to middle layer, i.e. U R U' R' U' F' U F or U' F' U F U R U' R'.

Basically put in a yellow edge (if you started with white) in the place of the flipped edge, that should move just the flipped edge to the top layer and then you can position it correctly.


If you have an open slot on the left like this:

open slot on left

Then you can use this algorithm:

(D (R U R') d'(L' U L) D')

This algorithm is especially versatile since it can be modified to accommodate an empty slot in any other position by changing the first and last Ds. Such as with D2 for the back-left slot.

But if you want something that doesn't touch the F2L at all AND is quick to execute, then you'll have a harder time finding them. (Generally speaking, the heavier the constraints, the worse the algorithms will be.) My advice is that if you don't have any empty slots, then you might as well continue doing what you're doing. Or you can use the slightly longer algorithm given by @Emrakul.

Either way, once you learn a more advanced method, the solution to this problem would be to avoid being backed into a corner with this case at all. (:

  • $\begingroup$ I've downvoted this answer because, objectively speaking, the algorithms I've provided in my answer, which was posted 11 hours ago, are all relatively fast to execute, and none of them touch F2L. $\endgroup$
    – user20
    Commented May 17, 2014 at 3:55
  • $\begingroup$ I've placed my downvote in again. The algorithm you've provided doesn't address the case listed in the answer above, where every edge is solved except one. While this does flip the single edge over, this also moves the corner out of place, and as a result, is not actually a solution to the OP's problem. Additionally, it is not nearly as efficient as simply removing the corner/edge pair, since you'd have to do this anyway to solve F2L from this position. Finally, it changes the orientation of the centers, which throws off future algorithms. $\endgroup$
    – user20
    Commented May 17, 2014 at 7:17

As a solver my methods are different and constantly evolving. As a beginner when the cube was first released I kept a notebook. I listed processes and their configurations, then tried to reverse them. Failure meant rebuilding the cube. The case you present is one I no longer solve at this point. I proceed to the final layer. Once in the last layer I place the corners first then orient them. The edge pieces are my final solve. Once the bottom edge pieces are put in place, either one or three edge pieces are flipped, due to the flipped medge. I rotate the medge piece into the final layer and in the process rotate a placed/oriented piece out of the final layer. This is done to create either 4 flipped edges, in the bottom layer, or 2 flipped edges, opposite one another. My edge processes basically leave corners alone.

I hold the cube so that the top two layers remain on the top. With 4 flipped edges I rotate the middle vertical slice 90 degrees, rotating the bottom edges into the front. I then turn the bottom slice 90 degrees causing the lower left corner to move to the lower right. This is then repeated twice more. Then the vertical slice is rotated once more but the bottom slice on the fourth rotation is turned opposite to the previous three times. The 4 vertical center turns are repeated and the bottom turns repeated, 3 one direction and the 4th one back. All 4 bottom edges are flipped in the process. You now need to rotate the moved middle edge back into the middle slice and in the process the relocated bottom edge back into the lower slice.

When only 2 edges need flipping I orient them so they are in the bottom opposite one another, one in the bottom front of the cube, the other at the back. The solution is nearly the same as the already explained process. The first 8 turns are identical. The next 8 reverse the bottom part of the sequence only. If the first 4 bottom slice turns were 3 clockwise and one counterclockwise, the next 4 need to be 3 counterclockwise turns followed by a clockwise one. Of course, the middle vertical slice is advanced 90 degrees first then between each bottom turn.

This flips the two bottom edges and retains all other positions.

Whatever moves were employed to rotate the flipped medge and position it opposite the flipped bottom edge piece need to be reversed.

ADDENDUM: If you don't want to wait until later the following occurred to me. Simply rotate the medge that needs flipping into the unsolved layer and perform the double edge flip as described above. Then rotate the medge back to its original position.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.