鲍勃被绑架，被困在迷宫中。您的工作是帮助他找到出路。但是由于这是一个非常黑暗和可怕的迷宫，他什么都看不到。他只有在碰到墙壁时才能感觉到墙壁，并且知道何时找到出口，但仅此而已。

由于他必须通过内存运行您的程序，因此它必须尽可能短。

注意：我从http://acmgnyr.org/year2016/problems.shtml中解决了这个问题，但略加修改，并亲自编写了法官程序/测试案例。

规格

• 这是一个交互式问题，因此您的程序将把输出输出到stdout，并接收来自stdin的响应。
• 招式您的程序可以输出一个right，left，down，up。
• 然后它将获得以下之一作为输入：
  • wall-这意味着鲍勃撞墙了。鲍勃将留在同一个地方。
  • solved-鲍勃找到了出口！您的程序现在也应该退出而不打印其他任何东西。
  • ok -鲍勃能够朝着给定的方向移动。
• 如果迷宫没有出口，那么您的程序应该输出，no exit以让Bob知道他应该放弃。然后，您的程序应退出而不打印其他任何内容。
• 由于Bob急于离开，因此您的程序不应做任何无关紧要的动作。换句话说，您的程序不允许从相同的正方形向相同的方向移动两次。
• 这是代码高尔夫球，所以最短的程序胜出！

例子

在以下示例中，S是起始正方形，X是出口，#是墙，并且空格是有效正方形。由于没有一个正确的答案，因此这些只是解决方案的示例。还要注意，迷宫的图形就在那儿供您查看，您的程序不会将其作为输入。

########
#S     #
###### #
     # #
     #X#

right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              wall
down
              ok
right
              wall
down
              ok
right
              wall
down
              solved

#####
# S #
#####

right
              ok
right
              wall
down
              wall
up
              wall
left
              ok
down
              wall
up
              wall
left
              ok
down
              wall
up
              wall
left
              wall
right
              ok
no exit
              solved

###############################
#S                            #
##############       ###      #
             #       #X#      #
             #                #
             ##################

right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              wall
down
              ok
right
              wall
down
              ok
right
              wall
down
              ok
right
              wall
down
              wall
left
              ok
down
              wall
up
              ok
up
              ok
left
              ok
down
              ok
down
              ok
down
              wall
left
              ok
down
              wall
up
              ok
up
              ok
left
              ok
down
              ok
down
              ok
down
              wall
left
              ok
down
              wall
up
              ok
up
              ok
left
              wall
down
              ok
left
              wall
down
              ok
left
              ok
down
              wall
up
              wall
left
              ok
down
              wall
up
              solved

检查程序

• 我已经用Python编写了一个解决方案检查器。您可以在https://gist.github.com/Maltysen/f0186019b3aa3812d812f8bb984fee19上找到它。
• 像这样运行它python mazechecker.py ./mazesolver。
• 它将在名为的文件夹中的所有迷宫中测试您的程序mazes。
• 迷宫位于与上面相同格式的单独文件中。
• 它会检查上面列出的所有条件，并在解决方案违反时通知您。
• 您可以使用来打印其他诊断信息python mazechecker.py -d ./mazesolver。
• 您可以在此处找到一个压缩mazes文件夹。您也可以根据需要添加自己的名称。

JavaScript（ES6）， 180  174个字节

用于prompt()输出方向并检索结果。

_=>(g=p=>[...'012301234'].some((d,i)=>g[p]>>d&1|i<4&g[P=[p[0]+(d-2)%2,p[1]+~-d%2]]>0?0:(r=prompt('up/left/down/right/no exit'.split`/`[g[p]|=1<<d,d]))<'s'?g(P):r<'t'))([0,0])

在线尝试！（带有自动I / O）

互动片段

警告：此代码将显示一个hint（）对话框，直到输入'solved'或该函数指出根本没有退出。

(
_=>(g=p=>[...'012301234'].some((d,i)=>g[p]>>d&1|i<4&g[P=[p[0]+(d-2)%2,p[1]+~-d%2]]>0?0:(r=prompt('up/left/down/right/no exit'.split`/`[g[p]|=1<<d,d]))<'s'?g(P):r<'t'))([0,0])
)()

已评论

_ => (                      // anonymous function taking no argument
  g = p =>                  // g = recursive function taking the current position p = [x, y]
    [ ...'0123',            // i<4  : try to move on squares that haven't been visited yet
      ...'0123',            // 3<i<8: try to go back to where we initially came from
      ...'4'                // i=8  : if everything failed, there must be no exit
    ].some((d, i) =>        // for each direction d at index i:
      g[p] >> d & 1         //   if this direction was already tried at this position
      | i < 4 &             //   or i is less than 4 and
      g[P = [               //   the square at the new position P = [X, Y] with:
        p[0] + (d - 2) % 2, //     X = x + dx[d]
        p[1] + ~-d % 2      //     Y = y + dy[d]
      ]] > 0 ?              //   was already visited:
        0                   //     abort
      : (                   //   else:
        r = prompt(         //     output the direction:
          [ 'up',           //       0 = up
            'left',         //       1 = left
            'down',         //       2 = down
            'right',        //       3 = right
            'no exit'       //       4 = no exit
          ][                //
            g[p] |= 1 << d, //       mark this direction as used
            d               //       d = actual index of the string to output
          ]                 //     r = result of prompt()
        )                   //
      ) < 's' ?             //     if r = 'ok':
        g(P)                //       do a recursive call at the new position
      :                     //     else:
        r < 't'             //       yield true if r = 'solved' or false if r = 'wall'
    )                       // end of some()
)([0, 0])                   // initial call to g at (0, 0)