Ihre Aufgabe ist es, ein Computerprogramm so zu schreiben, dass jede Anordnung der Zeilen eine andere Zahl zwischen 1 und n ausgibt, wenn es in Zeilen aufgeteilt wird (aufgeteilt auf das Zeilenumbruchzeichen) ! (wobei n die Gesamtzahl der Zeilen ist). Es sollte keine Nummer von zwei verschiedenen Arrangements ausgegeben werden und jedes Arrangement sollte eine Nummer in diesem Bereich ausgeben. Da gibt es n! Möglichkeiten, um die Zeilen eines Programms anzuordnen, bedeutet dies, dass jede Nummer durch eine Neuanordnung ausgegeben werden sollte.

Zum Beispiel das Python-Programm

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

Hat zwei Arrangements

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

und

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

Die ersten Ausgänge 1und die zweiten Ausgänge 2.

Sie können beliebige Ausgabeformate verwenden, die in der von Ihnen verwendeten Sprache Standard sind. Sie dürfen keine Art von Boilerplate annehmen. Ich denke, diese Herausforderung ist interessanter, wenn Sie die Formate umgehen müssen, auf denen die Sprache besteht.

Wertung

Ihre Punktzahl ist die Anzahl der Zeilen in Ihrem Programm, wobei eine höhere Punktzahl besser ist. Sie können Zahlen von 0 bis n! -1 ausgeben, wenn Sie möchten.

CJam , Ergebnis: ∞

Jede Zeile hat die Form

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

wo xist eine nummer von 0bis n-1. Das Ergebnis liegt im Bereich 0bis n!-1.

Probieren Sie es online! (Für n=3.)

Danksagung an jimmy23013 für den Code, der den tatsächlichen Permutationsindex berechnet. Ich habe nur das Bit ersetzt, das die Eingabe liest, mit ];Lx+:Lder das Ergebnis aus der vorherigen Zeile verworfen wird, und dann den Index der aktuellen Zeile zur Variablen hinzugefügt L(die anfänglich ein leeres Array ist).

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

Erweitern Sie auf eine beliebige Länge

Der Speicher wird schnell knapp, da die Speichernutzung gleich O (n ^ n) ist. Es wäre jedoch einfach, den Permutationsindexer durch O (n) Code zu ersetzen, nur länger. Ich zeige nur, wie Sie END{}diese Aufgabe in Perl ausführen können. Alle END{}Blöcke werden zur Exit-Zeit ausgeführt, aber nur der erste, der aufgerufen wird (der letzte im Code), gibt aufgrund des /A/Tests etwas aus, was nur einmal wahr ist

Beachten Sie, dass der $mZähler als Zeichenfolge zählen muss, da er als Zahl überlaufen würde (später als das Ende des Universums, aber es ist das Prinzip, das zählt). Aus dem gleichen Grund "zähle" ich die Anzahl der Zeilen, indem ich Aanstelle eines echten Zählers eine Zeichenfolge von s aufbaue, obwohl dieser Überlauf auch später auftreten würde.

Eine andere Möglichkeit, dies in Perl zu tun:

@{$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),

Dies nutzt die Tatsache, dass in foo = bar barnach ausgeführt wird foo. Diese Version ist übrigens zeitlich und räumlich nicht verrückt, aber das verlängert den Code

Es ist noch eine andere Idee zu verwenden, DESTROYdie den Vorteil hat, dass nur eine von ihnen ausgeführt wird. Ich werde den Permutationsindexcode, für den ich bereits zwei Beispiele gegeben habe, nicht wiederholen.

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

Oder mit 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;

Gelee , ∞

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

(Beispiel mit n=3.)

Probieren Sie es online!

23 13 11 Bytes pro Zeile.

Bei einem Programm mit nZeilen haben die Zeilen das Format

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

wobei <i>für die Zahl Literal iund jede Zeile einen anderen Wert für die im iBereich von 1bis n. (Die Werte für imüssen nicht unbedingt diese spezifischen Zahlen sein, sondern nur eindeutige positive Werte.) Dieses Programm wird nin der Zeilenstruktur nicht mehr verwendet .

Wie?

