Gravity Guy 는 유일한 사용자 입력이 중력 방향을 뒤집는 단일 키인 게임입니다. ASCII 아트 레벨이 주어지면 Gravity Guy가 끝날 수 있는지 확인하십시오.

규칙

• 초기 무게 방향은 아래로 입니다.
• 입력의 첫 번째 열은 항상에만 포함됩니다 하나의 # 중력 가이, 에 시작 의 상단.
• 반복 할 때 마다 오른쪽 의 캐릭터로 직접 이동 합니다 .
• 그의 경우 경로를 차단 하고 그가으로 이동 #, 플레이어는 잃는다 .
• 이동 후 플레이어는 선택적으로 중력 을 아래에서 위로 또는 위에서 아래로 전환 할 수 있습니다 .
• 그런 다음 중력 가이가 다음 중력으로 넘어갑니다# (현재의 중력 방향으로).
• #넘어 지지 않고 그리드 에서 떨어지면 플레이어 는 패배 합니다.
• Gravity Guy 가 입력 그리드 의 오른쪽을 벗어나면 플레이어가 승리 합니다.

예

이것이 입력 그리드 인 경우 :

  ### 

#  # #
 ###  

Gravity Guy는 x각 반복 후에 및 위치에서 시작합니다 . ^= 중력 스위치를 위로, v= 중력 스위치를 아래로

v                        ^                               v
-------------------------------------------------------------
  ###   |    ###   |    ###   |    ###   |    ###   |    ### 
x       |          |    x     |     x    |      x   |        
#  #    |  #x #    |  #  #    |  #  #    |  #  #    |  #  # x
 ### #  |   ### #  |   ### #  |   ### #  |   ### #  |   ### #

보시다시피,이 시점에서 중력을 전환하면 Gravity Guy가 끝까지 도달 하므로이 입력은 진실한 값을 반환합니다.

명세서

• 입력 그리드는 적절한 "그리드"형식 (공백으로 채워진 여러 줄 문자열, 줄 문자열 배열, 문자 배열 등) 일 수 있습니다.
• 플레이어가 레벨을 이길 수 있으면 truthy값을 출력하십시오 . 그렇지 않으면 falsey값을 출력하십시오 .
• 격자의 너비와 높이는 50최대 문자입니다.
• 이것은 code-golf 이며 바이트 단위의 가장 짧은 코드가 이길 수 있습니다!

테스트 사례

(각 케이스는으로 구분되며 ----------빈 줄도 공백으로 채워야합니다)

참된

 #########   ########      ######     ######    
          #  #       #    #      #   #      #   
###    #   # #    #   #  #       #  #        #  
  #    ##  # #    ##  # #     # #  #      ##    
  #    #   # #    #   # #    #     #     #######
  #       #  #       #  #     ###  #          # 
  #    ##    #    ##     #       #  #         # 
  #    #          #              #        #   # 
  #    ####################################   # 
  #                                           # 
  ############################################# 

----------


###

----------

   #####

####    

----------

 #####
 # # #

# # # 
 #####

----------

   ############   

######      ######

   ############   

----------

  ###   ###  
     # #     
####  #  ####
    #   #    
     # #     
      #      

----------

    ######  
   #        
 ##         
     #######
###     #   
   #    #   
    #####   


----------

    #####   
   #    #   
 ##     #   
     #######
###         
   #        
    ######  

----------

  ### 

#  # #
 ###  

----------

  ###  ###

###     ##
   #    # 
    ##### 

----------

  #        
     #   # 
       #   
#   #     #
        #  
   #       
      #    
 #         

----------

    ##### ####   
   #     #    #  
  #   # #  ##  # 
             #  #
#####  ####   #  
               # 
     #########   

----------

 ########################### 
 #   #   #   #     #   #   # 
 # # # #   #   # #   #   # # 
 # # # ######### ########### 
 # # # #  #       #     #  # 
   # # # ## ##### ### #      
## #   #    #          ## ###
 # ##### #### ###########  # 
 # #     #  #     #     ## # 
 # # #####  ### # # # # #  # 
 #              #   # #   ## 
 ########################### 

그릇된

 ###
   #
####

----------


### ###

----------

    #   
 ### ###

#### ###
    #   

----------

  ###     ###  
     # # #     
####  # #  ####
    #     #    
     #   #     
      # #      
       #       

----------

  ####### 
  #     # 
 ## ##### 

### ######
  #     # 
  ####### 

----------

 ########################### 
 #   #   #   #  #  #   #   # 
 # # # #   #   # #   #   # # 
 # # # ######### ########### 
 # # # #  #       #     #  # 
   # # # ## ##### ### #      
