เฮลิคอปเตอร์ที่เริ่มต้นที่มุมซ้ายบนสุดจะลงมา (ในพื้นที่ 2 มิติเพื่อจุดประสงค์ของคำถามนี้) สู่พื้น มันมีโหมดอัตโนมัติและโหมดแมนนวล

โหมดอัตโนมัติทำงานดังนี้:

• หากช่องว่างด้านล่างว่างให้ลงไป
• มิฉะนั้นย้ายขั้นตอนไปทางซ้ายหรือขวาโดยสิ้นเชิงโดยการสุ่ม (อาจย้ายหลายขั้นตอนในลักษณะนี้)

และมันยังคงทำซ้ำสองขั้นตอนเหล่านี้จนกระทั่งมันกระทบพื้น โหมดแมนนวลนั้นฉลาดกว่าและจะหาเส้นทางที่ดีที่สุดไปยังพื้นดินแม้ว่ามันจะต้องเคลื่อนที่ขึ้นไปหรือต้องใช้ความชำนาญ

งานของคุณคือการตรวจสอบว่า

1. อัตโนมัติจะผ่านในสถานการณ์ที่กำหนด
2. อัตโนมัติอาจล้มเหลวในสถานการณ์ที่กำหนด
3. Autopilot จะล้มเหลว แต่โหมดแมนนวลจะผ่านหรือ
4. ทั้งสองโหมดจะล้มเหลว (ไม่มีเส้นทางที่ถูกต้องไปยังพื้นดิน)

อินพุต

• รับสถานการณ์เป็นอาร์เรย์ 1d หรือ 2d ที่ไม่ว่างโดยใช้อักขระสองตัวที่แตกต่างกันเพื่อแทนช่องว่างที่ว่างและถูกบล็อก เครื่องหมายวรรคตอนเป็นตัวเลือก
• ทางเลือก: ขนาดของอาร์เรย์

เอาท์พุต

หนึ่งในสี่ตัวอักษรที่กำหนดไว้ล่วงหน้าซึ่งระบุกรณีที่เกิดขึ้น

ข้อมูลตัวอย่าง

ใช้ 0 (ว่าง) และ 1 (บล็อค) ในอินพุต, 1 2 3 4 ในเอาต์พุต (ตามหมายเลขด้านบน)

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

เอาท์พุท: 1

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

เอาท์พุท: 2(เฮลิคอปเตอร์จะพบ 1 ในแถวที่สี่และเป็นไปได้ที่มันจะดักตัวเองในตอนท้ายของแถวที่ 5 หากอยู่ในโหมดอัตโนมัติ)

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

เอาท์พุท: 3(ต้องเลื่อนขึ้นไปข้างบนเพื่อให้หม้อแปลงอัตโนมัติทำงานล้มเหลว)

1 0 0
0 0 0

เอาท์พุท: 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

เอาท์พุท: 4

ทับทิม, 259

ฉันสนุกมากกับสิ่งนี้ ขอบคุณ! ความท้าทายของกริดมักจะสนุกกับความท้าทายที่น่าสนใจ นี่ถือว่า "ตัวอักษร" ในคำถามสามารถเป็นจำนวนเต็ม

ฉันคิดว่าประเด็นสำคัญของการปรับปรุงที่นี่คือ:

1. การสร้างของ r
2. การละเมิดที่ไม่น่าสนใจอย่างน่ากลัวในบรรทัดที่สามอาจทำให้กลายเป็นสิ่งที่น่ากลัวมากขึ้น

->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 (ล้าสมัยเล็กน้อย แต่ใกล้เคียงจริง):

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