Il tuo compito è quello di scrivere un programma per computer in modo tale che quando viene tagliato in righe (diviso sul carattere di nuova riga) ogni disposizione delle righe produrrà un numero diverso tra 1 e n! (dove n è il numero totale di righe). Nessun numero dovrebbe essere prodotto da due diverse disposizioni e ogni disposizione dovrebbe produrre un numero in questo intervallo. Dal momento che ci sono n! modi per organizzare le linee di un programma, ciò significa che ogni numero dovrebbe essere emesso da un riarrangiamento.

Ad esempio il programma Python

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

Ha due arrangiamenti

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

e

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

Le prime uscite 1e le seconde uscite 2.

È possibile utilizzare qualsiasi formato di output standard nella lingua in uso. Non puoi assumere alcun tipo di piastra di cottura. Penso che questa sfida sia più interessante se devi aggirare i formati su cui insiste il linguaggio.

punteggio

Il tuo punteggio sarà il numero di righe nel tuo programma con un punteggio più alto migliore. Se lo desideri, puoi scegliere di generare numeri da 0 a n! -1 .

CJam , punteggio: ∞

Ogni riga è nella forma

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

dove xè un numero da 0a n-1. Il risultato è nel range 0din!-1 .

Provalo online! (Per n=3.)

Accredita a jimmy23013 per il codice che calcola l'indice di permutazione effettivo. Ho sostituito solo il bit che legge l'input con il ];Lx+:Lquale scarta il risultato dalla riga precedente e quindi aggiunge l'indice della riga corrente alla variabile L(che inizialmente è un array vuoto).

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/}

Estendi quanto vuoi

La memoria si esaurirà rapidamente poiché l'utilizzo della memoria è come O (n ^ n). Sarebbe comunque facile sostituire l'indicizzatore di permutazione con il codice O (n), solo più a lungo. Sto solo illustrando il modo in cui puoi usare END{}questo compito in perl. Tutti i END{}blocchi vengono eseguiti al momento dell'uscita, ma solo il primo che viene chiamato (l'ultimo nel codice) produrrà qualsiasi cosa a causa del /A/test che è vero solo una volta

Si noti che il $mcontatore deve contare come una stringa perché come numero traboccarebbe (più tardi della fine dell'universo ma è il principio che conta). Per lo stesso motivo, "conto" il numero di righe costruendo una stringa di As invece di usare un contatore reale sebbene questo overflow si verificherebbe anche più tardi.

Un altro modo per farlo in 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),

Questo utilizza quel fatto che in foo = bar barviene eseguito dopo foo. Questa versione non impazzisce nel tempo e nello spazio ma rende il codice più lungo

Un'altra idea è quella di utilizzare DESTROYche ha il vantaggio che solo una di esse verrà eseguita. Non ripeterò il codice di indicizzazione di permutazione di cui ho già dato due esempi.

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;

Gelatina , ∞

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

(Esempio con n=3.)

Provalo online!

23 13 11 byte per riga.

Per un programma con nlinee, le linee avranno il formato

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

dove <i>rappresenta il numero letterale ie ogni riga ha un valore diverso per ivariare da 1a n. (I valori per in irealtà non devono essere questi numeri specifici, devono solo avere valori positivi univoci.) Questo programma non utilizza più nnella struttura della linea.

Come?

• Senza discussione, inizia Jelly 0 .
• ;1aggiunge 1alla 0o dalla lista attiva.
• ⁼Q$è la monade condizionale per l'istruzione if ( ?) che controlla se gli elementi dell'elenco sono univoci. In tal caso, il collegamento sopra si chiama ( Ç) e un altro numero viene aggiunto all'elenco. Se non sono univoci, ciò significa che siamo passati al primo link. L'elemento ripetuto viene rimosso dall'elenco ( Q) e viene trovato l'indice della permutazione ( Œ¿). Si noti che all'inizio viene visualizzato un 0elenco, Œ¿ma questo non influisce sull'output poiché i valori per isono tutti positivi.

Nuova funzione Jelly

Con la nuova aggiunta Ƒrapida, possiamo ridurre ⁼Q$a QƑ, salvando un byte.

10 byte / linea (per cifre singole)

;1ÇQŒ¿$QƑ?

Provalo online!

Brain-Flak , 3

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

Provalo online!

L'ho pubblicato in chat in precedenza, ma si spera pubblicandolo qui le persone possono costruirlo.

Spiegazione

Iniziamo con il programma di base

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

Questo segna 2 da solo. Per passare al livello successivo, voglio aggiungere una nuova riga. La mia ipotesi iniziale era

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

Questo imposta il TOS su 2se è zero e non fa diversamente. Questo in realtà è un buon inizio. Con le altre due righe siamo in grado di ottenere tutti i numeri da 1a 6tranne 4, perché ci sono 2modi per produrre 2:

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

e

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

Per ovviare a questo, facciamo in modo che anche la nostra linea 2sia 4. Questo può essere fatto con

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

Per chiarezza, questo fondamentalmente implementa la funzione Haskell

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

Questo risolve il nostro problema perché uno dei programmi che in precedenza era in uscita 2ora emette 4senza altri cambi di programma.

Java 7, punteggio: ∞

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

Provalo online!

Questo può stampare da 0 a n! -1 . Le righe aggiuntive sono del seguente formato (dove INDICE è un numero compreso tra 1 e n! -1 ):

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

Questo metodo funziona leggendo la propria fonte per determinare le classi di ordine in cui sono elencate. Sfortunatamente non c'era alcun metodo più interessante che potessi trovare analizzando il file compilato o creando un ClassLoader personalizzato grazie a come java fa la compilazione JIT. Suppongo che ogni classe aggiuntiva possa stampare un numero definito staticamente, ma questo sembra più divertente. Ciò consentirebbe anche di rimuovere l' Binterfaccia, ma il punteggio non si basa sui byte, quindi lo lascerò per divertimento.

Come funziona (alto livello):

Legge il proprio codice sorgente riga per riga. Poiché ogni riga dichiara una nuova classe, utilizziamo la riflessione per creare un'istanza della nuova classe e invocare il ametodo che deve avere perché implementa l' Binterfaccia.

Rubino , punteggio: ∞

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

Provalo online!

Questo programma ha 61 byte per riga (per n <10). Ha lo stesso formato di base della soluzione di dylnan ; il primo numero in ciascuna riga avrà un valore diverso tra 1e n, e il secondo numero in ciascuna riga saràn .

Speravo di trovare un modo per evitare di includerlo nnel programma, ma non riuscivo a trovarne uno.

Brain-Flak , 2 (con -d)

{}(@ltN)

Provalo online!

05AB1E , punteggio: 1.114.112

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

Provalo online! 0-indicizzati. ˆ all'inizio di ogni riga spinge i caratteri distinti nell'array globale. Il resto del codice viene eseguito inutilmente tranne nell'ultima riga, dove concatena i valori in una stringa, quindi trova il suo indice di permutazione. 1.114.112 è il numero di possibili caratteri Unicode al momento della scrittura (ovviamente i punti di codice 48-57 sono i più facili da dimostrare).