47

फ़ंक्शन TREE (k) पेड़ों के सबसे लंबे अनुक्रम की लंबाई देता है T ₁ , T ₂ , ... जहां प्रत्येक शीर्ष को k के रंगों में से एक के साथ लेबल किया जाता है, पेड़ T में _मेरे पास अधिकांश i कोने हैं, और कोई भी पेड़ एक नहीं है अनुक्रम में किसी भी पेड़ के नाबालिग ।

TREE (1) = 1, उदाहरण के लिए T ₁ = (1)।

ट्रे (2) = 3: जैसे टी ₁ = (1); टी ₂ = (2)--(2); टी ₃ = (2)।

TREE (3) एक बड़ी संख्या है। ग्राहम की संख्या से भी बड़ा। आपका काम इससे भी बड़ी संख्या में उत्पादन करना है!

यह एक कोड-गोल्फ है इसलिए लक्ष्य किसी भी भाषा में सबसे छोटा प्रोग्राम लिखना है जो निर्धारित संख्या में TREE (3) (स्टडआउट के बराबर या उससे अधिक) को निर्धारित करता है।

आपको इनपुट लेने की अनुमति नहीं है।
आपका कार्यक्रम अंततः समाप्त होना चाहिए, लेकिन आप मान सकते हैं कि मशीन में अनंत स्मृति है।
आप मान सकते हैं कि आपकी भाषा का नंबर प्रकार किसी भी परिमित मूल्य को पकड़ सकता है, लेकिन यह समझाने की आवश्यकता है कि यह आपकी भाषा में कैसे कार्य करता है (उदाहरण: क्या एक फ्लोट में अनंत सटीकता है?)
- इनफिनिटी को आउटपुट के रूप में अनुमति नहीं है।
- एक संख्या प्रकार का अंडरफ्लो एक अपवाद फेंकता है। यह चारों ओर नहीं लपेटता है।
क्योंकि वृक्ष (3) इस तरह के एक जटिल संख्या है आप उपयोग कर सकते हैं तेजी से बढ़ रहा पदानुक्रम सन्निकटन च _{θ (Ω ^ω ω) +1} (3) ताल पर संख्या के रूप में।
आपको इस बात की व्याख्या प्रदान करने की आवश्यकता है कि आपका नंबर इतना बड़ा और आपके कोड का अनगुल्ड संस्करण यह जांचने के लिए है कि क्या आपका समाधान मान्य है (क्योंकि TREE (3) को संग्रहीत करने के लिए पर्याप्त मेमोरी वाला कोई कंप्यूटर नहीं है )

नोट: वर्तमान में यहाँ कोई भी उत्तर नहीं मिला है ।

TREE (3) इतना बड़ा क्यों है?

— PyRulez
स्रोत

9

@ स्टेफिन तुच्छ रूप से नहीं। ट्री (3) के लिए एक नए प्रतिमान की आवश्यकता है।

— 18

1

प्रासंगिक: codegolf.meta.stackexchange.com/questions/14057/…

— fejfo

11

TREE(3)+1वहां मैं जीतता हूं

— हाइपरनेत्रिनो

1

@Smarts आपको पता चलता है कि TREE (3) के करीब कोई भी उत्तर नहीं आता है?

— बस

2

@MDXF मैं कहने वाला हूं कि नहीं, क्योंकि INT_MAX का उपयोग करना एक धोखा है (अन्यथा, प्रिंट INT_MAX इंस्टा जीत जाएगा)। सामान्य तौर पर, किसी भी पर्याप्त बड़ी प्रणाली के लिए आपका आउटपुट समान होना चाहिए।

— PyRulez

38

नई रूबी, 135 बाइट्स, >> एच _{y (Ω ₃ () + 1))} (9)

जहां H , हार्डी पदानुक्रम है, ore मदोर के OCF का एक विस्तारित संस्करण है (नीचे समझाएगा) और len वेबल फ़ंक्शन है।

इसे ऑनलाइन आज़माएं!

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

