Mach die größte Unendlichkeit, die du kannst!

31

Kantor Normalform

Das Ordnungszahlensystem ist ein System mit unendlichen Zahlen. Viele unendliche Zahlen. So viele unendliche Zahlen, dass es buchstäblich keine Unendlichkeit gibt, um seine eigene Unendlichkeit darzustellen. Das obige Bild gibt eine kleine Vorstellung davon, wie sie funktionieren. Eine Ordnungszahl ( Von-Neumann-Konstruktion ) ist eine Reihe früherer Ordnungszahlen . Beispiel: 0 ist die leere Menge, 1 ist die Menge {0}, 2 ist die Menge {0, 1} usw. Dann erhalten wir ω, das ist {0, 1, 2, 3 ...}. ω + 1 ist {0, 1, 2, 3 ... ω}, ω mal zwei ist {0, 1, 2 ... ω, ω + 1, ω + 2 ...} und du machst einfach weiter so Das.

Ihr Programm gibt eine Reihe von Ordnungszahlen aus, z. B. {0, 1, 4}. Ihre Punktzahl ist dann die niedrigste Ordnungszahl mehr als die gesamte Ordnungszahl in Ihrem Satz. Für {0, 1, 4} wäre die Punktzahl 5. Für {0, 1, 2 ...} wäre die Punktzahl ω.

Wie geben Sie Ihre Ordnungszahlen aus, die Sie fragen? Code natürlich. Ihr Programm gibt eine möglicherweise unendliche Liste anderer Programme in Anführungszeichen in jeder Zeile aus (verwenden Sie die Literalzeichenfolge "\ n", um neue Zeilen darzustellen). Ein Programm entspricht der oben angegebenen Punktzahl. Zum Beispiel, wenn Sie ausgeben

"A"
"B"
"C"

Wenn A, B und C selbst gültige Antworten sind und die Punkte {0, 1, 4} haben, ist der Punktestand Ihres Programms 5. Beachten Sie, dass A, B und C vollständige Programme sein müssen, keine Fragmente.

Basierend auf den obigen Regeln hat ein Programm, das nichts ausgibt, eine Punktzahl von 0 (die kleinste Ordnungszahl größer als alle {} ist 0). Denken Sie auch daran, dass sich eine Menge über das Axiom der Grundlage nicht selbst enthalten kann . Jede Menge (und daher auch jede Ordnungszahl) hat nämlich einen Pfad bis auf Null. Dies bedeutet, dass das a full-quine ungültig ist, da es keine Menge ist.

Auch darf kein Programm auf fremde Ressourcen (eigene Datei, Internet etc ...) zugreifen. Wenn Sie Ihre Partitur auflisten, stellen Sie auch die Kantor-Normalform der Partitur daneben, wenn sie noch nicht in Kantor-Normalform vorliegt.

Unter Berücksichtigung der oben genannten Punkte muss die tatsächliche Antwort, die Sie veröffentlichen, unter 1.000.000 Byte liegen (ohne Kommentare). (Diese Obergrenze wird wahrscheinlich nur für automatisch generierten Code ins Spiel kommen.) Außerdem können Sie Ihre Punktzahl für jedes Byte erhöhen, das Sie nicht verwenden (da es sich um Unendlichkeiten handelt, wird dies wahrscheinlich nur berücksichtigt, wenn die Ordnungszahlen sehr nahe beieinander liegen oder gleich sind). Auch hier gilt dieser Absatz nur für die gepostete Antwort, nicht für die generierten oder die generierten und so weiter.

Dies hat das quine-Tag, da es hilfreich sein kann, zumindest einen Teil des Quellcodes zu generieren, um große Ordinalzahlen zu erstellen. Dies ist jedoch keinesfalls erforderlich (zum Beispiel würde eine Einreichung mit Punktzahl 5 wahrscheinlich keinen eigenen Quellcode benötigen).

Ein ausgearbeitetes und kommentiertes Beispiel finden Sie hier .

