Su tarea es escribir un programa de ordenador de tal manera que cuando se corta en líneas (fractura en el carácter de nueva línea) cada disposición de las líneas dará salida a un número diferente entre 1 y n! (donde n es el número total de líneas). Ningún número debe salir por dos arreglos diferentes y cada arreglo debe emitir un número en este rango. Como hay n! maneras de organizar las líneas de un programa, esto significa que cada número debe salir por una reordenación.

Por ejemplo el programa python

print 1;"""
print 2;"""

Tiene dos arreglos

print 1;"""
print 2;"""

y

print 2;"""
print 1;"""

Las primeras salidas 1y las segundas salidas 2.

Puede usar cualquier formato de salida que sea estándar en el idioma que esté usando. No puede asumir ningún tipo de repetitivo. Creo que este desafío es más interesante si tienes que trabajar en cualquier formato en el que el idioma insista.

Puntuación

Su puntaje será el número de líneas en su programa con un puntaje más alto mejor. Si lo desea, puede elegir generar números del 0 al n! -1 .

CJam , puntaje: ∞

Cada línea es de la forma

];Lx+:L{__(f<0+:+\,,(;1+:**\(;}h]:+

de dónde xes un número de 0a n-1. El resultado está en el rango 0de n!-1.

Pruébalo en línea! (Por n=3)

Créditos a jimmy23013 para el código que calcula el índice de permutación real. Solo he reemplazado el bit que lee la entrada con la ];Lx+:Lque descarta el resultado de la línea anterior y luego agrega el índice de la línea actual a la variable L(que inicialmente es una matriz vacía).

Perl: ∞

$z.="-1,";$_.=A;END{$m.=!!s/./{${z}B}/g,map(/B/||s/\d+\K/,/g*/(-\d*,).*\1/||($n{$_}||=$m++),sort glob),print$n{$z}if/A/}
$z.="-2,";$_.=A;END{$m.=!!s/./{${z}B}/g,map(/B/||s/\d+\K/,/g*/(-\d*,).*\1/||($n{$_}||=$m++),sort glob),print$n{$z}if/A/}
$z.="-3,";$_.=A;END{$m.=!!s/./{${z}B}/g,map(/B/||s/\d+\K/,/g*/(-\d*,).*\1/||($n{$_}||=$m++),sort glob),print$n{$z}if/A/}

Extiende a cualquier longitud que quieras

Se quedará rápidamente sin memoria ya que el uso de la memoria es como O (n ^ n). Sin embargo, sería fácil reemplazar el indexador de permutación por código O (n), solo por más tiempo. Solo estoy ilustrando la forma en que puede usar END{}para esta tarea en perl. Todos los END{}bloques se ejecutan al momento de la salida, pero solo el primero que se llama (el último en el código) generará algo debido a la /A/prueba, que solo es cierta una vez

Tenga en cuenta que el $mcontador debe contar como una cadena porque como un número se desbordaría (más tarde que el final del universo, pero es el principio el que cuenta). Por la misma razón, "cuento" el número de líneas construyendo una cadena de As en lugar de usar un contador real, aunque este desbordamiento ocurriría incluso más tarde.

Otra forma de hacer esto en perl:

@{$b.=A; if($a eq $b) {use bigint; $n=0;$n++for@F;$c=0;$c=$c*$n--+map{$z=$_;$a=grep$_&&$_>$z,@F;$_=0;}@F;print$c}}=()x push@F,"1".!($a.=A),
@{$b.=A; if($a eq $b) {use bigint; $n=0;$n++for@F;$c=0;$c=$c*$n--+map{$z=$_;$a=grep$_&&$_>$z,@F;$_=0;}@F;print$c}}=()x push@F,"2".!($a.=A),
@{$b.=A; if($a eq $b) {use bigint; $n=0;$n++for@F;$c=0;$c=$c*$n--+map{$z=$_;$a=grep$_&&$_>$z,@F;$_=0;}@F;print$c}}=()x push@F,"3".!($a.=A),

Esto usa el hecho de que in foo = bar barse ejecuta después foo. Por cierto, esta versión no se vuelve loca en el tiempo y el espacio, pero eso hace que el código sea más largo

Otra idea más es usar la DESTROYque tiene la ventaja de que solo uno de ellos será ejecutado. No voy a repetir el código de indexación de permutación del cual ya di dos ejemplos.

push@F,"1";bless\@F;DESTROY{print"Work out permutation index of @{$_[0]}\n" }
push@F,"2";bless\@F;DESTROY{print"Work out permutation index of @{$_[0]}\n" }
push@F,"3";bless\@F;DESTROY{print"Work out permutation index of @{$_[0]}\n" }

O usando BEGIN:

BEGIN{push@F,"1"} print"Work out permutation index of @F\n"; exit;
BEGIN{push@F,"2"} print"Work out permutation index of @F\n"; exit;
BEGIN{push@F,"3"} print"Work out permutation index of @F\n"; exit;

Jalea , ∞

;3ÇQŒ¿$⁼Q$?
;2ÇQŒ¿$⁼Q$?
;1ÇQŒ¿$⁼Q$?

(Ejemplo con n=3.)

Pruébalo en línea!

23 13 11 bytes por línea.

Para un programa con nlíneas, las líneas tendrán el formato

; <i> ÇQŒ¿$⁼Q$?

donde <i>representa el número literal iy cada línea tiene un valor diferente para ivariar de 1a n. (Los valores para en irealidad no tienen que ser estos números específicos, solo tienen que tener valores positivos únicos). Este programa ya no se usa nen la estructura de línea.

¿Cómo?

• Sin una discusión, Jelly comienza 0.
• ;1anexa 1al 0o la lista activa.
• ⁼Q$es la mónada condicional para la instrucción if ( ?) que verifica si los elementos de la lista son únicos. Si lo están, se llama al enlace de arriba ( Ç) y se agrega otro número a la lista. Si no son únicos, eso significa que hemos llegado al primer enlace. El elemento repetido se elimina de la lista ( Q) y se encuentra el índice de la permutación ( Œ¿). Tenga en cuenta que hay un 0al principio de la lista cuando Œ¿se toma, pero no afecta a la salida, ya que todos los valores ison positivos.

Nueva función de gelatina

Con el nuevo agregado Ƒrápido, podemos reducirlo ⁼Q$y QƑguardar un byte.

10 bytes / línea (para dígitos individuales)

;1ÇQŒ¿$QƑ?

Pruébalo en línea!

Brain-Flak , 3

(({}){})
({}())
(()(){([()()]{})()(){[()()](<{}>)}}{})

Pruébalo en línea!

Publiqué esto en el chat antes, pero espero que al publicarlo aquí la gente pueda construir a partir de él.

Explicación

Comenzamos con el programa básico.

(({}){})
({}())

Esto puntúa 2 por sí solo. Para avanzar al siguiente nivel, quiero agregar una nueva línea. Mi conjetura inicial fue

(()(){[()()]{}(<()>)}{})

Esto establece el TOS en 2si es cero y no hace nada diferente. Esto en realidad es un buen comienzo. Con las otras dos líneas podemos obtener todos los números de 1a 6excepto 4, porque hay 2formas de salida 2:

({}())
(({}){})
(()(){[()()]{}(<()>)}{})

y

({}())
(()(){[()()]{}(<()>)}{})
(({}){})

Para remediar esto, hacemos que nuestra línea también 2sea 4. Esto se puede hacer con

(()(){([()()]{})()(){[()()](<{}>)}}{})

Para mayor claridad, esto básicamente implementa la función Haskell

f 0 = 2
f 2 = 4
f x = x

Esto soluciona nuestro problema porque uno de los programas que antes estaba generando 2ahora sale 4sin ningún otro cambio de programa.

Java 7, puntuación: ∞

public class DerangedRearrangements implements B{public void a(){System.out.println("0");}public static void main(String[]a)throws Exception{java.util.regex.Pattern p=java.util.regex.Pattern.compile("^(?:public )?class ([\\w]+).*");java.io.BufferedReader r=new java.io.BufferedReader(new java.io.FileReader("./DerangedRearrangements.java"));String line; while((line=r.readLine())!=null){java.util.regex.Matcher m=p.matcher(line);if(m.matches()){((B)Class.forName(m.group(1)).getDeclaredConstructor().newInstance()).a();}}}}interface B{void a();}
class b1 implements B{public void a(){System.out.println(getClass().getName().substring(1));}}

Pruébalo en línea!

Esto se puede imprimir 0 a n! -1 . Las líneas adicionales tienen el siguiente formato (donde INDEX es un número de 1 a n! -1 ):

class b<INDEX> implements B{public void a(){System.out.println(getClass().getName().substring(1));}}

Este método funciona leyendo su propia fuente para determinar las clases de orden que figuran en él. Lamentablemente, no pude encontrar ningún método más interesante al analizar el archivo compilado o al crear un ClassLoader personalizado gracias a cómo Java compila JIT. Supongo que podría hacer que cada clase adicional imprima un número estáticamente definido, pero esto me pareció más divertido. Eso también lo haría para poder eliminar la Binterfaz, pero la puntuación no se basa en bytes, por lo que lo dejaré por diversión.

Cómo funciona (alto nivel):

Lee su propio código fuente línea por línea. Como cada línea declara una nueva clase, utilizamos la reflexión para crear una instancia de la nueva clase e invocar su amétodo que necesita tener porque implementa la Binterfaz.

Ruby , puntaje: ∞

(a||=[])<<2;a.size<3?0:(p 1+a.sort.permutation.to_a.index(a))
(a||=[])<<1;a.size<3?0:(p 1+a.sort.permutation.to_a.index(a))
(a||=[])<<3;a.size<3?0:(p 1+a.sort.permutation.to_a.index(a))

Pruébalo en línea!

Este programa tiene 61 bytes por línea (para n <10). Tiene el mismo formato básico que la solución de dylnan ; el primer número en cada línea será un valor diferente entre 1y n, y el segundo número en cada línea será n.

Tenía la esperanza de encontrar una manera de evitar incluir nen el programa, pero no pude encontrar una.

Brain-Flak , 2 (con -d)

{}(@ltN)

Pruébalo en línea!

05AB1E , puntuación: 1,114,112

0ˆ¯JD{œsk
1ˆ¯JD{œsk
2ˆ¯JD{œsk

Pruébalo en línea! 0 indexado. El ˆ al comienzo de cada línea empuja los caracteres distintos a la matriz global. El resto del código se ejecuta inútilmente excepto en la última línea, donde concatena los valores en una cadena, luego encuentra su índice de permutación. 1,114,112 es el número de caracteres Unicode posibles al momento de escribir (los puntos de código 48-57 son los más fáciles de demostrar, por supuesto).