Các hệ thống số thứ tự là một hệ thống với số lượng vô hạn. Rất nhiều số lượng vô hạn. Rất nhiều con số vô hạn mà theo nghĩa đen nó không có vô hạn để thể hiện sự vô hạn của chính nó. Hình ảnh trên cho một ý tưởng nhỏ về cách họ làm việc. Một số thứ tự ( xây dựng Von Neumann ) là một tập hợp các số thứ tự trước đó. Ví dụ: 0 là tập hợp trống, 1 là tập {0}, 2 là tập {0, 1} và v.v. Sau đó, chúng ta đến, đó là {0, 1, 2, 3 ...}. ω + 1 là {0, 1, 2, 3 ... ω}, lần hai là {0, 1, 2 ... ω, ω + 1, ω + 2 ...} và bạn cứ tiếp tục như thế cái đó.

Chương trình của bạn sẽ xuất ra một tập hợp các số thứ tự, chẳng hạn như {0, 1, 4}. Điểm số của bạn sau đó sẽ là thứ tự tối thiểu nhiều hơn tất cả các thứ tự trong tập hợp của bạn. Với {0, 1, 4} điểm sẽ là 5. Với {0, 1, 2 ...}, điểm sẽ là.

Làm thế nào để bạn đầu ra thứ tự bạn yêu cầu. Mã khóa học. Cụ thể, chương trình của bạn sẽ đưa ra một danh sách các chương trình khác có khả năng vô hạn, trong ngoặc kép, mỗi dòng trên mỗi dòng (sử dụng chuỗi ký tự "\ n" để thể hiện các dòng mới). Một chương trình tương ứng với điểm số của nó như được chỉ ra ở trên. Ví dụ: nếu bạn xuất

"A"
"B"
"C"

Trong đó A, B và C là câu trả lời hợp lệ và có điểm {0, 1, 4}, điểm của chương trình của bạn sẽ là 5. Lưu ý rằng A, B và C, phải là chương trình đầy đủ, không phải là các đoạn.

Dựa trên các quy tắc trên, một chương trình không có kết quả nào có điểm 0 (số thứ tự nhỏ nhất lớn hơn tất cả {} là 0). Ngoài ra, hãy nhớ một tập hợp không thể chứa chính nó, thông qua tiên đề của nền tảng . Cụ thể, mọi tập hợp (và do đó là thứ tự) có một đường dẫn xuống không. Điều này có nghĩa là một quine đầy đủ sẽ không hợp lệ vì nó không phải là một tập hợp.

Ngoài ra, không có chương trình nào được phép truy cập các tài nguyên bên ngoài (tệp riêng của nó, internet, v.v.). Ngoài ra, khi bạn liệt kê điểm số của mình, hãy đặt dạng bình thường của điểm số cùng với điểm số nếu nó chưa ở dạng bình thường của ca sĩ, nếu bạn có thể (nếu không, người khác có thể).

Sau khi tính tất cả các yếu tố trên, câu trả lời thực tế bạn đăng phải dưới 1.000.000 byte (không tính bình luận). (Giới hạn trên này có thể sẽ chỉ được sử dụng cho mã được tạo tự động). Ngoài ra, bạn có thể tăng số điểm của mình cho mỗi byte bạn không sử dụng (vì chúng tôi đang xử lý các lỗi vô hạn, điều này có thể sẽ chỉ được tính đến khi các lệnh rất gần hoặc giống nhau). Một lần nữa, đoạn này chỉ áp dụng cho câu trả lời được đăng, không phải câu trả lời được tạo hoặc câu trả lời được tạo, v.v.

Điều này có thẻ quine, bởi vì nó có thể hữu ích để tạo ít nhất một phần mã nguồn riêng, để sử dụng trong việc tạo ra các quy tắc lớn. Tuy nhiên, đó không phải là bắt buộc (ví dụ, một bài nộp với điểm 5 có thể sẽ không cần mã nguồn riêng của nó).

