Sistem bilangan ordinal adalah sistem dengan bilangan tak terbatas. Banyak sekali angka tak terbatas. Begitu banyak angka tak terbatas sehingga secara harfiah tidak memiliki tak terhingga untuk mewakili ketidakterbatasannya sendiri. Gambar di atas memberikan sedikit gambaran tentang cara kerjanya. Nomor urut ( konstruksi Von Neumann ) adalah seperangkat tata cara sebelumnya. Misalnya, 0 adalah himpunan kosong, 1 adalah himpunan {0}, 2 adalah himpunan {0, 1} dan lain-lain. Lalu kita sampai ke ω, yaitu {0, 1, 2, 3 ...}. ω + 1 adalah {0, 1, 2, 3 ... ω}, ω dua kali adalah {0, 1, 2 ... ω, ω + 1, ω + 2 ...} dan Anda terus seperti bahwa.

Program Anda akan menampilkan seperangkat tata cara, seperti {0, 1, 4}. Skor Anda kemudian akan menjadi yang paling ordinal daripada semua ordinal dalam set Anda. Untuk {0, 1, 4} skornya adalah 5. Untuk {0, 1, 2 ...}, skornya adalah ω.

Bagaimana Anda menghasilkan tata cara yang Anda minta. Kode tentu saja. Yaitu, program Anda akan menampilkan daftar program lain yang berpotensi tak terbatas, dalam tanda kutip, satu di setiap baris (gunakan string literal "\ n" untuk mewakili baris baru). Suatu program sesuai dengan nilainya seperti yang ditunjukkan di atas. Misalnya, jika Anda output

"A"
"B"
"C"

di mana A, B, dan C sendiri merupakan jawaban yang valid dan memiliki skor {0, 1, 4}, skor program Anda adalah 5. Perhatikan bahwa A, B, dan C, harus berupa program penuh, bukan fragmen.

Berdasarkan aturan di atas, sebuah program yang menghasilkan tidak ada yang memiliki skor 0 (paling ordinal lebih besar dari semua {} adalah 0). Juga, ingat satu set tidak dapat mengandung dirinya sendiri, melalui aksioma dasar . Yaitu, setiap set (dan karenanya ordinal) memiliki jalur ke nol. Ini berarti quine penuh akan tidak valid karena bukan set.

Juga, tidak ada program yang diizinkan untuk mengakses sumber daya luar (file sendiri, internet dll ...). Juga, ketika Anda membuat daftar skor Anda, masukkan bentuk normal skor penyanyi di samping itu jika sudah tidak dalam bentuk normal penyanyi, jika Anda bisa (jika tidak, orang lain bisa).

Setelah memperhitungkan semua hal di atas, jawaban aktual yang Anda poskan harus di bawah 1.000.000 byte (tidak termasuk komentar). (Batas atas ini kemungkinan hanya akan berperan untuk kode yang dibuat secara otomatis). Juga, Anda dapat menambah skor Anda untuk setiap byte yang tidak Anda gunakan (karena kami berhadapan dengan infinities, ini mungkin hanya akan diperhitungkan ketika ordinals sangat dekat atau sama). Sekali lagi, paragraf ini hanya berlaku untuk jawaban yang diposting, bukan yang dihasilkan, atau yang dihasilkan, dan seterusnya.

Ini memiliki tag quine, karena mungkin berguna untuk menghasilkan setidaknya sebagian dari kode sumber sendiri, untuk digunakan dalam membuat tata cara besar. Ini sama sekali tidak diperlukan (misalnya, pengiriman dengan skor 5 mungkin tidak memerlukan kode sumbernya sendiri).

Untuk contoh yang dikerjakan dan dijelaskan, lihat di sini .

Haskell: ψ (Ω ^{Ω ω} ) + 999672 poin

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 byte kode dengan ordinal ψ (Ω ^{Ω ω} ) + 1. Menggunakan representasi tata cara berbasis pohon yang ditemukan oleh Jervell (2005) . Pohon dengan anak-anak α , β ,…, γ dilambangkan α :@ (β :@ (… :@ (γ :@ Z)…)). Perintah dari kiri ke kanan ini setuju dengan Jervell, meskipun perhatikan bahwa Madore membalikkannya dari kanan ke kiri.

Haskell: Γ ₀ + 999777 poin

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 kode dengan ordinal Γ ₀ + 1. Ini didasarkan pada generalisasi Cacing Beklemishev untuk elemen bernilai ordinal, yang dengan sendirinya diwakili oleh cacing.

Haskell: ε ₀ + 999853 poin

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 kode dengan ordinal ε ₀ + 1. Ini didasarkan pada Cacing Beklemishev . Daftar

map(+1)α ++ [0] ++ map(+1)β ++ [0] ++ ⋯ ++ [0] ++ map(+1)γ

mewakili ordinal (ω ^gamma + ⋯ + ω ^ß + ω ^a ) - 1. Jadi output tingkat kedua [0], [1], [2], [3], ... mewakili 1, ω, ω ^ω , ω ^{ω ω} , ..., output-tingkat pertama merupakan ε ₀ , dan program awal mewakili ε ₀ +1.

Haskell: ε ₀ + 999807 poin

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 kode dengan ordinal ε ₀ +1.

Zmewakili 0, dan kita dapat membuktikan dengan induksi transfinite pada α , kemudian pada β , bahwa α :@ β≥ ω ^α + β . Jadi ada output tingkat kedua setidaknya sebesar menara ω ^{ω ⋰ ω} , yang berarti output tingkat pertama setidaknya ε ₀ dan program awal setidaknya ε ₀ + 1.

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

