İşlev AĞAÇ (k) ağaç T uzun dizinin uzunluğunu verir ₁ , T ₂ her köşe k renk, ağaç T biriyle etiketlenmiştir, ... _ı en ı köşelerinde yer alır, ve bir ağaç olan herhangi bir ağacın küçük sekansında takip edin.

TREE (1) = 1, örneğin T ₁ = (1).

Örneğin, T: AĞAÇ (2) 3 = ₁ = (1); T ₂ = (2)--(2); T ₃ = (2).

AĞAÇ (3) büyük bir sayıdır. Graham'ın sayısından bile büyük. İşiniz ondan daha büyük bir sayı çıkarmak !

Bu bir kod golfüdür, bu nedenle amaç, en kısa programı, TREE'den (3) (stdout'a) eşit veya daha büyük bir sayı belirleyen herhangi bir dilde yazmaktır.

• Giriş yapmanıza izin verilmiyor.
• Programınız sonunda sona ermelidir, ancak makinenin sonsuz belleği olduğunu varsayabilirsiniz.
• Dilinizin sayı türünün herhangi bir sonlu değeri tutabildiğini varsayabilir ancak bunun sizin dilinizde tam olarak nasıl çalıştığını açıklamanız gerekebilir (örneğin: bir şamandıra sonsuz hassasiyete sahip mi?)
  • Sonsuzluğa çıktı olarak izin verilmez.
  • Sayı türünün altına düşülmesi bir istisna atar. Etrafına sarılmaz.
• TREE (3) böylesine karmaşık bir sayı olduğundan, hızlı büyüyen hiyerarşi yaklaşımını f _{ϑ (Ω ^ω ω) +1} (3) _{' ^ü} yenmek için sayı olarak kullanabilirsiniz.
• Çözümünüzün geçerli olup olmadığını kontrol etmek için numaranızın neden bu kadar büyük ve kodunuzun eski bir sürümü olduğunu açıklamanız gerekir (çünkü TREE (3) ' i depolayacak kadar belleği olan bir bilgisayar olmadığı için )

Not: yanıtlardan hiçbiri şu anda bulunan buraya işi.

AĞAÇ (3) neden bu kadar büyük?

Yeni Yakut, 135 bayt, >> H _{ψ (φ 3 (Ω + 1))} (9)

nerede H Hardy hiyerarşidir, ψ Madore takımından OCF genişletilmiş bir versiyonudur (aşağıda açıklayacağız) ve φ Veblen işlevidir.

Çevrimiçi deneyin!

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: (işlevleri kullanarak, lambdas değil)

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

Madore'un genişletilmiş OCF'si:

Ve (kabaca) Veblen'in phi işlevi:

Ordinaller olmadan açıklama:

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]

Programım başlıyor k = 9, h = [[],9,9]. Daha sonra uygulanır k = k*kve h = f(h,k)kadar h == 0ve çıktılar k.

Ordinallerle açıklama:

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]

image '(ω ∙ α) ≈ ψ (α), yukarıdaki resimde açıklanan sıralı çöküş fonksiyonu.

Programım fazla veya daha az başlatır k = 9ve h = Ω(↑9)9sonra uygular k ← k²ve h ← h[k,h]kadar h = 1ve iadeler k.

Ve eğer bunu doğru yapsaydım [[],9,9], Bachmann-Howard sıralı ψ (Ω ^{Ω Ω ...} ) 'dan çok daha büyük, bu da ϑ (Ω ^ω ω) + 1'den daha büyük .

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

Eğer analizim doğruysa, o zaman ψ '(Ω ^Ω ∙ x) ~ = ψ * (Ω ^Ω ∙ x) olmalı , burada ψ * normal Madore psi fonksiyonudur. Bu durumda, benim sıra benim yaklaşık approximately * (φ ₃ (Ω + ω)).