अघोषित: (कार्यों का उपयोग करते हुए, लंबोदर नहीं)

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]Bachmann-हावर्ड क्रमसूचक ψ (Ω से जिस तरह से बड़ा है ^{Ω ^{Ω ^...}} ) है, जो θ से जिस तरह से बड़ा है (Ω ^ω ω) +1।

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

और अगर अपने विश्लेषण सही है, तो हम ψ होनी चाहिए '(Ω ^Ω ∙ एक्स) ~ = ψ * (Ω ^Ω ∙ x) है, जहां ψ * सामान्य Madore के साई कार्य है। यदि यह धारण करता है, तो मेरा क्रम लगभग φ * (Ω ₃ (ω +,)) है।

पुरानी रूबी, 309 बाइट्स, एच ₍_{' ₀ (( ₉ )} (9) ( संशोधन इतिहास देखें , इसके अलावा नया तरीका बेहतर है)

— सिंपल ब्यूटीफुल आर्ट
स्रोत

1

मैं केवल बहुत कम मूल्यों के लिए अपने कार्यक्रम का परीक्षण कर सकता था, इसलिए मुझे माफ करना अगर मैंने कहीं गलती की है।

— ब्यूटी आर्ट

1

Bleh, धीरे-धीरे लेकिन निश्चित रूप से मेरे रास्ते को सोचने और कुछ भी ठीक करने की कोशिश कर रहा हूं जिसे मैं गलत देखता हूं। :-( इतना थकाऊ।

— बस सुंदर कला

1

हम्म ... इसलिए $ f_ {ψ_0 ((9 (9))} (9) $ का मतलब है कि हमें कम से कम $ the_9 (9) $ th की जरूरत है, जो कि तेजी से बढ़ रहे पदानुक्रम के कमजोर कार्डिनल स्तर 9 के बेस $ 9 से बड़ा है। TREE (3) $

— गुप्त

1

@ नहीं, मैं सिर्फ एक बिट द्वारा ओवरशूट करना चाहता था, साथ ही TREE (3) के लिए एक करीब मूल्य पर काम करना मुझे बाहर लिखने के लिए अधिक बाइट्स खर्च करना होगा। और यहां कोई दुर्गम कार्डिनल का उपयोग नहीं किया जाता है।

— बस सुंदर कला

1

गोल्फ नाइटपिक्स: आप निश्चित रूप से गोल्फ कर सकते हैं a.class!=Array, सबसे मुहावरेदार है !a.is_a? Arrayलेकिन कम से कम मैं इसके बारे में सोच सकता हूं a!=[*a]। और विधियों को लंबोदर में परिवर्तित किया जा सकता है: f=->a,n=0,b=a{...}...f[x,y]कुछ पात्रों को बचाने के लिए और शायद प्रथम श्रेणी के ऑब्जेक्ट के रूप में उनका उपयोग करके रीफैक्टरिंग संभावनाओं को खोलना।

— हिस्टोक्रेट

23

हास्केल, 252 बाइट्स, ट्रे (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 और senrjan जोहानसन से मदद के लिए धन्यवाद!

जैसा कि 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 nnपेड़ों की सभी अनुक्रम लंबाई को सूचीबद्ध करता है , जैसे कि उस क्रम के विपरीत (क्योंकि हम इसे पीछे की ओर बनाते हैं) मान्य है। एक अनुक्रम वैध है यदि nth तत्व (जहां हम 1 पर गिनना शुरू करते हैं) में अधिकांश n नोड होते हैं, और कोई भी ट्री होमोमोर्फिक एक बाद में एम्बेड नहीं करता है।

mainसबसे छोटी को प्रिंट nकरता है ताकि लंबाई का कोई वैध क्रम न हो n।

चूंकि TREE(3)सबसे लंबे वैध अनुक्रम की लंबाई के रूप में परिभाषित किया गया है, TREE(3)+1इसलिए सबसे छोटा है nकि लंबाई के कोई वैध अनुक्रम नहीं हैं n, यही मेरा कार्यक्रम आउटपुट है।

— PyRulez
स्रोत

16

अजगर 2, 194 बाइट्स, ~ एच _{ψ (Ω ^{Ω ^Ω} )} (9)

जहां एच हार्डी पदानुक्रम है, और ψ Bachmann-हावर्ड नीचे क्रमसूचक गिर समारोह क्रमसूचक Pohlers द्वारा परिभाषित किया गया है।

-3 बाइट्स के लिए जोनाथन फ्रेच को धन्यवाद।

def S (T): 0if T == 1else [S (T [0])] + T [1] लौटाएं
def R (T): U = T [0]; V = T [1:]; "ग्लोबल B; B = T" *; (T [-1] == 0); वापसी [S (B)] + V यदि U == 1else [R (U)] * c + V यदि U और V
एक = [[[1,1], 1], 0]
ग = 9
जबकि ए: ए = आर (ए); सी * = सी
प्रिंट सी

इसे ऑनलाइन आज़माएं!

बेहतर स्थान दिया गया संस्करण:

डी एस (टी):
  वापसी 0 अगर टी == 1 और [एस (टी [0])] + टी [1:]

डी आर (टी):
  यू = टी [0]
  V = टी [1:]
  वैश्विक बी
  यदि T [-1] == 0:
    बी = टी
  यदि U == 1: 
    वापसी [एस (बी)] + वी
  वापसी [R (U)] * c + V यदि U और V हो

एक = [[[1,1], 1], 0]
ग = 9
जबकि एक:
  एक = आर (ए)
  ग * = ग
प्रिंट सी

स्पष्टीकरण:

यह कार्यक्रम Buchholz हाइड्रा के एक संस्करण को लागू करता है , प्रत्येक चरण में बस 0 और 1. के लेबल का उपयोग करते हुए, हम पेड़ के पहले पत्ते के नोड को देखते हैं, और देखें कि क्या इसे 0 या 1 के साथ लेबल किया गया है।

-अगर पत्ती का नोड 0 के साथ लेबल किया जाता है, तो हम लीफ नोड को हटा देते हैं, और फिर लीफ नोड के माता-पिता से शुरू होने वाले पेड़ की प्रतिलिपि बनाते हैं, सभी पत्ती नोड के दादा-दादी से जुड़ी प्रतियां।

-अगर पत्ती के नोड को 1 के साथ लेबल किया जाता है, तो हम रूट की ओर तब तक खोजते हैं जब तक कि हम पूर्वजों के नोड तक नहीं पहुंच जाते। 0. लेट एस उस पूर्वज नोड से शुरू होने वाला पेड़ हो। आज्ञा देना एस 'एस के साथ पत्ती नोड के साथ relabelled 0. बदलें पत्ती नोड एस के साथ बदलें'।

हम तब तक इस प्रक्रिया को दोहराते हैं जब तक हमारे पास रूट नोड के अलावा कुछ भी नहीं बचा है।

यह कार्यक्रम दो तरीकों से सामान्य बुचोलज़ हाइड्रा प्रक्रिया से भिन्न होता है: सबसे पहले, उपरोक्त प्रक्रिया करने के बाद, हम पेड़ को वापस ऊपर उठाते हैं, और मूल पत्ती नोड के प्रत्येक पूर्वज नोड के लिए ऊपर वर्णित लेबल 0 कॉपी प्रक्रिया करते हैं। यह पेड़ के आकार को बढ़ाता है, इसलिए हमारी प्रक्रिया सामान्य बुचोलज़ हाइड्रा की तुलना में अधिक समय लेगी, और इसलिए अंत में बड़ी संख्या में ले जाएगी; हालाँकि, यह अभी भी समाप्त हो जाएगा क्योंकि नए पेड़ के साथ जुड़े अध्यादेश अभी भी पुराने पेड़ से कम होंगे। दूसरा अंतर यह है कि सी = 1 से शुरू करने और प्रत्येक बार 1 बढ़ाने के बजाय, हम सी = 9 से शुरू करते हैं और इसे हर बार वर्ग करते हैं, क्योंकि क्यों नहीं।

पेड़ [[[1,1], 1], 0] क्रमसूचक ψ (Ω से मेल खाती है ^{Ω ^Ω} ) है, जो क्रमसूचक θ की तुलना में काफी बड़ा है (Ω ^ω ω), और इसलिए हमारे एच के बारे में की अंतिम संख्या जिसके परिणामस्वरूप _{ψ (Ω ^{Ω ^Ω} )} (9) निश्चित रूप से वृक्ष (3) से अधिक होगा।

— Deedlit
स्रोत

मेरे दोस्त को इतना गुदगुदाया नहीं :-)

— ब्यूटीफुल आर्ट

मुझे पता है। मुझे नहीं पता कि इसे और कैसे कम किया जाए, कम से कम पायथन में तो नहीं। शायद मैं कुछ रूबी सीखने की कोशिश कर सकता हूं।

— डीडलिट

क्या आर (टी) को एक लाइन पर रखना संभव है?

— बस खूबसूरत आर्ट

@SimplyBeautifulArt सबसे अधिक संभावना हां ( TIO लिंक ), हालांकि अप्रयुक्त।

— जोनाथन फ्रीच

@JonathanFrech आपकी मदद के लिए धन्यवाद! दुर्भाग्य से, जब मैंने आपके कोड की कोशिश की, तो यह एक त्रुटि संदेश दिया "वैश्विक बी परिभाषित नहीं है"। मुझे पता नहीं है कि यह एक त्रुटि देता है जबकि मूल कोड नहीं है, इसलिए मुझे नहीं पता कि इसे कैसे ठीक किया जाए।

— डीडलिट

6

रूबी, 140 बाइट्स, ~ एच _{ψ (Ω ^{Ω ^Ω} )} (81)

जहां एच है हार्डी पदानुक्रम , और ψ रूप में परिभाषित किया, मानक क्रमसूचक Bachmann-हावर्ड क्रमसूचक नीचे समारोह गिर है यहाँ ।

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

इसे ऑनलाइन आज़माएं!

Ungolfed संस्करण:

डी एस (ए)
  * वी, यू = ए
  अगर एक == १ 
    वापसी []
  अन्य
    वापसी v + [एस (यू)]
  समाप्त
समाप्त  

डी आर (टी)
  * वी, यू = टी
  अगर t [0] == []
    $ बी = टी
  समाप्त
  अगर यू == १
    वापसी v + [एस ($ बी)]
  elsif u == []
    वापसी v
  अन्य
    वापसी v + [आर (यू)] * $ सी
  समाप्त
समाप्त

$ c = 9

a = [[], [१, [११ ९]]]

जबकि (! []]
  $ c * = 9
  a = R (a)
समाप्त

$ c प्रिंट करें

यह कार्यक्रम मेरे [] पायथन 2 प्रविष्टि में वर्णित के रूप में [] के और 1 के साथ लेबल नोड्स के साथ बुचहोल हाइड्रा को लागू करता है।

पेड़ [[], [1, [1,1]]] क्रमसूचक ψ (Ω से मेल खाती है ^{Ω ^Ω} ) है, जो क्रमसूचक θ की तुलना में काफी बड़ा है (Ω ^ω ω) = ψ (Ω ^{Ω ^ω ω} ), और इसलिए हमारे एच के बारे में की अंतिम संख्या जिसके परिणामस्वरूप _{ψ (Ω ^{Ω ^Ω} )} (81) वृक्ष (3) से अधिक होगा।

— Deedlit
स्रोत

यह आप और आपके 149 बाइट्स खतरे।

— बस

लेकिन रूबी जीत के लिए: पी

— बस सुंदर कला

गोल्फ नाइटपिक: लिखने के बजाय u==0?v:u==[]?vआप लिख सकते हैं u==0?||u[0]?v, जो दो बाइट्स बचाता है।

— ब्यूटी आर्ट

@SimplyBeautifulArt मदद के लिए धन्यवाद! आपके दरबार में वापस आते हैं। : डी

— डिडलिट

2

D: <वह 1 बाइट अंतर हमारे बीच सबसे निराशाजनक बात है।

— बस सुंदर कला

6

जूलिया, 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))))))

