Sol üst köşeden başlayan bir helikopter yere (bu sorunun amacı için 2B alanda) iniyor. Otopilot modu ve manuel modu vardır.

Otopilot modu aşağıdaki gibi davranır:

• Doğrudan aşağıdaki alan boşsa, aşağı inin.
• Aksi takdirde, bir adımı tamamen rasgele sola veya sağa hareket ettirin. (Birden fazla adımı bu şekilde taşıyabilir.)

Ve yere çarpana kadar bu iki adımı tekrarlamaya devam ediyor. Manuel mod daha akıllıdır ve yukarı doğru hareket etmeyi veya usta bir manevra gerektirse bile zemine en uygun yolu bulacaktır.

İşiniz,

1. Otopilot verilen senaryoda geçecek,
2. Otopilot verilen senaryoda başarısız olabilir,
3. Otopilot başarısız olur, ancak manuel mod geçer veya
4. Her iki mod da başarısız olacaktır (toprağa geçerli bir yol yoktur).

Giriş

• Boş ve engellenmiş boşlukları temsil etmek için iki farklı karakter kullanarak 1d veya 2d boş olmayan bir dizi olarak senaryo verilir. Noktalama işaretleri isteğe bağlıdır.
• İsteğe bağlı: dizinin boyutları

Çıktı

Vakaların hangilerinin meydana geldiğini gösteren önceden tanımlanmış dört karakterden biri.

Örnek veri

Girişte 0 (boş) ve 1 (engellenmiş) kullanarak, çıkışta 1 2 3 4 (yukarıda numaralandırıldığı gibi)

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

Çıktı: 1

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

Çıktı: 2(Helikopter dördüncü sıradaki 1 ile karşılaşacak ve eğer otopilot modunda ise sıra 5'in sonunda kendini hapsetmesi olasıdır)

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

Çıktı: 3(Bu yukarı doğru hareket etmeyi gerektirir, bu yüzden otomatik pilot başarısız olur)

1 0 0
0 0 0

Çıktı: 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

Çıktı: 4

Yakut, 259

Bununla çok eğlendim. Teşekkür ederim! ızgara zorlukları ilginç zorluklarla mükemmel eğlenceli olma eğilimindedir. Bu, sorudaki "karakterlerin" tamsayı olabileceğini varsayar.

Bence buradaki önemli gelişme noktaları:

1. Oluşturulması r
2. Üçüncü satırdaki korkunç üçlü istismar muhtemelen daha korkunç bir hale getirilebilir, ancak bir şeyi tersine çevirebilir.

->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 (biraz güncel değil, ama gerçek kapanış):

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