Gần đây đã có một vài thử thách rắn thú cưng ASCII (ví dụ ở đây )

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

Thử thách này là bắt một con rắn thú cưng nằm ngang được tạo ngẫu nhiên (chiều cao năm dòng, chiều dài 30) và xác minh rằng:

• Mỗi cột chỉ có một 0
• Mỗi cái 0được "kết nối" với 0trước và sau nó (cách nhau theo chiều dọc chỉ 0 hoặc 1 dòng)

Đầu ra cuối cùng có thể truehoặc 1nếu con rắn hợp lệ, falsehoặc 0nếu con rắn không hợp lệ

Chỉnh sửa làm rõ

Giả sử đầu vào:

• Là một chuỗi
• Chỉ chứa '', '0' và '\ n'
• Có chính xác 30 ký tự mỗi dòng
• Có đúng 5 dòng

Tức là xác minh xem con rắn có được kết nối hay không, và không có ký tự đi lạc. Không cần xác nhận "khung vẽ" mà con rắn được in trên đó.

JavaScript (ES2018), 62 54 byte

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

Đầu vào là một chuỗi đơn:

• không theo dõi dòng mới
• chỉ chứa khoảng trắng, '0' và '\ n'
• 30 ký tự mỗi dòng, tổng cộng 5 dòng, 154 ký tự

Cờ scó nghĩa là một dấu chấm khớp với bất cứ thứ gì (bao gồm cả '\ n'). Tính năng này hiện được Chrome 63+, Opera 50+, Safari 11.1+ hỗ trợ, dựa trên bảng compat . Bạn có thể kiểm tra chức năng này với các trình duyệt được hỗ trợ này. Bạn sẽ có một ngoại lệ khi tải trang nếu trình duyệt của bạn không hỗ trợ tính năng này.

Làm thế nào nó hoạt động:

• Không có cột không có 0:
  • không khớp /( .{30}){4} /
• Không có hai 0s trong một cột:
  • không khớp /0.{30}(.{31})*0/
• Không 0không kết nối với hàng xóm của nó:
  • không phù hợp /0.{60}(.{31})*0/,/0.{62}(.{31})*0/

Hợp nhất tất cả các regex này, và cuối cùng bạn sẽ có cái này.

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>

Nhờ Martin Ender chỉ ra rằng một !toán tử đơn lẻ có thể tiết kiệm 8 byte.

SnakeEx , 51 byte

Đây rõ ràng là ngôn ngữ phù hợp cho nhiệm vụ. : ^ D

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

Khớp với toàn bộ đầu vào nếu nó là một con rắn hợp lệ; không phù hợp nếu không. Hãy thử nó ở đây!

Giải trình

SnakeEx là một ngôn ngữ khớp mẫu 2 chiều . Một chương trình bao gồm một danh sách các định nghĩa cho "rắn", chúng bò xung quanh các ký tự khớp đầu vào, thay đổi hướng và sinh ra các con rắn khác. Trong chương trình của chúng tôi, chúng tôi xác định hai con rắn svà c.

Chúng ta sẽ bắt đầu với cvì nó đơn giản hơn. Định nghĩa của nó là 0 *$, sẽ khá dễ đọc nếu bạn biết regex: match 0, theo sau là 0 hoặc nhiều khoảng trắng, theo sau là cạnh của lưới. Bắt chính ở đây: kết hợp này có thể tiến hành theo bất kỳ hướng nào. Chúng tôi sẽ sử dụng ccả lên và xuống từ con rắn, để xác minh rằng không có thêm 0s trong mỗi cột.

Bây giờ cho con rắn chính s,. Nó có dạng (...)%{30}, có nghĩa là "khớp với nội dung của dấu ngoặc đơn 30 lần" - một lần cho mỗi 0con rắn. Càng xa càng tốt. Những gì đi trong dấu ngoặc đơn?

{c<L>}