Đối với một ví dụ làm việc và chú thích, xem ở đây .

Haskell: (Ω ^{Ω ω} ) + 999672 điểm

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 của mã với thứ tự ψ (Ohm ^{Ohm w} ) + 1. Sử dụng một cây đại diện có trụ sở của ordinals phát hiện bởi Jervell (2005) . Cây với trẻ em alpha , β , ..., γ được ký hiệu α :@ (β :@ (… :@ (γ :@ Z)…)). Thứ tự từ trái sang phải này đồng ý với Jervell, mặc dù lưu ý rằng Madore lật nó từ phải sang trái.

Haskell: Γ ₀ + 999777 điểm

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 mã với thứ tự Γ ₀ + 1. Điều này dựa trên sự khái quát hóa Worm của Beklemishev đối với các phần tử có giá trị thứ tự, chúng được biểu diễn đệ quy bằng sâu.

Haskell: ε ₀ + 999853 điểm

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 mã với thứ tự ε ₀ + 1. Điều này dựa trên Worm của Beklemishev . Danh sách

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

đại diện cho thứ tự (ω ^gamma + ⋯ + ω ^beta + ω ^alpha ) - 1. Vì vậy, các kết quả đầu ra thứ hai cấp [0], [1], [2], [3], ... đại diện cho 1, ω, ω ^ω , ω ^{ω ω} , ..., đầu ra đầu tiên cấp đại diện cho ε ₀ và chương trình ban đầu đại diện cho ε ₀ + 1.

Haskell: ε ₀ + 999807 điểm

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 mã với thứ tự ε ₀ + 1.

Zđại diện cho 0, và chúng ta có thể chứng minh bằng quy nạp siêu hạn trên α , sau đó trên β , mà α :@ β≥ w ^α + β . Vì vậy, có hai mức độ đầu ra ít nhất là lớn như bất kỳ tháp w ^{w ⋰ w} , có nghĩa là sản lượng đầu tiên cấp cao nhất là ít nhất ε ₀ và chương trình ban đầu là ít nhất ε ₀ + 1.

Ruby, ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} ))} (0)) + 999.663 điểm

Giả sử tôi hiểu chương trình của tôi đúng, điểm số của tôi là ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} ))} (0)) + 999.663 điểm nơi ψ là một thứ tự chức năng sụp đổ, X là chi chức năng (chức năng thu gọn Mahlo) và M là 'thứ tự' đầu tiên của Mahlo.

Chương trình này là một phần mở rộng của chương trình tôi đã viết trên Golf một số lớn hơn TREE (3) và hoàn toàn bỏ qua tất cả các giải pháp khác ở đây cho đến bây giờ.

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

Hãy thử trực tuyến!

Ruby, ψ ₀ ( _I (I ^I )) + 999674 điểm

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

Hãy thử trực tuyến! (cảnh báo: nó sẽ không làm được gì nhiều, vì rõ ràng (0..1.0/0).map{...}không thể chấm dứt. Đó là cách tôi in vô số chương trình.)

Ruby, ψ ₀ ( _I (0)) + 999697 điểm

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

Hãy thử trực tuyến!

Một chương trình thử nghiệm hợp lý hơn thực hiện (0..5).map{...}thay thế:

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

Hãy thử trực tuyến!

Thật không may, ngay cả với (1..1).map{...}, bạn sẽ thấy chương trình này cực kỳ tốn bộ nhớ. Ý tôi là, độ dài của đầu ra vượt quá những thứ như SCG (13).

Bằng cách sử dụng chương trình đơn giản hơn, chúng tôi có thể xem xét một vài giá trị:

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

Hãy thử trực tuyến!

Về cơ bản, nó in cùng một chương trình nhiều lần, theo định dạng:

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

trong đó các xbản ghi khởi tạo thứ tự chương trình có liên quan đến, và "..."các chương trình giữ sau đó xđã bị giảm. Nếu x==0, sau đó nó in

p

đó là một chương trình không in gì với số điểm bằng 0, do đó

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

