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

입력 n을 받아 n-n-n "스네이크 매트릭스"를 생성 하는 코드를 작성하십시오.

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

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

정확한 출력 형식은 선택 사항입니다. 예를 들어 output [[1 2 3],[6 5 4],[7 8 9]]또는 이와 유사한 것을 사용할 수 있습니다 .

언어 이름과 코드와 완전히 일치하는 정규식을 제공해야합니다. 정규식의 세부 수준을 선택할 수 있습니다. 극단적으로, 가능한 모든 문자열과 일치하는 정규 표현식을 작성할 수 있으며,이 경우 코드를 해독하기가 매우 쉽습니다. n=4강도가 사용자가 선택한 정확한 형식을 알 수 있도록에 대한 출력도 제공해야합니다 .

regex101.com 또는 Ruby 풍미에서 사용할 수있는 정규 풍미 중 하나를 사용할 수 있습니다 .

• PCRE (PHP)
• 자바 스크립트
• 파이썬
• 골랑
• 루비

사용중인 것을 지정해야합니다.

노트:

• 합리적으로 큰 지원해야합니다 n. 데이터 유형이나 메모리가 오버플로되지 않는다고 가정 할 수 있습니다. 기본 데이터 유형이 8 비트 부호있는 정수인 n<=11경우 부호없는 8 비트 정수인 경우로 가정 할 수 있습니다 n<=15.
• 강도는 선행 / 트레일 링 공백 및 줄 바꾸기를 제외하고 제출 형식의 출력 형식과 일치해야합니다. SE 형식에 의해 제거 될 수 있기 때문입니다.

당첨 기준 :

우승자는 문자 수로 측정 된 가장 짧은 정규 표현식을 사용하여 크랙되지 않은 제출물이됩니다.

게시물이 7 일 동안 크랙되지 않은 상태로 남아 있으면 의도 한 솔루션을 게시하고 제출물을 안전하다고 표시 할 수 있습니다.

05AB1E , mbomb007 에 의해 금이

깨지기 쉬운 재미와 너무 분명하지 않습니다.

정규식 (PCRE) :

^\w*[+\-*\/%]*\w*.{0,2}$

출력 n = 4 :

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

독창적 인 솔루션

UXFXLNX*+NFR}ˆ

Python 2 , 길이 62, 갈라짐

정규식 (PCRE)

^while ((?=\S)[1di\W]|an|eval|nput|nt|or|pr){55}s(?1){45}n...$

샘플 출력

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

젤리 , 길이 6, 갈라짐

정규식 (PCRE)

^.{9}$

샘플 출력

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

R, 길이 14 plannapus에 의해 갈라짐

나는이 정규식을 얻었기를 바랍니다. 내가 말하고자하는 것은 제외 77 자 <space>, #, ;와 [. 나는 그것을 여기에서 테스트했다 .

정규식

^[^ #;\[]{77}$

샘플 출력 n = 4

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

05AB1E , 값 잉크 금

:)
한마디로 멋진 퍼즐입니다.

정규식 (PCRE)

^\w*..\w*$

출력 n = 4

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

> <> , 길이 49, Aaron에 의해 금이

정규식 (자바 스크립트)

^.{7}\n.{12}\n\?.{6};[^v^]{27}(\n.{13}:&.{2}){2}$

샘플 출력 (n = 4)

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

서식은 약간 이상하지만 숫자 길이를 확인하면 길이가 훨씬 길어집니다. 정규 표현식에서 약간 배 밖으로 떨어졌을 수도 있습니다. 확실하지 않습니다!

편집 : 또한 언급하는 것을 잊었습니다. 일반적인 물고기 입력이 아닌 입력에 초기 스택 (-v 플래그)을 사용합니다. 죄송합니다!

원본 코드 :

<v1*2&:
 >:{:}=?v:1+
?^{r0}v;>&:&[r]{&:&2*+}::&:::&*@+@(
+:}=?v>n" "o&:&{1
0~{oa<^v?)*&::&:}

아론은 훨씬 간단합니다! 내 원래 코드의 복잡성은 n[r]모든 n 번째 숫자를 사용하여 해당 세그먼트 (행)를 뒤집은 다음 모든 숫자를 한 번에 인쇄 한다는 아이디어를 기반으로합니다.

옴 , 금이

또한 내 첫 경찰과 강도가 도전 하므로이 패턴에 문제가 있는지 알려주세요 (특히 이것이 알려지지 않은 언어이기 때문에).

정규식 (PCRE)

^\S{6}\W{0,3}\w$

출력 (n = 4)

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

PHP, 221 바이트 ( Cracked )

