Sıra sayısı sistem sonsuz sayılarla bir sistemdir. Çok sayıda sonsuz sayı var. Kelimenin tam anlamıyla kendi sonsuzluğunu temsil edecek bir sonsuzluğa sahip olmadığı sonsuz sayıda sayı. Yukarıdaki resim nasıl çalıştıkları hakkında küçük bir fikir verir. Sıra numarası ( Von Neumann yapısı ) önceki sıralardan oluşan bir kümedir. Örneğin, 0 boş küme, 1 {0} küme, 2 {0, 1} küme vb. Sonra {get, {0, 1, 2, 3 ...} 'e gideriz. ω + 1 {0, 1, 2, 3 ... ω}, ω çarpı {0, 1, 2 ... ω, ω + 1, ω + 2 ...} ve devam ediyorsun söyledi.

Programınız, {0, 1, 4} gibi bir sıra dizisi çıkarır. Sizin skor ardından sette sıralı hepsinden daha az sıralı duyacaktır. {0, 1, 4} için puan 5 olur. {0, 1, 2 ...} için puan ω olur.

İstediğin sıradanı nasıl çıkardın? Elbette kodu. Yani, programınız her satırda birer tane olmak üzere, potansiyel olarak sınırsız sayıda başka program listesi çıkarır (yeni satırları temsil etmek için "\ n" hazır dizesini kullanın). Bir program yukarıda belirtilen puanına karşılık gelir. Örneğin, eğer çıktı

"A"
"B"
"C"

burada A, B ve C kendileri geçerli cevaplar ve {0, 1, 4} puanlarına sahiplerse, programınızın puanı 5 olacaktır. A, B ve C'nin parça değil, tam program olması gerektiğine dikkat edin.

Yukarıdaki kurallara dayanarak, hiçbir şey çıkaran bir programın puanı 0'dır (hepsinden daha büyük olan en küçük sıra, {}, 0'dır). Ayrıca, bir kümenin vakıf aksiyomuyla kendisini içeremeyeceğini unutmayın . Yani, her kümenin (ve dolayısıyla sıralamanın) sıfıra kadar bir yolu vardır. Bu, tam bir sıranın bir küme olmadığı için geçersiz olacağı anlamına gelir.

Ayrıca, hiçbir programın dış kaynaklara erişmesine izin verilmez (kendi dosyası, internet vb.). Ayrıca, puanınızı sıraladığınızda, eğer normal bir formda değilse, eğer (eğer başkası yapabilirse) normal bir formda değilse, normal bir skorun yanına normal bir form koyun .

Tüm bunları göz önünde bulundurduktan sonra, gönderdiğiniz asıl cevap 1.000.000 baytın altında olmalıdır (yorumları saymazsınız). (Bu üst sınır muhtemelen yalnızca otomatik olarak oluşturulan kod için devreye girecektir). Ayrıca kullanmadığınız her byte için puanınızı artırırsınız (sonsuzluklarla uğraştığımızdan, bu muhtemelen sadece sıralamalar çok yakın veya aynı olduğunda dikkate alınacaktır). Yine, bu paragraf yalnızca oluşturulan cevaplar için geçerlidir, üretilen cevaplar için değil, üretilenlerin cevapları ve diğerleri için.

Bu quine etiketine sahiptir, çünkü büyük sıralamalar yapmak için kaynakların kendi kodunun en azından bir bölümünü oluşturmakta yardımcı olabilir. Bununla birlikte, hiçbir şekilde gerekli değildir (örneğin, 5. puan olan bir gönderimin muhtemelen kendi kaynak koduna ihtiyacı yoktur).

Anlaşılmış ve açıklamalı bir örnek için, buraya bakın .

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

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"

Ordinal ψ (Ω ^{Ω ω} ) + 1 koduyla 329 bayt. Jervell (2005) tarafından bulunan sıralı ağaçların ağaç tabanlı gösterimini kullanır . Çocuklu ağaç a , β , ..., γ gösterilir . Bu soldan sağa düzen, Jervell ile aynı fikirde olsa da, Madore'un sağdan sola çevirdiğini unutmayın.α :@ (β :@ (… :@ (γ :@ Z)…))

Haskell: Γ ₀ + 999777 puan

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"

Ordinal or ₀ + 1 koduyla 224 bayt. Bu, Beklemişev'in Solucanını, solucanlar tarafından özyinelemeli olarak temsil edilen sıradan değerli öğelere genellemeye dayanır.

Haskell: ε ₀ + 999853 puan

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"

Sıra ile kod 148 bayt £ değerinin ₀ + 1 Bu dayanmaktadır Beklemishev en Solucan . Liste

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

ordinal (ω temsil ^γ + ⋯ + ω ^p + ω ^a ) - ikinci seviye çıkışları Böylece 1. [0], [1], [2], [3], ... 1, ω temsil ω ^ω , ω ^{ω ω} , ..., birinci düzey çıkış £ değenni temsil ₀ ve başlangıç ​​programı ε ₀ + 1'i temsil eder .

Haskell: ε ₀ + 999807 puan

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"

Sıra e ıle kod 194 bayt ₀ + 1.

Z0 temsil eder ve biz ötesi indüksiyonla kanıtlamak a daha sonra, P , bu α :@ β≥ co ^a + β . Bu yüzden, en azından bir kule ω kadar büyük ikinci seviye çıkışlar vardır ^{ω ⋰ ω} birinci seviyeli çıkış en azından ε olduğu anlamına gelir, ₀ ve ilk program, en azından ε olan ₀ + 1.

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