Old Ruby, 309 bytes, H _{ψ ' 0 (Ω 9 )} (9) ( revizyon tarihine bakınız , yenisinin yanı sıra daha iyidir)

Haskell, 252 Bayt, AĞAÇ (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, Laikoni ve Ørjan Johansen'den yardım aldığınız için teşekkür ederiz!

HyperNeutrino tarafından önerildiği gibi , programım tam olarak TREE (3) +1 (TREE çıktığı hesaplanabilir) çıktısı veriyor.

T n cetiket cve düğümleri olan bir ağaçtır n. colmalı 1, 2ya da 3.

l tağaçtaki düğüm sayısıdır t.

t1 # t2bu durum geçerlidir t1homeomorphically içine gömer t2(dayanan burada Tanımı 4.4 ) ve aksi halde false.

a nAğaçların büyük bir listesini çıkarır. Tam liste önemli değil. Önemli özelliği olmasıdır a niçin her ağaca içeren ndüğümleri ile etiketlenmiş edilir, düğümler 1, 2ya 3ve belki biraz fazla ağaç yanı (ama bu diğer ağaçlar da etiketlenir 1, 2ya 3). Ayrıca sonlu bir liste çıktısı garantilidir.

s nTüm sekansları nağaçların uzunluğunu listeler , öyle ki bu sekansın tersi (geriye doğru yaptığımızdan) geçerli olur. Eğer nth elemanı (1'de saymaya başladığımız yerde) çoğu düğümde değilse ve homeomorfik olarak hiçbir ağaç bir sonrakine gömülmezse, bir dizi geçerlidir.

mainngeçerli bir uzunluk dizisi olmayacak şekilde en küçüğünü yazdırır n.

Yana TREE(3)en uzun geçerli dizisinin uzunluğu olarak tanımlanır, TREE(3)+1küçüğüdür nuzunluğunun hiçbir geçerli dizileri vardır böyle nneyi programım çıkışları olan.

Python 2, 194 bayt, ~ H _{ψ (Ω ^{Ω Ω} )} (9)

Burada H , Hardy hiyerarşisidir ve ψ , Pohlers tarafından tanımlanan Bachmann-Howard sırasının altındaki sıralı çöküş işlevidir.

Jonathan Frech'e -3 bayt için teşekkür ederiz.

def S (T): 0 döndürür T == 1else [S (T [0])] + T [1:]
def R (T): U = T [0]; V = T [1:]; exec "global B; B = T" * (T [-1] == 0); return [S (B)] + V eğer U == 1saç [R (U)] * c + V ise U ise V
A = [[[1,1], 1] 0]
c = 9
A: A = R (A); c * = c
c yazdır

Çevrimiçi deneyin!

Daha iyi aralıklı versiyon:

def S (T):
  eğer T == 1 başkası varsa 0 döndür [S (T [0])] + T [1:]

def R (T):
  U T = [0]
  V T = [1:]
  küresel B
  eğer T [-1] == 0 ise:
    B = T
  eğer U == 1 ise: 
    dönüş [S (B)] + V
  [R (U)] * c + V, eğer U V ise

A = [[[1,1], 1] 0]
c = 9
A ise:
  A = R (A)
  c * = C
c yazdır

Açıklama:

Bu program sadece 0 ve 1 etiketlerini kullanarak bir Buchholz hydra varyantı uygular . Temel olarak, her adımda, ağacın ilk yaprak düğümüne bakarız ve 0 veya 1 ile etiketlenmiş olup olmadığına bakarız.

- Eğer yaprak düğümü 0 ile etiketlenmişse, yaprak düğümünü sileriz ve daha sonra ağacı yaprak düğümünün ebeveyninden başlayarak c sayısını kopyalar, tüm düğümlerin yaprak büyüklüğüne bağlı olan tüm kopyaları.

- Yaprak düğümü 1 ile etiketlenmişse, 0 ile etiketlenmiş bir ata düğümüne ulaşana kadar köke doğru arama yaparız. S ata ata düğümünden başlayan ağaç olsun. Yaprak düğümüyle S 'nin S ile tekrar işaretlenmesini sağlayın. Yaprak düğümünü S' ile değiştirin.

Daha sonra kök düğümden başka hiçbir şey kalmayıncaya kadar işlemi tekrarlıyoruz.

Bu program normal Buchholz hydra prosedüründen iki şekilde ayrılır: İlk olarak, yukarıdaki prosedürü yaptıktan sonra, ağacı tekrar tutturur ve orijinal yaprak düğümünün her ata düğümü için yukarıda açıklanan 0 kopyalama prosedürünü yaparız. Bu, ağacın boyutunu arttırır, bu nedenle prosedürümüz normal Buchholz hydra'dan daha uzun sürecektir ve bu nedenle sonuçta daha büyük bir sayıya yol açacaktır; ancak, yeni ağaçla ilişkilendirilen sıra, eski ağaçtan daha az olacağından, hala sonlanacaktır. Diğer fark, c = 1 ile başlamak ve her seferinde 1 artırmak yerine, c = 9 ile başlıyoruz ve her seferinde kare alıyoruz, çünkü neden olmasın.

[[1,1], 1], 0] ağacı, ϑ (Ω ^ω ω) sırasından bigger (Ω ^{Ω Ω} ) değerine tekabül eder ve sonuç olarak H _ψ değerindeki son _{sayımıza karşılık gelir. (Ω ^{Ω Ω} )} (9) kesinlikle AĞACI (3) aşacak.

Ruby, 140 bayt, ~ H _{ψ (Ω ^{Ω Ω} )} (81)

Burada H , Hardy hiyerarşisidir ve ψ , burada tanımlandığı gibi, Bachmann-Howard sırasının altındaki standart sıra sıra çöküş işlevidir .

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

Çevrimiçi deneyin!

Ungolfed versiyonu:

def S (a)
  * v, u = a
  eğer a == 1 
    dönüş []
  Başka
    dönüş v + [S (u)]
  son
son  

def R (t)
  * v, u = t
  eğer t [0] == [] ise
    $ b = t
  son
  eğer = = 1 ise
    dönüş v + [S ($ b)]
  elsif u == []
    dönüş v
  Başka
    v + [R (u)] * $ c döndür
  son
son

$ c = 9

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

a! = [] yaparken
  $ c * = 9
  a = R (a)
son

$ c yazdır

Bu program benim Python 2 girişimde açıklandığı gibi [] ve 1'ler ile etiketlenmiş düğümlü Buchholz hydra'yı uygular.

Ağaç [[], [1, 1,1] []] karşılık sıra -y (Ω için ^{Ω Ω} sıra İçeride ISTV melerin RWMAIWi'nin önemli ölçüde daha büyük olan), (Ω ^co co) = ψ (Ω ^{Ω co co} ) ve bu nedenle sonuçta ortaya çıkan son sayı olan H _{ψ (Ω ^{Ω Ω} )} (81) AĞAÇ (3) değerini aşacaktır.

Julia, 569 bayt, Yükleyicinin Numarası

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

Kendimi bir parça ayak izi kurtarmak için, Loader.c'yi Julia'ya neredeyse bire bir ulaştırmaya ve yukarıdaki kod bloğuna sıkıştırmaya karar verdim. Karşılaştırmaları kendileri yapmak isteyenler için (puanlamamı doğrulamak ya da hataları bulmama ya da kodumu düzeltmeme yardım etmek için), ağartılmış bir versiyon aşağıdadır:

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

Daha önce sayım yok çünkü yaptığım agresif golf oyununda çok fazla byte yanlış sayımı yaptım.

JavaScript, 190B, H _{ψ (ε Ω + 1 )} (9) _{Bu analizden yola çıkarak}

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

Bu program, JavaScript'teki bu 225B Çift-sıralı sayı çevirisinin değiştirilmiş bir sürümüdür . Çift sıra numarası ve orijinal kodu için buraya bakın .

Yapılan değişiklikler:

• BASIC yerine JavaScript'te.
• Yineleme yok (f _{ψ (Ω ω +1)} -> f _{ψ (Ω ω )} )
• Sıra, ψ (ε _{Ω + 1} ) değerine karşılık gelen (0,0) (1,1) (2,2) 'dir . _{Bu Hardy-hiyerarşi sıralamasında}