최근에 몇 가지 ASCII 애완용 뱀 문제가있었습니다 (예 : 여기 )

            0 0               
  0        0 0 000            
00 0     00       000 0      0
    000 0            0 0   00 
       0                000   

이 과제는 무작위로 생성 된 수평 애완 동물 뱀 (높이 5 줄, 길이 30)을 확인하고 다음을 확인하는 것입니다.

• 각 열에는 하나만 있습니다 0
• 각각 0은 0전후에 "연결"됩니다 (수직 간격으로 0 또는 1 줄만)

최종 출력 할 수 있습니다 true또는 1뱀이 유효한 경우, 또는 false나 0뱀이 유효하지 않은 경우

편집 — 설명

입력을 가정하십시오.

• 끈이다
• '', '0'및 '\ n'만 포함
• 한 줄에 정확히 30 자
• 정확히 5 줄

즉, 뱀이 연결되어 있고 길 잃은 문자가 없는지 확인하십시오. 뱀이 인쇄 된 "캔버스"를 확인할 필요가 없습니다.

자바 스크립트 (ES2018) 62 54 바이트

s=>!/0(.{30}|.{60,62}(.{31})*)0|( .{30}){4} /s.test(s)

입력은 단일 문자열입니다.

• 줄 바꿈없이
• 공백, '0'및 '\ n'만 포함
• 한 줄에 30 자, 5 줄, 총 154 자

플래그 s는 점이 무엇이든 일치하는 것을 의미합니다 ( '\ n'포함). 이 기능은 현재 compat-table 기반 Chrome 63 이상, Opera 50 이상, Safari 11.1 이상에서 지원됩니다 . 지원되는 브라우저에서이 기능을 테스트 할 수 있습니다. 브라우저가이 기능을 지원하지 않으면 페이지를로드 할 때 예외가 발생합니다.

작동 방식 :

• 열이 없습니다 0:
  • 일치하지 않는 /( .{30}){4} /
• 0한 열에 두 개가 없습니다 .
  • 일치하지 않는 /0.{30}(.{31})*0/
• 0이웃에 연결 하지 마십시오 :
  • 일치하지 않습니다 /0.{60}(.{31})*0/./0.{62}(.{31})*0/

이 정규식을 모두 병합하면 마침내이 정규식을 얻게됩니다.

f =

s=>!/0(.{30}|.{60,62}(.{31})*)0|( .{30}){4} /s.test(s)

<textarea id=i style="width:100%;height:100px">            0 0               
  0        0 0 000            
00 0     00       000 0      0
    000 0            0 0   00 
       0                000   </textarea>
<button onclick="o.value=f(i.value.slice(0,154))">Validate</button>
Result: <output id=o></output>

Martin Ender 덕분에 단일 !연산자를 사용하면 8 바이트를 절약 할 수 있습니다.

SnakeEx , 51 바이트

이것은 분명히 작업에 적합한 언어입니다. : ^ D

s:({c<L>}{c<R>}0[(<R> <L>)(<L> <R>)_?])%{30}
c:0 *$

유효한 뱀인 경우 전체 입력을 일치시킵니다. 일치하지 않으면 일치하지 않습니다. 여기 사용해보십시오!

설명

SnakeEx는 2D 패턴 일치 언어 입니다. 프로그램은 "뱀"에 대한 정의 목록으로 구성되며, 입력 일치 문자를 탐색하고 방향을 변경하며 다른 뱀을 생성합니다. 우리의 프로그램에서, 우리는 두 마리의 뱀을 정의 s하고 c.

c더 간단하기 때문에 시작하겠습니다 . 그 정의는이며 0 *$, regex : match를 알고 있으면 00 개 이상의 공백이 있고 그리드의 가장자리가 표시되면 읽을 수 있어야 합니다. 여기서 가장 중요한 것은이 매칭은 어느 방향으로나 진행될 수 있다는 것입니다. 우리는 c뱀에서 위쪽과 아래쪽으로 모두 사용 0하여 각 열에 여분 의 s 가 없는지 확인합니다 .

