Este é o tópico do policial. A linha do ladrão está aqui .

Escreva um código que aceite uma entrada ne crie uma "matriz de cobra" n por n.

Uma matriz de cobra é uma matriz que segue esse padrão:

3 por 3:

1  2  3
6  5  4
7  8  9

e 4 por 4:

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

O formato exato de saída é opcional. Você pode, por exemplo [[1 2 3],[6 5 4],[7 8 9]], saída , ou algo semelhante.

Você deve fornecer o nome do idioma e uma regex que corresponda totalmente ao seu código. Você pode escolher o quão detalhado deve ser o seu regex. No extremo, você pode escrever uma regex que corresponda a todas as seqüências possíveis; nesse caso, será muito fácil decifrar seu código. Você também deve fornecer a saída para n=4que os ladrões saibam o formato exato pelo qual você optou.

Você pode usar um dos sabores de regex disponíveis no regex101.com ou o sabor de Ruby.

• PCRE (PHP)
• Javascript
• Python
• Golang
• Rubi

Você deve especificar qual você está usando.

Notas:

• Você deve suportar qualquer razoavelmente grande n. Você pode supor que ele não excederá o tipo de dados ou a memória. Se o tipo de dados padrão for números inteiros assinados em 8 bits, você poderá assumir que n<=11, se forem números inteiros não assinados em 8 bits, poderá assumir n<=15.
• Os ladrões precisam corresponder ao formato de saída da submissão, exceto espaços à esquerda / à direita e novas linhas, pois isso pode ter sido removido pela formatação SE.

Critério de vitória:

O vencedor será o envio sem rachaduras com a menor expressão regular, medida em número de caracteres.

Se sua postagem permanecer sem crack por 7 dias, você poderá postar a solução pretendida e marcar seu envio como seguro.

05AB1E , rachado por mbomb007

Esperançosamente divertido de quebrar e não muito óbvio.

Regex (PCRE):

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

Saída n = 4:

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

Solução original

UXFXLNX*+NFR}ˆ

Python 2 , comprimento 62, rachado

Regex (PCRE)

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

Saída de amostra

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

Gelatina , comprimento 6, rachada

Regex (PCRE)

^.{9}$

Saída de amostra

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

R, comprimento 14 Rachado por plannapus

Espero ter acertado este regex. O que eu quero dizer é 77 caracteres excluindo <space>, #, ;e [. Eu testei aqui

Regex

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

Saída de amostra n = 4

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

05AB1E , rachado pelo valor da tinta

Vamos aumentar um pouco :)
Espero que seja um bom quebra-cabeça.

Regex (PCRE)

^\w*..\w*$

Saída n = 4

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

> <> , comprimento 49, Rachado por Aaron

Regex (Javascript)

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

Saída de amostra (n = 4)

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

A formatação é um pouco estranha, mas a verificação do tamanho do número teria feito muito mais tempo. Pode ter exagerado um pouco no regex, não tenho certeza!

Edit: Também esqueci de mencionar, eu uso a pilha inicial (-v flag) para entrada, não a entrada de peixe usual. Desculpe!

Código original:

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

Aaron é muito mais simples! A complexidade do meu código original é baseada na idéia de usar n[r]todo o n-ésimo número para inverter esse segmento (linha) e, em seguida, imprimir todos os números de uma vez no final

Ohm , rachado

Também meu primeiro desafio de Policiais e Ladrões, diga-me se há problemas com esse padrão (especialmente porque esse é um idioma bastante desconhecido).

Regex (PCRE)

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

Saída (n = 4)

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

PHP, 221 bytes ( rachado )

Espero que seja difícil o suficiente.

Regex (PCRE): 16 bytes

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

Sem espaço, sem comentários, sem uso de base64_decode. Diverta-se.

Saída

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

Código original

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

