Система порядковых чисел - это система с бесконечными числами. Много бесконечных чисел. Так много бесконечных чисел, что буквально не имеет бесконечности, чтобы представлять свою собственную бесконечность. Изображение выше дает небольшое представление о том, как они работают. Порядковый номер ( конструкция фон Неймана ) - это набор предыдущих порядковых чисел . Например, 0 - это пустой набор, 1 - это набор {0}, 2 - это набор {0, 1} и т. Д. Затем мы получаем ω, который равен {0, 1, 2, 3 ...}. ω + 1 равно {0, 1, 2, 3 ... ω}, ω, умноженное на два, равно {0, 1, 2 ... ω, ω + 1, ω + 2 ...}, и вы просто продолжаете что.

Ваша программа выведет набор порядковых чисел, например {0, 1, 4}. Тогда ваш счет будет наименьшим порядковым числом, чем все порядковые в вашем наборе. Для {0, 1, 4} оценка будет 5. Для {0, 1, 2 ...} оценка будет ω.

Как вы выводите свои порядковые номера вы спрашиваете. Код конечно. А именно, ваша программа выведет потенциально бесконечный список других программ в кавычках, по одной в каждой строке (используйте литеральную строку "\ n" для представления новых строк). Программа соответствует своей оценке, как указано выше. Например, если вы выводите

"A"
"B"
"C"

где A, B и C сами по себе являются действительными ответами и имеют оценки {0, 1, 4}, оценка вашей программы будет 5. Обратите внимание, что A, B и C должны быть полными программами, а не фрагментами.

Исходя из приведенных выше правил, программа, которая ничего не выводит, имеет оценку 0 (наименьший порядковый номер больше всех {} равен 0). Кроме того, помните, что набор не может содержать себя через аксиому основания . А именно, каждый набор (и, следовательно, порядковый номер) имеет путь до нуля. Это означает, что полная квинна будет недействительной, поскольку она не является набором.

Кроме того, ни одной программе не разрешен доступ к внешним ресурсам (собственный файл, Интернет и т. Д.). Кроме того , когда вы перечисляете ваш счет, положить Кантор нормальную форму партитуры рядом с ним , если он не в кантором нормальной форме уже, если вы можете (если нет, то кто - то другой может).

После учета всего вышесказанного фактический ответ, который вы публикуете, должен быть не более 1 000 000 байт (не считая комментариев). (Эта верхняя граница, скорее всего, вступит в действие только для автоматически сгенерированного кода). Кроме того, вы можете увеличивать свой счет за каждый байт, который вы не используете (поскольку мы имеем дело с бесконечностью, это, вероятно, будет учитываться только тогда, когда порядковые числа очень близки или одинаковы). Опять же, этот абзац применяется только к опубликованному ответу, а не к сгенерированным или сгенерированным, и так далее.

У него есть тег quine, поскольку может быть полезно сгенерировать хотя бы часть исходного кода для использования при создании больших порядковых чисел. Это ни в коем случае не требуется (например, для представления с оценкой 5, вероятно, не понадобится собственный исходный код).

Отработанный и аннотированный пример смотрите здесь .

Haskell: ψ (Ω ^{Ω ω} ) + 999672 баллов

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 байт кода с порядковым номером ψ (Ω ^{Ω ω} ) + 1. Используется древовидное представление ординалов, открытое Джервеллом (2005) . Дерево с детьми α , β ,…, γ обозначается α :@ (β :@ (… :@ (γ :@ Z)…)). Этот порядок слева направо согласуется с Джервеллом, хотя обратите внимание, что Мадор переворачивает его справа налево.

Haskell: Γ ₀ + 999777 баллов

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 байт коды с порядковым Г ₀ + 1. Это основан на обобщение Worm Беклемишева к порядковым многозначным элементам, которые сами по себе являются рекурсивно представлены червями.

Haskell: ε ₀ + 999853 очков

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 байт кода с порядковым е ₀ + 1. Это основано на Worm Беклемишев в . Список

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

представляет собой порядковый номер (ш & ^gamma + ⋯ + ш ^{& beta} ; + ш ^{& alpha} ; ) - 1. Таким образом, выходы второго уровня [0], [1], [2], [3], ... представляют собой 1, ш, ш ^ш , ш ^{ш ш} , ..., выходной сигнал первого уровня представляет е ₀ , и исходная программа представляет ε ₀ + 1.

Haskell: ε ₀ + 999807 очков

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 байта кода с порядковым номером ₀ + 1.

Zпредставляет 0, и мы можем доказать посредством трансфинитной индукции по α , а затем по β , что α :@ β≥ ω ^α + β . Таким образом, выходы второго уровня, по крайней мере, такие же большие, как и любая вышка ω ^{ω ⋰ ω} , что означает, что выход первого уровня составляет по крайней мере ε _0, а начальная программа - по крайней мере ε ₀ + 1.