Programımı doğru bir şekilde anladığımı varsayarsak, puanım ( ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} )))} (0)) + 999663 puan, ψ bir sıralı çöküş işlevidir; X , chi'dir. işlevi (Mahlo'nun çökmesi işlevi) ve M , ilk Mahlo 'sıralaması' dır.

Bu program ı yazdı birinin bir uzantısıdır AĞACI (3) küçük bir sayı daha büyük Golf ve tamamen koz şimdilik burada diğer tüm çözümleri.

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

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin! (Uyarı: çok fazla bir şey yapmaz, çünkü net bir şekilde (0..1.0/0).map{...}sonlanamaz. Sonsuz sayıda programı da böyle yazdırırım.)

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

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

Çevrimiçi deneyin!

Bunun (0..5).map{...}yerine uygulayan daha makul bir test programı :

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

Çevrimiçi deneyin!

Ne yazık ki, hatta birlikte (1..1).map{...}, söz konusu yöntemi bu programı bulacaksınız derece bellek yoğun. Yani, çıktının uzunluğu SCG (13) gibi şeyleri aşıyor.

Daha basit olan programı kullanarak birkaç değer düşünebiliriz:

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

Çevrimiçi deneyin!

Temelde, aynı programı tekrar tekrar, aşağıdaki biçimde basar:

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

ilklendirilen xprogramın ilgili olduğu sıralamayı kaydettiği ve indirildikten "..."sonra programları tutan x. Eğer x==0, o zaman yazdırır

p

bu hiçbir şeyi sıfır puanıyla basmayan bir programdır, dolayısıyla

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

1 puanına sahip ve

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

2 puan ve

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

3 vb. puanı vardır ve orijinal programım bu programları bu biçimde basar.

puts("...")

...yukarıda listelenen programlar nerede ?

Asıl programım aslında bu programları biçiminde yazdırıyor

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

Sınırsız sayıda, ve gibi değerler için ω, benzer bir şey yapar

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

Ve böylece, programın puanı

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

olduğunu 1+some_ordinal, ve skor

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

olduğunu 1+some_ordinal+1, ve 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]}\")")

olduğunu 1+some_ordinal+2.

Sıraların açıklaması:

f[a,n,b]bir sıra azaltır a.

Her doğal sayı, altındaki doğal sayıya düşer.

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

[c,0,e]halefidir cve her zaman azalır c.

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

[c,d,e] geriye doğru bir ilişkisel hiperperasyondur, aşağıdaki gibi azalır:

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] ilk sonsuz sıra (equivalent'ye eşdeğer) ve aşağıdaki gibi azalır:

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

[c] cth omega ordinal ve aşağıdaki gibi azalır:

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]ψ olan _d (c) ve aşağıdaki gibi azaltmaktadır:

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]Temel olarak [c,d,e], [c]halefi işlem yerine işlem üzerinde numaralandırması dışında aynıdır .

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 puan

Her biri en son çıktı olarak üreten sonsuz sayıda Brainf *** programı üreten bir java programı.

Niye ya? Çünkü yapabilirim.

Brainf *** jenerasyon bölümündeki herhangi bir iyileştirme kesinlikle kabul edilir.

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

Okuryazar Haskell (GHC 7.10): ω² + 999686 puan.

Bu örnek bir cevap olarak görev yapacak. Bir örnek olduğundan, sadece okuryazar programlamayı kullanmak anlamlıdır . Yine de iyi puan vermez. Kuşlar puanımı düşürecek, ama oh iyi. İlk önce, bir yardımcı işlev s yapalım. Eğer x bir sıralı ise, sx = x + 1, ancak s 'nin beklenmedik kullanımlarını buluruz.

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

Şov işlevi neyse ki bizim için tüm dize temizliği yapar. Aynı zamanda 0 yapmaya değer. Sıfır, hiçbir şeyin ardılı değildir, ancak s "", "main = putStrLn" "" değerine eşittir, bu, 0'a eşittir.

> z=s""

Şimdi n'yi alan ve ω * n döndüren bir fonksiyon yapacağız.

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

Ω * n yaparak {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ...} yaparak çalışır. Bu nedir? Neden, onun sebebi bir var quine etiketi. q, şu ana kadar yukarıdaki yardımcı fonksiyonlar.

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

Yardımcı fonksiyonlara ihtiyaç duymadıklarından, yalnızca q ihtiyaçları üzerine, haleflerinin hiçbirinin (s (o (n)), s (s (o (n)))) olmadığını) unutmayın. Şimdi sonlu n için sadece ω * n değerini göstermeliyiz.

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

Oraya gidiyoruz. 2 ^ 2 Yalnızca 314 kod karakteri kullandıktan sonra, 999686 final bonusunu iddia ediyorum, bana zaten normal formda olan ω ^ 2 + 999686 final skorunu verdim.

İlk dört çıktı satırı (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 puan

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

Muhtemelen daha iyi olabilir, ama daha büyük sıraları hata ayıklamak ve kanıtlamak için çok tembel oldu.

Küçük sıra

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

Nashorn , Java ile birlikte gelen Javascript motorudur. Bu da Rhino'da işe yarayabilir, ancak henüz bunu test etmedim.

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