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 .

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: Γ ₀ + 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 Γ ₀ + 1. Dies basiert auf einer Verallgemeinerung von Beklemishevs Wurm auf ordnungswertige Elemente, die selbst durch Würmer rekursiv dargestellt werden.

Haskell: ε ₀ + 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 ε ₀ + 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 ε ₀ und das Anfangsprogramm repräsentiert & epsi; ₀ + 1.

Haskell: ε ₀ + 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 ε ₀ + 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 ε ₀ und das Anfangsprogramm mindestens ε ₀ + 1.

Rubin, ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} ))} (0)) + 999663 Punkte

Vorausgesetzt, ich verstehe mein Programm richtig, ist meine Punktzahl ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 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, ψ ₀ (ψ _I (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, ψ ₀ (ψ _I (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]

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

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

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~

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+")")