Đây là chủ đề của tên cướp. Các chủ đề của cảnh sát là đây .

Ma trận rắn là một ma trận vuông theo mô hình này:

3 giờ 3:

1  2  3
6  5  4
7  8  9

và 4 giờ 4:

1  2  3  4
8  7  6  5
9  10 11 12
16 15 14 13

Nhiệm vụ của bạn là viết một mã lấy đầu vào nvà tạo một ma trận như vậy, trong cùng ngôn ngữ với một bài đăng cảnh sát và với một mã phù hợp với biểu thức chính thức của cảnh sát. Định dạng đầu ra của mã của bạn phải phù hợp với định dạng đầu ra của mã của cảnh sát.

Vui lòng để lại một bình luận dưới bài viết của Cop để chỉ ra rằng bạn đã bẻ khóa nó.

Tiêu chí chiến thắng:

Người chiến thắng sẽ là người dùng đã bẻ khóa nhiều bài nộp nhất. Trong trường hợp hòa, sau đó sẽ có nhiều người chiến thắng.

Jelly , 9 byte, vết nứt @Dennis 'câu trả lời

²sµUFḤ$¦G

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

Nên chính xác ngay bây giờ; Tôi đã phải suy nghĩ lại những gì tôi đang làm.

Giải trình

Phần khó nhất của vấn đề này là lấy danh sách các chỉ số chẵn bên trong ¦(áp dụng một thao tác tại các chỉ số cụ thể). Không giống như hầu hết các hoạt động, sử dụng đầu vào cho toàn bộ chương trình làm mặc định cho toán hạng thứ hai, ¦sử dụng giá trị được xem gần đây nhất làm mặc định (vì về mặt khái niệm nó có hai toán hạng bên trái, thay vì toán hạng bên trái và bên phải như hầu hết mọi thứ lấy trong hai giá trị).

Tuy nhiên, chúng ta có thể quan sát rằng chúng ta có một danh sách các số, bao gồm tất cả các số nguyên từ 1 đến một nửa đầu vào, đã có trong giá trị hiện tại tại thời điểm đó. Như vậy, làm phẳng và nhân đôi nó cho chúng ta một danh sách các số chẵn, bao gồm tất cả các chỉ số chẵn (cũng có một số số chẵn khác nhưng chúng ta không quan tâm đến những số đó). Thậm chí có thể chi tiêu một lần µduy nhất để tránh sự mơ hồ phân tích cú pháp và vẫn xuất hiện trong vòng 9 ký tự.

²sµUFḤ$¦G
 s         Split
²          {the list of numbers from 1 to} the square of {the input}
  µ        into a number of pieces equal to {the input};
   U       then reverse
       ¦   the elements at indexes
    F      obtained by flattening the split list
      $    and
     Ḥ     doubling each element in the flattened list;
        G  finally, format it into a grid.         

05AB1E, Biểu tượng

Đây là lần đầu tiên tôi sử dụng 05AB1E. Có nó với một chút giúp đỡ. Đó là niềm vui. :)

UXFXLNX*+N2BSR1k_iR}ˆ

Dùng thử trực tuyến

Giải trình:

U                       Assign input to X
 XF                     For N in range(0,X):
   XL                   Push list [1 .. X]
     NX*+               Add N*X to each element of the list
         N2BSR1k_       Super clever way to get N%2:
                            not bool(reversed(str(bin(N))).index('1')) (N%2 is odd)
                 iR}    if N%2 is odd, then reverse the list
                    ˆ   Add row to global array
                        Implicit print

Tôi thực sự đã tìm thấy chương trình tương tự này một mình, nhưng định dạng đầu ra là khác nhau:

UXFXLNX*+N2BSR1k_iR}=

Dùng thử trực tuyến

[1, 2, 3, 4]
[8, 7, 6, 5]
[9, 10, 11, 12]
[16, 15, 14, 13]

Xem lịch sử chỉnh sửa cho hai lần thử trước của tôi.

Con trăn 2, Dennis

Đây là một vấn đề golf token thú vị.

while ord>eval:1;int,eval=int<1and(int,eval+1)or(-input(),1);i=int;ord=i*i;print'%*s'%(-i,(eval+~i+~-eval%-i*~1,eval)[eval/i&1])+'\nt'[:-1<eval%int],

Xác minh Regex

Ồ, Nick Clifford

Lần đầu tiên tôi cố gắng Ohm.
Ngôn ngữ thực sự tốt đẹp mà tôi mong muốn được sử dụng lại :)

²@┼σ▓_^è?R

Giải trình

²             # square input
 @            # range [1 ... input^2]
  ┼σ          # split in input sized chunks
    ▓         # perform the following block on each element of the array
     _        # current element
      ^è?     # if index is odd
         R    # reverse

Nỗ lực đầu tiên của tôi không hoạt động như thêm một mảng và int là không thể:

@┼MDR┼+;W

Nỗ lực thứ hai của tôi không phù hợp với regex:

²@┼σ▓_^MR

05AB1E, Emigna (đệ trình 2)

Lần đầu tiên làm việc với 05AB1E.

VYLUYFYXDˆ+RU

Hãy thử trực tuyến! | Xác minh Regex

Giải trình

VYLUYFYXDˆ+RU  # Implicit input
V              # Save input to Y
 YL            # Push [1 .. Y]
   U           # Save list to X
    YF         # Repeat Y times:
      YX       # Push Y, then X
        Dˆ     # Add X into the global array (could've used X here instead)
          +    # Push X + Y
           R   # Reverse top of stack
            U  # Save updated list to X
               # Implicit loop end
               # Implicit global array print if stack is empty

