5
\$\begingroup\$

The challenge Solve Rubik's cube has a lot of flaws:

  • Arbitrary limits:

(say, max. 5 seconds on your machine and less than 1000 moves)

  • Cumbersome input format:

The input is in the format UF UR UB UL DF DR DB DL FR FL BR BL UFR URB UBL ULF DRF DFL DLB DBR (this particular input represents the solved cube). First 12 2-character strings are the edges in the UF, UR, ... BL positions (U=up, F=front, R=right, B=back, L=left, D=down), then the next 8 3-character strings are the corners in the UFR, URB, ... DBR positions.

  • Cumbersome output format:

D+ L2 U+ F+ D+ L+ D+ F+ U- F+ Where D1 or D+ represents turning the D (down) face clockwise 90 degrees, L2 is turning the L face 180 degrees, U3 or U- represents turning the U face counterclockwise 90 degrees.

  • It's five years old and only has three answers (likely due to the three points above).

I would like to rewrite it with less time/output limits and less I/O requirements.

Any objections/thoughts?

Posted

\$\endgroup\$
  • \$\begingroup\$ 3 actual answers, and 2 deleted nonanswers. Anyway, since the OP is still around, I think it would be best to just ask aditsu to either edit or repost the challenge. \$\endgroup\$ – Pavel Jan 10 '18 at 4:41
  • \$\begingroup\$ I'd recommend to either waiting for @aditsu to give permission or letting him edit directly (Ninja'd by Pavel) \$\endgroup\$ – Esolanging Fruit Jan 10 '18 at 4:41
  • 1
    \$\begingroup\$ The input format on the referenced challenge by aditsu is less human readable than the one at say codegolf.stackexchange.com/q/151476/15599 . But for coding a solver, the input format is much easier to handle on aditsu's challenge than on that one. So I am interested to see how you would make it less cumbersome. \$\endgroup\$ – Level River St Jan 14 '18 at 1:54
  • \$\begingroup\$ @LevelRiverSt I've allowed aditsu's input format in the (sandboxed) challenge I will be reposting. It's completely flexible. \$\endgroup\$ – MD XF Jan 14 '18 at 2:09
  • \$\begingroup\$ I can't wait for posting some code with random moves until the solution is found. Arbitrary limits are a GOOD THING \$\endgroup\$ – edc65 Jan 19 '18 at 7:38
7
\$\begingroup\$

Please do remake the challenge (getting permission) but with a lax and well-specified limit.

I think implementing some Rubik's cube solving algorithm is much more interesting than those writing generic path search over an enormous graph of ~265 configurations. And it's nice to have answers that actually run. Some fairly lax time limit should suffice for this, preferably given on a specific machine setup to avoid ambiguity.

\$\endgroup\$
  • \$\begingroup\$ Or a restricted-complexity? \$\endgroup\$ – Pavel Jan 11 '18 at 2:33
  • \$\begingroup\$ @Pavel I considered that, but since the overall number of states is still finite, it's not clear to me how the complexity would be defined. I guess you could work with an nnn cube, but that seems like a different challenge. \$\endgroup\$ – xnor Jan 11 '18 at 2:37
  • \$\begingroup\$ @xnor (unrelated) your comment has the n*n*n formatted wrongly. \$\endgroup\$ – user202729 Jan 11 '18 at 8:15
  • \$\begingroup\$ I've implemented these changes in the sandbox; is that what you were going for? \$\endgroup\$ – MD XF Jan 13 '18 at 22:10
  • \$\begingroup\$ @MDXF Looks good to me, though I was expecting an output format that's even more liberal. \$\endgroup\$ – xnor Jan 13 '18 at 23:07
  • \$\begingroup\$ @xnor any suggestions for how exactly to do that, for what to put in the challenge? \$\endgroup\$ – MD XF Jan 13 '18 at 23:13
  • \$\begingroup\$ @MDXF I don't know enough about cubing notation to make good suggestions, but are there perhaps other standard notations? Something that specifies the three elements of the orientation of the face, which of the two it is, and which direction it turns seems pretty natural to me. \$\endgroup\$ – xnor Jan 15 '18 at 1:08
  • \$\begingroup\$ @xnor status-completed; I completely opened up the output format so that answers can use any method of describing rotations they like. \$\endgroup\$ – MD XF Jan 15 '18 at 5:06
-1
\$\begingroup\$

Arbitrary limits: (say, max. 5 seconds on your machine and less than 1000 moves)

IMO that's not a flaw. The only thing you really gain by removing the arbitrary limits is the possibility of untestable answers. When the complexity of the problem is sufficiently low that answers can be checked for bugs by eye it's not a problem if they can't be tested, but I don't think this falls into that category.

In addition, it's these limitations which make it an interesting question. Brute force is less interesting than exploiting the structure of the group. See comments on Rubik's Revenge


It's five years old and only has five answers (likely due to the three points above).

I seriously doubt that the I/O has anything to do with it. The arbitrary limits probably go a long way to explaining it, because they require a certain level of mathematical sophistication.


IMO rather than reposting Rubik's cube, if you want to do something in the same area but without anti-brute-forcing constraints you might as well generalise and ask the word problem.

\$\endgroup\$
  • \$\begingroup\$ I agree with your points about time limits but not the rest, so I wrote a separate answer. \$\endgroup\$ – xnor Jan 10 '18 at 20:16

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .