强盗：破解正则表达式-做蛇

20

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

蛇形矩阵是遵循此模式的正方形矩阵：

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

您的任务是编写一个代码，该代码将使用输入n并创建这样的矩阵，并使用与警察职位相同的语言，并使用与警察的正则表达式匹配的代码。您代码的输出格式必须与警察代码的输出格式匹配。

请在警察的帖子下发表评论，表明您已破解它。

获奖标准：

获胜者将是提交量最多的用户。如果是平局，那么将有多个获胜者。

restricted-source  regular-expression  cops-and-robbers  matrix 
— 斯蒂夫·格里芬
source

Answers:

10

果冻，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.
— 社区
source
呃，这样¦的作品每一次杀了我，我这个昨天试过但Ṛ不是U决定了Ḥ不能正常工作了。
— 乔纳森·艾伦
很好，我差一点就拿到了，但是也卡在选择其他所有元素上。F是个好主意
— ETHproductions
我的原始代码与此基本相同。我只是用来J代替F。
— 丹尼斯，
@Dennis哦，J...我尝试过，LR但无法将其
— 保留
9

埃米尼亚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]

请参阅我的前两次尝试的编辑历史记录。

— mbomb007
source
不错的工作！与原始解决方案非常相似。
— Emigna '17
5
not bool(reversed(str(bin(N))).index('1'))...我认为这是我见过任何人N%2做手术的最荒谬的方式。
— Stewie Griffin
3
@StewieGriffin当生命给您柠檬，但没有水或糖时，您只需要生吃即可。：D
— mbomb007'3
6

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

正则表达式验证

— xsot
source
5

欧姆，尼克·克利福德

我第一次尝试欧姆。
我非常期待再次使用的非常好用的语言:)

²@┼σ▓_^è?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
— 艾米尼亚
source
您完全按照我的方式来做！做得好！
— 尼克·克利福德
5

05AB1E，Emigna（第二次提交）

第一次使用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
— 价值墨水
source
不错的工作！您得到了预期的解决方案：）
— Emigna
@Emigna谢谢！如果不是这里的其他解决方案（包括您的解决方案）使我意识到，如果堆栈为空，则将打印全局数组，我不会得到它！如果不是那样的话，我永远都不会想出来的。我一直试图做一些技巧，最终)以为那是在堆栈上获得正确结果的唯一方法。
— 价值墨水
是的，)当您只能使用2个非字母数字字符时，这几乎是不可能的。这里最棘手的部分是要构造程序，使其仅使用2个通配符并将它们按顺序排列。如果没有其他解决方案，可能会更难一些，但应该有些困惑：)
— Emigna
@Emigna我想知道的是是否^\w*..$有可能。
— mbomb007 '17
@ mbomb007：我不这么认为。使用这种策略，您需要将加法的结果保存到下一次迭代中，并且您不能为此使用堆栈，这意味着UV需要紧追其后+ˆ。我也想不出另一种方法，也可以只使用2个通配符。可以用3个通配符完成。
— Emigna
5

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堆叠。一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

请参阅我先前的解决方案以获取解释。

— 马丁·恩德
source
4

Python 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"
— 价值墨水
source
真好！：D FYI：如果您有兴趣解决它，我将在Python中创建另一个；）它的时间会更长一些，但是美丽之处在于它的坚韧不拔。
— Yytsi'3
4

R，MickyT

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

它给出相同的输出并匹配相同的正则表达式。

— 浮游动物
source
6
lets_make_a_snake...如果这是预期的解决方案，我会感到惊讶：P
— Stewie Griffin
@plannapus辛苦了。第一个基本上是我打算使用的for`和` if`，但是打高尔夫球比我的要好得多。
— MickyT
4

罗达，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}$。

在线尝试！

— 克里特西·里索斯
source
4

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

美化：

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中的技巧来打印奇数行和偶数行。谢谢Marcos，真的很有趣。

— 肯尼
source
非常好的解决方案
— Mitchell Spector
3

汤姆（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))
展开摘要

— ovs
source
3

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)

稍微分析一下警察的正则表达式会显示一个固定的模板：

________________________"___________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)
— 肯尼
source
真好！好了，几乎可以幸存了一个星期：D我将张贴原始代码。
— Yytsi
3

DC，米切尔斯佩克特

这是我第一次参加警察和强盗挑战赛，我玩得很开心。需要匹配的正则表达式很简单，^[^# !]{59}$基本上使我的工作变成了打高尔夫球，而无需使用这三个字符。最初，我很难获得低于60字节的字节，但最终将其破解。

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

在线尝试！

说明：

我的代码使用一个循环，进行N 2次迭代，保留基于零的计数器（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个循环，但最终超出了正则表达式字符限制。每次迭代生成数字（从零开始）：

  • 如果r % 2 = 0（正常行），n = (r * N) + c = counter
  • 如果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.
— Seshoumara
source
@MitchellSpector这是我的解释。如您所见，我们实际上有相同的算法，只有我使用该命令~一次性计算行索引和列索引。但是我以前的尝试之一确实像您一样分别计算了它们。英雄所见略同？:)
— seshoumara
1
是的，它确实是相同的算法。我喜欢您使用它~来缩短代码。
— 米切尔·史派克
我想你可以用一个字节缩短，如果你在宏的结尾使用平方根诀窍在环测试：?sN0[AP]sP[ddlN~_2*lN+1-r2%*+1+n32P1+dlN%0=PdvlN>L]dsLx tio.run/nexus/...
— 米切尔斯佩克特
@MitchellSpector你是对的，我在阅读你的解释时确实注意到了它，但在聊天室中发表了评论。
— seshoumara
是的，我现在看到了-今天早上我还没有看过聊天室。
— 米切尔·史派克
3

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" "
— 马特
source
很好，我使用了一个$script变量和一些非常凌乱的循环来填充它，[array]::Reverse()虽然很正确，但是恭喜您-我想您可能希望平衡$iand 的长度$MySnakeIndex。
— colsw
@ConnorLSW我知道您知道强盗有错误时，您将无法在晚上入睡。我已经解决了。
— 马特
3

果酱 林恩

像这样：

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的正则表达式。

在线尝试！

说明

正则表达式要求我们仅使用以下方法解决问题：

  • 小写字母。
  • {}，可用于创建块。
  • |，主要用于按位或。
  • ~，“ eval”和按位NOT（也称为“转储数组”，但我不会使用它）。

既然有了 ~如果可以构造任意字符串，则可以运行任意代码。但是，起初，如何做到这一点并不明显。

难题的第一步是，块是未评估的代码位，可以使用转换为字符串s。所以{abc}s给我们"{abc}"。接下来，我们可以使用eu将这些字符串转换为大写形式。

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

这样做的好处是大写字母是预先初始化的变量，因此，我们可以通过创建这样的字符串并将其评估两次来获得很多常量值（一旦将字符串变回一个块，然后一次执行该块）。我们无法获得所有字母，因为有些字母x不是有效的命令（因此CJam将拒绝解析包含它们的块）。我们不能f按原样使用，因为它需要跟在另一个命令之后，但是我们可以先使用fb两个值，然后再进行“或”运算。同样，我们可以使用ee代替e。就这样，我们可以得到的数字0，-1，3和10到19。的-1是方便，因为如果我们把它变成一个字符串（"-1"），然后进入一个字符（'-），然后进行评估，我们可以得到减法或设定差。就像我说的，我们不能X（for 1），但是我们可以取-1with 的绝对值z。

我们还可以使用s来获取包含空格的字符串，并将c其转换为空格字符：

{s}seu~~c

这很方便，因为从那里我们可以通过对空格与各种数字进行“或”运算来获得许多较低ASCII范围的有用命令。为了获得代码点以上的一些字符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和~字符串中我们发生。尽管这些字符已经是有效的字符，但是我们没有字符串文字或字符文字，因此我们也必须生成这些文字，并且从空间中构建更大的代码点有点烦人。相反，我在这里使用了设置减法，但是减去了两个块（以摆脱{}）：

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

这几乎就是它的全部。我们评估[。我们将通过各种计算从我们拥有的几个内置常量|，-（通过eval）和+（通过eval）中推入所有字符。我们评估]。我们将整个内容拼凑成一个字符串，因为有时我将一些字符串或数字添加到列表中。我们用来评估任意字符串~。

这些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.
— 马丁·恩德
source
3

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)

我使用了存储在register中的递归Vim宏q来进行第二个宏（我已jk映射到<Esc>）：f s(v(h(q(jkea))))jk@q。

这两个转换足以消除所有空间。

— 布莱恩·麦卡顿
source
做得很好！我的原始代码非常相似，尽管我编写了一个辅助宏，以使其编写时的痛苦减轻了。我对您对如何避免打印定义的符号的想法感到好奇-如果您愿意共享它们，我将在tinylisp聊天室中。
— DLosc
@DLosc完成，我张贴在那里。
— Brian McCutchon
2

斯威夫特@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)->()

验证：https：//regex101.com/r/7ukrM0/1

— 肯尼
source
我自己获得了“表达式解析为未使用的函数”，但是我不熟悉能够接受答案的所有内容。是eg`let a = <code>; 一个（CShort（4））; 需要使其运行没有必要？
— James Webster
@JamesWebster我不确定确切的规则，因为“代码”非常模棱两可。对于代码高尔夫球，提交可以是程序或函数，因此我仅在此处提供匿名函数。我们还如何接收输入参数？
— kennytm
我的原始内容是函数的主体，因此也不确定我的代码是否有效！因此，我将选择“确定，这很好”并赞成。:)
— James Webster's
@JamesWebster您可以将整个过程称为(…)(4)，而无需将整数文字转换为CShort。
— kennytm
是啊！我永远都不会想到这一点。
— James Webster
2

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

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~')
?>
— 肯尼
source
不错的变体。都怪我没有去想一个功能，使只有一个输出
— 约尔格Hülsermann
2

果冻，长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.
— 丹尼斯
source
2

Jelly，12字节，破解@JonathanAllan的第二个答案

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

在线尝试！

说明

这和我的其他答案几乎一样。我只是做了两个更改：

首先，我将U（“反转每个元素”）更改为Ṛ€（“反转”“每个元素”）。这本身并没有帮助，因为Ṛ也被禁止了。

然后，我将Ṛ（“ reverse”）更改为;@/（/“ fold by” ;“ concatenate” @“以与原始列表相反的顺序”）。这样可以避免所有被禁止的字符，从而提供有效的解决方案。

我假定下一步骤是开始禁止阵列操纵尽皆，除了原子。

— 社区
source
恩，我知道我应该禁止€...
— 乔纳森·艾伦
你可以写€来讲/太。比这个解决方案更冗长。
是的，一个可能;@\ṫ0，正则表达式也越来越长。
— 乔纳森·艾伦
2

果冻，长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.
— 丹尼斯
source
哦，等等，我错过了m吗？
— 乔纳森·艾伦
2

Scala，@ 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)
}

一段时间未接触Scala，重新访问很有趣。不幸的是，该解决方案错过了Scala的许多出色功能。

在这里尝试

正则表达式确认

— 数学迷
source
2

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此处省略。在五种允许的正则表达式中，

因此，只要我们不提及JavaScript，此破解就可以了。

— 肯尼
source
我会接受的，因为它可以在QB64中使用。但是，我还要说的是archive.org的QBasic（我认为它是实际的QBasic而不是仿真）抱怨REM立即跟随没有语句分隔符的语句。我原来的解决方案没有使用注释。我还有另一个即将发布的变化。：D
— DLosc '17
2

> <>，龙卷风

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

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. +并且-可用，因此我们可以用创建0，用n-n创建1 o=c;--o。
— 肯尼
source
次要问题是，警察版本是制表符分隔的，而不是空间限定的，但没有太大意义。
1

Ruby，@值墨水

->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-~]* 意思是“我可以写任何我喜欢的东西:)”

— 肯尼
source
啊，我搞砸了，不是吗
— 珍惜墨水
1

tinylisp，@ 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，以生成递增或递减的行。论据，ojrfg是运行索引，用于了解我们所在的行。
  • (f n)呼吁(k j r 1 1 n)开始一代。
— 肯尼
source
辛苦了 （顺便说一句，这是更地道只是做(f 4)--the disp是隐含的。）
— DLosc
1

PHP，@ Ionut Botizan

目前，我没有更好的主意来破解原始解决方案。

支持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)
)
?>
— 约格·赫尔瑟曼
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.