( http://ideone.com/ funciona)

Comprimento do sabor 58 do Regex PCRE testado no regex101

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

Somente o método é regexado. O método retorna um 2d int [,] array (int [4,4]) para uma entrada n = 4. Se impresso for assim:

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

Esta é minha primeira entrada em algo assim, deixe-me saber se fiz algo errado. Não estou tentando vencer pelo comprimento de regex, com certeza, só estou interessado em ver como me saí bem na prevenção de rachaduras :)

Código original:

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, comprimento 10 do regex ( rachado )

Regex

Deve funcionar com qualquer sabor de expressão regular, mas chamaremos de sabor de Python.

([A-Z]+.)+

NOTA: Minha solução usa QBasic não formatado; após a formatação, o código não corresponde à regex devido aos espaços adicionados. (Mas posso lhe dizer que essa é a única alteração que faz a diferença. ([A-Z]+ ?. ?)+Ainda funciona na versão formatada.)

Para fins de teste, usei o QB64 com a formatação de código desativada (em Opções> Layout de código). Se você não deseja fazer o download de algo, também pode executar o QBasic online em archive.org (mas não é possível desativar a formatação).

Saída de amostra

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

Python 3, 55 bytes (rachado)

Sabor PCRE / Python / Golang.

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

(Lembre-se de que é necessária a correspondência completa . Suponha ^e $durante o teste.)

Saída de amostra:

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

Solução original:

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

Deveria ter aparado 4 bytes: p

dc , comprimento 12 do Regex   Rachado por seshoumara!

^[^# !]{59}$

Essa expressão regular é simples o suficiente para que eu não pense que o sabor da regex importa - deve funcionar de maneira geral. (Observe o espaço após o # na regex.)

Testei todos os quatro tipos em regex101.com (PCRE / PHP, Javascript, Python e Golang), bem como a versão Ruby em rubular.com. O programa dc corresponde ao regex nas cinco versões do regex.

O programa dc recebe sua entrada no stdin e coloca sua saída no stdout.

Exemplo de saída para a entrada 4 (há um espaço à direita no final de cada linha):

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

Código original (adicionado após ser quebrado)

Isso foi quebrado por @seshoumara . Aqui está o meu código pretendido:

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

Explicação:

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

A soma no topo da pilha agora é o próximo número que queremos imprimir:

• É fácil ver que isso está correto se o número da linha for par, desde então a soma é apenas i.

• Para linhas com números ímpares, observe que i = d * (i / d) + (i% d) = d * (número da linha) + número da coluna. Daqui resulta que a soma i + d-2 * (número da coluna) -1 é d * (número da linha) + número da coluna + d - 2 * (número da coluna) - 1 = d * (número da linha + 1) - número da coluna - 1, que é o número que queremos colocar na linha e coluna indicadas para garantir a contagem regressiva nas linhas com números ímpares.

Voltando à explicação agora:

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, comprimento regex 38, rachado ( @kennytm )

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

Entrada:

n=4; <command>

Saída:

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

PHP

Espero que seja divertido! : D

Saída (n = 4)

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

Nível 1: PCRE (comprimento = 17) ( Rachado por Jörg Hülsermann )

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

• Sem aspas simples ou duplas, então ... sem seqüências de caracteres!
• Sem dígitos!
• Não é {assim ... não há funções anônimas!
• Não, ventão ... não eval()!
• Não, ;então ... deve ser uma única afirmação!
• Não <, não ... Heredocnem vários blocos PHP!
• O grande! No $ so ... boa sorte definindo variáveis! >: D

@ JörgHülsermann tinha uma abordagem interessante, mas não era o que eu tinha em mente :). Portanto, estou introduzindo um novo nível de dificuldade (prometo ter o código que se encaixa nisso e não estou apenas brincando com você):

Nível 2: PCRE (comprimento = 23) ( Rachado por Jörg Hülsermann )

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

• Todas as restrições do nível 1
• Novo neste nível: nenhum deles _~|&A-Z! :)

Diverta-se!

A SOLUÇÃO ORIGINAL

Portanto, proibir o $significado de que as variáveis ​​não podem ser acessadas da maneira regular, mas isso não significa que elas não possam ser usadas! Você ainda pode usar extract()/compact()para importar / exportar variáveis ​​para o escopo atual. :)

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

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

