Este es el hilo del policía. El hilo del ladrón está aquí .

Escriba un código que tome una entrada ny cree una "matriz de serpiente" n-por-n.

Una matriz de serpiente es una matriz que sigue este patrón:

3 por 3:

1  2  3
6  5  4
7  8  9

y 4 por 4:

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

El formato de salida exacto es opcional. Puede, por ejemplo [[1 2 3],[6 5 4],[7 8 9]], salida , o algo similar.

Debe proporcionar el nombre del idioma y una expresión regular que coincida completamente con su código. Puedes elegir qué tan detallada debe ser tu expresión regular. En el extremo, puede escribir una expresión regular que coincida con todas las cadenas posibles, en cuyo caso será muy fácil descifrar su código. También debe proporcionar la salida para n=4que los ladrones sepan el formato exacto que ha elegido.

Puede usar uno de los sabores regex que están disponibles en regex101.com , o el sabor Ruby.

• PCRE (PHP)
• Javascript
• Pitón
• Golang
• Rubí

Debe especificar cuál está utilizando.

Notas:

• Debe admitir cualquier razonablemente grande n. Puede suponer que no desbordará el tipo de datos o la memoria. Si el tipo de datos predeterminado es enteros con n<=11signo de 8 bits, puede suponer que si es un número entero de 8 bits sin signo, puede suponer n<=15.
• Los ladrones deben hacer coincidir el formato de salida del envío, excepto los espacios iniciales / finales y las nuevas líneas, ya que el formato SE podría haber eliminado.

Criterio ganador:

El ganador será la presentación sin descifrar con la expresión regular más corta, medida en número de caracteres.

Si su publicación ha permanecido sin descifrar durante 7 días, puede publicar la solución deseada y marcar su envío como seguro.

05AB1E , agrietado por mbomb007

Esperemos que sea divertido de descifrar y no demasiado obvio.

Regex (PCRE):

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

Salida n = 4:

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

Solución original

UXFXLNX*+NFR}ˆ

Python 2 , longitud 62, agrietada

Regex (PCRE)

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

Salida de muestra

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

Gelatina , longitud 6, agrietada

Regex (PCRE)

^.{9}$

Salida de muestra

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

R, longitud 14 Agrietado por plannapus

Espero haber entendido bien esta expresión regular. Lo que intento decir es de 77 caracteres excepto <space>, #, ;y [. Lo probé aquí

Regex

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

Salida de muestra n = 4

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

05AB1E , agrietado por tinta de valor

Vamos a subir un poco :)
Esperemos que sea un buen rompecabezas.

Regex (PCRE)

^\w*..\w*$

Salida n = 4

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

> <> , longitud 49, agrietado por Aaron

Regex (Javascript)

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

Salida de muestra (n = 4)

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

El formateo es un poco extraño, pero verificar la longitud del número lo hubiera hecho mucho más largo. Podría haber ido un poco por la borda en la expresión regular, ¡no estoy seguro!

Editar: También olvidé mencionar que uso la pila inicial (-v flag) para la entrada, no la entrada de pescado habitual. ¡Lo siento!

Código original

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

¡Aaron's es mucho más simple! La complejidad de mi código original se basa en la idea de usar n[r]cada enésimo número para voltear ese segmento (fila), luego imprimir todos los números a la vez al final

Ohm , agrietado

También es mi primer desafío para policías y ladrones, así que dime si hay problemas con este patrón (especialmente porque este es un lenguaje bastante desconocido).

Regex (PCRE)

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

Salida (n = 4)

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

PHP, 221 bytes ( agrietado )

Espero que sea lo suficientemente difícil.

Regex (PCRE): 16 bytes

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

Sin espacio, sin comentarios, sin uso de base64_decode. Que te diviertas.

Salida

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