## #   #    #          ## ###
 # ##### #### ###########  # 
 # #     #  #     #     ## # 
 # # #####  ### # # # # #  # 
 #              #   # #   ## 
 ########################### 

달팽이 , 15 바이트

온라인으로 사용해보십시오?

^
\ n\ ,=\#r}+~

0. ^패턴은 왼쪽 상단에서 시작해야하는 옵션입니다.

1. \ ​: 경기 공간

2. n: 어느 방향 으로든 90도 회전

3. \ ,​: 공간을 0 번 이상 일치

4. =\##우리 앞에 있는지 확인 하십시오

5. r: 방향을 오른쪽으로 설정

6. }+: 앞의 모든 것을 한 번 이상 수행하십시오.

7. ~ 그리드 범위를 벗어난 셀과 일치

Perl, 93 89 81 77 76 75 74 바이트

에 +2 포함 -0p

STDIN에서 입력 패턴을 사용하여 실행합니다 (모든 행 공간이 같은 길이로 채워짐).

gravity.pl < gravity.txt

gravity.pl:

#!/usr/bin/perl -0p
/
/;$n=".{@-}";s/#$n\K( $n)*\b |(^|w)([w ]$n)*\K $n#/w|$&/es&&redo;$_=m;w

이 파일 기반 버전에는 마지막 줄 바꿈이 필요하므로 실제로는 75 바이트입니다. 그러나 커맨드 라인 기반 버전에는 추가 줄 바꿈이 필요하지 않으므로 74 바이트로 계산됩니다.

perl -0pe '/
/;$n=".{@-}";s/#$n\K( $n)*\b |(^|w)([w ]$n)*\K $n#/w|$&/es&&redo;$_=m;w' < gravity.txt

설명:

이것은 w중력 사람이 도달 할 수있는 각 위치에 문자열을 구성합니다 . 따라서 두 번째에서 마지막으로 진실한 예를 위해 다음을 구성합니다.

     #########   
    ##### ####   
   #wwwww#wwww#  
  #w  # #w ##ww# 
wwwww wwwwwww#ww#
#####  ####  w#ww
     wwwwwwwwww# 
     #########   

따라서 중력 사람은 w마지막 열에 있는 경우에만 만들 수 있습니다 . 끈은 w각 라운드마다 하나의 도달 가능한 공간을 대체하여 구성됩니다 .

각 교체는 형태가됩니다

s/prefix \K space postfix/ w | $& /e

공백 앞에 접두사와 접미사가 있어야하지만 w고급 그룹화가 많이 필요하지 않고 공백 만 교체해야합니다 .

$n왼쪽과 오른쪽이 정확히 서로 아래에 있도록 충분히 진행되는 정규 표현식이 있다고 가정하십시오 . 그런 다음 관련 정규식은 다음과 같습니다.

/^( $n)*\K $n#/       From the first position drop down as long as you
                      encounter spaces until you encounter a #. 
                      This puts gravity guy on his starting platform

/#$n\K( $n)*\b /      A space immediately below a # and if you (optionally)
                      go down further from there (as as the descent is
                      over spaces) you get to a space that follows a word
                      boundary. The only way to get a word boundary is if 
                      there is a w in front of that space. This selects the
                      position gravity guy ends up on if starting from that
                      w and gravity is up
/w([w ]$n)*\K $n#/    A w followed by a space (or w) and if you go down from
                      there as long as it is over spaces (or w) you finally
                      end up on a space directly above a #. This handles the
                      gravity down case. The test uses "space or w" instead
                      of just space to handle this case:

                       #
                      ww
                      #x  
                       #

                      Position x is currently a space and must be replaced by a
                      w but the gravity up regex has already put a w directly
                      after the w gravity guy takes off from. So for gravity
                      down we must handle w as if it is still a space. This
                      is not needed for gravity up because regex always matches
                      starting at the earliest possible character, so 
                      gravity up matches before gravity down

그 방법으로 프로그램이 쉽습니다.

#!/usr/bin/perl -0p   Slurp all of STDIN into $_, at the end print $_

/\n/                  Match the first newline (needed to measure the row
                      length)
$n=".{@-}"            $n effectively becomes rowlength-1 times ".". This
                      will be the regex that goes one step down a column

s/#$n\K( $n)*\b |(^|w)([w ]$n)*\K $n#/w|$&/es

                     This is the 3 regexes shown above combined. The s 
                     modifier is needed so the . in $n also matches newline

    &&redo           Keep looping as long as w's keep getting added

$_=m;w\n;            Check if the last column contains a w: He made it!
                     The \n; at the end is not written. These 2 bytes sneakily
                     come from the -p option for the ; and the -e option
                     for the \n

자바 스크립트 (ES6), 174 바이트