Рубин, ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} ))} (0)) + 999663 баллов

Предполагая, что я правильно понимаю свою программу, мой результат равен ψ ₀ (ψ _{X (ψ M + 1 (Ω M + 1 ^{Ω M + 1} ))} (0)) + 999663 баллов, где ψ - ординальная коллапсирующая функция, X - chi функция (коллапсирующая функция Мало), а М - первый «ординал» Мало.

Эта программа является расширением той, которую я написал для Golf, на число больше, чем TREE (3), и пока полностью превосходит все остальные решения, представленные здесь.

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

Попробуйте онлайн!

Рубин, ψ ₀ (ψ _I (I ^I )) + 999674 очка

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

Попробуйте онлайн! (предупреждение: ничего не выйдет, поскольку явно (0..1.0/0).map{...}не может завершиться. Так я печатаю бесконечно много программ.)

Рубин, ψ ₀ (ψ _I (0)) + 999697 баллов

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

Попробуйте онлайн!

Более разумная тестовая программа, которая реализует (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]}\")")}

Попробуйте онлайн!

К сожалению, даже в этом случае (1..1).map{...}вы обнаружите, что эта программа чрезвычайно интенсивно использует память. Я имею в виду, длина вывода превышает такие вещи, как SCG (13).

Используя более простую программу, мы можем рассмотреть несколько значений:

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

Попробуйте онлайн!

Он в основном печатает одну и ту же программу несколько раз, в формате:

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

где инициализированные xзаписи - порядковый номер, к которому относится программа, и "..."удержания программ после xсокращения. Если x==0, то печатает

p

это программа, которая ничего не печатает с нулевым счетом, следовательно,

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

имеет оценку 1, и

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

имеет оценку 2, и

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

имеет 3 балла и т. д., и моя оригинальная программа печатает эти программы в формате

puts("...")

где ...программы, перечисленные выше.

Моя настоящая программа на самом деле печатает эти программы в формате

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

Бесконечно много раз, и для таких ценностей, как ω, он делает что-то похожее на

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

И, таким образом, оценка программы

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

есть 1+some_ordinal, и оценка

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

есть 1+some_ordinal+1, и оценка

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

есть 1+some_ordinal+2.

Объяснение ординалов:

f[a,n,b]уменьшает порядковый номер a.

Каждое натуральное число сводится к натуральному числу под ним.

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

[c,0,e]является преемником c, и это всегда сводится к c.

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

[c,d,e] является обратной ассоциативной гипероперацией, сводится к следующему:

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] является первым бесконечным порядковым числом (эквивалентным ω) и уменьшается следующим образом:

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

[c] порядковый номер омега ом и сокращается следующим образом:

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]ψ _d (c) и уменьшает следующим образом:

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]в основном такой же, как [c,d,e], за исключением того, что перечисляет операцию [c]вместо операции -преемника.

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 баллов

Java-программа, которая производит бесконечно много программ Brainf ***, каждая из которых выдает последнюю в качестве вывода.

Зачем? Потому что я могу.

Любые улучшения в части поколения Brainf ***, безусловно, приветствуются.

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

Грамотный Хаскелл (GHC 7.10): ω² + 999686 баллов.

Это послужит примером ответа. Поскольку это пример, имеет смысл использовать только грамотное программирование . Это не будет хорошо, хотя. Птички уменьшат мой счет, ну да ладно. Во-первых, давайте сделаем вспомогательную функцию s. Если x - ординал, sx = x + 1, но мы находим неожиданное использование s.

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

К счастью, функция show выполняет всю очистку строк. Также стоит сделать 0. Ноль не является преемником чего-либо, но s "" будет равно "main = putStrLn" "", что равно 0.

> z=s""

Теперь мы сделаем функцию, которая принимает n и возвращает ω * n.

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

Это работает, делая ω * n с помощью {ω * (n-1), ω * (n-1) +1, ω * (n-1) +2, ...}. Что это за д? Почему, это причина, по которой у нас есть тег quine . q вышеупомянутые вспомогательные функции до сих пор.

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

Обратите внимание, что только по потребностям q, а не по любому из его преемников (s (o (n)), s (s (o (n)))), так как им не нужны вспомогательные функции (кроме косвенно из o n.) Теперь нам нужно вывести только ω * n для конечного n.

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

Вот и мы. ω ^ 2 Используя только 314 кодовых символов, я требую окончательный бонус 999686, что дает мне окончательный результат ω ^ 2 + 999686, который уже находится в обычной форме кантора.

Первые четыре строки вывода (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 баллов

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

Возможно, это может быть и лучше, но мне стало лень отлаживать и доказывать большие порядковые числа.

Меньшие ординалы

#ω^ω^ω
#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 (Нашорн), ω2 + 999807 баллов

Nashorn - это движок Javascript, встроенный в Java. Это может также работать в Rhino, но я еще не проверял это в этом.

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