PyRulez
quelle
Bedeutet dies, dass die Ausgabe einer unendlichen Anzahl von Kardinälen nicht beendet werden sollte? Und wo ist der Teil mit eingeschränkten Quellen? Ich denke, dieses Tag ist nicht für Code-Längenbeschränkungen. Das Erfordernis, dass sowohl Anführungszeichen als auch Zeilenvorschübe in \ n konvertiert werden, erschien mir überflüssig. Sollten andere integrierte Listenformate zulässig sein?
Jimmy23013
@ user23013 Möglicherweise wird die Ausgabe einer unbegrenzten Anzahl von Ordnungszahlen nach Belieben nie beendet. Obwohl das Zitieren und Entziehen von Zeilenumbrüchen überflüssig ist, sind in vielen Sprachen Funktionen für genau diese Aufgabe integriert. Was meinst du mit anderen Listenformaten?
PyRulez
Ich meinte jedes Listen- oder Array-Format, das von der verwendeten Sprache erkannt werden kann. Oder machen Sie die Konvertierung einfach \ n optional. Eine schnelle Lösung in vielen Sprachen ist jedoch, keine Zeilenumbrüche zu verwenden.
Jimmy23013
3
Bild ist kaputt. Was bedeutet " Set kann es nicht "? " Die tatsächliche Antwort, die Sie posten, muss unter 1.000.000 Byte liegen " ist weitaus schwächer als die tatsächliche Grenze, da StackExchange keine Antwort mit mehr als 30000 Zeichen zulässt.
Peter Taylor
1
@NateEldredge Anders ausgedrückt, beweisen Sie, dass eine berechenbare Ordnungszahl abzählbar sein muss.
Einfach schön Art

Antworten:

20

Haskell: ψ (& OHgr; & OHgr; & ohgr; ) + 999.672 Punkte

main=print$f++shows f"$iterate(Z:@)Z";f="data N=Z|N:@N deriving Show;r=repeat;s Z=[];s(a:@Z)=r a;s(Z:@b)=($u b)<$>h b;s(a:@b)=do(f,c)<-h b`zip`s a;f<$>[c:@b,a]\nh=scanl(flip(.))id.t;t(Z:@Z)=r(:@Z);t(Z:@b)=((Z:@).)<$>t b;t(a:@b)=flip(:@).(:@b)<$>s a;u Z=Z;u(Z:@b)=u b;u(a:@_)=a;g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

329 Bytes Code mit Ordnungs ψ (& OHgr; & OHgr; & ohgr; ) + 1 verwendet einen Baum-basierte Darstellung von ordinals durch entdeckt Jervell (2005) . Der Baum mit den Kindern α , β ,…, γ wird bezeichnet α :@ (β :@ (… :@ (γ :@ Z)…)). Diese Reihenfolge von links nach rechts stimmt mit Jervell überein, obwohl Madore sie von rechts nach links dreht.

Haskell: Γ 0 + 999777 Punkte

main=print$f++shows f"$iterate((:[]).T)[]";f="data T=T[T]deriving(Eq,Ord,Show);r=reverse;s[]=[];s(T b:c)=(++c)<$>scanl(++)[](b>>cycle[fst(span(>=T b)c)++[T$r d]|d<-s$r b]);g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

224 Byte Code mit der Ordnungszahl Γ 0 + 1. Dies basiert auf einer Verallgemeinerung von Beklemishevs Wurm auf ordnungswertige Elemente, die selbst durch Würmer rekursiv dargestellt werden.

Haskell: ε 0 + 999853 Punkte

main=print$f++shows f"$map(:[])[0..]";f="s[]=[];s(0:a)=[a];s(a:b)=b:s(a:fst(span(>=a)b)++a-1:b);g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

148 Byte Code mit der Ordnungszahl ε 0 + 1. Dies basiert auf Beklemishevs Wurm . Die Liste