Điều này sinh ra một ccon rắn mới , quay trái 90 độ. Hướng này liên quan đến shướng của con rắn, vì vậy con rắn mới di chuyển về phía trên cùng của lưới (con rắn chính đang di chuyển về phía bên phải). Con crắn kiểm tra rằng ô lưới hiện tại là một 0và mọi ô phía trên nó là một khoảng trắng. Nếu thất bại, toàn bộ trận đấu thất bại. Nếu nó thành công, chúng tôi tiếp tục với

{c<R>}

mà làm điều tương tự, chỉ rẽ phải (về phía dưới cùng của lưới).

Lưu ý rằng những sinh sản này không ảnh hưởng đến vị trí của con trỏ khớp trong con rắn chính. Chúng hơi giống như những cái nhìn trong regex. (Có lẽ ở đây chúng ta có thể gọi chúng là "lookbesides"?) Vì vậy, sau khi xác minh rằng chúng ta đang chỉ đến một 0và phần còn lại của cột chỉ chứa khoảng trắng, chúng ta cần thực sự khớp với 0:

0

Bây giờ con trỏ khớp nằm trên ký tự bên phải của 0. Chúng ta cần kiểm tra ba tùy chọn khác nhau: con rắn nghiêng xuống, con rắn hướng lên hoặc con rắn đi thẳng. Đối với điều này, chúng ta có thể sử dụng biểu thức OR:

[...]

Trong OR của chúng tôi, chúng tôi có ba khả năng:

(<R> <L>)

Rẽ phải, khớp với một khoảng trắng và rẽ trái lần nữa (góc rắn xuống).

(<L> <R>)

Rẽ trái, khớp một khoảng trắng và rẽ phải lần nữa (góc nghiêng lên).

_?

Khớp 0 hoặc một dấu gạch dưới. Vì không có dấu gạch dưới trong đầu vào, đây sẽ luôn là một kết quả trống (con rắn đi thẳng).

Sau khi khớp một trong ba tùy chọn ở trên, con trỏ khớp sẽ được trỏ đến 0cột trong cột tiếp theo, sẵn sàng khớp lại biểu thức được ngoặc đơn.

CJam , 35 34 byte

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

Hãy thử trực tuyến! Đầu vào là một mảng hình chữ nhật của các mảng ký tự. Giả sử đầu vào chỉ chứa và 0.

Giải trình:

{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 byte

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

Hãy thử trực tuyến!

Giải trình

ζ                    # 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)

Husk , 12 byte

Tùy thuộc vào làm rõ quy tắc, có thể là 11 byte hoặc 13 byte .

±Λ=;1Ẋ×≈mηfT

Hãy thử trực tuyến!

Đầu vào là danh sách các dòng chỉ chứa khoảng trắng và 0; nếu cần một chuỗi đơn, hãy thêm vào ¶chương trình để chia thành các dòng. Liên kết TIO đã làm điều này cho rõ ràng. Đầu ra là 0 hoặc 1; nếu bất kỳ giá trị sai lệch và trung thực là tốt, ±có thể được loại bỏ.

Giải trình

±Λ=;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.

Ý tưởng là sử dụng ×≈để đảm bảo rằng (a) tất cả các cột chứa chính xác một 0 và (b) vị trí của chúng khác nhau nhiều nhất là một. Ví dụ, xem xét đầu vào 8 cột

0  0  0 
 000 0  
  00   0

Đầu tiên, mηfTchuyển đổi nó thành danh sách các danh sách chỉ mục

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

Sau đó Ẋ×≈cho

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

Mỗi 1chỉ số tương ứng với một cặp chỉ số khác nhau nhiều nhất là 1 và mỗi chỉ số 0tương ứng với một cặp không. Mỗi kết quả bằng [1]chính xác khi cả hai danh sách có một chỉ mục và các chỉ số khác nhau nhiều nhất là 1.

Python 2 , 71 byte

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

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng một chuỗi nhiều dòng. Thử nghiệm trường hợp từ Bubbler .

Cột đầu tiên được trích xuất như s[::31]và cột thứ hai s[1::31], và chúng được kiểm tra tính hợp lệ. Chúng tôi tái diễn sviệc loại bỏ ký tự đầu tiên, khiến các cặp cột liên tiếp được kiểm tra.

Việc kiểm tra hai cột sử dụng chuỗi so sánh của Python để inkết hợp nhiều kiểm tra:

• '0'in s[::31] kiểm tra xem cột đầu tiên có ít nhất một 0
• s[::31]in' %s '%s[1::31]kiểm tra xem cột đầu tiên có phải là chuỗi con của các cột thứ hai kẹp giữa hai khoảng trắng không, điều này đảm bảo vị trí của cột 0đã dịch chuyển nhiều nhất một khoảng trắng
• ' %s '%s[1::31]in'%6s'%0*2kiểm tra xem cột thứ hai chứa nhiều nhất một 0.

Đoạn kết *f(s[1:])cũng buộc trường hợp đệ quy là đúng.

C (gcc) ,246 245 232 215 212 byte

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

Hãy thử trực tuyến!

Hình tôi sẽ đưa ngôn ngữ yêu thích của mình vào điều này (mặc dù tôi có thể thấy từ nhiều mục khác, những mục nhỏ hơn có lẽ không lý tưởng cho loại thử thách này) và C những gì tôi có thể quản lý. Cách tiếp cận vấn đề của chương trình tương đối đơn giản, chỉ với rất nhiều byte bị chèn ép; nó lấy con rắn trên stdin và đưa ra kết quả của nó trong giá trị trả về của hàm chính (do đó là mã thoát;như được yêu cầu trong bài toán 0 chỉ ra một con rắn không hợp lệ và 1 hợp lệ mặc dù đối với mã thoát là lạnhư điển hình cho mã thoát 0 là rắn hợp lệ và 1 là rắn không hợp lệ). Với các macro được mở rộng và một số khoảng trắng đẹp, nó trông giống như sau:

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

Các dòng đầu vào được đọc vào hàng đầu tiên của bộ đệm, năm dòng tiếp theo là để theo dõi những nơi được dự kiến ​​(đọc: phải) có các số 0 trong hàng sau mỗi dòng hiện tại và cuối cùng là để theo dõi xem số 0 đã có chưa được đọc trong một cột nhất định, trong bất kỳ hàng nào. Chương trình xử lý lần lượt từng hàng.

Nó hoàn toàn không mạnh mẽ ( gets()chỉ là khởi đầu) và đầu vào phải chứa tất cả các khoảng trắng có liên quan (chẳng hạn như khoảng trắng ở bên trái), và gcc đưa ra các cảnh báo và ghi chú về chức năng stdlib được khai báo ngầm, v.v. la vie.

Nó cũng giả định rằng đầu rắn không cần phải ở hàng giữa và một con rắn hợp lệ phải có ít nhất một số 0 trong mỗi hàng (tức là không có hàng nào trong tất cả các khoảng trắng trong 5 hàng đầu vào). Nếu đây không phải là một yêu cầu, nó có thể được thực hiện ngắn hơn một chút - mọi thứ phải làm kvà ltrong chương trình có thể được loại bỏ hoặc thay thế bằng ít byte mã hơn trong trường hợp đó.

Cảm ơn người dùng202729 cho khoảng. Đã lưu 26 ​​byte.

MATL , 18 17 byte

32>&fun30=wd|2<vA

Đầu vào là một mảng char 2D. Bất kỳ nhân vật không phải không gian có thể được sử dụng cho con rắn.

Hãy thử trực tuyến!

Giải trình

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

Trượt , 28 byte

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

Kiểm tra nó ở đây.

Thạch , 19 byte

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

Hãy thử trực tuyến!

-2 byte nhờ ông Xcoder

Giải trình

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?

Đầu vào là một danh sách các chuỗi

Jelly , (14? *) 13 byte

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

Một liên kết đơn âm lấy một danh sách gồm năm chuỗi *, mỗi chuỗi có độ dài 30 bao gồm khoảng trắng và bất kỳ ký tự nào khác (ví dụ: 0 s) và trả về một số nguyên (1 nếu một con rắn như được xác định, 0 nếu không)

* Nếu đầu vào phải là một chuỗi (danh sách các ký tự) thì hãy thêm một Ỵchuỗi để tách chuỗi tại các nguồn cấp dữ liệu.

Hãy thử trực tuyến!

Làm sao?

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 byte ^CP437

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

24 byte khi giải nén,

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

Chạy và gỡ lỗi trực tuyến!

Có thể không phải là người chơi golf giỏi nhất nhưng tôi nghĩ phương pháp này mới lạ và thú vị.

Giải trình

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 byte

-8 byte nhờ FrownyFrog

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

Hãy thử trực tuyến!

Thạch , 16 byte

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

Hãy thử trực tuyến!

Giả sử rằng chuỗi đầu vào sẽ luôn chỉ chứa khoảng trắng và số không. Lấy đầu vào dưới dạng danh sách các chuỗi (mỗi chuỗi đại diện cho một dòng) và xuất ra 1 nếu trung thực, 0 nếu không.

Giải trình

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.

Python 2 , 141 byte

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)])