• Ohne ein Argument beginnt Jelly mit 0.
• ;1hängt 1an 0oder an die aktive Liste.
• ⁼Q$ist die bedingte Monade für die if-Anweisung ( ?), die prüft, ob die Elemente der Liste eindeutig sind. Wenn dies der Fall ist, wird der obige Link mit ( Ç) bezeichnet und eine weitere Nummer an die Liste angehängt. Wenn sie nicht eindeutig sind, haben wir uns um den ersten Link gekümmert. Das wiederholte Element wird aus der Liste entfernt ( Q) und der Index der Permutation wird gefunden ( Œ¿). Beachten Sie, dass sich 0am Anfang der Liste ein Œ¿befindet, wenn sie aufgenommen wird, dies hat jedoch keine Auswirkungen auf die Ausgabe, da die Werte für ialle positiv sind.

Neue Jelly-Funktion

Mit dem neu hinzugefügten ƑQuick können wir ⁼Q$auf QƑein Byte reduzieren .

10 Bytes / Zeile (für einzelne Ziffern)

;1ÇQŒ¿$QƑ?

Probieren Sie es online!

Brain-Flak , 3

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

Probieren Sie es online!

Ich habe dies früher im Chat gepostet, aber hoffentlich können die Leute es daraus machen, indem sie es hier posten.

Erläuterung

Wir beginnen mit dem Grundprogramm

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

Dies ergibt 2 für sich. Um in die nächste Ebene aufzusteigen, möchte ich eine neue Zeile hinzufügen. Meine anfängliche Vermutung war

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

Dies setzt die TOS auf, 2wenn sie Null ist und macht sonst nichts. Das ist eigentlich ein guter Anfang. Mit den anderen beiden Zeilen können wir alle Zahlen von 1bis 6außer abrufen 4, da es verschiedene 2Möglichkeiten gibt, sie auszugeben 2:

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

und

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

Um dem abzuhelfen, machen wir unsere Linie auch so eingestellt 2, dass sie ist 4. Dies kann mit erfolgen

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

Aus Gründen der Übersichtlichkeit implementiert dies im Wesentlichen die Haskell-Funktion

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

Dies behebt unser Problem, da eines der Programme, die zuvor ausgegeben wurden, 2jetzt ausgegeben wird, 4ohne dass ein anderes Programm geändert wird.

Java 7, Kerbe: ∞

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

Probieren Sie es online!

Dies kann 0 bis n! -1 ausgeben . Zusätzliche Zeilen haben das folgende Format (wobei INDEX eine Zahl von 1 bis n! -1 ist ):

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

Bei dieser Methode wird die eigene Quelle gelesen, um zu bestimmen, welche Ordnungsklassen darin aufgeführt sind. Leider gab es keine coolere Methode, die ich finden konnte, wenn ich die kompilierte Datei analysierte oder einen benutzerdefinierten ClassLoader erstellte, da Java die JIT-Kompilierung ausführte. Ich nehme an, ich könnte jede weitere Klasse einfach eine statisch festgelegte Zahl ausdrucken lassen, aber das schien mehr Spaß zu machen. Das würde auch dazu führen, dass ich die BSchnittstelle entfernen könnte, aber die Bewertung basiert nicht auf Bytes, also lasse ich das zum Spaß.

Wie es funktioniert (hohes Niveau):

Liest seinen eigenen Quellcode zeilenweise. Da jede Zeile eine neue Klasse deklariert, erstellen wir mit Reflection eine Instanz der neuen Klasse und rufen die aMethode auf, die sie benötigt, um die BSchnittstelle zu implementieren .

Ruby , Punktzahl: ∞

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

Probieren Sie es online!

Dieses Programm hat 61 Bytes pro Zeile (für n <10). Es hat das gleiche Grundformat wie Dylnans Lösung . Die erste Zahl in jeder Zeile ist ein anderer Wert zwischen 1und n, und die zweite Zahl in jeder Zeile ist ein anderer Wert n.

Ich hatte gehofft, einen Weg zu finden, um eine Aufnahme nin das Programm zu vermeiden , aber ich konnte keinen finden.

Brain-Flak , 2 (mit -d)

{}(@ltN)

Probieren Sie es online!

05AB1E , Score: 1.114.112

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

Probieren Sie es online! 0-indiziert. Das ˆ am Anfang jeder Zeile verschiebt die einzelnen Zeichen in das globale Array. Der Rest des Codes wird sinnlos ausgeführt, außer in der letzten Zeile, in der die Werte zu einer Zeichenfolge verkettet werden und der Permutationsindex ermittelt wird. 1.114.112 ist die Anzahl der möglichen Unicode-Zeichen zum Zeitpunkt des Schreibens (die Codepunkte 48-57 sind natürlich am einfachsten zu demonstrieren).