map(+1 ++ [0] ++ map(+1 ++ [0] ++  ++ [0] ++ map(+1

repräsentiert die Ordnungszahl (ω & ggr; + ⋯ + ω & bgr; + ω & agr; ) - 1. So sind die Ausgänge der zweiten Ebene [0], [1], [2], [3], ... 1 dar, ω, ω ω , ω ω ω , ..., stellt die erste Pegelausgang ε 0 und das Anfangsprogramm repräsentiert & epsi; 0 + 1.

Haskell: ε 0 + 999807 Punkte

main=print$f++shows f"$iterate(:@Z)Z";f="data N=Z|N:@N deriving Show;s Z=[];s(Z:@b)=repeat b;s(a:@Z)=scanl(flip(:@))Z$s a;s(a:@b)=(a:@)<$>s b;g f=mapM_$print.((f++shows f\"$s$\")++).show;main=g"

194 Byte Code mit der Ordnungszahl ε 0 + 1.

Zstellt 0 dar und wir können durch transfinite Induktion auf α , dann auf β beweisen , dass α :@ β≥ ω α + β ist . So gibt es Ausgänge der zweiten Ebene wenigstens so groß ist wie jeder Turm & ohgr; & ohgr; & ohgr; , was bedeutet , die erste Pegelausgang zumindest ε 0 und das Anfangsprogramm mindestens ε 0 + 1.

Anders Kaseorg
quelle
2
Gute Antwort. Denkst du, du könntest es mehr erklären? Ich mag Ihre Idee, einen geordneten Typ zu verwenden.
PyRulez
1
Welche Ordnungszahlen werden speziell als Ausgabe ausgegeben?
PyRulez
Kennen Sie auch die normale Form dieser Ordnungszahlen des Kantors?
PyRulez
Die normale Form von @PyRulez Cantor ist für die Beschreibung dieser Ordnungszahlen nicht hilfreich. ψ (Ω ^ Ω ^ ω), Γ₀ und ε₀ sind alle Epsilon-Zahlen . Wir können also nutzlos ähnliche Kreisgleichungen für ihre einstufige Cantor-Normalform schreiben (ψ (Ω ^ Ω ^ ω) = ω ^ ψ (Ω ^ Ω ^ ω), Γ₀ = ω ^ Γ₀, ε₀ = ω ^ ε₀) können wir nicht als Ausdrücke schreiben, bei denen jeder Exponent rekursiv in Cantor-Normalform vorliegt.
Anders Kaseorg
1
Deshalb sollten Sie für Ordinalkollapsfunktionen eine Veblen-ähnliche Normalform verwenden: p. Als solches würden Sie schreiben Γ₀ = ψ (Ω ^ Ω) und ε₀ = ψ (0).
Einfach schön Art
5

Rubin, ψ 0X (ψ M + 1M + 1 Ω M + 1 )) (0)) + 999663 Punkte

Vorausgesetzt, ich verstehe mein Programm richtig, ist meine Punktzahl ψ 0X (ψ M + 1M + 1 Ω M + 1 )) (0)) + 999663 Punkte, wobei ψ eine ordinale Kollapsfunktion ist, X das Chi Funktion (Mahlo-Kollapsfunktion), und M ist die erste Mahlo-Ordnungszahl.

Dieses Programm ist eine Erweiterung von der , die ich auf schrieb Golf eine Nummer größer als TREE (3) und völlig übertrumpft alle anderen Lösungen hier für jetzt.

z=->x,k{f=->a,n,b=a,q=n{c,d,e=a;!c ?q:a==c ?a-1:e==0||e&&d==0?c:e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:n<1?9:!d ?[f[b,n-1],c]:c==0?n:[t=[f[c,n],d],n,d==0?n:[f[d,n,b,t]]]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+";"};y)};h=-1;(0..1.0/0).map{|i|puts "puts \"#{z[[i,h=[h,h,h]],1]}\""}

Probieren Sie es online!

Rubin, ψ 0I (I I )) + 999674 Punkte

z=->x,k{f=->a,n,b=a{c,d,e,q=a;a==c ?a-1:e==0||d==0?(q ?[c]:c):e ?[[c,d,f[e,n,b],q],f[d,n,b],c,q]:[n<1?9:d&&c==0?[d]:d ?[f[c,n],d]:[f[b,n-1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};h=0;(0..1.0/0).map{|i|puts("puts(\"#{z[h=[h,h,h,0],1]}\")")}

Probieren Sie es online! (Warnung: Es macht nicht viel, da es sich eindeutig (0..1.0/0).map{...}nicht beenden lässt. So drucke ich auch unendlich viele Programme.)

Rubin, ψ 0I (0)) + 999697 Punkte

z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};h=0;(0..1.0/0).map{|i|h=[h];puts|i|puts("puts(\"#{z[hz[h=[h],1]}\")")}

Probieren Sie es online!

Ein vernünftigeres Testprogramm, das (0..5).map{...}stattdessen Folgendes implementiert :

z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..5).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};h=0;(0..5).map{|i|h=[h];puts("puts(\"#{z[h,1]}\")")}

Probieren Sie es online!

Leider (1..1).map{...}wird dieses Programm auch mit äußerst speicherintensiv sein. Ich meine, die Länge der Ausgabe übersteigt Dinge wie SCG (13).

Bei Verwendung des einfacheren Programms können wir einige Werte berücksichtigen:

a = value you want to enter in.
z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="x=#{f[x,k]};puts(x==0??p:"+w+"#{z[f[x,k],k*2+1]}"+w+");";y)};puts("puts(\"#{z[a,1]}\")")

Probieren Sie es online!

Grundsätzlich wird dasselbe Programm wiederholt im Format:

x=...;puts(x==0??p:"...");

wo die initialisierten xDatensätze die Ordnungszahl, auf die sich das Programm bezieht, und die "..."die Programme hält, nachdem xsie reduziert wurden. Wenn ja x==0, wird gedruckt

p

Das ist ein Programm, das nichts mit einer Punktzahl von Null druckt, daher

x=0;puts(x==0??p:"p");

hat eine Punktzahl von 1 und

x=1;puts(x==0??p:"x=0;puts(x==0??p:\"p\");");

hat eine Punktzahl von 2 und

x=2;puts(x==0??p:"x=1;puts(x==0??p:\"x=0;puts(x==0??p:\\\"p\\\");\");");

hat eine Punktzahl von 3 usw., und mein ursprüngliches Programm druckt diese Programme im Format

puts("...")

Wo ...sind die oben aufgeführten Programme?

Mein aktuelles Programm druckt diese Programme tatsächlich im Format

x=0;puts(x==0??p:"p;p;p;p;p;...");

Unendlich oft und für Werte wie ω, tut es etwas Ähnliches

x=ω;puts(x==0??p:"(x=0 program); (x=1 program); (x=2 program); ...")

Und damit die Punktzahl des Programms

x=(some_ordinal);puts(x==0??p:"...")

ist 1+some_ordinal, und die Punktzahl von

puts("x=(some_ordinal);puts(x==0??p:\"...\")")

ist 1+some_ordinal+1, und die Punktzahl von

z=->x,k{f=->a,n,b=a{c,d,e=a;a==c ?a-1:e==0||d==0?c:e ?[[c,d,f[e,n,b]],d-1,c]:[n<1?9:d&&c==0?[d]:d ?[f[c,n-1],d]:[f[b,n-=1],f[c,n,b]],n,n]};x==0??p:(w="\\"*k+"\"";y="";(0..1.0/0).map{|g|y+="x=#{f[x,g]};puts(x==0??p:"+w+"#{z[f[x,g],k*2+1]}"+w+");"};y)};puts("puts(\"#{z[some_ordinal,1]}\")")

ist 1+some_ordinal+2.


Erklärung der Ordnungszahlen:

f[a,n,b]reduziert eine Ordnungszahl a.

Jede natürliche Zahl reduziert sich auf die natürliche Zahl darunter.

f[k,n,b] = k-1

[c,0,e]ist der Nachfolger von cund reduziert sich immer auf c.

f[[c,0,e],n,b] = c

[c,d,e] ist eine rückwärtsassoziative Hyperoperation, reduziert sich wie folgt:

f[[c,d,0],n,b] = c
f[[c,d,e],n,b] = [[c,d,f[e,n,b]],f[d,n,b],c]

[0] ist die erste unendliche Ordnungszahl (äquivalent zu ω) und reduziert sich wie folgt:

f[[0],0,b] = [9,0,0]
f[[0],n,b] = [n,n,n]

[c] ist die c-te Omega-Ordnungszahl und reduziert sich wie folgt:

f[[c],0,b] = [9,0,0]
f[[c],n,b] = [[f[b,n-1,b],f[c,n,b]],n,n]
Note the two-argument array here.

[c,d]ist ψ d (c) und reduziert sich wie folgt:

f[[c,d],0,b] = [9,0,0]
f[[0,d],n,b] = [[d],n,n]
f[[c,d],n,b] = [[f[c,n,c],d],n,n]

[c,d,e,0]ist im Grunde dasselbe wie [c,d,e], außer dass es über die Operation [c]anstelle der Nachfolgeoperation zählt.

f[[c,0,e,0],n,b] = [c]
f[[c,d,0,0],n,b] = [c]
f[[c,d,e,0],n,b] = [[c,d,f[e,n,b],0],f[d,n,b],c,0]
Einfach schöne Kunst
quelle
Nach dem Googology-Wiki bin ich der erste unzugängliche Kardinal und der erste unzugängliche Ordinal.
PyRulez
@PyRulez Ja, obwohl es sinnvoller ist, hier eine Ordnungszahl anstelle einer Kardinalzahl zu haben. Normalerweise sagt man, dass dies Idie Ordinale ist, die sich auf den ersten unzugänglichen Kardinal bezieht, genauso wie sich ω auf aleph null bezieht.
Einfach schön Art
4