나는 그것이 충분히 어렵기를 바랍니다.

정규식 (PCRE) : 16 바이트

^[^\s/\#6]{221}$

공백이없고 주석이 없으며 base64_decode를 사용하지 않습니다. 즐기세요.

산출

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

원본 코드

$w=$argv[1];$s="";$r=range(1,$w**2);for($i=0;$i<$w;$i++)if($i%2)array_splice($r,$i*$w,$w,array_reverse(array_slice($r,$i*$w,$w)));foreach(($r)as$v)$s.=str_pad($v,$l=strlen(max($r))+1,"\x20",0);echo(chunk_split($s,$l*$w));

C # net46 ( 분쇄 됨 )

( http://ideone.com/ 작품)

정규식 PCRE 플레이버 길이 58은 정규식 101에서 테스트되었습니다.

^sta((?![\d%bh\/]|==|if|(\[.*){4}|(i.*){6}).){142}urn....$

메소드 만 정규화됩니다. 메소드는 입력 n = 4에 대해 2d int [,] 배열 (int [4,4])을 반환합니다. 인쇄 된 모습 :

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

이것은 이와 같은 첫 번째 항목입니다. 내가 잘못한 것을 알려주십시오. 정규 표현식 길이로이기려고하지 않고 균열을 방지하는 데 얼마나 잘했는지 알고 싶습니다. :)

원본 코드 :

static int[,]g(int n){int l,j,k=n-n,c,s;var _=new int[n,n];var d=n!=n;c=k;c++;s=k;for(l=k;l<n;l++){for(j=k;j<n;j++){_[l,d?n-j-c:j]=++s;}d=!d;}return _;}

Q 기본, 정규식 길이 10 ( 균열 )

정규식

정규식 맛에서 작동해야하지만 파이썬 맛이라고 부릅니다.

([A-Z]+.)+

참고 : 내 솔루션은 형식화되지 않은 QBasic을 사용합니다. 서식을 지정한 후 공백이 추가되어 코드가 정규식과 일치하지 않습니다. (그러나 나는 그것이 변화를 일으키는 유일한 변화라고 말할 수 있습니다 . ([A-Z]+ ?. ?)+여전히 포맷 된 버전에서 작동합니다.)

테스트 목적 으로 코드 형식을 해제 한 상태에서 QB64 를 사용 했습니다 (옵션> 코드 레이아웃에서). 다운로드하지 않으려면 archive.org 에서 온라인으로 QBasic을 실행할 수도 있습니다 (그러나 형식을 해제 할 수는 없습니다).

샘플 출력

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

Python 3, 55 바이트 (크랙 됨)

PCRE / Python / Golang 맛.

def [triangles=(1,SNAKE)]{27}:print[]SNAKE(--:>or[]{48}

( 전체 일치가 필요합니다 . 테스트 할 때 ^와 가정 $할 때)

샘플 출력 :

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

독창적 인 솔루션 :

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

4 바이트를 다듬어야합니다. : p

dc , 정규식 길이 12   seshoumara에 의해 금이!

^[^# !]{59}$

이 정규 표현식은 정규 표현식의 맛을 생각하지 않을만큼 간단합니다. 전역에서 작동해야합니다. (정규식에서 # 뒤에 공백이 있습니다.)

regex101.com (PCRE / PHP, Javascript, Python 및 Golang)과 rubular.com의 Ruby 버전에서 네 가지 맛을 모두 테스트했습니다. dc 프로그램은 5 가지 정규식 버전에서 정규식과 일치합니다.

dc 프로그램은 stdin에서 입력을 받아서 stdout에 출력을 넣습니다.

입력 4의 샘플 출력 (각 줄 끝에 후행 공백이 있음) :

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

원본 코드 (크랙 된 후 추가됨)

이것은 @seshoumara에 의해 금이 갔다 . 내 의도 된 코드는 다음과 같습니다.

?sd[AP]s+0[dddld/2%rld%2*1+ldr-*+1+n2CP1+dld%0=+dvld>l]dslx

설명:

?sd      Input number and store it in register d.
[AP]s+   Macro that prints a newline. The macro is stored in register '+'.
0        Push 0 on the stack, initializing a loop.  (The top of the stack is the index variable.  It will go up to d^2-1.)
[        Start a macro definition.  (The macro will be stored in register l.)
ddd      Push 3 copies of the loop index variable on the stack, so they'll be available later. I'll call this number i.
ld/      Divide the last copy of i by d (integer division); this computes the row of the square that we're in (starting with row 0).
2%       Replace the row number with 0 if the row number is even, with 1 if the row number is odd.
r        Swap the top two items on the stack, so the top item is now the next to last copy of i, and the second item on the stack is the row number mod 2.
ld%      Compute i mod d; this goes from 0 to d-1. It is the column in the square that the next number will be placed in.  (The leftmost column is column 0.)
2*1+     Top of the stack is replaced with 2*(column number)+1.
ldr      Inserts d as the second item on the stack.
-        Computes d-2*(column number)-1.
*        The second item on the stack is the row number mod 2, so multiplying yields 0 if the row number is even, and d-2*(column number)-1 if the row number is odd.
+        Add to the remaining copy of i. The sum is i itself in even-numbered rows, and it's i+d-2*(column number)-1 in odd-numbered rows.

이제 스택 맨 위에있는 합계는 다음에 인쇄하려는 숫자입니다.

• 행 번호가 짝 수면 그 합이 i이므로 올바른지 쉽게 알 수 있습니다.

• 홀수 행의 경우 i = d * (i / d) + (i % d) = d * (행 번호) + 열 번호입니다. i + d-2 * (열 번호) -1의 합은 d * (행 번호) + 열 번호 + d-2 * (열 번호)-1 = d * (행 번호 + 1)-열 번호입니다. -1-표시된 행과 열에 넣고 자하는 숫자로 홀수 번째 행에서 역 카운트를합니다.

지금 설명으로 돌아 가기 :

n        Print the desired number for the current row and column.
2CP      Print a space.  (2C, which is computed by dc as 20 + 12, is 32, the ASCII code for a space.)
1+       The original copy of i is at the top of the stack; add 1 to it.
dld%0=+  If (the incremented value of) i is a multiple of d, call the macro at register '+', which prints a newline.
dvld>l   If d > sqrt(i) (in other words, if i < d^2), then go back to the top of the loop by calling macro l again.
]dslx    End the macro definition, store the macro in register l, and execute it.

배쉬, 정규식 길이 38, 균열 ( @kennytm )

^sort -n <[1adegnopqrstx$\-*()|'; ]+$

입력:

n=4; <command>

산출:

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

PHP

나는 이것이 재미있는 것이기를 바란다! :디

출력 (n = 4)

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

레벨 1 : PCRE (길이 = 17) ( Jörg Hülsermann에 의해 금이갔습니다 )

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

• 작은 따옴표 나 큰 따옴표가 없으므로 문자열이 없습니다!
• 숫자가 없습니다!
• 아니 {... 익명의 기능이 없습니다!
• 안돼 v... 안돼 eval()!
• 아니요 ;.. 그것은 하나의 진술이어야합니다!
• 아니, 아니 <... 아니 Heredoc여러 PHP 블록!
• 큰 것! 아니 $ 너무 ... 행운의 변수를 정의! > : D

@ JörgHülsermann 은 흥미로운 접근법을 가지고 있었지만, 내가 생각한 것은 아닙니다 :). 따라서 새로운 수준의 난이도를 도입하고 있습니다 (이 코드에 맞는 코드가 있고 약속하지는 않습니다).

레벨 2 : PCRE (길이 = 23) ( Jörg Hülsermann에 의해 금이갔습니다 )

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

• 레벨 1 의 모든 제한
• 이 레벨의 새로운 기능 :이 중 어느 것도 없습니다 _~|&A-Z! :)

즐기세요!

오리지널 솔루션

따라서 $변수를 정기적으로 액세스 할 수 없다는 의미는 금지 했지만 전혀 사용할 수는 없습니다! extract()/compact()변수를 현재 범위로 가져 오거나 내보내는 데 계속 사용할 수 있습니다 . :)

$i = 1;
// can be written as
extract(['i' => 1])

echo $i;
// can be written as
echo compact('i')['i'];

그러나 compact('x')['x']++PHP의 변수가 하나의 예외를 제외하고 값으로 전달되기 때문에 작동하지 않습니다! 사물.

$x = (object) ['i' => 1];
// is
extract(['x' => (object) ['i' => 1]]);

// and
compact('x')['x']->i++;
// works just fine!

나머지는 쉽습니다.

• 숫자 0와 1쉽게 변환에 의해 생성되는 false과 true에 int로를 앞에 붙이는 +기호
• 사용 and및 or이후 &및 |금지
• 금지 된 따옴표를 해결하려면 문자열로 취급되는 정의되지 않은 상수를 사용하십시오.
• 정의되지 않은 상수를 사용하여 생성 된 알림을 표시하지 않으려면 @
• 금지 된 문자 v는을 사용하여 생성 할 수 있으며 위의 해결 방법 chr(ord('u') + 1)을 @chr(ord(u) + true)사용하는 것으로 해석됩니다.
• 밑줄은 위와 유사하다 chr(ord('a') - 2)으로 변환하는chr(ord(a) - true - true)
• 금지 된 문자를 포함하는 함수 호출은 함수 callable의 이름을 포함하는 문자열 일 수있는 PHP 유형 을 활용하여 수행 할 수 있습니다. 그래서, 당신은 정의되지 않은 상수에 의해 생성 한 문자열을 연결할 수 있습니다 ord()하여 함수의 이름과 같은 것이있는 invoke를 구축하기를 : array_reverse()가됩니다 (a.rray.chr(ord(a)-true-true).re.chr(ord(u)+true).erse)()( array있다고, 언어 구조가 왜 정의되지 않은 상수로의 분할 a과 rray)
• 조건부 및 루프 구문의 경우 구문이 바로 다음 명령문에만 적용되는 경우 중괄호는 선택 사항이라는 사실을 활용하십시오. 즉, 다음과 같은 작업을 수행 할 수 있습니다. if ($n = $argv[1] and $i = 0) while ($n > $i++ and do_some and other_stuff or exit)

사람이 읽을 수있는 코드의 논리는 다음과 같습니다.

if (
    $x = (object) [
        'result' => [],
        'i' => 0
    ]

    and

    define('n', $argv[1])

    and

    define('un', '_')

    and

    // create the initial set which we'll loop through
    define('segments', array_chunk(range(1, pow(n, 2)), n))
) while (
    // store each odd segment as-is and increment the "pointer"
    ($x->result[] = @segments[$x->i++])

    and

    // store each even segment reversed and increment the "pointer"
    ($x->result[] = @array_reverse(segments[$x->i++]))

    and

    // check if we need to break out of the loop
    n > $x->i

    or

    // exit and output the result if the above is false
    die(json_encode(
        // if n is odd, the above would have copied a NULL entry 
        // from the segments, so it needs to be filtered out
        array_filter($x->result)
    ))
)

그리고 정규식과 일치하는 비우호적 인 버전 :

<?php if (@extract([x=>(object)[s=>[],i=>+false]])and@define(n,compact(arg.chr(ord(u)+true))[arg.chr(ord(u)+true)][+true]?:+true)and@define(un,chr(ord(a)-true-true))and@define(s,(a.rray.un.chunk)(range(+true,pow(n,true+true)),n)))while((@compact(x)[x]->s[]=s[@compact(x)[x]->i++])and(@compact(x)[x]->s[]=(a.rray.un.re.chr(ord(u)+true).erse)(s[@compact(x)[x]->i++]))and(n>@compact(x)[x]->i)or(@die((json.un.encode)((a.rray.un.filter)(@compact(x)[x]->s)))))?>

루비 [금이 간]

첫 경찰과 강도가 도전합니다. 나는 이것을 너무 쉽게하지 않기를 바랍니다.

편집 : 대신 \g<1>에 (?1)그들은 분명 PCRE에 해당이기 때문에.

정규식 (PCRE)

^(\W?\W\w){4}..(?1){2}[(-=Z-~]*(?1){5}\w*(?1)(.)\2$

출력 (n = 4)

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

(배열의 배열을 반환합니다. 람다, BTW이지만 너무 많이 줄 수 있습니까?)

자바 스크립트 (Cracked)

경찰과 강도 도전을 처음으로했을 때, 바르게 행동하십시오.

정규식 (자바 스크립트)

^.*(\.\w+\(.*\)){4}$

산출

다음과 같은 배열

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

스위프트, 정규식 25 (분쇄 됨)

알았어, 내가 이것에 매달린 지 보자. 이것은 나의 첫번째 경찰과 강도 포스트이다. 그래서 lemme는 내가 엉망이되었는지 알고있다!

정규식

regex101.com에서 자바 스크립트 맛을 사용했습니다.

^.{21}print[^/]{49}o.{7}$

샘플 출력

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

원본 코드

(0..<n).forEach{i in print((0..<n).map{i%2>0 ?(i+1)*n-$0 :i*n+$0+1},separator:",")}

C – 길이가 42자인 정규식 – 크랙

regex101 에서 사용되는 Javascript 정규식 .

^[-h<=*c+m?{printf("\/a: %d\\',o);}]{137}$

이것을 추측하는 것은 사소한 일입니다 ...

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

출력은 \n각 줄 다음에 탭으로 구분됩니다 .

내 솔루션, 여기에 0의 정수 - (2)를 통해 얻을 수 있었다 t-t, t/t그리고 t:

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

젤리 , 길이 14 금이

데니스에 의해 금이

[^/P-`mvḊ-ṫ€]*

파이썬 정규식.

m미끄러지게 한 후에 다시 추가되었습니다 .

/(빠르게 줄이십시오);
에서 P에 (제품) `(다이 애드의 빠른에서 모나드);
m(모듈로 색인화);
v(이발 다이아 드);
에서 Ḋ로 (디큐) ṫ(꼬리); 그리고
€(각 빠른)

4광산 출력 의 입력 :

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

...로 목록 목록을 그리드로 형식화했기 때문입니다 G.

파워 쉘, 23 바이트

매트에 의해 금이

^.+?%.{42}%.{11}:.{35}$

원래 솔루션 :

$n="$args";$script:r=0;$a=1..$n|%{$t=++$script:r..($script:r+=$n-1);if(!($_%2)){[Array]::Reverse($t)};,$t};$a|%{$_-join" "}

입력을 인수로 받아서 stdout에 출력

잘하면이 정규식은 괜찮습니다. 많은 것을 난독 화하지 않았기 때문에이 균열이 너무 어려울 것으로 기대하지는 않습니다. 정규식은 격차를 메울 수있는 좋은 출발점을 제공합니다. 첫 번째 세그먼트에는 한 가지가 있습니다. 코드 골프에서 매우 드문 일이지만 누군가를 잡을 수 있습니다.

우선 경찰이 도전합니다.

1..4 | % { "----$_----" ; .\snake-cops.ps1 $_  }
----1----
1
----2----
1 2
4 3
----3----
1 2 3
6 5 4
7 8 9
----4----
1 2 3 4
8 7 6 5
9 10 11 12
16 15 14 13

Röda 0.12 , 길이 19 (@KritixiLithos에 의해 크랙 됨)

PCRE :

^{(\|[^\/#\s]*){8}$

샘플 출력 (n = 4) :

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

원본 코드 :

{|n|seq(0,n-1+n%2)|push([{|i|seq(n*i+1,n*i+n)}(_)],[{|j|seq(n*j+n,n*j+1,step=-1)}(_)])|head(n)}

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

PHP 7 (안전)

원본 코드

for($z=0,$q="";$z<($x=$argv[1])**2;){$w=($d=intdiv($z,$x))%2?($d+1)*$x-$z%$x:($z+1);for($f=0;$f<(log10($x**2)^0)-(log10($w)^0);$f++)$q.="\x20";$q.=++$z%$x?"$w\x20":"$w\n";}print(rtrim($q));

두 번째 시도

정규식 (PCRE) : 29 바이트

^[^A-Z#\/\s\>busy_heck]{189}$

공백이없고 주석이 없으며 base64_decode를 사용하지 않습니다.

많은 기능이 허용되지 않습니다! 밑줄

출력 n = 11

  1   2   3   4   5   6   7   8   9  10  11
 22  21  20  19  18  17  16  15  14  13  12
 23  24  25  26  27  28  29  30  31  32  33
 44  43  42  41  40  39  38  37  36  35  34
 45  46  47  48  49  50  51  52  53  54  55
 66  65  64  63  62  61  60  59  58  57  56
 67  68  69  70  71  72  73  74  75  76  77
 88  87  86  85  84  83  82  81  80  79  78
 89  90  91  92  93  94  95  96  97  98  99
110 109 108 107 106 105 104 103 102 101 100
111 112 113 114 115 116 117 118 119 120 121

출력 n = 4

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

출력 n = 3

1 2 3
6 5 4
7 8 9

MATL , 길이 12 (안전)

정규식

파이썬 풍미를 사용합니다 :

(\w{3}\W){5}

출력 예

의 경우 n=4:

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

해결책

txU:GeG:oEq*S5M*TTx!

이것이 어떻게 작동하는지 보려면 input을 고려하십시오 n=4.

tx   % Implicit input n, duplicate, delete. So this does nothing
     % STACK: 4
U    % Square
     % STACK: 16
:    % Range
     % STACK: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
Ge   % Reshape as an n-row array in column major order
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
G:   % Push range [1 2 ... n]
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
               [1 2 3 4]
o    % Modulo 2
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
              [1  0  1  0]
Eq   % Times 2, minus 1 (element-wise)
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
              [1 -1  1 -1]
*    % Multiply (element-wise with broadcast)
     % STACK: [1 -5  9 -13;
               2 -6 10 -14
               3 -7 11 -15
               4 -8 12 -16]
S    % Sort each column
     % STACK: [1 -8  9 -16;
               2 -7 10 -15;
               3 -6 11 -14;
               4 -5 12 -13]
5M   % Push [1 -1 1 -1] again
     % STACK: [1 -8  9 -16;
               2 -7 10 -15;
               3 -6 11 -14;
               4 -5 12 -13]
              [1 -1  1  -1]
*    % Multiply (element-wise with broadcast)
     % STACK: [1  8  9  16;
               2  7 10  15;
               3  6 11  14;
               4  5 12  13]
TTx  % Push [true true] and delete it. So this does nothing
!    % Transpose. Implicitly display
     % STACK: [ 1  2  3  4;
                8  7  6  5;
                9 10 11 12;
               16 15 14 13]

젤리 , 길이 17 (안전)

[^/P-`mvÇ-ıḃ-ṫ€]*

파이썬 정규식.

매듭을 조이면 더 유용한 것들이 금지됩니다. 여기에 도움이되는 것은 금지 된 바이트입니다.

/PQRSTUVWXYZ[\]^_`mvÇÐÑ×ØÞßæçðñ÷øþĊċĖėĠġİıḃḄḅḊḋḌḍḞḟḢḣḤḥḲḳḶḷṀṁṂṃṄṅṆṇṖṗṘṙṚṛṠṡṢṣṪṫ€

그중 1/3 이하!

4광산 출력 의 입력 :

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

...로 목록 목록을 그리드로 형식화했기 때문입니다 G.

해결책 :

’:2o1
Ḃ¬aẋ@0
’r0;0ẋ$ẋ1Ŀ¬0¦;2ĿÆ¡œ?⁸²¤s⁸G

온라인으로 사용해보십시오! / 정규식 101

여기서 주요 트릭은 자연수의 순열을 n ² 까지의 사전 순으로 정렬 된 목록으로 색인화하고 ( œ?길이 n ² ! 의 목록 작성을 피하기 위해 사용 ) 결과를 길이 n의 청크로 분할하는 것 입니다. 상기 언급 된 지수는 "미분 할"뱀이 규정 된 방식으로 요소를 치환함으로써 생성되기 때문에 공식적인 계승 수 시스템 에서 그 표현을 형성함으로써 발견된다 (이것은로 쉽게 숫자로 변환 될 수있다 Æ¡).

내가 제시 한 솔루션은 Ŀ이전 링크를 모나드 (바꾸기 Ñ및 Ç) 로 참조 하는 데 사용 되지만 $이러한 도우미 기능을 "인라인"하기 위해 여러 행을 사용할 수 있습니다. 또한 사용 r이후 Ḷ및 R금지된다.

’:2o1 - Link 1, periodic repetitions in the factorial base representation: n
’     - decrement n
 :2   - integer divide by 2
   o1 - or 1 (keep one period in the cases n=1 and n=2)

Ḃ¬aẋ@0 - Link 2, n zeros if n is even, else an empty list: n
Ḃ      - mod 2
 ¬     - not
   ẋ@0 - 0 repeated n times
  a    - and

’r0;0ẋ$ẋ1Ŀ¬0¦;2ĿÆ¡œ?⁸²¤s⁸G - Main link: n                    e.g. 6
’r0                        - inclusive range(n-1, 0)              [5,4,3,2,1,0]
    0ẋ$                    - 0 repeated n times                   [0,0,0,0,0,0]
   ;                       - concatenate (makes one "period")     [5,4,3,2,1,0,0,0,0,0,0,0]
        1Ŀ                 - call link 1 as a monad               2
       ẋ                   - repeat list                          [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,0]
           0¦              - apply to index 0 (rightmost index):
          ¬                -     not (make the last 0 a 1)        [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,1]
              2Ŀ           - call link 2 as a monad               [0,0,0,0,0,0]
             ;             - concatenate                          [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,1,0,0,0,0,0,0]
                Æ¡         - convert from factorial base          45461852049628918679695458739920
                      ¤    - nilad followed by link(s) as a nilad
                    ⁸      -     left argument, n                 6
                     ²     -     square                           36
                  œ?       - lexicographical permutation lookup   [1,2,3,4,5,6,12,11,10,9,8,7,13,14,15,16,17,18,24,23,22,21,20,19,25,26,27,28,29,30,36,35,34,33,32,31]
                       s⁸  - split into chunks of length n        [[1,2,3,4,5,6],[12,11,10,9,8,7],[13,14,15,16,17,18],[24,23,22,21,20,19],[25,26,27,28,29,30],[36,35,34,33,32,31]]
                         G - format as a grid

핍 , 정규식 길이 3 (안전)

솔루션은 n 을 명령 줄 인수로 사용 하는 전체 프로그램입니다 . 명령 행 플래그를 사용하지 않습니다.

정규식 (모든 맛)

\w+

샘플 출력

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

내 솔루션

YENsXaPBsPOyY_MUyFi_MUENsXaIiBA1PsPUPODQENsXiXaPBsX_PBsMRVyEI1PsPUPODQENsXiXaPBsX_PBsMy

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

전략

작성 하고자 하는 코드는 다음과 같습니다 .

Y \,a
F i ,a
 I i%2
  P i*a+_.s M RVy
 E
  P i*a+_.s M y

그건:

• 숫자 1을 통해 저장 a에y
• i0에서 0까지 의 루프 오버 값a-1
• 경우 i홀수, 역 Y가 추가 i*a, 각 요소에 각각의 요소에 대한 공간을 연결하고, 인쇄
• 그렇지 않으면 같은 작업을 수행하지만 먼저 되 돌리지 마십시오.

어려움

Pip의 많은 명령과 변수는 문자를 사용하지만 일부 중요한 문자와 문자는 사용하지 않습니다.

• 범위 및 포함 범위 ( ,및 \,)
• 대부분의 수학 연산 ( +, -, *, %, ++)
• 과제 ( :)
• 우리는 하나 이상의 문장으로 된 루프 또는 함수 본문을 가질 수 없습니다 (필요한 {})
• 우선 순위를 적용하기 위해 괄호를 사용할 수 없습니다

이러한 한계를 극복하는 방법 :

• EN대신에 umerate를 사용할 수 있습니다 ,. 원하는 문자 수를 가진 문자열 만 있으면되며 다음과 같은 구조에서 각 하위 목록의 첫 번째 요소를 추출해야합니다 [[0 "H"] [1 "i"]].
• F또는 루프로 문제를 해결할 수 있다면 아무것도 증가시킬 필요가 없습니다 .
• ank 연산자로 y변수를 할당 할 수 있습니다 Y.
• 문자열로 수학을 수행 할 수 있습니다. X문자열 곱셈이며 PUsh (또는 PB"push-back")은 문자열을 다른 문자열에 연결합니다. 문자열의 길이를 얻기 위해 문자열 EN을 계산하고 결과 목록에서 올바른 숫자를 추출 할 수 있습니다 .
• 를 사용하여 단일 표현식 람다 함수로 작성할 수있는 한 함수를 사용할 수 있습니다 _.

사양

우리 프로그램의 빌딩 블록 :

범위

_MUENsXa

그것은 map-unpack(_, enumerate(repeat(space, a)))의사 코드입니다. Map-unpack은 Python과 같습니다 itertools.starmap: 목록 목록이 주어지면 각 하위 목록의 항목에 대해 함수를 호출합니다. _첫 번째 인수를 반환하므로 _MU각 하위 목록의 첫 번째 항목 만 가져옵니다. 예를 들어, a = 3 : 인 경우

     sXa  "   "
   EN     [[0 " "] [1 " "] [2 " "]]
_MU       [0 1 2]

...와 같습니다 ,a.

포함 범위

inclusive-range(1, a)단일 식 으로 수행 할 수있는 방법이 확실하지 않지만 다행히 한 번만 필요하므로 y3 단계로 변수에 구성 할 수 있습니다 .

YENsXaPBs

의사 코드에서 yank(enumerate(repeat(space, a).push-back(space))):

   sXa     "   "
      PBs  "    "
 EN        [[0 " "] [1 " "] [2 " "] [3 " "]]
Y          Store that in y

그런 다음 POy첫 번째 항목을 팝 y하고 버리고 버리십시오 [[1 " "] [2 " "] [3 " "]].

드디어,

Y_MUy

즉, yank(map-unpack(_, y)): 각 하위 목록의 첫 번째 요소를 추출하고 결과 목록을 다시로 가져옵니다 y. y지금 [1 2 3]입니다.

길이

PODQENaPBs

의사 코드에서 pop(dequeue(enumerate(a.push-back(space)))). 여기서 어려운 점은 열거는 우리에게만 숫자를 제공 len(a)-1하지만 우리는 원한다는 것 len(a)입니다. 먼저 공백을 a로 확장하여 한 문자 씩 늘리고 len-1새 문자열 을 가져 옵니다.

      a     "xyz"
       PBs  "xyz "
    EN      [[0 "x"] [1 "y"] [2 "z"] [3 " "]]
  DQ        [3 " "]
PO          3

수학

이제 문자열 길이를 취할 수있는 방법이 있으므로 문자열을 사용하여 곱셈과 숫자를 더할 수 있습니다.

PODQENsXaXbPBs
PODQENsXaPBsXbPBs

첫 번째는 공백 sXaXb문자열을 a*b만든 다음 길이를 가져옵니다. 두 번째는 공백 sXaPBsXb문자열을 b공백 문자열로 푸시 한 a다음 길이를 가져옵니다.

좋은 부분은 우리가 여기에서 사용하고있는 모든 사업자가 (즉 PU, PO, PB, DQ, EN, X)와 함께 사용할 수있는 _형태로 람다 표현식. 따라서 우리는 수학 변환을 앞에서 구성한 포괄적 인 범위에 매핑 할 수 있습니다.

또한 i%2루프 내부 를 확인해야 하지만 비트 AND :로 쉽게 수행 할 수 있습니다 iBA1.

함께 넣어

공백이 추가 된 전체 코드 :

YENsXaPBs POy Y_MUy              Get \,a into y
F i _MUENsXa                     For i in ,a
 I iBA1                           If i%2=1
  P sPUPODQENsXiXaPBsX_PBs M RVy   Print sPUi*a+_ M RVy
 EI1                              Elseif 1 (using E would cause a parsing problem)
  P sPUPODQENsXiXaPBsX_PBs M y     Print sPUi*a+_ M y

CJam, PCRE, 길이 8, 갈라짐

^[a-~]*$

4 : 출력 예

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

CJam, PCRE, 길이 9, 갈라짐

^[a-z~]*$

4 : 출력 예

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

이제 {|}금지되어 있습니다.

Mathematica, 정규식 길이 11, 경쟁 없음 , 갈라짐

PCRE 풍미 :

^[^]@]{49}$

올바른 솔루션은 정수를 사용하여 다음과 같이 중첩 목록으로 출력을 반환하는 함수입니다.

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

tinylisp , 정규식 길이 3 ( 금 )

tinylisp 코드를 온라인 에서 시험해보십시오!

정규식 (모든 맛)

\S+

하드 코어 갈 시간.

산출

솔루션은 단일 정수 인수를 사용하고 다음과 같은 목록을 반환 하는 함수 를 정의합니다 (n = 4의 경우).

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

내 원래 코드는 Brian McCutchon이 제시 한 것과 동일한 기본 아이디어를 사용하여 목록을 작성하고 평가합니다. 여기 한 줄에 있습니다.

(v(c(h(q(d)))(c(h(q(d')))(c(c(h(q(q)))(c(c()(c(q(arglist))(c(c(h(q(v)))(c(c(h(q(c)))(c(c(h(q(q)))(q(d)))(q(arglist))))()))())))()))()))))(d'(seq-args(c(h(q(start)))(c(h(q(stop)))(c(h(q(step)))())))))(d'(seq(c(c(h(q(accum)))seq-args)(q((i(e(v(h(q(start))))stop)(c(v(h(q(start))))accum)(seq(c(v(h(q(stop))))accum)start(s(v(h(q(stop))))step)step)))))))(d'(f'(c(c(h(q(index)))(c(h(q(size)))seq-args))(q((i(e(v(h(q(index))))size)()(c(seq()start(v(h(q(stop))))step)(f'(a(h(q(1)))index)size(a(v(h(q(stop))))size)(a(v(h(q(start))))size)(s(h(q(0)))step)))))))))(d'(f(q((size)(f'(h(q(0)))size(h(q(1)))size(h(q(1))))))))

나는 완전한 construct-and-eval 메소드를 한 번 사용하여 d'와 같은 정의를 만드는 매크로 를 정의 d했지만 인수를 목록으로 묶었습니다. 대신 (d x 42), 대신 할 수 있습니다 (d'(x 42)). 그런 다음 공백이 필요할 수있는 정의의 목록을 다시 작성하는 것이 었습니다 (q(a b)).-> (c a(q(b)))->(c(h(q(a)))(q(b))) .

Python3, 길이 162 (Cracked!)

정규식 : ^([^"' #]){24}"(?1){11}i%n(?1){4}2\*n-(?1){4}i%n(?1){10}i\/n(\)\/\/1)(?1){5}(?2)(?1){3}2\*\(i%n\)(?1){4}[int()2\/]{16}for i in range\(j,(?1){4}\]\)(?1){6}\"\*n\)$

알았어요, 꽤 길어요 다행히도, 일주일도 지나지 않아 ... : 'D.

나는 내가 실수를하지 않았다고 생각한다.

출력 형식

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

원본 코드 :n=int(input());j=0;exec("print([int(i%n+1+(2*n-(2*(i%n)+1))*((((i/n)//1+1)/2)//1)+(2*(i%n)+1)*int(int(i/n)/2))for i in range(j,j+n)]);j+=n;"*n)