No entanto, há uma pegadinha: compact('x')['x']++não funcionaria porque variáveis ​​no PHP são passadas por valor ... com uma exceção! Objetos

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

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

O resto é fácil.

• Números 0e 1são facilmente gerada através da conversão de falsee truepara int, antecedendo-os com o +sinal
• Use ande ordesde &e |é proibido
• Para contornar as aspas proibidas, use constantes indefinidas, que são tratadas como strings
• Para suprimir os avisos gerados usando constantes indefinidas, basta usar @
• A letra proibida vpode ser gerada usando chr(ord('u') + 1), que se traduz em @chr(ord(u) + true)usar as soluções alternativas acima
• O sublinhado é semelhante ao acima: chr(ord('a') - 2)que se traduz emchr(ord(a) - true - true)
• As funções de chamada que contêm caracteres proibidos podem ser feitas tirando proveito do callabletipo do PHP , que pode ser uma string contendo o nome da função. Assim, você pode concatenar constantes indefinidos e cadeias de caracteres individuais gerados por ord()construir o nome da função e chamá-lo assim: array_reverse()torna-se (a.rray.chr(ord(a)-true-true).re.chr(ord(u)+true).erse)()( arrayé um construtor de linguagem, que é por isso que é dividido nas constantes indefinidos ae rray)
• Aproveite o fato de que, quando se trata de construções condicionais e de loop, os colchetes são opcionais se a construção se aplicar apenas à instrução imediatamente a seguir. Isso significa que você pode fazer coisas como: if ($n = $argv[1] and $i = 0) while ($n > $i++ and do_some and other_stuff or exit)

A lógica no código legível por humanos seria:

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

E a versão hostil que corresponde ao regex:

<?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 [rachado]

Primeiro desafio de Policiais e Ladrões. Espero não ter facilitado muito as coisas.

EDIT: substituído \g<1>por (?1)porque é evidentemente equivalente no PCRE.

Regex (PCRE)

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

Saída (n = 4)

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

(Retorna uma matriz de matrizes. É uma lambda, BTW, mas talvez isso dê muito?)

JavaScript (Rachado)

Primeira vez em um desafio de Policiais e Ladrões, espero que esteja certo.

Regex (JavaScript)

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

Saída

Uma matriz igual a:

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

Swift, regex 25 (Rachado)

Certo, vamos ver se eu entendi isso. Este é o meu primeiro post de policiais e ladrões, então deixe-me saber se eu errei!

Regex

Eu usei o sabor javascript no regex101.com

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

Saída de amostra

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

Código original

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

C - regex de 42 caracteres - rachado

Regex Javascript conforme usado em regex101 .

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

Adivinhar isso será trivial ...

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

A saída é delimitada por tabulação \napós cada linha.

Minha solução, aqui inteiros 0-2 foram obtidos via t-t, t/te 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');}

Gelatina , comprimento 14 rachada

rachado por Dennis

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

Regex Python.

Adicionado mnovamente depois que eu deixei escapar.