( http://ideone.com/ works)

Regex PCRE sabor longitud 58 probado en regex101

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

Solo el método es regexed. El método devuelve una matriz 2d int [,] (int [4,4]) para una entrada n = 4. Si impreso se ve así:

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

Esta es mi primera entrada en algo como esto, avíseme si hice algo mal. No estoy tratando de ganar por la duración de la expresión regular con seguridad, solo estoy interesado en ver qué tan bien hice para evitar el agrietamiento :)

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, longitud de expresión regular 10 ( agrietada )

Regex

Debería funcionar en cualquier sabor regex, pero lo llamaremos sabor Python.

([A-Z]+.)+

NOTA: Mi solución usa QBasic sin formato; después de formatear, el código no coincide con la expresión regular debido a espacios agregados. (Pero puedo decirte que ese es el único cambio que marca la diferencia.([A-Z]+ ?. ?)+ Todavía funciona en la versión formateada).

Para fines de prueba, utilicé QB64 con el formato de código desactivado (en Opciones> Diseño de código). Si no desea descargar algo, también puede ejecutar QBasic en línea en archive.org (pero allí no puede desactivar el formateo).

Salida de muestra

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

Python 3, 55 bytes (Agrietado)

Sabor PCRE / Python / Golang.

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

(Recuerde que se requiere una coincidencia completa . Suponga ^y$ cuando realice la prueba).

Salida de muestra:

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

Solución 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))

Debería haber recortado 4 bytes: p

dc , longitud de expresión regular 12 ¡   Agrietado por seshoumara!

^[^# !]{59}$

Esta expresión regular es tan simple que no creo que el sabor de la expresión regular sea importante, debería funcionar en todos los ámbitos. (Tenga en cuenta el espacio después del # en la expresión regular).

He probado los cuatro sabores en regex101.com (PCRE / PHP, Javascript, Python y Golang), así como la versión Ruby en rubular.com. El programa dc coincide con la expresión regular en las cinco versiones de expresión regular.

El programa de CC toma su entrada en stdin y pone su salida en stdout.

Salida de muestra para la entrada 4 (hay un espacio final al final de cada línea):

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

Código original (agregado después de ser descifrado)

Esto ha sido resuelto por @seshoumara . Aquí está mi código previsto:

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

Explicación:

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

La suma en la parte superior de la pila ahora es el siguiente número que queremos imprimir:

• Es fácil ver que eso es correcto si el número de fila es par, ya que la suma es solo i.

• Para las filas impares, observe que i = d * (i / d) + (i% d) = d * (número de fila) + número de columna. De ello se deduce que la suma i + d-2 * (número de columna) -1 es d * (número de fila) + número de columna + d - 2 * (número de columna) - 1 = d * (número de fila + 1) - número de columna - 1, que es el número que queremos poner en la fila y columna indicadas para asegurar que estamos contando hacia atrás en las filas impares.

Volviendo a la explicación ahora:

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, expresión regular 38, agrietada ( @kennytm )

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

Entrada:

n=4; <command>

Salida:

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

PHP

¡Espero que sea divertido! :RE

Salida (n = 4)

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

Nivel 1: PCRE (longitud = 17) ( Agrietado por Jörg Hülsermann )

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

• Sin comillas simples o dobles, así que ... ¡sin cadenas!
• ¡Sin dígitos!
• No { no ... ¡no hay funciones anónimas!
• No vtan ... no eval()!
• No, ;entonces ... ¡debe ser una sola declaración!
• No, <no ... ¡ Heredocni bloques múltiples de PHP!
• ¡El Grande! No $ entonces ... ¡buena suerte definiendo variables! >: D

@ JörgHülsermann tenía un enfoque interesante, pero no es lo que tenía en mente :). Por lo tanto, estoy introduciendo un nuevo nivel de dificultad (prometo que tengo el código que se ajusta a esto y no solo estoy jugando contigo):

Nivel 2: PCRE (longitud = 23) ( Agrietado por Jörg Hülsermann )

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

• Todas las restricciones del nivel 1
• Nuevo en este nivel: ninguno de estos _~|&A-Z! :)

¡Que te diviertas!

LA SOLUCIÓN ORIGINAL

Por lo tanto, prohibir el $significado de las variables no se podía acceder de la manera regular, ¡pero eso no significa que no se puedan usar en absoluto! Todavía puede usar extract()/compact()para importar / exportar variables al alcance actual. :)

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

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

