Policías: hacer una expresión regular - hacer una serpiente

40

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.

Stewie Griffin
fuente
55
Seed, longitud 1, ..
Kritixi Lithos
1
¿Puedo usar uno de los idiomas documentados aquí? codegolf.stackexchange.com/questions/61804/…
2
@KritixiLithos Excepto que tiene que lanzar su programa original para estar seguro ;-)
ETHproductions
3
@DeepakAgarwal: escriba su código para generar una serpiente, luego proporcione una expresión regular que coincida. La solución del ladrón debe estar en el mismo idioma y coincidir también con la expresión regular. Entonces, una estrategia es proporcionar una expresión regular restrictiva, para dificultar al ladrón, ¡pero no tan restrictiva como para dar la solución!
2
¿Este meta consenso que permite E / S unarias para sed, que no tiene tipos de datos, es válido para este desafío?
seshoumara

Respuestas:

9

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}ˆ
Emigna
fuente
oooooomg - amigo que es tonto (cumplido, por supuesto)
Tilak Maddy
@ mbomb007: las letras con acento no coinciden con el \wno. Puedes probarlo en regex101
Emigna
1
Podrías acortar tu expresión regular cambiando .{0,2}a.?.?
Aaron
1
Puede colocar la -última posición de la clase char entre corchetes ( [+*\/%-]) para no tener que escapar de ella.
Dada
@Dada: Eso sí funciona en PCRE. No estoy terriblemente preocupado por acortarlo en este momento, ya que estoy bastante seguro de que se romperá. Sin embargo, si se cumple, incorporaré las sugerencias tuyas y de Aarons. Gracias :)
Emigna
8

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

Dennis
fuente
Agrietado
xsot
7

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
Dennis
fuente
3
Esto está obligando a jugar al golf realmente bien en Jelly: D
Yytsi
1
¿ Nueve caracteres? Te sientes generoso! : D
AdmBorkBork
1
'Any nine' ¿Cuántas funciones había en Jelly?
Matthew Roh
Estoy 99% seguro de que el último carácter tiene que ser Gformatear la salida correctamente. Estoy cerca de resolver el resto, pero no puedo entender cómo revertir todos los demás elementos en una matriz con Jelly ...
ETHproductions
@ETHproductions: estaba bastante seguro de que lo tenía casi resuelto y tengo un método para revertir cualquier otro elemento. Mi problema es que no puedo entender cómo unir todo (no he probado el tutorial). Sin embargo, esperaba verlo resuelto ahora. Quizás sea más difícil de lo que pienso.
Emigna
6

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  
MickyT
fuente
Pensé que esto sería fácil, pero estoy teniendo grandes problemas para que produzca esos números como ese (frente a una matriz de algún tipo). Buen trabajo.
BLT
1
@BLT Gracias, fue un problema interesante intentarlo y dificultarlo.
MickyT
Agrietado , aunque probablemente no sea el mismo código que el tuyo.
plannapus
6

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]]
Emigna
fuente
Lo tengo
Value Ink
6

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

torcado
fuente
1
..es más corto que .{2};)
Aaron
¡No importa, lo descifró ! Obviamente no seguí demasiado tu código, pero de todos modos fue un desafío interesante. ¡Por favor comparte tu código original! Además, si lo desea, puede devolver el favor ;)
Aaron
@Aaron buen trabajo! Además, sí, no estoy seguro de cómo no me di cuenta de eso en la expresión regular. oh bueno :)
Veré
5

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]]
Nick Clifford
fuente
1
En todo caso, puede ser demasiado fácil. Si tiene .*en su expresión regular, podría ser cualquier cosa. Entonces, si el idioma tiene comentarios, podrían escribir cualquier programa seguido de un comentario.
mbomb007
@ mbomb007 Buen punto.
Nick Clifford
1
Agrietado :)
Emigna
@Emigna ¡Bien hecho!
Nick Clifford
5

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));
Jörg Hülsermann
fuente
Tenga en cuenta que las respuestas pueden usarse base64_decodeporque su expresión regular no lo rechaza.
CalculatorFeline
44
@CalculatorFeline: los bloques de expresiones regulares 6, que podrían bloquearse base64_decode.
nneonneo
Vaya, me perdí eso. Pero ^ así que no importa.
CalculatorFeline
5

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 _;}
EklipZ
fuente
Bien hecho, debería haber tratado de hacer que la longitud sea más desafiante al menos ...
EklipZ
5

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 
DLosc
fuente
Por lo tanto, todos los símbolos en la fuente deben ir precedidos de una letra.
CalculatorFeline
@CalculatorFeline Una o más letras.
mbomb007
Bueno, mi requisito es equivalente porque \w+\Wse puede dividir en \w*y \w\W. ( \w*es null(trivial) o \w+(se coló fácilmente con un símbolo))
CalculatorFeline
@CalculatorFeline No hay nada que diga que .no puede ser un carácter de palabra. Puede ser una letra minúscula o un dígito. De hecho, incluso podría ser una letra mayúscula, en el caso de que el último carácter del programa sea uno.
mbomb007
5

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