/(reduzir rapidamente);
de P(produto) para `(mônada da díade rápida);
m(indexação do módulo);
v(díade eval);
de Ḋ(desenfileirar) a ṫ(cauda); e
€(para cada rápida)

Para uma entrada das 4saídas da mina:

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

... porque eu formatei uma lista de listas como uma grade com G.

Powershell, 23 bytes

Rachado por Matt

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

Solução original:

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

Recebe entrada como argumento e gera saída para stdout

Espero que este regex esteja OK, não espero que seja muito difícil de decifrar, pois não ofusquei muito dele, e o regex fornece alguns bons pontos de partida para preencher as lacunas, existe uma coisa no primeiro segmento que é muito incomum no código de golfe, o que pode atrapalhar alguém, acho que é necessária uma correspondência não gananciosa para tornar isso um pouco mais difícil.

Os primeiros policiais desafiam de qualquer maneira.

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 , comprimento 19 (Rachado por @KritixiLithos)

PCRE:

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

Saída de amostra (n = 4):

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

Código original:

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

Experimente online!

PHP 7 (Seguro)

Código original

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

Segunda tentativa

Regex (PCRE): 29 bytes

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

Sem espaço, sem comentários, sem uso de base64_decode.

Muitas funções não são permitidas! sublinhado

Saída 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

Saída n = 4

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

Saída n = 3

1 2 3
6 5 4
7 8 9

MATL , comprimento 12 (seguro)

Regex

Usa o sabor Python:

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

Saída de exemplo

Para n=4:

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

Solução

txU:GeG:oEq*S5M*TTx!

Para ver como isso funciona, considere a entrada 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]

Gelatina , comprimento 17 (seguro)

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

Regex Python.

Apertando o nó, isso proíbe algumas coisas mais úteis, para sua ajuda aqui estão os bytes proibidos:

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

pouco menos de um terço deles!

Para uma entrada das 4saídas da mina:

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

... porque eu formatei uma lista de listas como uma grade com G.

Uma solução:

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

Experimente online! / regex101

O principal truque aqui é indexar em uma lista lexicograficamente classificada das permutações dos números naturais até n ² (usando œ?para evitar a construção da lista de comprimento n ² ! ) E dividir o resultado em pedaços de comprimento n . O índice acima mencionado é encontrado através da formação de sua representação no sistema de números fatoriais, que é de fórmula, uma vez que a cobra "sem fatia" é criada permutando elementos de uma maneira prescrita (isso pode ser facilmente convertido em um número com Æ¡).

A solução que apresento usa Ŀpara referenciar links anteriores como mônadas (substituindo Ñe Ç), mas vários $em uma linha podem ser empregados para "alinhar" essas funções auxiliares. Ele também usa ruma vez Ḷe Rsão proibidos.

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

Pip , comprimento de regex 3 (seguro)

A solução é um programa completo que aceita n como argumento da linha de comando. Ele não usa nenhum sinalizador de linha de comando.

Regex (qualquer sabor)

\w+

Saída de amostra

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

Minha solução

YENsXaPBsPOyY_MUyFi_MUENsXaIiBA1PsPUPODQENsXiXaPBsX_PBsMRVyEI1PsPUPODQENsXiXaPBsX_PBsMy

Experimente online!

Estratégia

Aqui está o código que iria gostar de escrever:

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

Isso é:

• Armazenar os números de 1 a aemy
• Loop sobre valores de i0 aa-1
• Se ifor ímpar, inverta y, adicionei*a a cada elemento, concatene um espaço para cada elemento e imprima
• Caso contrário, faça a mesma coisa, mas sem reverter primeiro

Dificuldades

Muitos comandos e variáveis ​​no Pip usam letras, mas alguns importantes não:

• Faixa e faixa inclusiva ( ,e\, )
• A maioria das operações matemáticas ( +, -, *, %,++ )
• Tarefa (: )
• Não podemos ter um loop ou corpo de função com mais de uma instrução (isso precisaria {} )
• Não podemos usar parênteses para impor precedência

Como contornamos essas limitações:

• ENumerate pode ser usado no lugar de ,; só precisamos de uma string com o número de caracteres que queremos e precisamos extrair o primeiro elemento de cada sub-lista em uma estrutura como [[0 "H"] [1 "i"]].
• Não precisamos incrementar nada se pudermos resolver o problema com Fou loops.
• Podemos atribuir à yvariável com o Yoperador ank.
• Podemos fazer contas com strings: Xé a multiplicação de strings e PUsh (ou PB"push-back") concatenará uma string com outra string no local. Para obter o comprimento de uma string, podemos ENumerá-la e extrair o número certo da lista resultante.
• Podemos usar funções desde que possam ser escritas como funções lambda de expressão única usando _.

Específicos

Os elementos básicos do nosso programa:

Alcance

_MUENsXa

Isso está map-unpack(_, enumerate(repeat(space, a)))no pseudocódigo. Map-unpack é como o Python itertools.starmap: dada uma lista de listas, ele chama uma função nos itens de cada sub-lista. _retorna seu primeiro argumento, portanto, _MUapenas obtém o primeiro item de cada sub-lista. Por exemplo, se a = 3:

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

... que é o mesmo que ,a.

Gama inclusiva

Não tenho certeza de que haja uma maneira de fazer inclusive-range(1, a)em uma única expressão, mas felizmente precisamos apenas dela uma vez, para que possamos construí-la na yvariável em três etapas.

YENsXaPBs

Em pseudocódigo, yank(enumerate(repeat(space, a).push-back(space))):

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

Em seguida, POyaparece o primeiro item ye o descarta, saindo [[1 " "] [2 " "] [3 " "]].

Finalmente,

Y_MUy

Ou seja yank(map-unpack(_, y)),: extraia o primeiro elemento de cada sub-lista e puxe a lista resultante novamente y. yé agora[1 2 3] .

comprimento

PODQENaPBs

No pseudocódigo pop(dequeue(enumerate(a.push-back(space)))),. A dificuldade aqui é que enumerar apenas nos dá números len(a)-1, mas queremos len(a). Primeiro, empurramos um espaço para a, alongando-o em um caractere e depois pegamos len-1a nova string.

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

Matemática

Agora que temos uma maneira de obter o comprimento das strings, podemos usá-las para multiplicar e adicionar números:

PODQENsXaXbPBs
PODQENsXaPBsXbPBs

O primeiro faz sXaXbpara criar uma cadeia de a*bespaços e depois leva o comprimento dela; o segundo faz sXaPBsXbempurrar uma sequência de bespaços para uma sequência de aespaços e, em seguida, leva o comprimento dela.

A parte boa é que todos os operadores que estamos usando aqui ( PU, PO, PB, DQ, EN, X) pode ser utilizado com_ a expressões forma lambda. Assim, podemos mapear transformações matemáticas para o intervalo inclusivo que construímos anteriormente.

Também precisamos verificar o i%2interior do loop, mas isso é facilmente realizado com AND: bit a bit iBA1.

Coloque-os juntos

O código completo, com alguns espaços em branco adicionados:

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, comprimento 8, rachado

^[a-~]*$

Exemplo de saída para 4:

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

CJam, PCRE, comprimento 9, rachado

^[a-z~]*$

Exemplo de saída para 4:

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

Agora também {|}estão proibidos.

Mathematica, comprimento de regex 11, não concorrente , rachado

Sabor PCRE:

^[^]@]{49}$

A solução correta será uma função que pega um número inteiro e retorna a saída como uma lista aninhada, como:

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

tinylisp , comprimento 3 do regex ( rachado )

Você pode testar o código tinylisp em Experimente online!

Regex (qualquer sabor)

\S+

Hora de ir hardcore.

Saída

A solução define uma função que usa um único argumento inteiro e retorna uma lista como esta (para n = 4):

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

Meu código original usa a mesma idéia básica de Brian McCutchon, construindo listas e avaliando-as. Aqui está em uma linha:

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

Eu usei o método completo de construção e avaliação uma vez, para definir uma macro d'que faz definições como d, mas pega seus argumentos agrupados em uma lista: então, em vez de (d x 42), você pode fazer (d'(x 42)). Depois, basta reescrever qualquer lista nas definições que possam precisar de espaço em branco: (q(a b))-> (c a(q(b)))-> (c(h(q(a)))(q(b))).

Python3, comprimento 162 (rachado!)

Regex: ^([^"' #]){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\)$

Ok, eu sei, é muito longo. Felizmente, não será quebrado em menos de uma semana ...: 'D.

Acho que não cometi nenhum erro em nenhum lugar, isso permitiria respostas brechas.

Formato de saída

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

Código original: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)