Java + Brainf ***, ω + 999180 Punkte

Ein Java-Programm, das unendlich viele Brainf *** -Programme erzeugt, von denen jedes das letzte als Ausgabe erzeugt.

Warum? Weil ich kann.

Verbesserungen am Brainf *** Generationsteil sind auf jeden Fall willkommen.

import java.io.*;import java.util.*;import static java.lang.System.*;
class O{
    static String F(String s){
        String t="++++++++++++++++++++";
        List<Character> c=Arrays.asList('+','-','.','<','>','[',']');
        t+="[->++>++>++>+++>+++>++++>++++<<<<<<<]>+++>+++++>++++++>>++>+++++++++++>+++++++++++++";
        for(int x=0,i=6;x<s.length();x++){
            int d=c.indexOf(s.charAt(x)),k=d;
            while(d>i){d--;t+=">";}
            while(d<i){d++;t+="<";}
            t+=".";i=k;
        }return t;
    };
    static void p(String a){
        int i=48;while(i<a.length()){out.println(a.substring(i-48,i));i+=48;}
        out.println(a.substring(i-48));out.println();
    }
    public static void main(String[]a) throws Exception{setOut(new PrintStream("o.txt"));String b="";while(true)p(b=F(b));}
}
SuperJedi224
quelle
1
Natürlich nach Ihrem Geschmack, aber die Verwendung des richtigen Namens erleichtert die Suche. :)
luser droog
1
@Luserdroog Nicht wahr. Da Sie sicher wissen, wie man mehrere Suchbegriffe einfügt, ist es gleichermaßen schwierig, nach BF-Programmen mit unterschiedlichen Namen zu suchen.
mbomb007
@ mbomb007 Schlagen Sie vor, dass die Eingabe von "brainfuck | brainf * ck | brainfcuk | brainf ** k | brainf *** | brain **** | brainfu * k | ..." genauso schwierig ist wie die Eingabe von "brainfuck"?
Sparr
@Sparr StackExchange wird *als Platzhalterzeichen verwendet. Geben Sie also einfach brainf***oder ein brainf. All diese Variationen tauchen in den Suchergebnissen auf. codegolf.stackexchange.com/help/searching
mbomb007
@ mbomb007 danke, das wusste ich nicht
Sparr
4

Literate Haskell (GHC 7.10): ω² + 999686 Punkte.

Dies wird als Beispielantwort dienen. Da es sich um ein Beispiel handelt, ist es nur sinnvoll, gebildete Programmierung zu verwenden . Es wird aber nicht gut punkten. Die Birdies werden meine Punktzahl verringern, aber na ja. Lassen Sie uns zuerst eine Hilfsfunktion s erstellen. Wenn x eine Ordnungszahl ist, ist sx = x + 1, aber wir finden unerwartete Verwendungen von s.

> s x="main=putStrLn "++show x

Die Show-Funktion erledigt zum Glück die gesamte Saitensanierung für uns. Es lohnt sich auch 0. Null ist nicht der Nachfolger von irgendetwas, aber s "" wird gleich "main = putStrLn" "" sein, was gleich 0 ist.

> z=s""

Nun werden wir eine Funktion erstellen, die n nimmt und ω * n zurückgibt.

> o 0=z
> o n=q++"\nmain=putStrLn$unlines$map show$iterate s$o "++show(n-1)

Es funktioniert, indem ω * n durch {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ...} gebildet wird. Was ist das q? Das ist der Grund, warum wir einen Tag haben. q ist die oben genannten Hilfsfunktionen bis jetzt.

> h x = x ++ show x
> q = h "s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h "