이제 주 뱀을 위해 s. 이 형식 (...)%{30}은 "괄호 안의 내용을 30 번 일치시킵니다"라는 의미 0입니다. 뱀 마다 한 번씩 . 여태까지는 그런대로 잘됐다. 괄호 안에 무엇이 있습니까?

{c<L>}

이것은 새로운 c뱀을 생성하고 왼쪽으로 90도 회전합니다. 방향은 s뱀의 방향을 기준으로하므로 새 뱀은 그리드의 상단으로 이동합니다 (주 뱀은 오른쪽으로 이동). c현재의 그리드 셀이 인 뱀 검사 0위의 모든 셀이 공백이고있다. 실패하면 전체 경기가 실패합니다. 성공하면 계속

{c<R>}

이것은 똑같은 일을합니다 (오른쪽 그리드 방향으로).

이 스폰은 메인 스네이크에서 일치 포인터의 위치에 영향을 미치지 않습니다. 그들은 정규식의 예견과 조금 같습니다. (어쩌면 여기에서 "lookbesides"라고 부를 수 있을까요?) 따라서 a를 가리키고 0있고 나머지 열에 공백 만 포함되어 있는지 확인한 후에 실제로 다음과 일치해야합니다 0.

0

이제 일치 포인터가의 오른쪽에 있습니다 0. 뱀 각도가 내려가거나 뱀 각도가 올라가거나 뱀이 똑바로 세 가지 옵션을 확인해야합니다. 이를 위해 OR 표현식을 사용할 수 있습니다.

[...]

수술실 내부에는 세 가지 가능성이 있습니다.

(<R> <L>)

우회전, 공백을 맞추고 다시 좌회전 (뱀 각도 내리기).

(<L> <R>)

왼쪽으로 돌리고 공간을 맞추고 다시 오른쪽으로 돌리십시오 (뱀 각도).

_?

밑줄을 0 개 또는 1 개 일치시킵니다. 입력에 밑줄이 없기 때문에 이것은 항상 비어있는 일치입니다 (뱀이 똑바로갑니다).

위의 세 가지 옵션 중 하나를 일치시킨 후 일치 포인터는 0다음 열에서를 가리키고 괄호로 묶은 표현식을 다시 일치시킬 수 있어야합니다.

CJam , 35 34 바이트

{z_{'0e=1=}%:*\'0f#2ew::-[W0X]-!*}

온라인으로 사용해보십시오! 입력은 문자 배열의 직사각형 배열입니다. 입력에 and 만 포함되어 있다고 가정합니다 0.

설명:

{z_{'0e=1=}%:*\'0f#2ew::-[W0X]-!*}   Function taking a character matrix:
 z                                      Transpose.
   {      }%                            Consider whether each row
      e=                                  contains
        1=                                exactly one
    '0                                    of the character '0'.
            :*                            This must be true for every row.
                  #                     Next, find the position
               '0                         of the character '0'
                 f                        at every row
  _           \                           in the original input.
                       :-               Find the differences between
                      :                   each
                   2                      pair
                    ew                    of adjacent elements (in other words, compute
                                            the increments).
                                        For the snake to be valid, this array of increments
                                            must only contain {0, 1, -1}, so
                              -         Remove from this list
                         [   ]            the elements
                          W                 -1,
                           0                0,
                            X               and 1,
                               !          and then check whether the array is empty.
                                *       The previous code tested two different properties
                                          of the matrix; they both must be true for a
                                          valid snake.

05AB1E , 18 바이트

ζDε0k}¥Ä2‹sεþg}ìPΘ

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

설명

ζ                    # transpose
 D                   # duplicate
  ε  }               # for each row in the first copy (column of input)
   0k                # get the index of the first 0
      ¥Ä             # calculate absolute delta's
        2‹           # check that each is less than 2
          sε  }      # for each row in the second copy (column of input)
            þg       # calculate the length of the string with non-digits removed
               ì     # concatenate the lists
                P    # calculate product
                 Θ   # truthify (turn false values to 0)