अपने आप को थोड़ा लेगवर्क बचाने के लिए, मैंने लोडर को पोर्ट टू जूलिया को लगभग एक-एक करने का फैसला किया और इसे ऊपर दिए गए कोड के ब्लॉक में कॉम्पैक्ट किया। उन लोगों के लिए जो खुद की तुलना करना चाहते हैं (या तो मेरी स्कोरिंग को सत्यापित करने में या मुझे गलतियां ढूंढने में मदद करने के लिए या अपना कोड सुधारने के लिए), एक अनगॉल्फड संस्करण नीचे है:

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

पिछले कोई मायने नहीं रखता है क्योंकि मैंने जिस आक्रामक गोल्फिंग में काम किया है, उसमें बहुत से बाइट मिसकॉउट हैं।

— eaglgenes101
स्रोत

1

ओह प्रिय। एक जगह के इस पागलपन के अलावा 1 और।

— ब्यूटी आर्ट

1

इसके अलावा, जबकि मेरे पास इसका कोई सबूत नहीं है, मुझे लगता है कि D (D (D (99))) काफी बड़ा है। : | हो सकता है कि D (D (D (99)) काफी बड़ा हो।

— बस

1

अगर कोई यहाँ मेरी मदद करना चाहता है, तो हमले की अगली तार्किक योजना एक मैक्रो को कॉम्पैक्ट करने के लिए उत्पन्न करना है "(x = ¬)"% 2! = 0 "एकल-अक्षर मैक्रो में। खुद जूलिया मैक्रों का पता नहीं लगा सकते, इसलिए कोई और यहां इस्तेमाल कर सकता है।

— eaglgenes101

4

जावास्क्रिप्ट, 190 बी, एच _{ψ (ε _{1 + 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 जोड़ी-अनुक्रम संख्या अनुवाद का एक संशोधित संस्करण है । जोड़ी-अनुक्रम संख्या और उनके मूल कोड के लिए, यहां देखें ।

किए गए संशोधन:

यह BASIC के बजाय JavaScript में है।
कोई यात्रा (च _{ψ (Ω _ω +1)} -> च _{ψ (Ω _ω )} )
अनुक्रम (0,0) (1,1) (2,2) है, जो क्रमिक ((ε ) _{+ 1} ) से मेल खाता है । _{यह हार्डी-पदानुक्रम अध्यादेश में है}

— Naruyoko
स्रोत

TREE (3) से बड़ा एक गोल्फ

नई रूबी, 135 बाइट्स, >> एच y (Ω 3 () + 1)) (9)

पुरानी रूबी, 309 बाइट्स, एच ( ' 0 (( 9 ) (9) ( संशोधन इतिहास देखें , इसके अलावा नया तरीका बेहतर है)

हास्केल, 252 बाइट्स, ट्रे (3) +1

अजगर 2, 194 बाइट्स, ~ एच ψ (Ω Ω Ω ) (9)

रूबी, 140 बाइट्स, ~ एच ψ (Ω Ω Ω ) (81)

जूलिया, 569 बाइट्स, लोडर की संख्या

जावास्क्रिप्ट, 190 बी, एच ψ (ε 1 + 1 ) (9) इस विश्लेषण के आधार पर

नई रूबी, 135 बाइट्स, >> एच _{y (Ω ₃ () + 1))} (9)

पुरानी रूबी, 309 बाइट्स, एच ₍_{' ₀ (( ₉ )} (9) ( संशोधन इतिहास देखें , इसके अलावा नया तरीका बेहतर है)

अजगर 2, 194 बाइट्स, ~ एच _{ψ (Ω ^{Ω ^Ω} )} (9)

रूबी, 140 बाइट्स, ~ एच _{ψ (Ω ^{Ω ^Ω} )} (81)

जावास्क्रिप्ट, 190 बी, एच _{ψ (ε _{1 + 1} )} (9) _{इस विश्लेषण के}_{आधार पर}