Функция TREE (k) дает длину самой длинной последовательности деревьев T ₁ , T ₂ , ... где каждая вершина помечена одним из k цветов, дерево T _i имеет не более i вершин, и ни одно дерево не является несовершеннолетний любого дерева, следующего за ним в последовательности.

TREE (1) = 1, например, T ₁ = (1).

TREE (2) = 3: например, T ₁ = (1); Т ₂ = (2)--(2); Т ₃ = (2).

ДЕРЕВО (3) - это большое большое число. Даже больше, чем число Грэма. Ваша задача - вывести число, даже большее, чем оно!

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

• Вы не можете принимать участие.
• Ваша программа должна в конечном итоге завершиться, но вы можете предположить, что машина имеет бесконечную память.
• Вы можете предположить, что числовой тип вашего языка может содержать любое конечное значение, но вам нужно объяснить, как это точно работает в вашем языке (например: имеет ли плавание бесконечную точность?)
  • Бесконечности не допускаются как выходные данные.
  • Недостаток числового типа вызывает исключение. Это не обернуть вокруг.
• Поскольку TREE (3) является таким комплексным числом, вы можете использовать приближение быстро растущей иерархии f _{ϑ (Ω ^ω ω) +1} (3) в качестве числа, которое нужно разбить.
• Вам необходимо предоставить объяснение, почему ваш номер такой большой, и версию вашего кода, не содержащую заглавных букв, чтобы проверить, является ли ваше решение действительным (поскольку нет компьютера с достаточным объемом памяти для хранения TREE (3) )

Примечание: Ни один из ответов в настоящее время не найдено здесь работа.

Почему TREE (3) такой большой?

Новый Рубин, 135 байт, >> H _{ψ (φ 3 (Ω + 1))} (9)

где H - иерархия Харди, ψ - расширенная версия OCF Мадора (поясню ниже), а φ - функция Веблена.

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

f=->a,n,b=a{c,d,e=a;a==c ?a-1:e ?a==a-[0]?[[c,d,f[e,n,b]],d-1,c]:c:[n<1||c==0?n:[f[c||b,n-1]],n,n]};h=[],k=9,k;h=f[h,p(k*=k)]while h!=0

Ungolfed: (используя функции, а не лямбды)

def f(a,n,b)
  c,d,e = a
  if a == c
    return a-1
  elsif e
    if a == a-[0]
      return [[c,d,f(e,n,b)],d-1,c]
    else
      return c
    end
  else
    x = c || b
    if n < 1 || c == 0
      return [n,n,n]
    else
      return [f(x,n-1,x),n,n]
    end
  end
end

k = 9
h = [[],k,k]
while (h != 0) do
  k *= k
  p k
  h = f(h,k,h)
end

Расширенный OCF Мадора:

И (грубо) фи функции Веблена:

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

f(a,n,b) reduces an array recursively. (if no third argument given, it takes the first argument twice.)
f(k,n,b) = k-1, k is a positive int.
f([c,d,0],n,b) = f([c,0,e],n,b) = c
f([c,d,e],n,b) = [[c,d,f(e,n,b)],d-1,c], d ≠ -1 and c ≠ 0

f([a],0,b) = [0,0,0]
f([0],n,b) = [n,n,n]
f([],n,b) = f([b],n,b)
f([a],n,b) = [f[a,n-1,a],n,n]

Моя программа начинается k = 9, h = [[],9,9]. Затем применяется k = k*kи h = f(h,k)до h == 0и выходы k.

Пояснение с порядковыми номерами:

Ordinals follow the following representation: n, [], [a], [a,b,c], where n,d is a natural number and a,c are all ordinals.
x = Ord(y) if y is the syntactic version of x.
a[n,b] = Ord(f(a,n))
ω = Ord([0]) = Ord(f([a],-1,b))
n = Ord(n)
Ω = Ord([])
ψ'(a) = Ord([a])
ψ'(a)[n] = Ord(f([a],n))
φ(b,c) ≈ Ord([[0],b,c])
a(↓b)c = Ord([a,b,c]) (down-arrows/backwards associative hyper operators I designed just for ordinals)