Beachten Sie, dass nur bei Bedarf q, keiner seiner Nachfolger (s (o (n)), s (s (o (n))) benötigt wird, da sie die Hilfsfunktionen nicht benötigen (außer indirekt von o n). Jetzt müssen wir nur noch alles von ω * n für endlich n ausgeben.

> main=mapM(print.o)[0..]

Da gehen wir. ω ^ 2 Nachdem ich nur 314 Codezeichen verwendet habe, beanspruche ich einen Endbonus von 999686, was mir eine Endpunktzahl von ω ^ 2 + 999686 ergibt, die bereits in der normalen Form des Kantors vorliegt.

Die ersten vier Zeilen der Ausgabe (0, ω, ω * 2, ω * 3):

"main=putStrLn \"\""
"s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h \"s x=\\\"main=putStrLn \\\"++show x\\nz=s\\\"\\\"\\no 0=z\\no n=q++\\\"\\\\nmain=putStrLn$unlines$map show$iterate s$o \\\"++show(n-1)\\nh x = x ++ show x\\nq = h \"\nmain=putStrLn$unlines$map show$iterate s$o 0"
"s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h \"s x=\\\"main=putStrLn \\\"++show x\\nz=s\\\"\\\"\\no 0=z\\no n=q++\\\"\\\\nmain=putStrLn$unlines$map show$iterate s$o \\\"++show(n-1)\\nh x = x ++ show x\\nq = h \"\nmain=putStrLn$unlines$map show$iterate s$o 1"
"s x=\"main=putStrLn \"++show x\nz=s\"\"\no 0=z\no n=q++\"\\nmain=putStrLn$unlines$map show$iterate s$o \"++show(n-1)\nh x = x ++ show x\nq = h \"s x=\\\"main=putStrLn \\\"++show x\\nz=s\\\"\\\"\\no 0=z\\no n=q++\\\"\\\\nmain=putStrLn$unlines$map show$iterate s$o \\\"++show(n-1)\\nh x = x ++ show x\\nq = h \"\nmain=putStrLn$unlines$map show$iterate s$o 2"
PyRulez
quelle
Schreiben Sie jetzt eine ernsthafte Lösung :-)
Simply Beautiful Art
2

GolfScript, ε₀ + 1 + 999537 Punkte

{{
{"{"lib`+"}:lib~~"@++"~"+p}:output;
{{}}:nothing;
{{1{).2$`+output 1}do}}:list;
{{\.(`2$`+" iter"+@`if output}}:iter;
{{1${@`@(2$`{rep~}+++\}{;;}if~}}:rep;
{\`\+}:combine;
{{\@@~}}:swap;
{{1${1$(1$`{rangemap~}+[+@@[\\]]{~}/+}{;;}if}}:rangemap;
{`{}+}:wrap;
}}:lib~~
nothing {iter combine list~} {rep combine} {~swap combine combine} rep combine swap combine combine {~list~} combine rangemap {~~} combine combine swap combine combine swap combine combine list~

Es kann wahrscheinlich besser sein, aber ich wurde zu faul, um größere Ordnungszahlen zu debuggen und zu beweisen.

Kleinere Ordnungszahlen

#ω^ω^ω
#nothing {iter combine list~} {rep combine swap combine combine list~} {rep combine swap combine combine swap combine combine list~} rep combine swap combine combine swap combine combine swap combine combine list~
#ω^ω^2
#nothing {iter combine list~} { {rep combine swap combine combine list~} rep combine swap combine combine swap combine combine list~} rep combine swap combine combine swap combine combine list~
#ω^nω
#nothing {iter combine list~} 2 { {rep combine swap combine combine list~} rep combine swap combine combine swap combine combine list~} rep~
#ω^ω
#nothing {iter combine list~} {rep combine swap combine combine list~} rep combine swap combine combine swap combine combine list~
#ω^n
#nothing {iter combine list~} 3 {rep combine swap combine combine list~} rep~
#ω^3
#nothing {{iter combine list~} rep combine swap combine combine list~} rep combine swap combine combine list~
#ω^2
#nothing {iter combine list~} rep combine swap combine combine list~
#nω
#nothing 3 {iter combine list~} rep~
#2ω
#nothing iter combine list combine iter combine list~
#ω
#nothing iter combine list~
#finite
#2 nothing iter~
jimmy23013
quelle
1

Javascript (Nashorn), ω2 + 999807 Punkte

Nashorn ist die in Java integrierte Javascript-Engine. Das funktioniert vielleicht auch in Rhino, aber ich habe es noch nicht getestet.

c="(b=function(a){print(a?\"(b=\"+b+\")(\"+(a-1)+\")\":\"c=\\\"(b=function(a){print(a?'(b='+b+')'+'('+(a-1)+')':'')})(\\\";a=0;while(++a)print(c+a+\\\")\\\")\")})(";a=0;while(++a)print(c+a+")")
SuperJedi224
quelle
Ist es 2ω oder ω²?
Kamoroso94
@ kamoroso94 FYI 2ω = ω.
Einfach schön Art
Okay, ω • 2, meine schlechte.
Kamoroso94