이것은 강도의 실입니다. 경찰의 스레드가 여기에있다 .

뱀 행렬은이 패턴을 따르는 정사각 행렬입니다.

3x3 :

1  2  3
6  5  4
7  8  9

및 4x4 :

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

당신의 임무는 입력 n을 받아 경찰 게시물과 같은 언어로 그리고 경찰의 정규 표현식과 일치하는 코드로 행렬을 만드는 코드를 작성하는 것 입니다. 코드의 출력 형식은 경찰 코드의 출력 형식과 일치해야합니다.

경찰의 게시물 아래에 주석을 달아서 크래킹했음을 표시하십시오.

당첨 기준 :

우승자는 가장 많이 제출 한 사용자가됩니다. 동점 인 경우에는 여러 명의 승자가 있습니다.

젤리 , 9 바이트, @Dennis의 답변에 균열

²sµUFḤ$¦G

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

지금 정확해야합니다. 오히려 내가하고있는 일을 다시 생각해야했습니다.

설명

이 문제의 가장 어려운 부분은 ¦(특정 인덱스에서 연산을 적용하는) 내부의 짝수 인덱스 목록을 얻는 것 입니다. 전체 프로그램에 대한 입력을 두 번째 피연산자의 기본값으로 사용하는 대부분의 연산과 달리 가장 ¦최근에 본 값을 기본값으로 사용합니다. 두 가지 값을 취하십시오).

그러나 우리는 이미 현재 값에 입력의 1에서 절반까지의 모든 정수를 포함하여 숫자 목록이 있음을 알 수 있습니다. 따라서, 평평하고 배가하면 모든 짝수 인덱스를 포함하여 짝수의 목록을 제공합니다 (일부 다른 짝수이지만 우리는 그에 신경 쓰지 않습니다). µ구문 분석 모호성을 피하기 위해 하나만 사용 하는 것이 가능 하며 여전히 9 자 이내로 입력 할 수 있습니다.

²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, 에미 냐

05AB1E를 사용한 것은 이번이 처음입니다. 약간의 도움으로 얻었습니다. 재미있었습니다. :)

UXFXLNX*+N2BSR1k_iR}ˆ

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

설명:

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

실제로이 비슷한 프로그램을 직접 찾았지만 출력 형식이 다릅니다.

UXFXLNX*+N2BSR1k_iR}=

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

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

이전 두 번의 시도에 대한 편집 기록을 참조하십시오.

파이썬 2, 데니스

이것은 재미있는 토큰 골프 문제입니다.

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

정규식 검증

옴 클리포드

옴을 처음 시도했습니다.
다시 사용하기를 기대하는 정말 멋진 언어 :)

²@┼σ▓_^è?R

설명

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

배열과 int를 추가하는 것으로 작동하지 않은 첫 번째 시도는 불가능합니다.

@┼MDR┼+;W

정규식과 일치하지 않는 두 번째 시도 :

²@┼σ▓_^MR

05. Emigna AB1E (2 차 제출)

05AB1E를 처음 사용합니다.

VYLUYFYXDˆ+RU

온라인으로 사용해보십시오! | 정규식 검증

설명

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 , 린

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

모든 줄 바꿈은 미용 목적을위한 것이며 프로그램에 영향을주지 않고 제거 할 수 있습니다.

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

설명

Lynn {|}이 허용 된 문자 목록에서 제거한 후 새로운 것을 시도해야했습니다. 우리는 여전히 임의의 문자열을 구성하고 코드로 평가할 수 있습니다.

먼저 스택에 가치를 부여해야합니다. 먼저 다른 뭔가를 보여주고없이 (그리고 입력을 읽지 않고) 뭔가를 밀어 수있는 유일한 내장 된 기능은 es, ea와 et. 나는 당신 이이 모든 방법으로 시작할 수 있다고 확신하지만, 나는 es현재 타임 스탬프를 밀어 넣었습니다 . 실제 가치에 대해 어떤 가정도하고 싶지 않았기 때문에 mp( 0와 1)을 사용 0하여 그 우선 성을 테스트하고 그 가치의 우선 성을 다시 테스트 하여 스택에 있는지 확인하십시오 . A는 1우리가 계산할 수 있도록, 더 유용 할 것 exp(0)와 me와와의 정수로 돌려 i. 따라서 모든 숫자는 다음으로 시작합니다.

esmpmpmei

이제 우리는 다양한 단항 수학 연산자를 가지고 있습니다 :

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)

다음과 같은보다 정교한 기능을 위해 몇 가지 내장 기능을 결합 할 수도 있습니다 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.