CJam , Lynn

esmpmpmeimtmemqmememqicelic
esmpmpmeimememqmlmtmemoc
esmpmpmeimememqmtmtmtmtmeic
esmpmpmeimememqmtmtmtmtmeic
esmpmpmeimeiscic
esmpmpmeimemeimfsic
esmpmpmeisciscimqmtmemeic
esmpmpmeiscimlmqmqmemeic
esmpmpmeimemomqmqmemeic
esmpmpmeisciscimfsimqic
esmpmpmeimeiscic
esmpmpmeisciscimfsimqic
esmpmpmeimemomqmemqmemtmemoc
esmpmpmeiscic
esmpmpmeimemomeimqmeic
esmpmpmeimemeimqmlmtmeic
esmpmpmeimtmtmqmemtmtmeic
esmpmpmeimemomqmqmtmeic
esmpmpmeimemqmqmemeic
esmpmpmeiscimlmqmqmemeic
esmpmpmeiscimqmtmtmtmqmemeic
esmpmpmeimeimemtmqmemeic
esmpmpmeimeiscimlmlmtmlmtic
esmpmpmeimemeimqmlmtmeic
~~

Tất cả các dòng sản phẩm là cho mục đích thẩm mỹ và có thể được gỡ bỏ mà không ảnh hưởng đến chương trình.

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

Giải trình

Sau khi Lynn loại {|}khỏi danh sách các nhân vật được phép, tôi phải thử một cái gì đó mới. Hóa ra chúng ta vẫn có thể xây dựng các chuỗi tùy ý và đánh giá chúng dưới dạng mã.

Đầu tiên, chúng ta cần nhận được một số giá trị trên ngăn xếp. Các phần dựng sẵn có duy nhất đẩy một cái gì đó mà không bật cái gì khác trước (và không đọc đầu vào) là es, eavà et. Tôi chắc chắn rằng bạn có thể bắt đầu từ tất cả các cách này hay cách khác, nhưng tôi đã đi theo esđó đẩy dấu thời gian hiện tại. Vì tôi không muốn đưa ra bất kỳ giả định nào về giá trị thực của nó, tôi đã kiểm tra tính nguyên thủy của nó với mp(cung cấp 0và 1) và kiểm tra tính nguyên thủy của giá trị đó một lần nữa để đảm bảo tôi đã có được một 0ngăn xếp. Một 1sẽ hữu ích hơn, vì vậy chúng tôi tính toán exp(0)với mevà biến nó thành một số nguyên với i. Vì vậy, tất cả các số bắt đầu bằng:

esmpmpmei

Bây giờ chúng ta đã có một loạt các toán tử đơn nguyên để làm việc với:

i    int(x) (floor for positive numbers, ceiling for negative)
me   exp(x)
ml   ln(x)
mq   sqrt(x)
mo   round(x)
mt   tan(x)

Chúng tôi cũng có thể kết hợp một vài tích hợp cho các chức năng phức tạp hơn của x:

sci     Extract first digit of x and add 48 (convert to string, convert
        to character, convert to integer).
ceui    Convert to character, convert to upper case, convert to integer.
celi    Convert to character, convert to lower case, convert to integer.
mfsi    Get a sorted list of prime factors of x and concatenate them into 
        a new number.
mfseei  Get a sorted list of prime factors, interleave it with 1,2,3,..., and
        concatenate the result into a new number.

Sử dụng những số này, chúng tôi có thể nhận được bất kỳ số nào trong 0 <= x < 128(và nhiều số khác) trong chưa đầy 10 bước từ 1. Tôi chắc rằng một tập hợp con nhỏ hơn nhiều của các lệnh này cũng sẽ đủ. Tôi đã viết một chương trình Mathicala nhỏ, để xác định tất cả các đoạn mã này (nó không dễ đọc lắm, xin lỗi):

