这是警察的话题。在强盗的线程是在这里。

编写一个接受输入n并创建n×n“蛇阵”的代码。

蛇矩阵是遵循此模式的矩阵：

3乘3：

1  2  3
6  5  4
7  8  9

和4比4：

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

确切的输出格式是可选的。例如[[1 2 3],[6 5 4],[7 8 9]]，您可以输出或类似内容。

您必须提供语言名称以及与您的代码完全匹配的正则表达式。您可以选择正则表达式的详细程度。在极端情况下，您可以编写与每个可能的字符串匹配的正则表达式，在这种情况下，很容易破解您的代码。您还必须提供的输出n=4，以便强盗知道您选择的确切格式。

您可以使用regex101.com上提供的一种regex风味或Ruby风味。

• PCRE（PHP）
• Java脚本
• 蟒蛇
• 高朗
• 红宝石

您必须指定使用的是哪一个。

笔记：

• 您必须支持任何较大的对象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 被扁虫弄碎

我希望我正确使用此正则表达式。我想说的是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破解

正则表达式（JavaScript）

^.{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 

格式化有点奇怪，但是检查数字长度会使其更长。不确定regex可能有点过头了！

编辑：我也忘了提一下，我使用初始堆栈（-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字节（破解）

我希望这足够困难。

正则表达式（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/有效）

Regex PCRE风味长度58在regex101上测试

^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 _;}

QBasic，正则表达式长度10（开裂）

正则表达式

应该可以在任何正则表达式中使用，但我们将其称为Python风格。

([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程序在所有五个正则表达式版本中都与正则表达式匹配。

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.

Bash，正则表达式长度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

希望这会很有趣！：D

输出（n = 4）

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

1级：PCRE（长度= 17）（由约格·赫尔瑟曼（JörgHülsermann）破解）

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

• 没有单引号或双引号，所以...没有字符串！
• 没有数字！
• 否{...没有匿名功能！
• 不，不v...不eval()！
• 不能;。它必须是一个声明！
• 不行<，不行，Heredoc也不存在多个PHP块！
• 大的那个！否$这样...祝您好运，定义变量！>：D

@JörgHülsermann有一个有趣的方法，但这不是我想的:)。因此，我正在介绍一个新的难度级别（我保证我拥有适合这个难度的代码，而不仅仅是与你惹恼）：

2级：PCRE（长度= 23）（由约格·赫尔瑟曼（JörgHü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)
• 可以通过利用PHP的callable类型来调用包含禁止字符的函数，该类型可以是包含函数名称的字符串。因此，您可以将未定义的常量和生成的单个字符串连接起来，ord()以构建函数的名称并按如下方式调用它：array_reverse()gets (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)))))?>

Ruby [破解]

第一警察和强盗挑战。希望我没有太过容易。

编辑：替换为\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]]

（返回一个数组数组。这是一个lambda，顺便说一句，但可能会给出太多吗？）

JavaScript （破解）

第一次进行警察和强盗挑战，希望做对了。

正则表达式（JavaScript）

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

输出量

等于的数组：

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

Swift，regex 25 （破解）

对，让我们看看我是否掌握了这个要诀。这是我的第一个警察和强盗帖子，所以我知道我是否搞砸了！

正则表达式

我在regex101.com上使用了JavaScript风格

^.{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 regex 。

^[-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Ḋ-ṫ€]*

Python正则表达式。

m我滑开后又重新加入。

/（快速减少）；
从P（产品）到`（来自dyad quick的monad）;
m（模索引）;
v（评估组）；
从Ḋ（出队）到ṫ（尾巴）; 和
€（每个快速）

输入4地雷输出：

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

...因为我将清单的清单格式化为网格G。

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

罗达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（安全）

正则表达式

使用Python风味：

(\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Ç-ıḃ-ṫ€]*

Python正则表达式。

收紧结，这会禁止一些更有用的东西，为您提供帮助，这是被禁止的字节：

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

不到其中的三分之一！

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

在线尝试！/ regex101

这里的主要技巧是索引一个按字典顺序排序的自然数（最多n ^2个）的排列列表（œ?以避免建立长度为n ²！的列表），并将结果拆分为长度为n的块。通过在阶乘数系统中形成它的表示，可以找到上述索引，这是公式化的，因为“未切片的”蛇是通过以规定的方式对元素进行排列而创建的（可以使用轻松地将其转换为数字Æ¡）。

我提出的解决方案使用Ŀmonad来引用以前的链接（替换Ñ和Ç），但是$可以采用连续多个来“内联”这些辅助函数。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
• 循环i从0到的值a-1
• 如果i为奇数，则将y取反，将其添加i*a到每个元素，将一个空格连接到每个元素，然后打印
• 否则，请执行相同的操作，但不要先反转

难点

Pip中的许多命令和变量都使用字母，但是一些重要的命令和变量却不使用字母：

• 范围和包含范围（,和\,）
• 大多数数学运算（+，-，*，%，++）
• 作业（:）
• 我们的循环或函数体不能包含一个以上的语句（这需要{}）
• 我们不能使用括号来强制优先

我们如何克服这些限制：

• EN可以用枚举代替,; 我们只需要一个带有所需字符数的字符串，并且需要在像这样的结构中提取每个子列表的第一个元素[[0 "H"] [1 "i"]]。
• 如果可以使用For循环解决问题，则无需增加任何内容。
• 我们可以y使用Yank运算符分配给变量。
• 我们可以使用字符串进行数学运算：X是字符串乘法，而PUsh（或PB“推回”）会将字符串串联到另一个字符串中。要获取字符串的长度，我们可以EN将其枚举并从结果列表中提取正确的数字。
• 我们可以使用函数，只要它们可以使用编写为单表达式lambda函数即可_。

细节

我们程序的基本组成部分：

范围

_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)在单个表达式中执行此操作，但是幸运的是，我们只需要执行一次，因此可以y分三步在变量中构造它。

YENsXaPBs

用伪代码yank(enumerate(repeat(space, a).push-back(space)))：

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

Next 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）可以与使用_，以形式lambda表达式。因此，我们可以将数学变换映射到我们之前构建的包含范围。

我们还需要检查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))))))))

我使用的全面建设和-eval方法一次，定义一个宏d'，使定义一样d，但需要它的参数包裹在一个列表：所以不是(d x 42)，你可以做(d'(x 42))。然后，只需重写定义中可能需要空格的任何列表即可：(q(a b))-> (c a(q(b)))->(c(h(q(a)))(q(b)))。

Python3，长度162 （破解！）

正则表达式： ^([^"' #]){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)