Sin embargo, hay un problema: compact('x')['x']++no funcionaría porque las variables en PHP se pasan por valor ... ¡con una excepción! Objetos.

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

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

El resto es fácil.

• Números 0y 1se generan fácilmente mediante la conversión falsey trueal intanteponiendo con el +signo
• Uso andy ordesde &y |están prohibidos
• Para evitar las comillas prohibidas, solo use constantes indefinidas, que se tratan como cadenas
• Para suprimir los avisos generados mediante el uso de constantes indefinidas, solo use @
• La letra prohibida vse puede generar mediante el uso chr(ord('u') + 1), que se traduce en@chr(ord(u) + true) uso de las soluciones alternativas anteriores
• El guión bajo es similar al anterior: lo chr(ord('a') - 2)que se traduce enchr(ord(a) - true - true)
• Las funciones de llamada que contienen caracteres prohibidos se pueden hacer aprovechando el callabletipo de PHP , que puede ser una cadena que contiene el nombre de la función. Por lo tanto, puede concatenar constantes indefinidas y cadenas de caracteres individuales generadas por ord()para construir el nombre de la función e invocarla así: se array_reverse()convierte (a.rray.chr(ord(a)-true-true).re.chr(ord(u)+true).erse)()( arrayes una construcción de lenguaje, es por eso que se divide en constantes indefinidas ay rray)
• Aproveche el hecho de que, cuando se trata de construcciones condicionales y de bucle, los corchetes son opcionales si la construcción se aplica solo a la siguiente declaración. Esto significa que puedes hacer cosas como: if ($n = $argv[1] and $i = 0) while ($n > $i++ and do_some and other_stuff or exit)

La lógica en el código legible para humanos sería:

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

Y la versión hostil que coincide con la expresión regular:

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

Rubí [agrietado]

Primer desafío de policías y ladrones. Espero no haberlo hecho demasiado fácil.

EDITAR: reemplazado \g<1>por (?1)porque son evidentemente equivalentes en PCRE.

Regex (PCRE)

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

Salida (n = 4)

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

(Devuelve una matriz de matrices. Es una lambda, por cierto, pero ¿tal vez eso revela demasiado?)

JavaScript (agrietado)

La primera vez que hago un desafío de policías y ladrones, con suerte lo haremos bien.

Regex (JavaScript)

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

Salida

Una matriz igual a:

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

Swift, regex 25 (Agrietado)

Bien, veamos si tengo el truco de esto. Esta es mi primera publicación de policías y ladrones, ¡así que déjame saber si me equivoqué!

Regex

Utilicé el sabor de JavaScript en regex101.com

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

Salida de muestra