껍질 , 12 바이트

규칙 설명에 따라 11 바이트 또는 13 바이트 일 수 있습니다 .

±Λ=;1Ẋ×≈mηfT

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

입력은 공백과 0 만 포함하는 행 목록입니다. 단일 문자열이 필요한 ¶경우 프로그램 앞에 추가 하여 행으로 분할하십시오. TIO 링크는 이미 명확성을 위해이 작업을 수행합니다. 출력은 0 또는 1입니다. 잘못된 값과 진실한 값이 ±있으면 제거 할 수 있습니다.

설명

±Λ=;1Ẋ×≈mηfT  Implicit input: a list of lines.
           T  Transpose into list of columns.
        m     For each column,
         ηf   get list of indices of truthy elements.
              In Husk, whitespace characters are falsy and other are truthy,
              so this gets us the indices of 0s on each column.
     Ẋ        For each adjacent pair of these index lists,
      ×       for all pairs drawn from the two lists,
       ≈      give 1 if they differ by at most 1, otherwise 0.
              For each adjacent pair, this produces a list of 1s and 0s.
 Λ            Do all of these lists
  =;1         equal [1]? Return either 0 or 30 (length of the outer list + 1).
±             Signum; convert to 0 or 1.

아이디어는 ×≈(a) 모든 열에 정확히 하나의 0이 포함되고 (b) 그 위치가 최대 1만큼 달라 지도록하는 것입니다. 예를 들어, 8 열 입력을 고려하십시오.

0  0  0 
 000 0  
  00   0

먼저 mηfT인덱스 목록으로 변환

[[1],[2],[2,3],[1,2,3],[],[2],[1],[3]]

그런 다음 Ẋ×≈제공

[[1],[1,1],[1,1,0,1,1,1],[],[],[1],[0]]

각각 1최대 1만큼 다른 인덱스 쌍에 0해당하고 그렇지 않은 쌍에 해당합니다. [1]두 목록에 하나의 색인이 있고 색인이 최대 1 씩 다른 경우 각 결과는 정확하게 같습니다 .

파이썬 2 , 71 바이트

f=lambda s:s[1]<' 'or'0'in s[::31]in' %s '%s[1::31]in'%6s'%0*2*f(s[1:])

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

여러 줄 문자열로 입력을받습니다. Bubbler에서 사례 를 테스트합니다 .

첫 번째 열로 추출 s[::31]하고 상기 제로서 s[1::31], 이들은 유효성을 체크한다. 우리 s는 첫 번째 문자 를 제거하고 반복하여 열 쌍을 검사합니다.

두 열 in검사는 여러 검사 를 결합 하기 위해 Python의 비교 체인을 사용 합니다.

• '0'in s[::31] 첫 번째 열에 하나 이상의 열이 있는지 확인 0
• s[::31]in' %s '%s[1::31]첫 번째 열이 두 공간 사이의 두 번째 열 샌드위치의 하위 문자열인지 확인 0하여 최대 한 공간 의 위치 가 이동 했는지 확인합니다
• ' %s '%s[1::31]in'%6s'%0*2두 번째 열에 최대 하나가 포함되어 있는지 확인합니다 0.

엔딩 *f(s[1:])은 또한 재귀 사례를 강제로 적용합니다.

C (gcc) ,246 245 232 215 212 바이트

