Một máy bay trực thăng bắt đầu từ góc trên bên trái đang đi xuống (trong không gian 2D, cho mục đích của câu hỏi này) hướng về mặt đất. Nó có chế độ lái tự động và chế độ thủ công.

Chế độ lái tự động hoạt động như sau:

• Nếu không gian trực tiếp bên dưới là miễn phí, hãy hạ xuống nó.
• Mặt khác di chuyển một bước sang trái hoặc phải, hoàn toàn ngẫu nhiên. (Nó có thể di chuyển nhiều bước theo cách này.)

Và nó cứ lặp đi lặp lại hai bước này cho đến khi chạm đất. Chế độ thủ công thông minh hơn và sẽ tìm thấy đường dẫn tối ưu xuống mặt đất, ngay cả khi điều này đòi hỏi phải di chuyển lên trên, hoặc một số thao tác khéo léo.

Công việc của bạn là xác định xem

1. Chế độ lái tự động sẽ vượt qua trong kịch bản đã cho,
2. Chế độ lái tự động có thể thất bại trong kịch bản đã cho,
3. Chế độ lái tự động sẽ thất bại, nhưng chế độ thủ công sẽ vượt qua hoặc
4. Cả hai chế độ sẽ thất bại (không có đường dẫn hợp lệ xuống mặt đất).

Đầu vào

• Đưa ra kịch bản dưới dạng mảng không trống 1d hoặc 2d, sử dụng hai ký tự khác nhau để thể hiện các khoảng trống tự do và bị chặn. Dấu câu tùy chọn.
• Tùy chọn: kích thước của mảng

Đầu ra

Một trong bốn ký tự được xác định trước cho biết trường hợp nào đã xảy ra.

Dữ liệu mẫu

Sử dụng 0 (trống) và 1 (bị chặn) trong đầu vào, 1 2 3 4 ở đầu ra (như được đánh số ở trên)

0 0 0 0
0 1 0 0
0 0 0 1
1 1 0 0

Đầu ra: 1

0 0 1 0
1 0 0 1
0 0 0 0
0 1 1 0
0 0 0 1

Đầu ra: 2(Máy bay trực thăng sẽ gặp số 1 ở hàng thứ tư và có thể nó sẽ tự bẫy ở cuối hàng 5, nếu ở chế độ lái tự động)

0 0 0 1 0
0 1 1 0 0
0 1 0 0 0
0 0 0 1 0
1 1 1 1 0

Đầu ra: 3(Điều này đòi hỏi phải di chuyển lên trên, vì vậy chế độ lái tự động không thành công)

1 0 0
0 0 0

Đầu ra: 4

0 0 0 0 1
1 1 1 0 0
1 0 0 1 0
0 1 0 0 0
0 0 1 1 1

Đầu ra: 4

Ruby, 259

Tôi đã có rất nhiều niềm vui với điều này. Cảm ơn bạn! những thách thức lưới có xu hướng là niềm vui tuyệt vời với những thách thức thú vị. Điều này giả định rằng "ký tự" trong câu hỏi có thể là số nguyên.

Tôi nghĩ rằng những điểm chính của cải tiến ở đây là:

1. Việc tạo ra r
2. Lạm dụng ternary ghê tởm trên dòng thứ ba có thể có thể được thực hiện thành một thứ ghê gớm hơn, nhưng căng thẳng hơn một cái gì đó.

->a,h,w{f=->l,s=0,y=[0]{r=w-2<s%w ?w:1,1>s%w ?w:-1,w
v=(l ?r+[-w]:a[s+w]==0?[w]:r).map{|d|a[m=s+d]==0&&!y[m]?m:p}-q=[p]
a[s]>0?q:s/w>h-2?8:v[0]?v.map{|o|f[l,y[o]=o,y]}.flatten-q :r.any?{|i|a[s+i]<1}?p: !0}
g=f[p]
[8,g[0]&&g.all?,g.any?,f[8].any?,!p].index !p}

Ungolfed (hơi lỗi thời, nhưng thực sự gần gũi):

# a is a one-dimensional array of 0s and 1s, h is height, w is width
->a,h,w{
  # f recursively walks the array and returns true/false/nil for each path.
  #    True means we can reach ground.
  #    False means we are stuck in a local minimum and cannot escape
  #    Nil means we reached a local dead-end and need to backtrack.
  # l: {true=>"manual", false=>"autopilot"}
  # s: the position index
  # y: an array of booleans - true-ish means we've visited that square before
  #         (this is to prevent infinite loops, esp in manual mode)
  f=->l,s=0,y=[0]{
    # d: all the legal deltas from s (maximally, that's [1,-1,w,-w], aka [LRDU])
    # r: but the right and left get tricky on the edges, so let's pre-calculate those
    #    we'll default to "down" if "left" or "right" are illegal
    r=[w-2<s%w ?w:1,1>s%w ?w:-1]
    # if manual, [LRDU]; if auto, and you can go down, [D]. else, [LR] 
    d=l ?r+[w,-w]:a[s+w]==0?[w]:r
    # v: the legal deltas that you can go to from s (that is, unvisited and unblocked)
    v=d.map{|d|a[m=s+d]==0&&!y[m]?m:p}-[p]


    a[s]>0 ? [p]     # if we're currently blocked, return [nil] (this is only the case when a[0]==1)
      : s/w>h-2 ? !p # if we're at the bottom, return true
        : v[0] ?     # if we have a place to go....
        v.map{|o|f[l,y[o]=o,y]}.flatten-[p] # recurse with each step.
                                            # y[o]=o is a neat trick to make y[o] truthy and return o
          : r.any?{|i|a[s+i]==0} ? # otherwise, we have nowhere to go. If we could visit left/right, but have already been there
            p                      #    this is not a dead-end - return nil to remove this path
            : !!p                  # If we have a true dead-end (auto-mode with a local minimum), false
  }
  # g is the auto flight
  g=f[p]
  # finally, choose the first "true" out of:
  # 0: always 8.  Cuz why not 8?
  # 1: there is at least one auto path, and all are truthy
  # 2: any auto path is truthy
  # 3: any manual path is truthy
  # 4: true
  [8,g[0]&&g.all?,g.any?,f[!p].any?,!p].index !p
}