왼쪽 상단에서 시작하는 헬리콥터가 지상으로 내려갑니다 (이 질문의 목적을 위해 2D 공간에서). 자동 조종 장치 모드와 수동 모드가 있습니다.

자동 조종 장치 모드는 다음과 같이 작동합니다.

• 바로 아래 공간이 비어 있으면 그 공간으로 내립니다.
• 그렇지 않으면 단계를 완전히 무작위로 왼쪽 또는 오른쪽으로 이동하십시오. (이 방법으로 여러 단계를 이동할 수 있습니다.)

그리고 땅에 닿을 때까지이 두 단계를 계속 반복합니다. 수동 모드는 더 똑똑하고 위쪽으로 이동하거나 숙련 된 조작이 필요한 경우에도 최적의 접지 경로를 찾을 수 있습니다.

당신의 임무는 여부를 결정하는 것입니다

1. 자동 조종 장치는 주어진 시나리오에서 통과합니다.
2. 주어진 시나리오에서 자동 조종 장치가 실패 할 수 있습니다.
3. 자동 조종 장치는 실패하지만 수동 모드는 통과하거나
4. 두 모드 모두 실패합니다 (지상 경로가 유효하지 않음).

입력

• 여유 공간과 차단 된 공간을 나타내는 두 개의 다른 문자를 사용하여 1d 또는 2d 비어 있지 않은 배열로 시나리오가 제공됩니다. 문장 부호는 선택 사항입니다.
• 선택 사항 : 배열의 크기

산출

발생한 사례를 나타내는 사전 정의 된 4 개의 문자 중 하나입니다.

샘플 데이터

입력에 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(4 행에서 헬리콥터가 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
}