A simple blindfold problem

[sgsawant]

Here's a simple problem for which I did not have a short answer:

The whole cube is solved except EP(1 7)(2 6). The orientation of the edges is alright - by the definition of the 3-cycle method (that's what I use). Now this should have been a simple double transposition problem. But think it over and you will see that setting it up is an involved process.

Please let me know if you think this is problem has a simple answer and if I am overlooking any obvious solution. I don't need the optimal solution (I can look it up myself with a simple A-star program). All I need is a solution which is short and can be implemented by the generic algorithms used for blindfold cubing (the 3-cycle method).

Regards,

-sgsawant

 

[Stefan]

More people would know what you're talking about if you wrote something like UF rather than a number.

 

[Mike Hughey]

Do (1 7 2). That will solve 7, 2 will have 1, and 1 will have 6.

Then, you just do (1 6 2), and it's solved.

Just 2 easy 3-cycles.

Not optimal, but I think it does what you want, doesn't it?

More people would know what you're talking about if you wrote something like UF rather than a number.

If I understood what was being asked, this was a generic question where it didn't matter what actual pieces were being discussed. But maybe I just understood the question.

 

[Stefan]

Just 2 easy 3-cycles.

Well...

2-cycles of edges can only be solved in pairs (double transpositions)

 

[blah]

D' x H perm U2 x' D

 

[Stefan]

For edges?

 

[blah]

oops

 

[riffz]

I agree with Stefan. I had no clue what those numbers meant.

 

[Stefan]

Well, *assuming* he's using Macky's guide so he's talking about F2B2 orientation and (UF BR)(UL BL), I'd say R'U'LU(Zperm)U'L'UR is obvious and U2lB(Hperm)B'l'U2 is shortest.

 

[Mike Hughey]

Just 2 easy 3-cycles.

Well...

2-cycles of edges can only be solved in pairs (double transpositions)

Sorry. I guess this was a side effect of me doing BH for so long. When I saw

All I need is a solution which is short and can be implemented by the generic algorithms used for blindfold cubing (the 3-cycle method).

I was thinking "a solution which can be implemented with just 3-cycles". But it seems much more likely that you're reading it the way he was.

This is a potentially significant drawback of BH. If you're doing pure BH, you always solve pairs of 2-cycles as 2 3-cycles, which is generally significantly more moves than a setup into an H perm or a Z perm or something similar. In fact, I generally don't even notice that I have a case of pairs of 2-cycles, so I'd never even think to optimize it.

 

[Micael]

Still, 2 3-cycles is good when using memory system.

 

[mr6768]

I would do R' B2 U R' U' Z perm and undo the setup !

 

[mr6768]

Well, *assuming* he's using Macky's guide so he's talking about F2B2 orientation and (UF BR)(UL BL), I'd say R'U'LU(Zperm)U'L'UR is obvious and U2lB(Hperm)B'l'U2 is shortest.

I think (1 6)(2 7) means this : (UF BL)(UL BR)

 

[Stefan]

This is a potentially significant drawback of BH. If you're doing pure BH, you always solve pairs of 2-cycles as 2 3-cycles, which is generally significantly more moves than a setup into an H perm or a Z perm or something similar.

Well, at least Z perm isn't so short. How would you solve this particular case with BH?

I would do R' B2 U R' U' Z perm and undo the setup !

Is that supposed to be better than mine in any way?

I think (1 6)(2 7) means this : (UF BL)(UL BR)

Um... he asked for (1 7)(2 6)?

 

[mr6768]

Um... he asked for (1 7)(2 6)?

Oh sorry . My bad ! yes he asked for that

Is that supposed to be better than mine in any way?

I didn't say it's better ! I just said the first idea came into my head !
By the way I don't use Cycle method for edges , I prefer your M2 method Mr.Pochmann !

 

[Sakarie]

With BH using UF as buffer, it could be
[U': F E' F'] [U': F' E F] or
[R' U' R: E'] [L': B M2 B'] as easiest. If I got the commutator notation right.

 

[cmhardw]

I really don't think I would have seen this during a solve, but if you do two commutator three cycles just right, you get 1 move cancellation. You have to do an 8 mover Drop and Catch followed by a A9, so it's still 16 moves, but the two commutator types use the same set of turns. Do (UF UL BL) (UF BR UL)
x'
[L', U' M' U]
U2 L' U' M' U L U' M U'
x

Which is:
x' (L' U' M' U L U' M U) (U2 L' U' M' U L U' M U') x

And this can be executed as:
r' U' M' U L U' M U' L' U' M' U L U' M U' x = 16 turns STM

---------------------------
I wouldn't be using UF as my buffer, but UB. If I had the FB reflected cycle of (UB FR)(UL FL) on a real solve then I probably would have done:
[L' E2 L, U'] y' [U, L E' L'] y

Which means that for the original cycle of (UF BR)(UL BL) I would most likely have done:
[L E2 L', U] y' [U', R' E R] y

--edit--
Seeing it now, this would be a fast way to do the cycle possibly:
[L E2 L', U] x' U' M' U L' U' M U r
--edit--

Chris

 

[Sakarie]

But it wouldn't be faster than
[U': F E' F'] [U': F' E F]
with cuberotation, would it?
zx R' U M' U' R U M U' R' U' M U R U' M' U x'z'

It's not faster than Pochmann's, but I guess it's good threecycle way.
Another possibility is:
x' M U M U2 M' U l' U' M' U L U' M U x 14 STM

 

[XXGeneration]

I'm pretty sure that you can solve a 2cycle in 2-3cycles.

Copy pasted from Macky's site:

Say we need to solve the cycles (AB)(CDEF). Doing (ABC) breaks into a second cycle and leaves us with (ADEFC). Note that C, which we used to break into the second cycle, must be attached to the end of the cycle. In 3-cycle methods, this allows us to avoid leaving 2-cycles unsolved in even cycles. In effect, we replace the double transposition (XY)(ZW) with two 3-cycles, (XYZ)(XWZ). This is especially useful for 4x4, where double transpositions are hard to set up.

 

[cmhardw]

I'm pretty sure that you can solve a 2cycle in 2-3cycles.

Copy pasted from Macky's site:

...
In effect, we replace the double transposition (XY)(ZW) with two 3-cycles, (XYZ)(XWZ). This is especially useful for 4x4, where double transpositions are hard to set up.

Keep in mind that sometimes (XZW)(XZY) is also useful.

Chris