이를 사용하여 0 <= x < 128에서 10 단계 미만으로 임의의 숫자를 얻을 수 있습니다 1. 이 명령의 훨씬 작은 하위 집합도 충분할 것입니다. 나는이 모든 스 니펫을 결정하기 위해 작은 Mathematica 프로그램을 작성했습니다 (매우 읽기 쉽지 않습니다, 죄송합니다).

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나중에 각 문자를 문자로 변환 할 수 있습니다. 실행하려는 전체 코드를 푸시하면 95( ])를 누릅니다 . 우리는 그 ~문자열을 다른 모든 문자열로 감싸기 위해 평가 한 다음 그 문자열을로 평가합니다 ~.

프로그램 끝에서 실행되는 실제 코드는 다음과 같습니다.

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

설명은 이전 솔루션 을 참조하십시오 .

파이썬 3, TuukkaX

죄송합니다. 사용한 정규 표현식이 너무 쉽지 않았습니다. 아니 0, #나 ? 문제 없어!

예제 출력을 잘못 해석했을 수도 있지만 45 개의 여분의 문자가 남아 있기 때문에 조정이 여전히 쉽습니다.

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, 미키

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

테스트 사례 :

> 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 

정규식 확인 : https://regex101.com/r/OB8ZIM/1

나는 또한했다 :

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

동일한 출력을 제공하고 동일한 정규 표현식 일치합니다 .

로다 , 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="||||||"}

이것은이 PCRE 정규식과 일치하는 익명 함수입니다 ^{(\|[^\/#\s]*){8}$.

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

배쉬, @ 마르코스 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')

확인 됨 :

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
)

하위 명령의 첫 번째 부분은 생성 1 2 3 4, 9 10 11 12및 두 번째 부분을 생성한다 8 7 6 5, 16 15 14 13. 외부sort -n 는 뱀 패턴을 형성하기 위해 그것들을 적절히 혼합합니다.

나는 /superuser//a/101760 의 트릭을 사용하여 홀수 및 짝수 줄을 인쇄했습니다. 정말 재미있는 마르코스 감사합니다.

자바 스크립트, 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))

파이썬 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)

• 확인 : https://regex101.com/r/GI1Zvh/1

경찰의 정규 표현식을 약간 분석하면 고정 템플릿이 표시됩니다.

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