[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 - expresión regular de 42 caracteres de longitud - agrietada

Javascript regex como se usa en regex101 .

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

Adivinar esto será trivial ...

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

La salida está delimitada por tabuladores con \n después de cada línea.

Mi solución, aquí los números enteros a 0 - 2 se obtuvieron a través de t-t, t/ty 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 , longitud 14 agrietada

agrietado por Dennis

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

Python regex.

Agregué mnuevamente después de que lo dejé pasar.

/(reducir rápido);
de P(producto) a `(mónada de díada rápida);
m(indexación de módulo);
v(eval dyad);
de Ḋ(cola) a ṫ(cola); y
€ (para cada rápido)

Para una entrada de 4salidas de mina:

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

... porque formateé una lista de listas como una cuadrícula con G.

Powershell, 23 bytes

Agrietado por Matt

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

Solución original

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

Toma entrada como argumento y salidas a stdout

Espero que esta expresión regular esté bien, no espero que sea demasiado difícil de descifrar, ya que no he ofuscado mucho, y la expresión regular da algunos buenos puntos de partida para llenar los vacíos, hay una cosa en el primer segmento Sin embargo, lo cual es muy poco común en el golf de código, lo que puede sorprender a alguien, creo que se requiere un partido no codicioso para hacer esto un poco más difícil.

Los primeros policías desafían de todos modos.

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 , longitud 19 (Agrietado por @KritixiLithos)

PCRE:

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

Salida de muestra (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)}

Pruébalo en línea!

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

Segundo intento

Regex (PCRE): 29 bytes

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

Sin espacio, sin comentarios, sin uso de base64_decode.

¡Muchas funciones no están permitidas! guion bajo

Salida 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

Salida n = 4

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

Salida n = 3

1 2 3
6 5 4
7 8 9

MATL , longitud 12 (seguro)

Regex

Utiliza sabor Python:

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

Salida de ejemplo

Para n=4:

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

Solución

txU:GeG:oEq*S5M*TTx!

Para ver cómo funciona esto, considere la 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 , longitud 17 (seguro)

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

Python regex.

Apretando el nudo, esto prohíbe algunas cosas más útiles, para su ayuda aquí están los bytes prohibidos:

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

justo debajo de un tercio de ellos!

Para una entrada de 4salidas de mina:

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

... porque formateé una lista de listas como una cuadrícula con G.

Una solución:

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

Pruébalo en línea! / regex101

El truco principal aquí es indexar en una lista ordenada lexicográficamente de las permutaciones de los números naturales hasta n ² (¡ œ?para evitar construir la lista de longitud n ² ! ), Y dividir el resultado en trozos de longitud n . El índice mencionado anteriormente se encuentra formando su representación en el sistema de números factoriales que es formulado ya que la serpiente "sin cortar" se crea permutando elementos de una manera prescrita (esto puede convertirse fácilmente en un número conÆ¡ ).

La solución que presento utiliza Ŀpara hacer referencia a enlaces anteriores como mónadas (reemplazando Ñy Ç), pero se $podrían emplear múltiples seguidos para "en línea" estas funciones auxiliares. También usa rdesde Ḷy Restá prohibido.

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

Pipa , regex longitud 3 (seguro)

La solución es un programa completo que toma n como argumento de línea de comandos. No utiliza ningún indicador de línea de comandos.

Regex (cualquier sabor)

\w+

Salida de muestra

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

Mi solución

YENsXaPBsPOyY_MUyFi_MUENsXaIiBA1PsPUPODQENsXiXaPBsX_PBsMRVyEI1PsPUPODQENsXiXaPBsX_PBsMy

Pruébalo en línea!

Estrategia

Aquí está el código que nos gustaría escribir:

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

Es decir:

• Almacene los números del 1 aaly
• Recorrer valores de i0 aa-1
• Si ies impar, invierta y, agregue i*aa cada elemento, concatene un espacio con cada elemento e imprima
• De lo contrario, haga lo mismo, pero sin invertir primero

Dificultades

Muchos comandos y variables en Pip usan letras, pero algunos importantes no:

• Rango y rango inclusivo ( ,y \,)
• La mayoría de las operaciones matemáticas ( +, -, *, %, ++)
• Asignación ( :)
• No podemos tener un bucle o cuerpo de función con más de una declaración (que necesitaría {})
• No podemos usar paréntesis para imponer precedencia

Cómo superamos esas limitaciones:

• ENumerate se puede usar en lugar de ,; solo necesitamos una cadena con el número de caracteres que queremos, y necesitamos extraer el primer elemento de cada sublista en una estructura como[[0 "H"] [1 "i"]] .
• No necesitamos incrementar nada si podemos resolver el problema con Fo bucles.
• Podemos asignar a la yvariable con elY operador ank.
• Podemos hacer cálculos matemáticos con cadenas: Xes la multiplicación de cadenas, y PUsh (o PB"push-back") concatenará una cadena a otra cadena en su lugar. Para tomar la longitud de una cuerda, podemosEN umerarla y extraer el número correcto de la lista resultante.
• Podemos usar funciones siempre que se puedan escribir como funciones lambda de expresión única usando _.

Detalles específicos

Los bloques de construcción de nuestro programa:

Distancia

_MUENsXa

Eso está map-unpack(_, enumerate(repeat(space, a)))en pseudocódigo. Map-unpack es como Python itertools.starmap: dada una lista de listas, llama a una función en los elementos de cada sublista. _devuelve su primer argumento, por lo que _MUsolo obtiene el primer elemento de cada sublista. Por ejemplo, si a = 3:

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

... que es lo mismo que ,a.

Rango inclusivo

No estoy seguro de que haya una manera de hacerlo inclusive-range(1, a)en una sola expresión, pero afortunadamente solo la necesitamos una vez, por lo que podemos construirla en la yvariable en tres pasos.

YENsXaPBs

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

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

A continuación, POysaca el primer elemento yy lo descarta, dejando [[1 " "] [2 " "] [3 " "]].

Finalmente,

Y_MUy

Es decir yank(map-unpack(_, y)): extraiga el primer elemento de cada sublista y vuelva a tirar de la lista resultante y. yes ahora[1 2 3] .

Longitud

PODQENaPBs

En pseudocódigo, pop(dequeue(enumerate(a.push-back(space)))). La dificultad aquí es que enumerar solo nos da números hasta len(a)-1, pero queremos len(a). Entonces, primero empujamos un espacio hacia a, alargándolo en un carácter, y luego tomamos len-1la nueva cadena.

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

Mates

Ahora que tenemos una manera de tomar la longitud de las cadenas, podemos usar cadenas para multiplicar y sumar números:

PODQENsXaXbPBs
PODQENsXaPBsXbPBs

El primero lo hace sXaXbpara crear una cadena de a*bespacios y luego toma la longitud del mismo; el segundo lo hace sXaPBsXbpara empujar una cadena de bespacios a una cadena de aespacios y luego toma la longitud de la misma.

La parte buena es que todos los operadores que estamos usando aquí ( PU, PO, PB, DQ, EN, X) se pueden utilizar con _las expresiones lambda forma. Entonces podemos mapear transformaciones matemáticas al rango inclusivo que construimos anteriormente.

También tenemos que comprobar i%2dentro del bucle, pero esto se logra fácilmente con la función Y: iBA1.

Póngalos juntos

El código completo, con algunos espacios en blanco agregados:

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, longitud 8, agrietado

^[a-~]*$

Ejemplo de salida para 4:

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

CJam, PCRE, longitud 9, agrietado

^[a-z~]*$

Ejemplo de salida para 4:

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

Ahora también {|}están prohibidos.

Mathematica, regex longitud 11, no competitiva , agrietada

Sabor PCRE:

^[^]@]{49}$

La solución correcta será una función que toma un número entero y devuelve el resultado como una lista anidada como:

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

tinylisp , regex longitud 3 ( agrietada )

Puede probar el código de tinylisp en ¡ Pruébelo en línea!

Regex (cualquier sabor)

\S+

Es hora de ir al hardcore.

Salida

La solución define una función que toma un argumento entero único y devuelve una lista como esta (para n = 4):

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

Mi código original usa la misma idea básica que se le ocurrió a Brian McCutchon, crear listas y evaluarlas. Aquí está en una línea:

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

Usé el método completo de construcción y evaluación una vez, para definir una macro d'que hace definiciones como d, pero toma sus argumentos envueltos en una lista: así que en lugar de hacerlo (d x 42), puede hacerlo (d'(x 42)). Luego fue solo una cuestión de reescribir cualquier lista en las definiciones que pudieran necesitar espacios en blanco: (q(a b))-> (c a(q(b)))-> (c(h(q(a)))(q(b))).

Python3, longitud 162 (¡Agrietado!)

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

Bien, lo sé, es bastante largo. Afortunadamente, no se descifrará en menos de una semana ...: 'D.

Creo que no cometí ningún error en ninguna parte, eso permitiría respuestas de escapatoria.

Formato de salida

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)