a=>[...a[0]].map((_,i)=>[...t].map(x=>s[x]<'#'&&g(s.indexOf('#',x),-1)&&g(s.lastIndexOf('#',x),1),s=a.map(s=>s[i]),t=new Set),t=new Set([0]),g=(i,d)=>i<0||t.add(i+d))&&t.size

문자열의 가로 배열을 사용하여 종료점 수를 반환합니다. 배열을 바꾸려면 29 바이트가 필요합니다. 언 골프 드 :

function gravity(array) {
    var set = new Set;
    set.add(0); // starting point
    for (var i = 0; i < array[0].length; i++) {
        var s = array.map(s => s[i]); // transpose array
        var old = set;
        set = new Set;
        for (var x of old) {
            if (s[x] == '#') continue; // hit wall
            var j = s.indexOf('#', x); // try downward gravity
            if (j >= 0) set.add(j - 1);
            j = s.lastIndexOf('#', x); // try upward gravity
            if (j >= 0) set.add(j + 1);
        }
    }
    return set.size;
}

핍 , 85 68 62 59 + 1 = 60 바이트

-r플래그를 사용하여 stdin의 모든 행을 읽습니다.

FcZg{YlFxiIc@xQsyPB(Jc@<x@?`# *$`)+1PB(c@>x@?'#)+x-1i:UQy}i

온라인으로 사용해보십시오!

간단한 설명

이 전략은 본질적으로 광범위한 우선 검색입니다. 우리는 입력을 바꾸고 선 (열)을 반복하여 플레이어가 그 열에서 도달 할 수있는 y 위치의 목록을 유지합니다. 마지막 열 이후의 결과는 플레이어가 이길 수있는 경우 비어 있지 않은 목록이거나 플레이어를 잃으면 빈 목록 (후행 줄 바꿈으로 인쇄 됨)입니다.

전체 설명

내장이 프로그램에서 사용하는 변수 : i == 0, l == [], s == " ".

이 -r플래그는 입력 행 목록을에 넣습니다 g. 각 열에 FcZg{...}지퍼 g와 루프 c. (Unary Z는 iterable 목록에 적용될 때 Python처럼 작동 zip(*g)하여 깔끔하게 2D 배열을 바꿉니다.) c문자열이 아닌 목록 이 됩니다.

열 루프 안에서 anking y하여 빈 목록으로 Y재설정 l합니다. Fxi반복됩니다 i. 이후 반복에서는 i이전 열에서 플레이어가 도달 할 수있는 y 좌표 목록이됩니다. 처음으로, 우리는 단지 0(왼쪽 위 모서리) 로 시작하고 싶습니다 . 변수는 0List가 아닌 Scalar로 사전 초기화 [0]되지만 Pip은 어느 쪽이든 괜찮습니다.

마지막 열의 유효한 위치마다 Ic@xQs현재 열의 해당 위치에 공백이 있는지 확인합니다. 그렇지 않다면, 플레이어는 방금 벽에 닿아 다음 가능성을 시도합니다. 그렇다면 플레이어는 각 무게 방향에 대해이 열에서 플레이어가 떨어질 위치를 찾고 ush ack 연산자를 y사용하여 목록에 추가하려고합니다 .PB

중력 상승 (조옮김 버전에서 왼쪽) :

(Jc@<x@?`# *$`)+1
  c@<x             Slice everything left of x in the column
 J                 Join into a string so we can do a regex search on it
      @?`# *$`     Find index of the last # in this string
(             )+1  The player's index is the space below/to the right of this #

내려가는 중력 (전치 된 버전에서) :

(c@>x@?'#)+x-1
 c@>x              Slice everything right of x in the column
     @?'#          Find index of the first # in this list (no need to join into string)
(        )+x       Translate to index number in entire column
            -1     The player's index is the space above/to the left of this #

플레이어가 특정 방향으로 그리드에서 떨어지면 각 @?작업 에서 a를 찾지 못하고 #nil을줍니다. 이것은 유효한 인덱스가 아니며 다음 반복에서 일부 경고를 생성하지만 -w플래그 없이는 표시되지 않습니다 . 우리의 목적을 위해, 이러한 경우는 본질적으로 고려되지 않습니다.

내부 루프 후에 우리가 만든 위치 i:UQy목록 y을 가져 와서 중복을 제거하고에 할당합니다 i. (그렇지 않으면 목록이 기하 급수적으로 증가하기 때문에 중복을 제거해야합니다.) 그런 다음 다음 열로 이동합니다. 우리가 모든 열을 반복했을 때, 유효한 경로 i가 있다면, 비어 있지 않은 위치 목록이 될 것입니다 (truthy). 그렇지 않으면 빈 목록이됩니다 (falsey).