#define F)exit(1);
#define L for(i=l=0;i<30;i++)
#define X b[7][i]
char b[8][31];k,j,l;main(i){for(;j++<5;){gets(b);L{if(i[*b]>47){if(X++F memset(b[j+1]+i-1,l=1,3);}else if(!X&b[j][i]F}k+=!!l;}if(k<5 F L if(!X F}

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

나는 내가 좋아하는 언어를 이것에 적용 할 것이라고 생각했다. 문제에 대한 프로그램의 접근 방식은 많은 바이트 페니-피칭과 함께 비교적 간단합니다. 그것은 뱀을 stdin에 가져 와서 main의 반환 값으로 결과를 제공합니다 (따라서 종료 코드;문제에서 요청 한대로 0은 잘못된 뱀을 나타내며 1은 이상한 종료 코드에도 유효합니다.종료 코드에서 일반적으로 0은 유효한 뱀이고 1은 잘못된 뱀입니다. 매크로가 확장되고 멋진 공백이 있으면 다음과 같이 보입니다.

char b[8][31];l,j,k;                           //Declares a buffer to work in, initialized all to 0; l j and k default to int and as globals are init to 0
main(i) {                                      //This is run no-args, so argc is 1 and the undeclared type defaults to int.
  for (; j++ < 5;) {                           //Iterating over each row, 1-indexed for convenience accessing the buffer
    gets(b);                                   //Reads into b[0] because of stack array decl layout
    for (i = l = 0; i < 30; i++) {             //j and l both init each time we begin this overall loop
      if (i[*b] > 47) {                        //Did we read a zero?
        if(b[7][i]++) exit(1);                 //If the snake already had a zero in this column, fail out
        memset(b[j+1] + i-1, l = 1, 3);        //Expect them on the next row in the columns left and right of this one (also set l)
      } else if (!b[7][i] & b[j][i]) exit(1);  //If we didn't read a zero, and we had reason to expect one this row, and there wasn't already a zero in this column, fail out
    }
    k+=!!l;                                    //Adds 1 to k iff l is nonzero 
  } if (k < 5) exit(1);                        //If less than 5 rows had zeroes in them, fail out
  for(i = l = 0 ; i < 30; i++) {               //l isn't relevant in this loop but saves some bytes when sharing a macro with the other horizontal loop
    if(!b[7][i]) exit(1);                      //If any columns didn't have zeroes, fail out
  }                                            //Else, snake is valid. main default returns 0.
}

입력 라인은 버퍼의 첫 번째 행으로 읽히고, 다음 5 개는 각 현재 행 다음에 행에 0이있는 것으로 예상되는 위치 (읽기 : 필수)를 추적하기위한 것이며, 마지막은 0이 이미 있는지 여부를 추적하기위한 것입니다. 주어진 열의 모든 행에서 읽습니다. 프로그램은 각 행을 차례로 처리합니다.

그것은 전혀 견고하지는 않으며 ( gets()시작일뿐입니다) 입력은 모든 관련 공간을 포함해야합니다 (예 : 왼쪽 후행 공백 없음) gcc는 암시 적으로 선언 된 stdlib 기능에 대한 경고와 메모를 뿌립니다. 라비

또한 뱀 머리가 중앙 행에있을 필요는 없으며 유효한 뱀은 모든 행에 적어도 하나의 0이 있어야한다고 가정합니다 (즉, 5 개의 입력 행에 모든 공간의 행이 없음). 후자가 요구 사항이 아닌 경우 조금 더 짧아 질 수 있습니다.이 경우 프로그램 k과 관련 l하여 모든 것을 파싱하거나 더 적은 바이트의 코드로 바꿀 수 있습니다.

에 대한 user202729에게 감사합니다. 26 바이트가 저장되었습니다.

MATL , 18 17 바이트

32>&fun30=wd|2<vA

입력은 2D 문자 배열입니다. 공백이 아닌 문자를 뱀에 사용할 수 있습니다.

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

설명

32>      % Implicit input. Transform non-space into 1, space into 0
&f       % Push vector of row indices and vector of column indices of nonzeros
u        % Unique: vector of deduplicated entries
n        % Length
30=      % Does it equal 30? (*)
w        % Swap. Moves vector of row indices to top
d|       % Absolute consecutive differences
2<       % Is each value less than 2? (**)
v        % Concatenate results (*) and (**) vertically
A        % All: true if all entries are nonzero. Implicit display

슬립 , 28 바이트

((\|/)?0(<(?| *$^)<){2}){30}

여기에서 테스트하십시오.

젤리 , 19 바이트

Zn⁶T€L€=1$$;FIỊ$$$Ạ

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

Mr. Xcoder 덕분에 -2 바이트

설명

Zn⁶T€L€=1$$;FIỊ$$$Ạ  Main Link
Z                    Transpose the matrix of characters
                         (string -> list of chars in Jelly)
 n⁶                  != " " (vectorizing)
   T€                For each column, get (row) indices of snake parts
     L€=1$$          For each index list, is its length 1? (that is, exactly one snake part per column)
           ;     $   Append (helper part)
            FIỊ$$    helper part:
            F        flatten index list
             I       get increments/forward differences
              Ị      are the values insignificant? (|z| <= 1)
                  Ạ  Are these all true?

입력은 문자열 목록입니다

젤리 , (14? *) 13 바이트

Zn⁶T€z-IỊ0-¦Ȧ

공백과 다른 문자로 구성된 각 길이 30의 5 개 문자열 * 목록을 가져 오는 모나드 링크 (예 : 0 s) 오고 정수를 반환하는 뱀이 정의 된 경우 1, 그렇지 않으면 0)

* 입력이 단일 문자열 (문자 목록)이어야하는 경우 앞에 Ỵ 줄 바꿈에서 문자열을 분할 위해 를 .

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

방법?

Zn⁶T€z-IỊ0-¦Ȧ - Link: list of lists of characters, Lines
Z             - transpose the lines -> columns
  ⁶           - literal space character
 n            - not equal? -> 0 where there were spaces and 1 where there were "0"s
   T€         - truthy indices for each -> e.g. [0,0,1,0,0] -> [3] or [0,1,1,0,0] -> [2,3]
              -                           note: [0,0,0,0,0] -> []
      -       - literal minus one
     z        - transpose with filler (-1) -> {valid: a single list of heights {top:1,...,bottom:5}
              -                              invalid: list of >1 lists, some of which contain -1
              -                                       ...OR an empty list (no 0s in the input at all)}
       I      - differences -> {up:-1; down:1; flat:0; invalid:-6,-5,...,-2,2,...4}
        Ị     - insignificant (abs(z)<=1) -? {up/down/flat:1; invalid:0}
           ¦  - sparse application///
         0    - ...action: literal zero
          -   - ...to indices: [-1] -> make penultimate list into a zero (when one exists)
            Ȧ - any & all -> when flattened:{empty or contains a 0:0; otherwise:1}

Stax , 20 바이트 ^CP437

Å┴m▐◘5)ît╢V¼≥+╝╜►º½ê

압축을 풀 때 24 바이트

LM{'0|Ic%vChm:-{Jh!f%29=

온라인으로 실행하고 디버그하십시오!

최고의 골프 ​​선수는 아니지만 그 방법은 참신하고 흥미 롭습니다.

설명

LM                          Load the input string as a 2d array of characters, and transpose it

  {         m               Map array with block
   '0|I                     Get all indices of substring "0"
       c%vC                 Map to nothing if the indices are not unique
           h                Otherwise map to the unique index

             :-             Take pairwise difference

               {   f        Filter array with block
                Jh!         Only keep 0, 1 and -1

                    %29=    Check whether the final array has exactly 29 elements

J , 38, 37 30 바이트

FrownyFrog 덕분에 -8 바이트

[:($e.~[:(-:*)2-/\])@:I.'0'=|:

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

젤리 , 16 바이트

Zµi€”0IỊ;ċ€⁶=4ƊẠ

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

입력 문자열이 항상 공백과 0 만 포함한다고 가정합니다. 입력을 문자열 목록 (각각 줄을 나타냄)으로 취하고, 참이면 1을 출력 합니다. 0 그렇지 않으면 합니다.

설명

Zµi€”0IỊ;ċ€⁶=4ƊẠ | Monadic full program.
Z                | Transpose.
 µ               | Start a new monadic chain.
  i€”0           | Retrieve the first index of 0 in each column.
      IỊ         | Check whether their increments are insignificant (element-wise).
        ;     Ɗ  | Append the result of the following:
         ċ€⁶     | In each list of characters, count the occurrences of a space.
            =4   | Check whether they equal 4 (returns a boolean array).
               Ạ | All. Check whether all the elements are truthy.

파이썬 2 , 141 바이트

lambda g:(lambda a:all(map(len,a)+[-2<x-y<2 for b in[sum(a,[])]for x,y in zip(b,b[1:])]))([[i for i in range(5)if"0"==r[i]]for r in zip(*g)])

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

입력은 문자 그리드입니다.

파이썬 2 와 파이썬 (3) , 122 (120) 119 바이트

lambda s:s.count('0')<31and all(s[i-31*(i>30):31*(i<124)-~i:31].strip(' ')for i,x in enumerate(s,1)if' '<x)and' '<s[62]

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

입력 형식은 길이가 154 인 문자열 (5 x 30 자, 줄 바꾸기 4 개)입니다.

'''
            0 0               
  0        0 0 000            
00 0     00       000 0      0
    000 0            0 0   00 
       0                000   '''[1:] # to exclude starting newline

머리가 가운데 줄이 아니어도

센터 로우 헤드 요구 사항은 원래 도전에 있었지만 여기서는 그렇지 않습니다 (적어도 명시 적으로 언급되지 않았습니다).

파이썬 2 와 파이썬 (3) , 124 (123) 바이트

lambda s:s.count('0')<31and all(s[i-31*(i>30):31*(i<124)-~i:31].strip(' ')for i,x in enumerate(s,1)if' '<x)and'0'in s[::31]

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

편집하다:

• equals를 변경하여 2 바이트 감소 (== )를 각 코드의 부등식 였습니다.
• 덜 제한적인 버전에서 실수를 찾아 수정했습니다. (아쉽게도 너무 끔찍하지는 않으므로 모든 버전의 길이를 비슷하게 유지할 수 있습니다.) 후자의 두 TIO 링크에서 추가 테스트 사례를 볼 수 있습니다.
• Py2 솔루션에서 매달려있는 바이트를 발견하여 all()Py3 에서 트릭을 무의미하게 만들었으므로 두 버전을 병합했습니다.

Excel (VBA), 68 바이트

Cell[A6]출력으로 직접 실행 창 사용

[A1:AD5]="=CHOOSE(ROUND(RAND()+1,),0,"""")":[A6]="=COUNT(A1:AD5)=30"

달팽이 , 18 바이트

\0!(ud.,\0)raa7)30

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

Grime , 30 26 23 바이트

7 바이트를 절약하고 버그를 지적한 Zgarb에게 감사합니다.

e`" 0/0 "oO|#29ddv&d#1+

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

루비 , 93 바이트

->x{x.transpose.map{|x|x.count(?0)<2&&x.index(?0)}.each_cons(2).all?{|x,y|x&&y&&(x-y).abs<2}}

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

자바 스크립트 (Node.js) , 128 (126) 바이트

입력이 "문자열"임을 나타내는 입력 설명 후 편집됩니다.

F=(a,l=29,r=0,t=/^( *)0 *$/.exec(a.split`
`.map(p=>p[l]).join``),q=t&&~t[1].length)=>q&&(s=q-(r=r||q))>-2&s<2?l?F(a,l-1,q):1:0

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

파이썬 3 , 197 185 바이트

명령 프롬프트 verify.py<snake.txt에서 또는 bash에서cat snake.txt | python verify.py . 어디에snake.txt확인할 뱀이 포함 된 파일은 ?

뱀이 올바른 경우 아무것도 출력되지 않습니다. 그것이 정확하지 않으면 파이썬은 색인 오류를 발생시킵니다.

import sys
s=sys.stdin.read().split("\n")
x=0
exec('t,y="",0\nwhile y<5:t+=s[y][x];y+=1\ns+=[t];x+=1;'*30)
s=list(map(lambda l:len(l.rstrip()),s))
while y<35:"ee"[abs(s[y]-s[y+1])];y+=2