어디 _를 제외한 모든 문자 [ '"#]와 ^의입니다 [int()2/].

"*n)말은 명확하게 표시 eval("..."*n)또는 exec("..."*n)우리가 확인해야하므로, 진행되고 "..."인쇄 j 번째 행을.

는 for i in range(j,어떤없이 지능형리스트를 암시, 문자열의 마지막에 너무 가까이 있습니다 if. 우리는 사람들을 사용하여 i 번째 열을 구성 할 필요가 그래서 i%n, 2*n물건을.

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 , 미첼 스펙터

이것은 경찰과 강도 도전에 대한 나의 첫 출입이었다. 그리고 나는 많은 재미를 가지고 있었다. 정규식을 일치시켜야하는 것은 간단했습니다. ^[^# !]{59}$기본적 으로이 작업은 3자를 사용하지 않고 골프 작업으로 바꿨습니다. 처음에는 60 바이트 미만으로 얻는 데 어려움이 있었지만 결국에는 크랙했습니다.

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

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

설명:

내 코드는 N ² 와 함께 하나의 루프를 사용합니다. 반복으로 하여 0 기반 카운터 (1D)를 유지하고 해당 행렬 행과 열 (r, c) 좌표를 기반으로 인쇄해야 할 숫자를 계산합니다.

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

복잡해 보이지만 중개 단계가 도움이됩니다. 또한 처음부터 2 루프를 사용해 보았지만 정규식 문자 제한을 초과했습니다. 각 반복에서 숫자 생성 (0부터 시작) :

• if r % 2 = 0(일반 행)n = (r * N) + c = counter
• if r % 2 = 1(역행),n = ((r + 1) * N) - c - 1 = counter + N - (2 * c) - 1

또는 하나의 기반 번호 매기기로 한 번에 : 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

갈라진 금

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

문제에 대한 더 작은 솔루션으로 시작하여 정규식을 일치시키기 위해 변수 이름을 채웠습니다. 콜론에 대한 사용을 찾으려고 노력하는 것이 머리를 감싸기 가장 어려운 부분이라고 생각합니다.

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

설명

# 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, 린

이 같은:

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

모든 공백은 "가독성"을위한 것이며 Lynn의 정규식을 준수하기 위해 생략 할 수 있습니다.

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

설명

정규식은 다음을 사용하여 문제를 해결해야합니다.

• 소문자.
• {}블록을 만드는 데 사용할 수 있습니다.
• |비트 OR에 주로 사용됩니다.
• ~, "eval"및 bitwise NOT (또한 "덤프 배열"이지만 사용하지는 않겠습니다).

우리는 ~임의의 문자열을 구성 할 수 있다면 임의의 코드를 실행할 수 있습니다. 그러나 처음에는 그렇게하는 방법이 명확하지 않습니다.

퍼즐의 첫 번째 부분은 블록이 평가되지 않은 코드 비트이며으로 문자열로 바뀔 수 있다는 것입니다 s. 그래서 {abc}s우리를 제공합니다 "{abc}". 다음 eu으로 이러한 문자열을 대문자로 변환 하는 데 사용할 수 있습니다 .

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

이것의 장점은 대문자가 미리 초기화 된 변수이므로 그러한 문자열을 생성하고 두 번 평가하여 문자열을 다시 한 번 블록으로 바꾸고 한 번 반복하여 많은 상수 값을 얻을 수 있다는 것입니다 해당 블록을 실행하십시오). x유효한 문자가 아니기 때문에 모든 문자를 얻을 수 는 없습니다. 따라서 CJam은 문자를 포함하는 블록의 구문 분석을 거부합니다. 우리는 사용할 수 없습니다 f가 다른 명령이 준수해야 할 필요가 있기 때문에, 한, 그러나 우리는 사용할 수 있습니다 fb함께 두 개의 값을 다음 OR. 마찬가지로 ee대신에 사용할 수 있습니다 e. 즉, 우리는 숫자를 얻을 수 있습니다 0, -1, 3,과 10에 19. 은 -1우리가 문자열 (으로 바꿀 경우 때문에 편리합니다 "-1"(다음 문자로)'-)를 평가 한 다음 빼거나 차이를 설정할 수 있습니다. 내가 말했듯이, 우리는 X(for 1)을 얻을 수 없지만 -1with 의 절대 값을 취할 수 있습니다 z.

우리는 또한 사용할 수 있습니다 sA A 공간을 포함하는 문자열 및 사용을 얻기 위해 c우주로 그것을 설정하는 캐릭터 :

{s}seu~~c

거기에서 다양한 숫자로 공백을 정렬하여 하위 ASCII 범위에서 유용한 명령을 많이 얻을 수 있기 때문에 편리합니다. code point 위의 일부 문자를 얻으려면 대신 48문자 '0를 기본으로 사용하십시오.

{t}seu~~si

'+다음 코드 조각에서 (추가 및 문자열 연결)을 얻을 수 있기 때문에 이미 임의의 문자열을 구성하기에 충분합니다 .

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

그리고 우리는 문자를 가지고 1있기 때문에 공백 문자를 밀어서 필요한 값으로 늘린 다음 모두 함께 연결할 수 있지만 약간 지루하고 코드가 커집니다.

대신, 나는 그것들을 생성 [하고 ]회피하여 내가 밀어 넣는 모든 문자가 자동으로 문자열에 싸여 있습니다. 이것이이 두 줄입니다.

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

마지막으로, 생성 할 문자열 f과 ~문자열 이 필요합니다 . 이것들은 이미 유효한 문자이지만 문자열 리터럴이나 문자 리터럴이 없으므로이를 생성해야하며 공간에서 더 큰 코드 포인트를 작성하는 것은 약간 성가신 일입니다. 대신 여기에서 set 빼기를 사용했지만 두 블록을 빼서 (을 제거하기 위해 {}) :

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

그것은 거의 모든 것입니다. 우리는 평가 [합니다. 우리의 다양한 계산하여 얻은 모든 문자를 밀어 몇 내장 우리가 상수, |, -(평가를 통해) 및 +(평가를 통해). 우리는 평가 ]합니다. 어떤 시점에서 문자열이나 숫자를 목록에 추가했기 때문에 전체를 문자열로 병합했습니다. 우리는 임의의 문자열을로 평가합니다 ~.

는 ri...p실제 최종 프로그램의 일부입니다, 그러나 인코딩을 필요로하지 않기 때문에 내가 그들을 추출했습니다.

마지막으로 이것은 우리가 실제로 실행중인 프로그램입니다.

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

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

f응답을 반환 하는 함수 를 정의합니다 . 또한 stdout에 정의한 함수의 이름을 인쇄하지만 적어도 코드 골프에 대해 [출력 스트림을 선택할 수 있기 때문에] 중요하지 않습니다. 큰 문제라면 인쇄하지 않도록 조정할 수 있다고 생각합니다. 내가 어떻게 했어? 나는 상당히 표준적인 것으로 시작했습니다.

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

그런 다음 함수 정의를 다음과 같이 변형 할 수 있음을 관찰했습니다.

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

된다

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

그리고 함수 호출은 다음과 같습니다 :

(a x y)

된다

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

나는 레지스터에 저장이 재귀 빔 매크로를 사용 q(내가 한 두 번째 하나를 수행하기 위해, jk매핑 <Esc>) f s(v(h(q(jkea))))jk@q.

이 두 변형은 모든 공간을 제거하기에 충분했습니다.

스위프트, @ 제임스 웹스터

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

확인 : 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~')?>

• 확인 : https://regex101.com/r/81pUrB/1
• TIO : https://tio.run/#aNvF0

221 바이트가 너무 길기 때문에 (스네이크) 공백이 없으면 쉽게 해결할 수 있습니다.

확인 됨 :

<?=
(
    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~')
?>

젤리, 길이 12, @JonathanAllan

Ḷ-*m@"s@²$G

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

작동 원리

Ḷ-*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.

젤리 , 12 바이트, @JonathanAllan의 두 번째 답변

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

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

설명

이것은 내 다른 대답 과 거의 동일 합니다. 방금 두 가지 변경했습니다.

먼저, U( "각 요소의 역수")를 Ṛ€""역의 요소 "로 변경했습니다. Ṛ금지되어 있기 때문에 그 자체로는 도움이되지 않습니다 .

그런 다음 Ṛ( "역방향")을 ;@/( /" 원본 목록과 반대 순서로 "접음 " ;"연결 " @")으로 변경했습니다. 금지 된 모든 문자를 피하고 유효한 솔루션을 제공합니다.

다음 단계는 원자 외에도 배열 조작 퀵 금지를 시작하는 것이라고 가정합니다 .

젤리, 길이 13, @JonathanAllan

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

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

작동 원리

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.

젤리, 길이 14, @JonathanAllan

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

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

스칼라, @Soapy

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

한동안 스칼라를 건드리지 않았지만 다시 방문하는 것이 즐거웠습니다. 불행히도이 솔루션은 많은 스칼라의 멋진 기능을 놓치고 있습니다.

여기서 사용해보십시오

정규식 확인

QBasic (QB64), @DLosc

.일치하지 않기 때문에 \n(U + 000A, LF) 여기서 줄 바꿈은 \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

검증:

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

가장 어려운 점은 ;. 뒤에 단어를 삽입하는 방법 입니다. 고맙게도 QB64는 CR을 줄 바꿈으로 취급하지만 Python의 정규 표현식은 그렇지 않으므로 REM\r여기서 빠져 나올 수 있습니다. 허용되는 5 가지 정규식 맛 중

• 펄 수락 "\r" =~ /./
• 자바 스크립트 거부 !/./.test('\r') ( \n, \r, \u2028, \u2029모든 라인 분리는 )
• 파이썬은 허용 re.match('.', '\r')( 단 \n줄 바꿈으로 간주됩니다 )
• 골랑 수락 regexp.Match(".", "\r")
• 루비는 받아들입니다 /./ =~ "\r"

자바 스크립트를 언급하지 않는 한이 균열은 괜찮습니다 ... 🤐

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

정규식 검증

> <>, 토르 카도

!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');}

프로그램은 숫자를 포함 할 수 없지만 다음을 통해 숫자를 얻을 수 있습니다.

1. c일반적으로 "argc"라고하며 항상 2입니다.
2. +그리고 -우리가 공을 만들 수 있도록 사용할 수 있습니다 n-n, 그리고 함께 만들기 1 o=c;--o.

루비, @ 가치 잉크

->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-~]* "나는 내가 좋아하는 것을 쓸 수있다":

지독한, @DLOSC

매우 간단한 솔루션이며 완전히 최적화되지 않았습니다. :)

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

로 전화하십시오 (disp (f 4)).

• (p m n)빼기를 사용하여 m + n을 계산합니다 s(m + n == m-((1-1)-n))
• (j f g) 생성 (f f+1 f+2 ... g-1)
• (r f g) 생성 (g-1 g-2 g-3 ... f)
• (k m o f g n)뱀 행렬의 한 행을 생성 한 다음 n 개의 행이 생성 될 때까지 다음 행에 대해 자체적으로 반복합니다. 인수는 m, o치환되고 j/ r증가 시키거나 열을 감소 생성한다. 인수는 f, g우리가있는 행 알 수있는 지표를 실행하고 있습니다.
• (f n)(k j r 1 1 n)세대를 시작하는 호출 .

PHP, @ 이오 ut 보티 잔

현재로서는 원래 솔루션을 해독하는 것이 좋습니다.

n <= 15 지원

getopt를 사용하는 것은 처음입니다. 옵션을 입력으로 사용하는 것이 가장 좋은 방법은 아닙니다.

이 같은 명령 줄에서 시작

php hack.php -a=4

원래 정규식

레벨 1:

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

편지의 아주 좋은 조합. 경찰 스레드를 자유롭게 투표하십시오.

strrev-array_reverse-get_defined_vars와 같은 기능을 차단합니다.

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

레벨 2:

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

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

해결책

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

레벨 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)
)
?>