có số điểm là 1 và

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

có điểm 2 và

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

có số điểm là 3, v.v. và chương trình gốc của tôi in các chương trình này theo định dạng

puts("...")

nơi ...là những chương trình được liệt kê ở trên.

Chương trình thực tế của tôi thực sự in các chương trình này theo định dạng

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

Vô cùng nhiều lần và đối với các giá trị như ω, nó làm một cái gì đó giống với

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

Và do đó, điểm số của chương trình

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

là 1+some_ordinal, và điểm số của

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

là 1+some_ordinal+1, và điểm số của

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

là 1+some_ordinal+2.

Giải thích về các chức vụ:

f[a,n,b]làm giảm một thứ tự a.

Mỗi số tự nhiên giảm xuống số tự nhiên bên dưới nó.

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

[c,0,e]là sự kế thừa cvà nó luôn giảm xuống c.

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

[c,d,e] là một siêu phẫu thuật liên kết ngược, được giảm như sau:

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] là số thứ tự vô hạn đầu tiên (tương đương với ω) và giảm như sau:

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

[c] là thứ tự omega thứ c và giảm như sau:

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]là ψ _d (c) và giảm như sau:

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]về cơ bản là giống như [c,d,e], ngoại trừ nó liệt kê qua hoạt động [c]thay vì hoạt động kế nhiệm.

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 điểm

Một chương trình java tạo ra vô số chương trình Brainf ***, trong đó mỗi chương trình tạo ra cuối cùng là đầu ra.

Tại sao? Bởi vì tôi có thể.

Bất kỳ cải tiến nào cho phần thế hệ Brainf *** chắc chắn đều được hoan nghênh.

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

Biết chữ Haskell (GHC 7.10): ω² + 999686 điểm.

Điều này sẽ phục vụ như là một câu trả lời ví dụ. Vì đây là một ví dụ, nó chỉ có ý nghĩa khi sử dụng lập trình biết chữ . Nó sẽ không đạt điểm cao mặc dù. Birdies sẽ giảm điểm của tôi, nhưng oh tốt. Đầu tiên, hãy tạo một hàm trợ giúp s. Nếu x là một thứ tự, sx = x + 1, nhưng chúng tôi tìm thấy việc sử dụng bất ngờ của s.

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

Chức năng hiển thị may mắn làm tất cả các chuỗi vệ sinh cho chúng ta. Nó cũng đáng để tạo ra 0. Zero không phải là người kế thừa của bất cứ điều gì, nhưng s "" sẽ bằng "main = putStrLn" "", bằng 0.

> z=s""

Bây giờ chúng ta sẽ tạo một hàm lấy n và trả về ω * n.

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

Nó hoạt động bằng cách tạo * n bằng {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ...}. Q này là gì Tại sao, đó là lý do chúng tôi có một thẻ quine . q là các hàm trợ giúp ở trên cho đến nay.

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

Lưu ý rằng chỉ theo nhu cầu q, không phải bất kỳ người kế vị nào (s (o (n)), s (s (o (n)))), vì họ không cần các hàm trợ giúp (ngoại trừ gián tiếp từ o n.) Bây giờ chúng ta chỉ phải xuất tất cả ω * n cho n hữu hạn.

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

Chúng tôi đi đây. ω ^ 2 Chỉ sử dụng ký tự mã 314, tôi nhận phần thưởng cuối cùng là 999686, cho tôi số điểm cuối cùng là ω ^ 2 + 999686, ở dạng bình thường.

Bốn dòng đầu ra đầu tiên (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 điểm

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

Nó có thể tốt hơn, nhưng tôi trở nên quá lười biếng để gỡ lỗi và chứng minh các chức vụ lớn hơn.

Các chức vụ nhỏ hơn

#ω^ω^ω
#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 điểm

Nashorn là công cụ Javascript được tích hợp sẵn trong Java. Điều này cũng có thể hoạt động ở Rhino, nhưng tôi chưa thử nó ở đó.

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