We follow the following FS for our ordinals:
k[n,b] = k-1, k < ω
ω[n,b] = n(↓n)n
(a(↓b)0)[n,b] = (a(↓0)c)[n,b] = a
(a(↓b)c)[n,b] = (a(↓b)(c[n,b]))(↓b[n,b])a, b ≥ 0 and c > 0.
ψ'(a)[0,b] = 0(↓0)0
ψ'(a)[n,b] = (ψ'(a[n-1,a]))(↓n)ω, a > 0 and n ≥ 0. (also note that we've changed from [n,b] to [n,a].)
Ω[n,b] = ψ'(b)[n,b]

('(ω ∙ α) ≈ ψ (α), ординальная коллапсирующая функция, описанная на рисунке выше.

Моя программа более или менее запускается, k = 9а h = Ω(↑9)9затем применяется k ← k²и h ← h[k,h]до h = 1и возвращается k.

И поэтому, если я сделал это правильно, [[],9,9]он намного больше ординала Бахмана-Говарда ψ (Ω ^{Ω Ω ...} ), который намного больше, чем ϑ (Ω ^ω ω) +1.

ψ (Ω (↓ 9) 9)> ψ (Ω (↓ 4) 3)> ψ (Ω ^{Ω Ω} ) +1> ψ (Ω ^{Ω ω ω} ) +1> ϑ (Ω ^ω ω) +1

И если мой анализ верен, то мы должны иметь ψ ′ (Ω ^Ω ∙ x) ~ = ψ * (Ω ^Ω ∙ x), где ψ * - это нормальная функция Мадси Пси. Если это верно, то мой порядковый номер приблизительно равен ψ * (φ ₃ (Ω + ω)).

Старый Рубин, 309 байт, H _{ψ ' 0 (Ω 9 )} (9) (см. Историю изменений , кроме того, новый лучше)

Haskell, 252 байта, TREE (3) +1

data T=T[T]Int
l(T n _)=1+sum(l<$>n)
a@(T n c)#T m d=any(a#)m||c==d&&n!m
l@(x:t)!(y:u)=l!u||x#y&&t!u
x!_=null x
a n=do x<-[1..n];T<$>mapM(\_->a$n-1)[2..x]<*>[1..3]
s 0=[[]]
s n=[t:p|p<-s$n-1,t<-a n,(l t<=n)>any(#t)p]
main=print$[x|x<-[0..],null$s x]!!0

Спасибо за помощь от H.PWiz, Лайкони и Орьяна Йохансена за помощь в игре в гольф!

Как предполагает HyperNeutrino , моя программа выдает TREE (3) +1, точно (как оказалось, TREE вычислима).

T n cэто дерево с меткой cи узлами n. cдолжно быть 1, 2или 3.

l tэто количество узлов в дереве t.

t1 # t2Истинно, если t1гомеоморфно встраивается t2(в соответствии с определением 4.4 здесь ), и ложно в противном случае.

a nвыводит большой список деревьев. Точный список не важен. Важным свойством является то , что a nсодержит каждое дерево до nузлов, с узлами, меченным 1, 2, или 3, и , возможно , еще несколько деревьев , а также (но эти другие деревья также будут помечены 1, 2или 3). Также гарантированно выводится конечный список.

s nперечисляет все последовательности последовательностей nдеревьев, так что обратное (поскольку мы строим его в обратном порядке) этой последовательности является действительным. Последовательность действительна, если n-й элемент (где мы начинаем считать с 1) имеет не более n узлов, и ни одно дерево не гомеоморфно встраивается в более поздний.

mainвыводит наименьшее n, так что нет допустимых последовательностей длины n.

Так TREE(3)как определяется как длина самой длинной действительной последовательности, она TREE(3)+1является наименьшей n, так что нет допустимых последовательностей длины n, которые выводит моя программа.

Python 2, 194 байта, ~ H _{ψ (Ω ^{Ω Ω} )} (9)

где H - иерархия Харди, а ψ - ординальная коллапсирующая функция ниже ординала Бахмана-Говарда, определенного Полерсом.

Спасибо Джонатану Фреху за -3 байта.

def S (T): вернуть 0, если T == 1else [S (T [0])] + T [1:]
def R (T): U = T [0]; V = T [1:]; exec "global B; B = T" * (T [-1] == 0); возврат [S (B)] + V, если U == 1, еще [R (U)] * c + V, если U еще V
А = [[[1,1], 1], 0]
с = 9
в то время как A: A = R (A); c * = c
печать с

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

Лучше разнесенная версия:

def S (T):
  вернуть 0, если T == 1 else [S (T [0])] + T [1:]

def R (T):
  U = T [0]
  V = T [1:]
  глобальный B
  если T [-1] == 0:
    В = Т
  если U == 1: 
    возврат [S (B)] + V
  вернуть [R (U)] * c + V, если U еще V

А = [[[1,1], 1], 0]
с = 9
пока А:
  А = R (A)
  с * = с
печать с

Объяснение:

Эта программа реализует вариант гидры Бухгольца , используя только метки 0 и 1. По сути, на каждом шаге мы смотрим на первый листовой узел дерева и видим, помечен ли он 0 или 1.

-Если конечный узел помечен 0, то мы удаляем конечный узел, а затем копируем дерево, начиная с c родительского узла конечного узла, все копии, связанные с прародителем конечного узла.

-Если конечный узел помечен 1, то мы ищем обратно к корню, пока не достигнем узла предка, помеченного 0. Пусть S будет деревом, начинающимся с этого узла предка. Пусть S 'будет S с листовым узлом, перемаркированным с 0. Замените листовой узел на S'.

Затем мы повторяем процесс, пока у нас не останется ничего, кроме корневого узла.

Эта программа отличается от обычной процедуры гидра Бухгольца в двух отношениях: во-первых, после того, как мы выполним описанную выше процедуру, мы вернемся обратно в дерево и выполним процедуру копирования метки 0, описанную выше, для каждого узла-предка исходного листового узла. Это увеличивает размер дерева, поэтому наша процедура займет больше времени, чем обычная гидра Бухгольца, и, следовательно, приведет к большему числу в конце; тем не менее, он все равно завершится, потому что порядковый номер, связанный с новым деревом, будет все же меньше старого дерева. Другое отличие состоит в том, что вместо того, чтобы начинать с c = 1 и увеличивать 1 каждый раз, мы начинаем с c = 9 и возводим его в квадрат каждый раз, потому что почему бы и нет.

Дерево [[[1,1], 1], 0] соответствует порядковому ф (Ом ^{Ом Ом} ), что значительно больше , чем порядкового Q (Ом ^ш ш), и таким образом , наши в результате чего окончательное число около H _{ф (Ω ^{Ω Ω} )} (9) определенно превысит TREE (3).

Ruby, 140 байт, ~ H _{ψ (Ω ^{Ω Ω} )} (81)

где H - иерархия Харди , а ψ - стандартная порядковая коллапсирующая функция ниже ординала Бахмана-Говарда, как здесь определено .

s=->t{*v,u=t;t==1?[]:v<<s[u]}
r=->t{*v,u=t;$b=t[0][0]?$b:t;u==1?v<<s[$b]:u[0]?v+[r[u]]*$c:v}
$c=9
a=[],[1,[1,1]]
($c*=9;a=r[a])while a[0]
$c

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

Безголовая версия:

def S (a)
  * v, u = a
  если == 1 
    вернуть []
  еще
    вернуть v + [S (u)]
  конец
конец  

def R (t)
  * v, u = t
  если t [0] == []
    $ b = t
  конец
  если и == 1
    вернуть v + [S ($ b)]
  elsif u == []
    возврат v
  еще
    вернуть v + [R (u)] * $ c
  конец
конец

$ с = 9

a = [[], [1, [1,1]]]

пока! = [] сделать
  $ c * = 9
  a = R (a)
конец

печатать $ c

Эта программа реализует гидру Бухгольца с узлами, помеченными [] и 1, как описано в моей записи Python 2.

Дерево [[], [1, [1,1]]] соответствует ординалу ψ (Ω ^{Ω Ω} ), который значительно больше ординала inal (Ω ^ω ω) = ψ (Ω ^{Ω ω ω} ), и Таким образом, полученное нами окончательное число около H _{ψ (Ω ^{Ω Ω} )} (81) превысит TREE (3).

Юлия, 569 байт, номер загрузчика

r,/,a=0,div,0;¬x=x/2;r<s=r?s:0;y\x=y-~y<<x;+x=global r=(x%2!=0)<1+(+¬x);!x=¬x>>+x;√x=S(4,13,-4,x);S(v,y,c,t)=(!t;f=x=r;f!=2?f>2?f!=v?t-(f>v)%2*c:y:f\(S(v,y,c,!x)\S(v+2,t=√y,c,+x)):S(v,y,c,!x)$S(v,y,c,+x));y$x=!y!=1?5<<y\x:S(4,x,4,+r);D(x)=(c=0;t=7;u=14;while(x!=0&&D(x-1);(x=¬x)%2!=0)d=!!D(x);f=!r;x=!r;c==r<((!u!=0||!r!=f||(x=¬x)%2!=0)<(u=S(4,d,4,r);t=t$d);¬f&(x=¬x)%2!=0<(c=d\c;t=√t;u=√u));(c!=0&&(x=¬x)%2!=0)<(t=((~u&2|(x=¬x)%2!=0)<(u=1<<(!c\u)))\(!c\t);c=r);¬u&(x=¬x)%2!=0<(c=t\c;u=√t;t=9)end;global a=(t\(u\(x\c)))\a);D(D(D(D(D(BigInt(99))))))

Чтобы сэкономить немного усилий, я решил портировать Loader.c на Julia почти один к одному и сжать его в блок кода выше. Для тех, кто хочет делать сравнения самостоятельно (либо для проверки моего выигрыша, либо для того, чтобы помочь мне найти ошибки или улучшить мой код), ниже приведена версия без заглядывания:

r,/,a=0,div,0;
¬x=x/2;
r<s=r?s:0;
y\x=y-~y<<x;
+x=global r=(x%2!=0)<1+(+¬x);
!x=¬x>>+x;
√x=S(4,13,-4,x);
S(v,y,c,t)=(
    !t;
    f=x=r;
    f!=2?
        f>2?
            f!=v?
                t-(f>v)%2*c
                :y
            :f\(S(v,y,c,!x)\S(v+2,t=√y,c,+x))
        :S(v,y,c,!x)$S(v,y,c,+x)
);
y$x=!y!=1?5<<y\x:S(4,x,4,+r);
D(x)=(
    c=0;
    t=7;
    u=14;
    while(x!=0&&D(x-1);(x=¬x)%2!=0) 
        d=!!D(x);
        f=!r;
        x=!r;
        c==r<(
            (!u!=0||!r!=f||(x=¬x)%2!=0)<(
                u=S(4,d,4,r);
                t=t$d
            );
            ¬f&(x=¬x)%2!=0<(
                c=d\c;
                t=√t;
                u=√u
            )
        );
        (c!=0&&(x=¬x)%2!=0)<(
            t=((~u&2|(x=¬x)%2!=0)<(u=1<<(!c\u)))\(!c\t);
            c=r
        );
        ¬u&(x=¬x)%2!=0<(
            c=t\c;
            u=√t;
            t=9
        )
    end;
    global a=(t\(u\(x\c)))\a
);
D(D(D(D(D(BigInt(99))))))

Никаких предыдущих подсчетов, потому что в агрессивном гольфе я сделал слишком много ошибок в байтах.

JavaScript, 190B, H _{ψ (ε Ω + 1 )} (9) _{Основано на этом анализе}

A=[0,1,2];B=[0,1,2];for(F=C=9;F;F--){for(C++,G=0;G<=F;G++)(A[F]||A[F-G]<A[F]-H)&&(B[F]?(I=G,G=F):(H=A[F]-A[F-G],B[F-G]<B[F]&&(I=G,G=F)));for(J=0;J<C*I;J++)A[F]=A[F-I]+H,B[F]=B[F-I],F++;H=0}C

Эта программа является модифицированной версией перевода 225B с парным порядковым номером на JavaScript . Порядковый номер пары и их оригинальный код см. Здесь .

Сделанные изменения:

• Это в JavaScript вместо BASIC.
• Без итерации (f _{ψ (Ω ω +1)} -> f _{ψ (Ω ω )} )
• Последовательность (0,0) (1,1) (2,2), что соответствует порядковому номеру ψ (ε _{Ω + 1} ). _{Это в порядковой иерархии Харди}