kennytm
fuente
Me parece que te pierdes el )en la segunda parte de la expresión regular
Jörg Hülsermann
@ JörgHülsermann no falta nada, la expresión regular es correcta.
kennytm
1
@ JörgHülsermann El extra (está dentro de una clase de personaje que comienza después printy termina antes {48}. Me tomó un tiempo verlo también. ;) (Para el caso, el par de paréntesis anterior también está dentro de una clase de caracteres.)
DLosc
@DLosc Ahora está claro. Gracias
Jörg Hülsermann
Agrietado
xsot
5

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.
Mitchell Spector
fuente
¿Se #omiten los caracteres y `` para que una solución más corta no pueda usar comentarios para alcanzar 59 bytes? Si es así, no es necesario, ya que en DC hay muchas maneras de agregar comandos que no cambian nada, por ejemplo. qcomandos repetitivos al final del guión.
seshoumara
@seshoumara Se supone que es un guiño en esa dirección mientras se mantiene breve la expresión regular. Pero tienes razón, por supuesto. (Esta es mi primera entrada de policías y ladrones, así que no estoy seguro de lo fácil que es)
Mitchell Spector,
¡Agrietado! . Llegar a un poco más de 59 bytes fue fácil, pero igualar su límite o menos fue más difícil de lo que esperaba. En cuanto a la expresión regular, el espacio estaba bien para omitir, mi mal, ya que uno tiene que imprimirlo, así que tuve que usar algo más.
seshoumara
@seshoumara ¡Buen trabajo!
Mitchell Spector
@seshoumara Por cierto, los espacios también son útiles en CC para separar dos constantes numéricas sucesivas, por lo que prohibir espacios requiere una solución alternativa si necesita esa funcionalidad. Sin embargo, imprimir un espacio no es gran cosa, porque 32Pes más corto que de [ ]ntodos modos.
Mitchell Spector
5

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
Marcos M
fuente
Codegolf.stackexchange.com/a/112656/32353 agrietado . Este es bueno: D
kennytm
¡Me alegro de que lo hayas disfrutado @kennytm, has encontrado la solución exacta como mi comando original!
Marcos M
5

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

Ionut Botizan
fuente
@ JörgHülsermann Dado que mi expresión regular era bastante larga y no esperaba tener ninguna oportunidad de ganar, simplemente asumí que la gente no se obsesionará demasiado con los tecnicismos como la sensibilidad a mayúsculas y minúsculas del motor de expresiones regulares. De todos modos, edité mi respuesta para que la expresión regular ahora incluya una mayúscula V. ¡Que te diviertas! :)
Ionut Botizan
2
Agrietada codegolf.stackexchange.com/questions/112300/...
Jörg Hülsermann
1
@ JörgHülsermann En realidad es el mismo código, pero inicialmente utilicé una expresión regular más flexible porque tenía curiosidad sobre qué otras soluciones podrían encontrar las personas. Lo daré un día más (tal vez a alguien le gustaría intentarlo durante el fin de semana) y publicaré mi código y las explicaciones mañana por la noche. Lo que puedo decirte ahora es que estabas en el camino correcto sobre el uso de constantes indefinidas como cadenas. Además, estabas equivocado acerca de algo en tu solución. Usted puede llamar (array_re.chr(ord(u)+true).erse)()! :) (... o al menos podrías cuando _se permitía)
Ionut Botizan
3
@IonutBotizan Podrías mantener la solución del Nivel 1 en secreto por ahora, ya que está agrietada. Todavía es mejor para ti hacer el Nivel 2 como una nueva publicación, es más fácil para otras personas verificar si está descifrado o no.
kennytm
1
nivel 2 agrietado regex101.com/r/XtVl9G/1 gracias por la pista. Ahora estoy esperando el nivel 3 :-)
Jörg Hülsermann
5

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