Hãy thử trực tuyến!

Đầu vào là một lưới các ký tự.

Python 2 và Python 3 , 122 120 119 byte

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]

Hãy thử trực tuyến!

Định dạng đầu vào là một chuỗi có độ dài 154 (5 x 30 ký tự, 4 dòng mới):

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

Nếu đầu không phải là hàng trung tâm

Yêu cầu đầu hàng trung tâm là trong thử thách ban đầu, nhưng tôi thấy rằng nó không phải là trường hợp ở đây (ít nhất là nó không được đề cập rõ ràng).

Python 2 và Python 3 , 124 123 byte

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]

Hãy thử trực tuyến!

Chỉnh sửa:

• Giảm 2 byte bằng cách thay đổi bằng (== ) thành bất đẳng thức cho mỗi mã.
• Tìm thấy lỗi trong phiên bản ít giới hạn hơn, và sửa đổi nó. (May mắn là nó không quá khủng khiếp, vì vậy tôi có thể giữ tất cả các phiên bản có độ dài tương tự nhau.) Bạn có thể thấy các trường hợp thử nghiệm bổ sung trong hai liên kết TIO sau.
• Tìm thấy một byte lơ lửng trong các giải pháp Py2, làm cho all()thủ thuật này trở nên vô nghĩa trong Py3, do đó đã hợp nhất cả hai phiên bản.

Excel (VBA), 68 byte

Sử dụng cửa sổ ngay lập tức, Cell[A6]như đầu ra.

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

Ốc , 18 byte

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

Hãy thử trực tuyến!

Vết bẩn , 30 26 23 byte

Cảm ơn Zgarb vì đã lưu 7 byte và chỉ ra một lỗi.

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

Hãy thử trực tuyến!

Ruby , 93 byte

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

Hãy thử trực tuyến!

JavaScript (Node.js) , 128 126 byte

Được chỉnh sửa sau khi làm rõ đầu vào cho biết đầu vào là "một chuỗi".

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

Hãy thử trực tuyến!

Con trăn 3 , 197 185 byte

Trong dấu nhắc lệnh làm verify.py<snake.txthoặc trong bash làm cat snake.txt | python verify.py. Ở đâusnake.txt một tập tin có chứa một con rắn để xác minh.

Nếu con rắn là chính xác, không có gì sẽ được đầu ra. Nếu nó không đúng, Python sẽ gây ra lỗi chỉ mục.

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