Bob bị bắt cóc và bị mắc kẹt trong một mê cung. Công việc của bạn là giúp anh ta tìm ra lối thoát. Nhưng vì nó là một mê cung rất tối và đáng sợ, anh ta không thể nhìn thấy gì. Anh ta chỉ có thể cảm thấy những bức tường khi anh ta chạy vào đó, và biết khi nào anh ta đã tìm thấy lối ra, nhưng không biết gì thêm.

Vì anh ta phải chạy chương trình của bạn theo bộ nhớ, nên nó phải càng ngắn càng tốt.

Lưu ý: Tôi đã lấy vấn đề này từ http://acmgnyr.org/year2016/probols.shtml , nhưng đã điều chỉnh nó một chút và tự mình viết chương trình xét xử / các trường hợp thử nghiệm.

Sự chỉ rõ

• Đây là một vấn đề tương tác, vì vậy chương trình của bạn sẽ xuất các bước di chuyển đến thiết bị xuất chuẩn và nhận phản hồi từ stdin.
• Của bạn một đầu ra chương trình lon di chuyển right, left, down, up.
• Sau đó, nó sẽ nhận được một trong những điều sau đây:
  • wall- điều này có nghĩa là Bob đã va vào tường. Bob sẽ ở cùng một chỗ.
  • solved- Bob đã tìm thấy lối ra! Chương trình của bạn bây giờ cũng sẽ thoát mà không in bất cứ điều gì khác.
  • ok - Bob đã có thể di chuyển theo hướng đã cho.
• Nếu mê cung không có lối ra, chương trình của bạn sẽ xuất ra no exitđể cho Bob biết rằng anh ta nên từ bỏ. Chương trình của bạn sau đó sẽ thoát mà không in bất cứ điều gì khác.
• Vì Bob đang vội vã thoát ra, chương trình của bạn không nên thực hiện bất kỳ động thái ngoại lai nào. Nói cách khác, chương trình của bạn không được phép di chuyển theo cùng một hướng từ cùng một hình vuông hai lần .
• Đây là môn đánh gôn , vì vậy chương trình ngắn nhất sẽ thắng!

Ví dụ

Trong các ví dụ sau, Slà hình vuông bắt đầu, Xlà lối ra, #là một bức tường và không gian là hình vuông hợp lệ. Vì không có câu trả lời đúng duy nhất, đây chỉ là những ví dụ chạy của một giải pháp. Cũng lưu ý rằng các bản vẽ của mê cung chỉ ở đó để bạn xem, và chương trình của bạn sẽ không lấy chúng làm đầu vào.

########
#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

Chương trình kiểm tra

• Tôi đã viết một trình kiểm tra giải pháp bằng Python. Bạn có thể tìm thấy nó tại https://gist.github.com/Maltysen/f0186019b3aa3812d812f8bb984fee19 .
• Chạy nó như thế nào python mazechecker.py ./mazesolver.
• Nó sẽ kiểm tra chương trình của bạn trên tất cả các mê cung trong một thư mục có tên mazes.
• Các mê cung nằm trong các tệp riêng biệt có cùng định dạng từ phía trên.
• Nó kiểm tra tất cả các điều kiện được liệt kê ở trên và thông báo cho bạn nếu giải pháp của bạn vi phạm bất kỳ.
• Bạn có thể có nó in thông tin chẩn đoán bổ sung với python mazechecker.py -d ./mazesolver.
• Bạn có thể tìm thấy một mazesthư mục nén ở đây . Bạn cũng có thể thêm của riêng bạn vào nó nếu bạn muốn.

JavaScript (ES6),  180  174 byte

Sử dụng prompt()để xuất hướng và lấy kết quả.

_=>(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])

Hãy thử trực tuyến! (với I / O tự động)

Đoạn tương tác

CẢNH BÁO : mã này sẽ hiển thị hộp thoại nhắc () cho đến khi 'giải quyết' được nhập hoặc hàm chỉ ra rằng không có lối thoát nào cả.

(
_=>(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])
)()

Đã bình luận

_ => (                      // 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)