Tinta de valor
fuente
4

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]]
Tom
fuente
Es posible que desee un $al final de la expresión regular si el código en sí termina al final de la expresión regular. De lo contrario, podría hacer, por ejemplo, x=>x.toString().toString().toString().toString()y luego lo que quiera después de eso.
ETHproductions
@ETHproductions Buen punto, ¡gracias por la sugerencia!
Tom
Agrietado
ovs
1
@ovs Wow, eso fue rápido. ¡Buen trabajo!
Tom
44
@Tom The .*al principio lo habría hecho realmente fácil. Podría ser cualquier programa seguido de un comentario. Básicamente, no incluya .*en su expresión regular.
mbomb007
4

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:",")}
James Webster
fuente
Parece que este envío no toma ncomo entrada, pero requiere una variable codificada . Si eso es correcto, me temo que esto no es válido según el meta consenso.
Stewie Griffin
Nota: Puedes conservar la publicación, ya que ya está rota :)
Stewie Griffin
@Stewie. Gracias por la información, ¡hay una razón por la que he evitado este tipo de preguntas en el pasado! Creo que entiendo el concepto de "solo una función" un poco mejor ya que esta respuesta fue descifrada. Supuse que significaba el cuerpo de una función, pero ahora entiendo que significa una variable de función.
James Webster
4

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');}
Comunidad
fuente
Puedes eliminar uno ren tu expresión regular.
kennytm
@kennytm - gracias - lo perdí
Codegolf
kennytm
4

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.

Jonathan Allan
fuente
Agrietado. Esto fue divertido.
Dennis
4

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
colsw
fuente
Agrietado
Matt
¿Cuál fue tu solución?
Matt
@ Matt añadió, pensé que sería más difícil teniendo en cuenta la cantidad de cosas que no código de golf que he añadido, es decir, utilizando [Array]::Reverse()en lugar de $array[9..0]y $script:rvariables que son en su mayoría innecesaria.
colsw
4

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!

fergusq
fuente
1
Es un juego justo siempre que sea anterior a este desafío y tenga un intérprete disponible (gratis). La primera vez que probé MATL fue cuando intentaba descifrar una publicación policial . No se sorprenda si alguien aprende a Röda solo para descifrar esta respuesta :)
Stewie Griffin
Espero que la documentación esté en inglés, no en finlandés :)
Stewie Griffin
@StewieGriffin Hay algo de documentación disponible. ¿Debo agregar un enlace a mi respuesta o es lo suficientemente fácil de encontrar desde la página de Github?
fergusq
¡Agrietado! :)
Kritixi Lithos
4

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
Jörg Hülsermann
fuente
Creo que su respuesta ahora es segura :)
Aaron
@ Aaron, me pregunto si no fue descifrado. Se agrega el código original
Jörg Hülsermann
4

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]
Luis Mendo
fuente
4

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 2œ?para evitar construir la lista de longitud n 2 ! ), 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
Jonathan Allan
fuente
4

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
DLosc
fuente
¿Se nos permite usar banderas como -S?
Brian McCutchon
@BrianMcCutchon Buena pregunta: la respuesta es no . (Dado que no son parte del código sujeto a la expresión regular, parecía demasiado vacíos para usarlos). Editado para aclarar.
DLosc
Hasta ahora tengo que a*bes _V_VRVENCGaRLbPU1, ,aes _MUENZGa, aJ" "es aJ_VRVky a@ies algo así _V_VRVaZCGi, aunque todavía no puedo resolver la precedencia sin paréntesis. Además, una vaga idea de que puedo obtener las permutaciones de un rango (creado como se indica arriba, usando el equivalente de ,(a*a)) y usarlo para seleccionar la permutación correcta para cada fila.
Brian McCutchon el
@BrianMcCutchon No puedo comentar nada específico, por supuesto, pero realmente estoy disfrutando de la actualización del progreso. ^ _ ^
DLosc
Creo que es seguro ahora. Como lo hiciste
Brian McCutchon
3

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]]
Lynn
fuente
Agrietado. Buena idea. :) Parece que hay muchos enfoques que funcionan, me pregunto qué tenías en mente.
Martin Ender
Mi respuesta realmente satisface una expresión regular más estricta : ¡lo mostraré cuando se rompa!
Lynn
3

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.

Lynn
fuente
Agrietado.
Martin Ender
¡Buen trabajo! Mi respuesta fue básicamente la misma, excepto que solo usó un montón de mey mqpara aproximar el número, por lo que fue extremadamente largo (~ 20k bytes).
Lynn
3

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}}
Martin Ender
fuente
@kennytm Oh, esa es una buena solución. Muy diferente de lo que tenía. Veré si publico el mío más tarde o si agrego una expresión regular más restrictiva.
Martin Ender
3

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

DLosc
fuente
1
Agrietada . No fue facil.
Brian McCutchon
2

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)

Yytsi
fuente