Dengan asumsi saya memahami program saya dengan baik, skor saya adalah ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} ))} (0)) + 999663 poin di mana ψ adalah fungsi runtuh ordinal, X adalah chi fungsi (fungsi Mahlo runtuh), dan M adalah Mahlo 'ordinal' pertama.

Program ini merupakan perpanjangan dari yang saya tulis di Golf nomor lebih besar dari TREE (3) dan benar - benar mengalahkan semua solusi lain di sini untuk saat ini.

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

Cobalah online!

Ruby, ψ ₀ (ψ _I (I ^I )) + 999674 poin

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]}\")")}

Cobalah online! (peringatan: tidak akan berbuat banyak, karena jelas (0..1.0/0).map{...}tidak dapat berakhir. Begitulah cara saya mencetak banyak program juga.)

Ruby, ψ ₀ (ψ _I (0)) + 999697 poin

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]}\")")}

Cobalah online!

Program pengujian yang lebih masuk akal yang mengimplementasikan (0..5).map{...}:

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]}\")")}

Cobalah online!

Sayangnya, walaupun dengan (1..1).map{...}, Anda akan menemukan program ini menjadi sangat intensif memori. Maksud saya, panjang output melebihi hal-hal seperti SCG (13).

Dengan menggunakan program yang lebih sederhana, kami dapat mempertimbangkan beberapa nilai:

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]}\")")

Cobalah online!

Ini pada dasarnya mencetak program yang sama berulang kali, dalam format:

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

di mana inisialisasi xmencatat ordinal program terkait, dan "..."memegang program setelah xdikurangi. Jika x==0, maka ia mencetak

p

yang merupakan program yang tidak mencetak apa pun dengan skor nol, karenanya

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

memiliki skor 1, dan

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

memiliki skor 2, dan

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

memiliki skor 3, dll, dan program asli saya mencetak program-program ini dalam format

puts("...")

di mana ...program-program yang tercantum di atas.

Program saya yang sebenarnya mencetak program-program ini dalam format

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

Berkali-kali, dan untuk nilai-nilai seperti ωitu, ia melakukan sesuatu yang serupa

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

Dan dengan demikian, skor program

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

adalah 1+some_ordinal, dan skor

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

adalah 1+some_ordinal+1, dan skor

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]}\")")

adalah 1+some_ordinal+2.

Penjelasan tata cara:

f[a,n,b]mengurangi ordinal a.

Setiap bilangan alami berkurang menjadi bilangan alami di bawahnya.

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

[c,0,e]adalah penerus c, dan selalu berkurang hingga c.

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

[c,d,e] adalah hyperoperation asosiatif mundur, dikurangi sebagai berikut:

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] adalah ordinal tak terbatas pertama (setara dengan ω) dan mengurangi sebagai berikut:

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

[c] adalah come omega ordinal dan mengurangi sebagai berikut:

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]adalah ψ _d (c) dan mengurangi sebagai berikut:

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]pada dasarnya sama dengan [c,d,e], kecuali ia menyebutkan operasi [c]bukan operasi penerus.

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 poin

Sebuah program java yang menghasilkan banyak program Brainf ***, yang masing-masing menghasilkan yang terakhir sebagai keluaran.

Mengapa? Karena aku bisa.

Setiap perbaikan pada bagian generasi Brainf *** pasti disambut.

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 poin.

Ini akan berfungsi sebagai contoh jawaban. Karena ini adalah contoh, itu hanya masuk akal untuk menggunakan pemrograman melek . Itu tidak akan mencetak gol dengan baik. Birdie akan mengurangi nilaiku, tapi oh well. Pertama, mari kita buat fungsi pembantu. Jika x adalah ordinal, sx = x + 1, tetapi kami menemukan penggunaan s yang tidak terduga.

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

Fungsi pertunjukan untungnya melakukan semua sanitasi string untuk kita. Nilainya juga bernilai 0. Nol bukanlah penerus dari apa pun, tetapi s "" akan sama "main = putStrLn" "", yang sama dengan 0.

> z=s""

Sekarang kita akan membuat fungsi yang mengambil n, dan mengembalikan ω * n.

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

Ia bekerja dengan membuat ω * n oleh {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ...}. Apa q ini? Mengapa, itu alasan kami memiliki tag quine . q adalah fungsi pembantu di atas sejauh ini.

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

Perhatikan bahwa hanya pada kebutuhan q, bukan penerusnya (s (o (n)), s (o (n))))), karena mereka tidak memerlukan fungsi pembantu (kecuali secara tidak langsung dari o.) Sekarang kita hanya perlu menampilkan semua ω * n untuk hingga n.

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

Itu dia. ω ^ 2 Setelah hanya menggunakan 314 karakter kode, saya mengklaim bonus final 999686, memberi saya skor akhir ω ^ 2 + 999686, yang sudah dalam bentuk normal cantor.

Empat baris output pertama (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 poin

{{
{"{"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~

Mungkin bisa lebih baik, tetapi saya menjadi terlalu malas untuk men-debug dan membuktikan tata cara yang lebih besar.

Tata cara yang lebih kecil

#ω^ω^ω
#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 poin

Nashorn adalah mesin Javascript yang dibangun di Jawa. Ini juga bisa bekerja di Badak, tapi saya belum mengujinya.

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