codes = SortBy[
  Select[Nest[Select[DeleteDuplicatesBy[SortBy[Join @@ (Through[{
               List,
               If[1 <= # < 50, {Exp@#, #2 <> "me"}, Nothing] &,
               If[# >= 1, {Log@#, #2 <> "ml"}, Nothing] &,
               If[# > 1, {Sqrt@#, #2 <> "mq"}, Nothing] &,
               {If[# > 0, Floor@#, Ceiling@#], #2 <> "i"} &,
               {Floor[# + 1/2], #2 <> "mo"} &,
               {Tan@#, #2 <> "mt"} &,               
               If[NumberQ@# && # >= 0, {First@
                   ToCharacterCode@ToString@#, #2 <> "sci"}, 
                 Nothing] &,
               If[IntegerQ@# && 
                  32 < # < 65536, {First@
                   ToCharacterCode@
                    ToUpperCase@FromCharacterCode@#, #2 <> "ceui"}, 
                 Nothing] &,
               If[IntegerQ@# && 
                  32 < # < 65536, {First@
                   ToCharacterCode@
                    ToLowerCase@FromCharacterCode@#, #2 <> "celi"}, 
                 Nothing] &,
               If[IntegerQ@# && # > 0, ## & @@ {
                   {FromDigits[
                    "" <> (ToString /@ (f = 
                    Join @@ Table @@@ FactorInteger@#))], #2 <> 
                    "mfsi"},
                   {FromDigits[
                    "" <> (ToString /@ 
                    MapIndexed[## & @@ {#2[[1]] - 1, #} &, f])], #2 <>
                     "mfeesi"}
                   }, Nothing] &
               }@##] &) @@@ #, StringLength@*Last], 
       First], #[[1]] < 1000000 &] &, {{1, "esmpmpmei"}}, 9], 
   IntegerQ@# && 0 <= # < 128 &@*First], First]

Cùng với đó, chúng ta có thể chỉ cần đẩy một danh sách mã ký tự tùy ý, chuyển đổi từng ký tự thành ký tự csau đó. Khi chúng tôi đã đẩy toàn bộ mã mà chúng tôi muốn thực thi, chúng tôi sẽ đẩy 95( ]). Chúng tôi eval rằng một với ~để bọc tất cả những người khác trong một chuỗi, và sau đó chúng tôi eval chuỗi đó với ~.

Mã thực tế chạy ở cuối chương trình là một lần nữa:

ri__2#,:)/2/[1W]f.%:~<p

Xem giải pháp trước đây của tôi để được giải thích.

Con trăn 3, TuukkaX

Xin lỗi, regex bạn đã sử dụng quá dễ để tầm thường hóa. Không 0, #hay ? Không vấn đề gì!

Tôi có thể đã hiểu sai đầu ra ví dụ nhưng nó vẫn khá dễ điều chỉnh vì tôi còn 45 ký tự dự phòng

n=int(input())
print(str(n)+":")
x=1-1
exec("print([*range(1+x*n,1+n*-~x)][::(1,-1)[x%2]]);x+=1;"*n)
"no-op:a_string_that_doesnt_actually_matter"

R, MickyT

lets_make_a_snake<-function(n)`for`(i,1:n,cat(i*n+1-`if`(i%%2,n:1,1:n),"\n"))

Các trường hợp xét nghiệm:

> lets_make_a_snake(4)
1 2 3 4 
8 7 6 5 
9 10 11 12 
16 15 14 13 
> lets_make_a_snake(7)
1 2 3 4 5 6 7 
14 13 12 11 10 9 8 
15 16 17 18 19 20 21 
28 27 26 25 24 23 22 
29 30 31 32 33 34 35 
42 41 40 39 38 37 36 
43 44 45 46 47 48 49 

Và xác nhận regex: https://regex101.com/r/OB8ZIM/1

Tôi cũng đã có:

invisible(sapply(1:(n=scan()),function(i)cat(i*n+1-`if`(i%%2,n:1,1:n),"\n")))

cung cấp cùng một đầu ra và khớp với cùng một biểu thức chính quy .

Röda , fergusq

{|i|;a=1;while[a<=i]do;b=a*i-i+1;c=[];while[b<=a*i]do;c+=b;b++;done;{d=[];x=0;while[x<i]do;d+=c[i-x-1];x++;done[d]}if[a%2<1]else{[c]};a++;done;r="||||||"}

Đây là một chức năng ẩn danh phù hợp với biểu thức PCRE này: ^{(\|[^\/#\s]*){8}$ .

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

Bash, @Marcos M

sort -n <(seq 1 $((n * n)) | xargs -n$n | sed -n 'p;n'; seq $((n * n)) 1 | xargs -n$n | sort -n | sed -n 'n;p')

Chuẩn bị:

sort -n <(               # feed the stdout of this subshell into stdin for `sort -n`
    seq 1 $((n * n)) |   #   generate 1 2 3 ... n²
        xargs -n$n |     #     add line break every n numbers
        sed -n 'p;n';    #     print only odd lines
    seq $((n * n)) 1 |   #   generate n² ... 3 2 1
        xargs -n$n |     #     add line break every n numbers
        sort -n |        #     reverse all lines (keeping each row decreasing)
        sed -n 'n;p'     #     print only even lines
)

Phần đầu tiên của subcommand sẽ tạo ra 1 2 3 4, 9 10 11 12và phần thứ hai sẽ tạo ra 8 7 6 5, 16 15 14 13. Bên ngoài sort -nsẽ trộn chúng đúng cách với nhau để tạo thành mô hình con rắn.

Tôi đã sử dụng thủ thuật trong /superuser//a/101760 để in các dòng lẻ và chẵn. Cảm ơn Marcos, thực sự là một niềm vui.

Javascript, Tom

f=(a,i=1,j=0)=>Array(a).fill(0).map(b=>Array(a).fill(0).map(a=>i++)).map(a=>j++%2?a.reverse():a).map(a=>a)

console.log(f(4))

Python 3, @TuukkaX

n=int(input());j=0;exec("print([(j-+i%n-n++2*n-0,j+i%n+1)[1&int(i/n)//1^(0x1)//1]*(2*(i%n)*0+2222222//2222222)for i in range(j,j+n)]);j+=n;"*n)

• Xác minh: https://regex101.com/r/GI1Zvh/1

Phân tích một chút về biểu thức chính thức của cảnh sát cho thấy một mẫu cố định:

________________________"___________i%n____2*n-____i%n__________i/n)//1_____)//1___2*(i%n)____^^^^^^^^^^^^^^^^for i in range(j,____])______"*n)

nơi _là bất kỳ ký tự trừ [ '"#]và^ là bất kỳ [int()2/].

Các "*n)cuối cùng cho thấy rõ ràng một eval("..."*n)hoặcexec("..."*n) đang xảy ra, vì vậy chúng ta chỉ cần để đảm bảo "..."bản in j thứ hàng.

Các for i in range(j,quá gần cuối của chuỗi, gợi ý danh sách hiểu mà không cần bất kỳ if. Vì vậy, chúng ta cần phải xây dựng thứ i cột bằng những i%n, 2*nthứ.

n = int(input())
j=0
exec("""print([
    (
        j - +i%n - n ++ 2*n - 0,    # equivalent to (n + j - i%n) for the decreasing rows
        j + i%n + 1                 # equivalent to (j + i%n + 1 == i + 1) for the increasing rows
    )[1 & int(i/n)//1 ^ (0x1)//1]   # int(i/n)   ->    get row number 0, 1, 2, 3, ...; 
                                    # 1 & int(i/n)//1    ->    0 for increasing rows, 1 for decreasing rows, 
                                    # 1 & int(i/n)//1 ^ (0x1)//1    ->   flip 0 and 1
    * (2*(i%n)*0+2222222//2222222)  # multiply by the constant 1.
    for i in range(j,j+n)
]); j+=n; "*n)

dc , Spector

Đây là lần đầu tiên tôi tham gia một thử thách cảnh sát và cướp, và tôi đã có rất nhiều niềm vui. Regex cần phải được khớp là đơn giản, ^[^# !]{59}$về cơ bản đã biến công việc của tôi thành một môn đánh gôn, mà không sử dụng 3 ký tự đó. Ban đầu tôi gặp khó khăn khi nhận được dưới 60 byte, nhưng cuối cùng tôi đã bẻ khóa nó.

?sN0[AP]sP[ddlN~_2*lN+1-r2%*+1+n32P1+dlN%0=PdlNd*>L]dsLxqqq

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

Giải trình:

Mã của tôi sử dụng một vòng lặp với N ² lần lặp, giữ bộ đếm dựa trên số không (1D) và tính toán số nào cần được in dựa trên tọa độ hàng và cột ma trận tương ứng (r, c).

Ví dụ về những gì tôi muốn nói, nếu N = 4:

 0  1  2  3            (0,0) (0,1) (0,2) (0,3)             1  2  3  4
 4  5  6  7     ->     (1,0) (1,1) (1,2) (1,3)     ->      8  7  6  5
 8  9 10 11            (2,0) (2,1) (2,2) (2,3)             9 10 11 12
12 13 14 15            (3,0) (3,1) (3,2) (3,3)            16 15 14 13

Có vẻ phức tạp, nhưng bước trung gian là hữu ích. Thêm vào đó, tôi đã thử sử dụng 2 vòng lặp từ đầu, nhưng cuối cùng tôi đã vượt quá giới hạn ký tự regex. Tạo số tại mỗi lần lặp (không dựa trên):

• nếu r % 2 = 0(hàng bình thường),n = (r * N) + c = counter
• if r % 2 = 1(hàng đảo ngược),n = ((r + 1) * N) - c - 1 = counter + N - (2 * c) - 1

Hoặc tất cả cùng một lúc, như một cách đánh số dựa trên: n = counter + ((N - (2 * c) - 1) * (r % 2)); n++

?sN0             # read input, save as N, initialize iteration counter
[AP]sP           # macro 'P' that prints a newline (ASCII code 10 = A)
[                # start loop
    ddlN~        # push N, calculate row and column coordinates:
                 #r = int(counter / N), c = counter % N, '~' calculates both
    _2*lN+1-     # c is on top, so this does: N - (2 * c) - 1
    r2%*+        # now r is on top, do: (r % 2) * (previous result) + counter
    1+n32P       # do: n++, print space (ASCII code 32)
    1+           # increment counter
    dlN%0=P      # call macro 'P' every Nth printed number
    dlNd*>L      # if: N * N > counter, repeat loop
]dsLx            # this saves the loop to macro 'L', then executes it
qqq              # my script was shorter, so I added a bunch of quit commands to
                 #fit the regex limit. Use of comments ('#') was prohibited.

PowerShell, ConnorLSW

Nứt

$mySnakeIndex=1;$seq=1..$args[0];$seq|%{$rowNum=$seq|%{($mySnakeIndex++)};if(!($_%2)){[array]::Reverse($rowNum)};$rowNum-join" "}

Tôi bắt đầu với một giải pháp nhỏ hơn cho vấn đề và đệm tên biến của mình để có biểu thức chính quy phù hợp. Cố gắng tìm cách sử dụng cho đại tràng tôi cho là phần khó nhất để quấn đầu tôi.

$a=1..$args[0];$i=1;$a|%{$r=$a|%{($i++)};if(!($_%2)){[array]::Reverse($r)};$r-join" "}

Giải trình

# Initialize a counter that starts at one.
$mySnakeIndex=1
# Save the integer array from 1 to the input value. 
$seq=1..$args[0]
# For each row of the output...
$seq|%{
    # Build the integer array for this row sequentially
    $rowNum=$seq|%{
        # Increase the integer index while sending it down the pipeline
        ($mySnakeIndex++)}
        # Check if this is and odd row. If so reverse the integer array.
        if(!($_%2)){[array]::Reverse($rowNum)}
        # Take this row and join all the numbers with spaces.
        $rowNum-join" "

CJam, Lynn

Một cái gì đó như thế này:

ri
{s}seu~~ci{zs}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c~

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~c{a}seu~~|
{s}seu~~c{c}seu~~|
{t}seu~~sc{a}seu~~|
{s}seu~~c{a}seu~~|{w}seu~~z{w}seu~~sc~c
{s}seu~~sc{fb}seu~~||
{s}seu~~sc{i}seu~~|
{s}seu~~sc{fb}seu~~||
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c
{a}seu~~scs
{w}seu~~
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c
{fb}s{b}s{w}seu~~sc~
{s}seu~~sc{ee}seu~~||
{s}seu~~sc{z}seu~~|{w}seu~~{w}seu~~sc~{w}seu~~{w}seu~~sc~
{t}seu~~sc{a}seu~~|
{~}s{}s{w}seu~~sc~
{t}seu~~sc{c}seu~~|

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c~
s~
p

Tất cả các khoảng trắng là dành cho ... "khả năng đọc" ... và có thể được bỏ qua để tuân thủ regex của Lynn.

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

Giải trình

Regex yêu cầu chúng tôi chỉ giải quyết vấn đề bằng cách sử dụng:

• Chữ viết thường.
• {}, có thể được sử dụng để tạo khối.
• |, chủ yếu được sử dụng cho bitwise OR.
• ~, "eval" và bitwise KHÔNG (cũng là "kết xuất mảng", nhưng tôi sẽ không sử dụng nó).

Vì chúng ta có ~ nếu chúng ta có thể xây dựng các chuỗi tùy ý, chúng ta có thể chạy mã tùy ý. Tuy nhiên, ban đầu không rõ ràng làm thế nào để làm điều đó.

Phần đầu tiên của câu đố là các khối là các đoạn mã không được đánh giá, có thể biến thành chuỗi với s. Vì vậy, {abc}scho chúng tôi "{abc}". Tiếp theo, chúng ta có thể sử dụng euđể chuyển đổi các chuỗi này sang chữ hoa.

{abc}seu  e# gives "{ABC}"

Lợi ích của việc này là các chữ cái viết hoa là các biến được khởi tạo trước, vì vậy chúng ta có thể nhận được rất nhiều giá trị không đổi bằng cách tạo một chuỗi như vậy và đánh giá nó hai lần (một lần để biến chuỗi trở lại thành một khối và một lần để thực hiện khối đó). Chúng tôi không thể nhận được tất cả các chữ cái, vì một số, như xcác lệnh không hợp lệ (vì vậy, CJam sẽ từ chối phân tích một khối có chứa chúng). Chúng ta không thể sử dụng nguyên trạng f, bởi vì nó cần phải được tuân theo bởi một lệnh khác, nhưng chúng ta có thể sử dụng fbvà sau đó HOẶC hai giá trị với nhau. Tương tự như vậy, chúng ta có thể sử dụng eethay vì e. Cùng với đó, chúng ta có thể có được những con số 0, -1, 3, và 10để 19. Điều -1này là thuận tiện, bởi vì nếu chúng ta biến nó thành một chuỗi ( "-1") thì thành một ký tự ('-) và sau đó đánh giá nó, chúng ta có thể có được phép trừ hoặc đặt chênh lệch. Như tôi đã nói, chúng ta không thể có X(cho .1), nhưng chúng ta có thể lấy giá trị tuyệt đối của -1vớiz

Chúng ta cũng có thể sử dụng sđể có được một chuỗi chứa một khoảng trắng và sử dụng cđể biến chuỗi đó thành một ký tự khoảng trắng :

{s}seu~~c

Điều này rất thuận tiện, vì từ đó chúng ta có thể nhận được rất nhiều lệnh hữu ích trong phạm vi ASCII thấp hơn bằng cách OR khoảng trắng với nhiều số khác nhau. Để có được một số ký tự trên điểm mã 48, chúng tôi sử dụng ký tự '0làm cơ sở thay thế:

{t}seu~~si

Điều này đã đủ để xây dựng các chuỗi tùy ý, bởi vì chúng ta có thể nhận được '+(nối và nối chuỗi) từ đoạn mã sau:

{s}seu~~c{b}seu~~|

Và chúng tôi có một nghĩa đen 1 để chúng tôi có thể đẩy các ký tự không gian, tăng chúng đến giá trị chúng tôi cần và sau đó ghép tất cả chúng lại với nhau, nhưng điều đó hơi nhàm chán và mã sẽ trở nên khổng lồ.

Thay vào đó, tôi đã tạo [và loại ]bỏ chúng, để tất cả các ký tự tôi đẩy vào giữa được tự động gói trong một chuỗi. Đó là hai dòng:

{s}seu~~ci{zs}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c~

...

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c~

Và cuối cùng, chúng ta sẽ cần fvà ~trong chuỗi chúng ta tạo ra. Mặc dù đó là những ký tự hợp lệ, chúng tôi không có chuỗi ký tự hoặc ký tự, vì vậy chúng tôi cũng phải tạo ra các ký tự này và xây dựng các điểm mã lớn hơn từ không gian là một chút khó chịu. Thay vào đó, tôi đã sử dụng phép trừ tập hợp ở đây, nhưng trừ hai khối (để loại bỏ {}):

{fb}s{b}s{w}seu~~sc~
...
{~}s{}s{w}seu~~sc~

Đó là khá nhiều tất cả là có nó. Chúng tôi eval [. Chúng tôi đẩy tất cả các ký tự, thu được bằng các tính toán khác nhau từ một vài hằng số tích hợp mà chúng tôi có |, -(thông qua eval) và +(thông qua eval). Chúng tôi eval ]. Chúng tôi san phẳng toàn bộ mọi thứ thành một chuỗi, bởi vì tại một số điểm tôi đã thêm một số chuỗi hoặc số vào danh sách. Chúng tôi đánh giá chuỗi tùy ý của chúng tôi với~ .

Các ri...p là một phần của chương trình thực tế cuối cùng, nhưng tôi đã trích xuất chúng vì chúng không cần mã hóa.

Cuối cùng, đây là chương trình chúng tôi thực sự đang chạy:

ri___*,:)/2/[1-1]f.%:~<p

ri      e# Read input and convert to integer.
__      e# Make two copies.
_*      e# Square the last copy.
,       e# Turn into range [0 1 ... n^2-1].
:)      e# Increment each to get [1 2 ... n^2].
/       e# Split into chunks of length n, creating a square.
2/      e# Split into pairs of lines.
[1-1]   e# Push [1 -1].
f.%     e# Use this to reverse the second line in each pair. If n was odd,
        e# this will pair a -1 with the last line.
:~      e# Flatten the pairs back into the square.
<       e# Truncate to n lines to get rid of that extraneous -1 for odd inputs.
p       e# Pretty-print.

tinylisp , @DLosc

(v(c(h(q(d)))(c(h(q(f)))(q((c(q(n))(q((g(v(h(q(n))))(s(v(h(q(n))))(v(h(q(1)))))())))))))))(v(c(h(q(d)))(c(h(q(mod)))(q((c(c(h(q(x)))(q(y)))(q((i(l(v(h(q(x))))(v(h(q(y)))))x(mod(s(v(h(q(x))))(v(h(q(y)))))y))))))))))(v(c(h(q(d)))(c(h(q(range)))(q((c(c(h(q(x)))(c(h(q(y)))(c(h(q(z)))(q(w)))))(q((i(l(times(v(h(q(z))))(v(h(q(x))))(v(h(q(0)))))(times(v(h(q(z))))(v(h(q(y))))(v(h(q(0))))))(range(v(h(q(x))))(s(v(h(q(y))))(v(h(q(z)))))z(c(s(v(h(q(y))))(v(h(q(z)))))w))w)))))))))(v(c(h(q(d)))(c(h(q(times)))(q((c(c(h(q(x)))(c(h(q(y)))(q(acc))))(q((i(l(v(h(q(x))))(v(h(q(0)))))(times(s(v(h(q(0))))(v(h(q(x)))))(s(v(h(q(0))))(v(h(q(y)))))acc)(i(e(v(h(q(x))))(v(h(q(0)))))acc(times(s(v(h(q(x))))(v(h(q(1)))))y(a(v(h(q(y))))(v(h(q(acc))))))))))))))))(v(c(h(q(d)))(c(h(q(g)))(q((c(c(h(q(n)))(c(h(q(w)))(q(r))))(q((i(l(v(h(q(w))))(v(h(q(0)))))r(g(v(h(q(n))))(s(v(h(q(w))))(v(h(q(1)))))(c(i(e(v(h(q(0))))(mod(v(h(q(w))))(v(h(q(2))))))(range(a(v(h(q(1))))(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0))))))(a(a(v(h(q(1))))(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0))))))n)1())(range(a(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0)))))n)(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0)))))(s(v(h(q(0))))(v(h(q(1)))))()))r)))))))))))

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

Điều này xác định một hàm ftrả về câu trả lời. Nó cũng in tên của các hàm tôi đã xác định cho thiết bị xuất chuẩn, nhưng tôi cho rằng điều đó không quan trọng, vì [chúng tôi được phép chọn luồng đầu ra của chúng tôi] cho mã golf, ít nhất là. Nếu đó là một vấn đề lớn, tôi nghĩ rằng tôi có thể điều chỉnh nó để không in chúng. Làm thế nào tôi làm điều đó? Tôi bắt đầu với một cái gì đó khá chuẩn:

(d f (q ((n)
  (g n (s n 1) ()))))

(d mod (q((x y)
  (i (l x y) x
    (mod (s x y) y)))))

(d range (q((x y z w)
  (i (l (times z x 0) (times z y 0))
    (range x (s y z) z (c (s y z) w))
    w))))

(d times (q ((x y acc)
  (i (l x 0) (times (s 0 x) (s 0 y) acc)
  (i (e x 0) acc
    (times (s x 1) y (a y acc)))))))

(d g (q ((n w r)
  (i (l w 0) r
    (g n (s w 1)
       (c (i (e 0 (mod w 2))
             (range (a 1 (times w n 0)) (a (a 1 (times w n 0)) n) 1 ())
             (range (a (times w n 0) n) (times w n 0) (s 0 1) ()))
          r))))))

Sau đó, tôi quan sát thấy rằng người ta có thể chuyển đổi các định nghĩa hàm như thế này:

(d mod (q ((x y) (body))))

trở thành

(v(c(h(q(d)))(c(h(q(mod)))(q((c(c(h(q(x)))(q(y)))(q((body)))))))))

Và chức năng gọi như thế này:

(a x y)

trở thành

(a(v(h(q(x))))y)

Tôi đã sử dụng macro Vim đệ quy này, được lưu trữ trong thanh ghi q, để thực hiện cái thứ hai (tôi đã jkánh xạ tới <Esc>) : f s(v(h(q(jkea))))jk@q.

Hai biến đổi này là đủ để loại bỏ tất cả các không gian.

Swift, @James Webster

{n in for j in 0..<n{print((1...n).map{j%2==0 ?$0+j*n:j*n+n+1-$0})}} as(CShort)->()

Xác minh: https://regex101.com/r/7ukrM0/1

PHP, @ JörgHülsermann

<?=(function($n,$snake){foreach(array_chunk(range(1,$n*$n),$n)as$i=>$a){if($i%2)$a=array_reverse($a);echo"\n",join('',array_map(function($e){return(sprintf("%3d",$e));},$a));}})($argv[1],'-=-=-=-=-=-=-=-=-=-=-=-=-=-o~')?>

• Xác minh: https://regex101.com/r/81pUrB/1
• TIO: https://tio.run/#aNvF0

221 byte là quá dài (do đó là con rắn) và việc thiếu khoảng trắng có thể dễ dàng xử lý.

Chuẩn bị:

<?=
(
    function($n, $snake) {
        foreach (array_chunk(range(1, $n*$n), $n) as $i => $a) {
            if($i % 2)
                $a = array_reverse($a);
            echo "\n", join('', array_map(function($e) {
                return (sprintf("%3d", $e));
            }, $a));
        }
    }
)($argv[1], '-=-=-=-=-=-=-=-=-=-=-=-=-=-o~')
?>

Thạch, dài 12, @Jonathan ALLan

Ḷ-*m@"s@²$G

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

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

Ḷ-*m@"s@²$G  Main link. Argument: n

Ḷ            Unlength; yield [0, ..., n-1].
 -*          Yield [(-1)**0, ..., (-1)**(n-1)].
         $   Combine the two links to the left into a chain.
        ²    Yield n².
      s@     Split [1, ..., n²] into chunks of length n.
   m@"       Take the lists to the right modulo the units to the left, 1 being
             normal order and -1 being reversed.

Jelly , 12 byte, vết nứt @ Câu trả lời thứ hai của Jonathan ALLan

²sµ;@/€FḤ$¦G

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

Giải trình

Điều này gần giống như câu trả lời khác của tôi . Tôi vừa thực hiện hai thay đổi:

Đầu tiên, tôi thay đổi U("đảo ngược từng yếu tố") thành Ṛ€("đảo ngược" "từng yếu tố"). Điều đó không giúp ích gì cho chính nó, bởi vì Ṛcũng bị cấm.

Sau đó, tôi đã thay đổi Ṛ("đảo ngược") thành ;@/( /"gấp bằng" ;"ghép"@ "theo thứ tự ngược lại với danh sách ban đầu"). Điều đó tránh tất cả các ký tự bị cấm, đưa ra một giải pháp hợp lệ.

Tôi giả định bước tiếp theo sẽ là bắt đầu cấm các thao tác xử lý mảng nhanh , ngoài các nguyên tử.

Thạch, dài 13, @Jonathan ALLan

1r-*Nm@"s@²$G

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

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

1r-*Nm@"s@²$G  Main link. Argument: n

1r             Range 1; yield [1, ..., n].
 -*            Yield [(-1)**1, ..., (-1)**n].
   N           Negate each unit.
           $   Combine the two links to the left into a chain.
          ²    Yield n².
        s@     Split [1, ..., n²] into chunks of length n.
     m@"       Take the lists to the right modulo the units to the left, 1 being
               normal order and -1 being reversed.

Thạch, dài 14, @Jonathan ALLan

²sµðạ"J×2$$¦GµL.xị"ḅ1µ$

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

Scala, @Soacco

def g(n:Int) = {
    var vec = Vector.fill(0)(Vector.fill(0)(1))
    for (p <- 1 to n) {
        var vec2 = Vector.fill(0)(1)
        for (q <- (p-1)*n+1 to p*n) {
            vec2 = vec2 ++ Vector(q)
        }
        if (p%2==1) vec = vec ++ Vector(vec2)
        else vec = vec ++ Vector(vec2.reverse)

    }
    println(vec)
}

Không được chạm vào Scala trong một lúc, thật vui khi xem lại. Thật không may, giải pháp này bỏ lỡ rất nhiều tính năng thú vị của Scala.

Dùng thử ở đây

Xác nhận Regex

QBasic (QB64), @DLosc

Lưu ý rằng vì .không khớp \n(U + 000A, LF), dòng mới ở đây là \r(U + 000D, CR).

INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR J=ONE TO N:IF ZERO=I MOD(ONE+ONE)THEN PRINT I*N+J;ELSE PRINT I*N+N-J+ONE;REM
NEXT:PRINT:NEXT

Kiểm chứng:

>>> re.match('^([A-Z]+.)+$', 'INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR J=ONE TO N:IF ZERO=I MOD(ONE+ONE)THEN PRINT I*N+J;ELSE PRINT I*N+N-J+ONE;REM\rNEXT:PRINT:NEXT')
<_sre.SRE_Match object; span=(0, 141), match='INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR >

Khó khăn chính là làm thế nào để chèn một từ sau ;. Rất may, QB64 coi CR là một dòng mới trong khi regex của Python thì không, vì vậy chúng tôi có thể trượt REM\rở đây. Trong số năm hương vị regex được phép,

• Perl chấp nhận "\r" =~ /./
• Javascript Rejects !/./.test('\r') ( \n, \r, \u2028, \u2029đều tách dòng )
• Python chấp nhận re.match('.', '\r')( chỉ \nđược coi là ngắt dòng )
• Golang chấp nhận regexp.Match(".", "\r")
• Ruby chấp nhận /./ =~ "\r"

Vì vậy, vết nứt này vẫn ổn miễn là chúng ta không đề cập đến JavaScript ... 🤐

Con trăn 3, kennytm

def S(N,A=1,K=1,E=list,r=range):print(E(r(A,A+N)[::K]))or(A>N*N-N)or(((S(N,A+N,-K))))

Xác minh Regex

> <>, bánh mì

!v &0_!
_<>~ao1+>_v_
?______;__>:&:&=?;::2%:}+&:&*{3+0$.
?!v1+:n' 'o:&:&%_
?!v:n' 'o1-:&:&%_

C, @Yimin Rong

main(int c,char**p){int n=atoi(*++p),i=n-n,t,o=c;for(--o;i<n;++i)for(t=o;t<=n;++t)printf("%-*d%c",n-o,i%c?i*n+n+o-t:i*n+t,t%n?' ':'\n');}

Chương trình không thể chứa số, nhưng chúng tôi có thể lấy số qua:

1. c, thường được gọi là "argc", luôn luôn là 2.
2. +và -có sẵn, vì vậy chúng ta có thể tạo 0 với n-nvà tạo 1 với o=c;--o.

Ruby, @Value Ink

->n{(1..n).map{|r|x=(r*n-n+1..r*n).to_a;if(r.modulo(2)==1)then(x)else(x.reverse)end}}#1-2-3-4-5-6--

[(-=Z-~]* có nghĩa là "Tôi có thể viết bất cứ điều gì tôi thích :)"

tinylisp, @DLosc

Một giải pháp rất đơn giản và hoàn toàn không được tối ưu hóa :)

(d p(q((m n)(s m(s(s 1 1)n)))))(d j(q((f g)(i(l f g)(c f(j(p f 1) g))()))))(d r(q((f g)(i(l f g)(c(s g 1)(r f(s g 1)))()))))(d k(q((m o f g n)(i(l n g)()(c(m f(p f n))(k o m(p f n)(p g 1) n))))))(d f(q((n)(k j r 1 1 n))))

Gọi như (disp (f 4)).

• (p m n)tính m + n bằng phép trừ s(m + n == m - ((1 - 1) - n))
• (j f g) tạo ra (f f+1 f+2 ... g-1)
• (r f g) tạo ra (g-1 g-2 g-3 ... f)
• (k m o f g n)tạo một hàng của ma trận rắn và sau đó tự lặp lại cho hàng tiếp theo, cho đến khi n hàng được tạo. Các đối số m, ođược thay thế bằng j/ rđể tạo các hàng tăng hoặc giảm. Các đối số f, gđang chạy các chỉ số để biết chúng ta đang ở hàng nào.
• (f n)các cuộc gọi (k j r 1 1 n)để bắt đầu thế hệ.

PHP, @Iovy Botizan

Hiện tại tôi không có ý tưởng nào tốt hơn để bẻ khóa giải pháp ban đầu.

Hỗ trợ n <= 15

Đây là lần đầu tiên tôi sử dụng getopt. Có lẽ không phải là ý tưởng tốt nhất để sử dụng các tùy chọn làm đầu vào.

bắt đầu từ dòng lệnh như thế này

php hack.php -a=4

Regex gốc

Cấp độ 1:

^<[^'"\d{vV;<$]+$

Kết hợp chữ rất đẹp. Hãy bỏ phiếu lên chủ đề cảnh sát.

Nó chặn các hàm của tôi như - strrev - mảng numverse - get_dained_vars

https://regex101.com/r/5rGTnw/2

Cấp độ 2:

^<[^'"\d{v;<$_~|&A-Z]+$

https://regex101.com/r/XtVl9G/1

Dung dịch

 <?php
    error_reporting(~E_NOTICE)&
    define(A,a.chr(E_COMPILE_ERROR-E_NOTICE+E_WARNING))
    &define(B,getopt(A,[])[a])&print_r(array_chunk(
    array_slice(
    array_merge(
    range(E_ERROR,B)
    ,range(E_WARNING*B,E_ERROR+B)
    ,range(E_WARNING*B+E_ERROR,(E_WARNING+E_ERROR)*B)
    ,range(E_PARSE*B,+E_ERROR+(E_WARNING+E_ERROR)*B)
    ,range(E_PARSE*B+E_ERROR,(E_PARSE+E_ERROR)*B)
    ,range((E_PARSE+E_WARNING)*B,+E_ERROR+(E_PARSE+E_ERROR)*B)
    ,range((E_PARSE+E_WARNING)*B+E_ERROR,(E_NOTICE-E_ERROR)*B)
    ,range(E_NOTICE*B,+E_ERROR+(E_NOTICE-E_ERROR)*B)
    ,range(E_NOTICE*B+E_ERROR,(E_NOTICE+E_ERROR)*B)
    ,range((E_NOTICE+E_WARNING)*B,E_ERROR+(E_NOTICE+E_ERROR)*B)
    ,range((E_NOTICE+E_WARNING)*B+E_ERROR,(E_NOTICE+E_WARNING+E_ERROR)*B)
    ,range((E_NOTICE+E_PARSE)*B,E_ERROR+(E_NOTICE+E_WARNING+E_ERROR)*B)
    ,range((E_NOTICE+E_PARSE)*B+E_ERROR,(E_NOTICE+E_PARSE+E_ERROR)*B)
    ,range((E_CORE_ERROR-E_WARNING)*B,E_ERROR+(E_NOTICE+E_PARSE+E_ERROR)*B)
    ,range((E_CORE_ERROR-E_WARNING)*B+E_ERROR,(E_CORE_ERROR-E_ERROR)*B)
    )
    ,B-B,B*B
    ),B)
    )
    ?>

Cấp độ 2:

<?php
define(aa,a.chr(ord(strtoupper(a))-ord(h)+ord(a)))and
define(bb,getopt(aa,[])[a])and
define(us,chr(ord(a)-true-true))and
(prin.t.(us).r)(
(arra.y.(us).chunk)(
(arra.y.(us).slice)(
(arra.y.(us).merge)(
range((ord(b)-ord(a)),bb)
,range((ord(c)-ord(a))*bb,(ord(b)-ord(a))+bb)
,range((ord(c)-ord(a))*bb+(ord(b)-ord(a)),((ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb,+(ord(b)-ord(a))+((ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb,+(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))-(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb,+(ord(b)-ord(a))+((ord(e)-ord(a))-(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(e)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(e)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(q)-ord(a))-(ord(c)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(q)-ord(a))-(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(q)-ord(a))-(ord(b)-ord(a)))*bb)
)
,bb-bb,bb*bb
),bb)
)
?>