BigNum Bakeoff Reboot

12

Beberapa dari Anda mungkin akrab dengan BigNum Bakeoff , yang berakhir dengan cukup menarik. Tujuannya kurang lebih dapat diringkas sebagai menulis program C yang outputnya akan menjadi yang terbesar, di bawah beberapa kendala dan kondisi teoritis misalnya komputer yang dapat menjalankan program.

Dengan semangat yang sama, saya mengajukan tantangan serupa yang terbuka untuk semua bahasa. Syaratnya adalah:

  • Maksimum 512 byte .

  • Hasil akhir harus dicetak ke STDOUT. Ini skor kamu. Jika beberapa bilangan bulat dicetak, mereka akan digabungkan.

  • Output harus berupa bilangan bulat. (Catatan: Infinity bukan bilangan bulat .)

  • Tidak ada konstanta bawaan yang lebih besar dari 10, tetapi angka / digit baik-baik saja (mis. Konstanta Avogadro (sebagai konstanta bawaan) tidak valid, tetapi 10.000 tidak.)

  • Program harus diakhiri ketika sumber daya yang disediakan cukup untuk dijalankan.

  • Hasil cetak harus deterministik ketika disediakan sumber daya yang cukup untuk dijalankan.

  • Anda diberikan bilangan bulat atau bigint yang cukup besar untuk dijalankan oleh program Anda. Misalnya, jika program Anda mengharuskan penerapan operasi dasar ke angka yang lebih kecil dari 10 1.000.000 , maka Anda dapat menganggap komputer yang menjalankan ini dapat menangani angka setidaknya hingga 10 1.000.000 . (Catatan: Program Anda juga dapat dijalankan pada komputer yang menangani angka hingga 10 2.000.000 , jadi hanya memanggil bilangan bulat maksimum yang dapat ditangani komputer tidak akan menghasilkan hasil yang deterministik.)

  • Anda diberikan daya komputasi yang cukup untuk program Anda untuk menyelesaikan eksekusi dalam waktu kurang dari 5 detik. (Jadi jangan khawatir jika program Anda telah berjalan selama satu jam di komputer Anda dan tidak akan selesai dalam waktu dekat.)

  • Tidak ada sumber daya eksternal, jadi jangan berpikir untuk mengimpor fungsi Ackermann kecuali itu built-in.

Semua benda ajaib dipinjam sementara dari dewa yang murah hati.

Sangat besar dengan batas yang tidak diketahui

di mana B³F adalah ordinal Gereja-Kleene dengan urutan mendasar

B³F[n] = B³F(n), the Busy Beaver BrainF*** variant
B³F[x] = x, ω ≤ x < B³F

Papan peringkat:

  1. Seni Cukup Cantik , Ruby f ψ 0 (X (Ω M + X (Ω M + 1 Ω M + 1 ) ))) + 29 (9 9 9 )

  2. Steven H , Pyth f ψ (Ω Ω ) + ω² + 183 (256 27! )

  3. Leaky Nun , Python 3 f ε 0 (9 9 9 )

  4. fejfo , Python 3 f ω ω 6 (f ω ω 5 (9e999))

  5. Steven H , Python 3 f ω ω + ω² (9 9 9 99 )

  6. Simply Beautiful Art , Ruby f ω + 35 (9 9 99 )

  7. i .. , Python 2 , f 3 (f 3 (141))

Beberapa catatan:

Jika kami tidak dapat memverifikasi skor Anda, kami tidak dapat meletakkannya di papan peringkat. Jadi, Anda mungkin ingin sedikit menjelaskan program Anda.

Demikian juga, jika Anda tidak mengerti seberapa besar angka Anda, jelaskan program Anda dan kami akan mencoba menyelesaikannya.

Jika Anda menggunakan jenis program Loader , saya akan menempatkan Anda dalam kategori terpisah yang disebut "Sangat besar dengan batas tidak diketahui" , karena nomor Loader tidak memiliki batas atas non-sepele dalam hal hierarki yang tumbuh cepat untuk ' urutan dasar standar '.

Angka akan diberi peringkat melalui hierarki yang tumbuh cepat .

Bagi mereka yang ingin belajar bagaimana menggunakan hierarki yang tumbuh cepat untuk memperkirakan jumlah yang sangat besar, saya hosting server Discord hanya untuk itu. Ada juga ruang obrolan: Ordinality .

Tantangan serupa:

Nomor Terbesar yang Dapat Dicetak

Golf angka lebih besar dari TREE (3)

Program terminasi terpendek yang ukuran outputnya melebihi angka Graham

Bagi mereka yang ingin melihat beberapa program sederhana yang menghasilkan hierarki yang tumbuh cepat untuk nilai-nilai kecil, inilah mereka:

Ruby: hierarki yang tumbuh cepat

#f_0:
f=->n{n+=1}

#f_1:
f=->n{n.times{n+=1};n}

#f_2:
f=->n{n.times{n.times{n+=1}};n}

#f_3:
f=->n{n.times{n.times{n.times{n+=1}}};n}

#f_ω:
f=->n{eval("n.times{"*n+"n+=1"+"}"*n);n}

#f_(ω+1):
f=->n{n.times{eval("n.times{"*n+"n+=1"+"}"*n)};n}

#f_(ω+2):
f=->n{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}};n}

#f_(ω+3):
f=->n{n.times{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}}};n}

#f_(ω∙2) = f_(ω+ω):
f=->n{eval("n.times{"*n+"eval(\"n.times{\"*n+\"n+=1\"+\"}\"*n)"+"}"*n);n}

dll.

Untuk beralih dari f_xke f_(x+1), kami menambahkan satu loop dari n.times{...}.

Kalau tidak, kita mendiagonalisasi terhadap semua contoh sebelumnya

f_ω(1) = f_1(1)
f_ω(2) = f_2(2)
f_ω(3) = f_3(3)

f_(ω+ω)(1) = f_(ω+1)(1)
f_(ω+ω)(2) = f_(ω+2)(2)
f_(ω+ω)(3) = f_(ω+3)(3)

dll.

Seni Cukup Indah
sumber
Apakah angka dihitung sebagai konstanta bawaan?
PyRulez
3
@CloseVoters Bagaimana ini bisa terlalu luas ... Ya, meminta pengguna untuk mengeluarkan satu nomor dalam jumlah yang tak terhingga tidak sama dengan meminta pengguna untuk memilih salah satu dari banyak tugas yang tak terbatas untuk dilakukan. Agar adil pertanyaan ini meminta pengguna untuk melakukan hal yang sama juga. 4 suara tutup sudah terlalu luas ...
user202729
1
@ Οurous Ya, Anda mungkin menganggap itu. Tetapi sadari bahwa ketika program Anda diberi lebih banyak sumber daya, termasuk perhitungan yang lebih cepat, hasilnya tetap harus deterministik.
Simply Beautiful Art
1
Saya menyatakan di bagian komentar lain mengapa saya pikir fungsi Brainfuck Busy Beaver yang dibatasi akan menjadi eksponensial, tetapi saya ingin menambahkan bahwa secara umum, saya tidak berpikir ordinal Church-Kleene akan menjadi level yang sesuai untuk setiap program komputer . Fungsi yang dapat dikodekan dengan program dapat dihitung, dan karenanya harus jatuh ke dalam fungsi rekursif yang terbukti dari beberapa teori suara rekursif yang cukup kuat. Teori itu akan memiliki bukti teoretis bukti rekursif, dan fungsi itu akan berada di bawah ordinal dalam FGH, dengan asumsi urutan fundamental yang masuk akal.
Deedlit
1
Tentu saja fungsi Sibuk Berang-berang yang sebenarnya tidak dapat dikodekan ke dalam program (selain bahasa hiperkomputasi), dan fungsi Sibuk Berang yang dapat diprogram harus karena kebutuhan pertumbuhannya jauh lebih lambat.
Deedlit

Jawaban:

7

Ruby, f ψ 0 (X (Ω M + X (Ω M + 1 Ω M + 1 ) ))) + 29 (9 9 9 )

di mana M adalah 'ordinal' Mahlo pertama, X adalah fungsi chi (fungsi Mahlo runtuh), dan ψ adalah fungsi runtuh ordinal.

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,c==-1?[]:d==0?n:[f[d,n,b,t]]]};(x=9**9**9).times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{h=[];x.times{h=[h,h,h]};h=[[-1,1,[h]]];h=f[h,p x*=x]until h!=0}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

Cobalah online!

Rincian Kode:

f=->a,n,b=a,q=n{          # Declare function
                c,d,e=a;          # If a is an integer, c=a and d,e=nil. If a is an array, a=[c,d,e].compact, and c,d,e will become nil if there aren't enough elements in a (e.g. a=[1] #=> c=1,d=e=nil).
                        !c ?[q]:          # If c is nil, return [q], else
                                a==c ?a-1:          # If a==c, return a-1, else
                                          e==0||e&&d==0?c:          # If e==0 or e is not nil and d==0, return c, else
                                                          e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:          # If e is not nil, return an array inside an array, else
                                                                                             n<1?9:          # If n<1, return 9, else
                                                                                                   !d ?[f[b,n-1],c]:          # If d is nil, return [f[b,n-1],c], else
                                                                                                                    c==0?n:          # If c==0, return n, else
                                                                                                                           [t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]          # t=[f[c,n],d]. If c==-1, return [t,n,[]], else if d==0, return [t,n,n], else return [t,n,[f[d,n,b,t]]].
                                                                                                                                                                        };          # End of function
                                                                                                                                                                          (x=9**9**9)          # Declare x
                                                                                                                                                                                     x.times{...}          # Looped within 33 x.times{...} loops
                                                                                                                                                                                                 h=[];          # Declare h
                                                                                                                                                                                                      x.times{h=[h,h,h]};          # Nest h=[h,h,h] x times
                                                                                                                                                                                                                         h=f[h,p x*=x]          # Apply x*=x, print x, then h=f[h,x]
                                                                                                                                                                                                                                      until h==0          # Repeat previous line until h==0

Rincian Matematika:

fmengurangi aberdasarkan n,b,q.

Ide dasarnya adalah membuat sarang yang sangat bersarang adan menguranginya berulang kali hingga berkurang menjadi a=0. Untuk kesederhanaan, biarkan

g[0,n]=n
g[a,n]=g[f[a,n],n+1]

Untuk saat ini, mari kita khawatirkan saja n.

Untuk bilangan bulat apa pun k, kami dapat f[k,n]=k-1, sehingga kami dapat melihatnya

g[k,n]=n+k

Kami kemudian memiliki, untuk setiap d, f[[0,d],n]=nsehingga kita dapat melihat bahwa

g[[0,d],n]
= g[f[[0,d],n],n+1]
= g[n,n+1]
= n+n+1

Kami kemudian memiliki, untuk setiap c,d,e, f[[c,0,e],n]=f[[c,d,0],n]=c. Sebagai contoh,

g[[[0,d],0,e],n]
= g[f[[[0,d],0,e]],n+1]
= g[[0,d],n+1]
= (n+1)+(n+1)+1
= 2n+3

Kami kemudian memiliki, untuk apa pun c,d,eyang tidak termasuk dalam kasus sebelumnya f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e],. Di sinilah mulai rumit. Beberapa contoh:

g[[[0,d],1,1],n]
= g[f[[[0,d],1,1],n],n+1]
= g[[[0,d],1,0],0,[0,d]],n+1]
= g[f[[[0,d],1,0],0,[0,d]],n+1],n+2]
= g[[[0,d],1,0],n+2]
= g[f[[[0,d],1,0],n+2],n+3]
= g[[0,d],n+3]
= (n+3)+(n+3)+1
= 2n+7

#=> Generally g[[[0,d],1,k],n] = 2n+4k+3

g[[[0,d],2,1],n]
= g[f[[[0,d],2,1],n],n+1]
= g[[[[0,d],2,0],1,[0,d]],n+1]
= g[f[[[[0,d],2,0],1,[0,d]],n+1],n+2]
= g[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2]
= g[f[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2],n+3]
= g[[[[0,d],2,0],1,n+1],n+3]
= ...
= g[[[0,d],2,0],3n+6]
= g[f[[[0,d],2,0],2n+6],3n+7]
= g[[0,d],3n+7]
= (3n+7)+(3n+7)+1
= 6n+15

Dengan cepat landai dari sana. Beberapa tempat menarik:

g[[[0,d],3,[0,d]],n] ≈ Ack(n,n), the Ackermann function
g[[[0,d],3,[[0,d],0,0]],63] ≈ Graham's number
g[[[0,d],5,[0,d]],n] ≈ G(2^^n), where 2^^n = n applications of 2^x, and G(x) is the length of the Goodstein sequence starting at x.

Akhirnya memperkenalkan lebih banyak argumen ffungsi serta lebih banyak kasus untuk array memungkinkan kita untuk melampaui sebagian besar notasi yang dapat dihitung. Beberapa yang sangat dikenal:

g[[[0],3,[0,d]],n] ≈ tree(n), the weak tree function
g[[[[0],3,[0,d]],2,[0,d]],n] ≈ TREE(n), the more well-known TREE function
g[[[[0,d]],5,[0,d]],n] >≈ SCG(n), sub-cubic graph numbers
g[[[0]],n] ≈ S(n), Chris Bird's S function
Seni Cukup Indah
sumber
1
Penjelasan biasa?
CalculatorFeline
Apakah ini nomor terbesar yang Anda tetapkan? Tampaknya begitu!
ThePlasmaRailgun
3

Pyth, f ψ (Ω Ω ) + ω 2 +183 (~ 256 27! )

=QC`.pGL&=^QQ?+Ibt]0?htb?eb[Xb2yeby@b1hb)hbXb2yeb@,tb&bQ<b1=Y_1VQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQ.v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Qs["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q\YuyFYHpQ)

Membutuhkan input yang tidak kosong, tetapi nilainya tidak digunakan.

Penjelasan (untuk versi baru dan benar-benar skor ):

=QC`.pG                   Sets the value of the autofill variable to app. 256^27!  
                                  27! ~= the number of characters in the string
                                  containing all permutations of the alphabet. 
                                  We interpret that string as a base-256 number.
       L                  Define a function y(b,global Q):
        &=^QQ             Set Q to Q^Q and:
        ?+Ibt]0           If (?) the variable (b) is (I)nvariant on (+)adding itself
                             to the empty array (i.e. if it's an array itself):
               ?htb        If the second element of b is not 0:
                   ?eb         If the last element is not 0
                       [Xb2yeby@b1hG)   return [b with its last element replaced with y(b[-1]), y(b[1]), b[0]]
                     hb                 else return b[0]
                 Xb2yeb     else return b with its last element replaced with y(b[-1])
           @,tb&bQ<b1      If b isn't an array,return:
                               either b-1 if it's a standard ordinal (1 or more)
                               or Q if b is ω
                               or 0 if b is 0
 =Y_1                          Set the global variable Y to -1 (representing ω)
 VQ                        Q times, do (the rest of the explanation):
  VQVQ....VQ               Iterate from 0 to Q-1 183 times, each subiteration
                              reading the most recent value of Q when it starts:
  .v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Q
                            Iterate from 0 to Q-1 Q times, each subiteration 
                               reading the most recent value of Q when it starts:                        
 s["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q
                             Y = [Y,Y,Y] Q times, stacking with previous iterations.
 uyFYHpQ)                    Run y_x(Y) for x incrementing until y_(x-1)(Y)=0

Sangat sulit bagi saya untuk menghitung ukuran ini, terutama karena ini sudah sore dan saya tidak terlalu akrab dengan hierarki yang tumbuh cepat atau bagaimana saya akan mencoba mencari tahu berapa kali Q melewati y()alat pemeras. Sementara saya sekarang tahu lebih banyak tentang tata cara, saya masih tidak tahu bagaimana menghitung nilai tata cara yang diwakili oleh definisi rekursif dalam program saya. Saya akan bergabung dengan server Discord, tapi itu dengan nama samaran saya lebih suka tidak dihubungkan dengan nama asli saya.

Sayangnya, karena saya tahu sedikit tentang kata hierarki yang tumbuh cepat, saya mungkin sudah kehilangan jawaban Ruby. Sulit bagi saya untuk mengatakannya. Saya mungkin telah mengalahkan jawaban Ruby, tetapi saya tidak 100% yakin. ¯ \ _ (ツ) _ / ¯

Steven H.
sumber
Jika saya mengerti benar, skor Anda mungkin di suatu tempat di stadion baseball 27^^^27^^27^^4, atau f<sub>4</sub>(27^^27^^4)) ≈ f<sub>4</sub>(f<sub>3</sub>(f<sub>3</sub>(19))).
Simply Beautiful Art
Saya membuat perubahan kecil yang seharusnya saya pikirkan kemarin, tetapi entah bagaimana tidak - membuat yoperasi untuk diulang y(Q-1)alih-alih beroperasi hanya pada Q. Bagaimana hal ini memengaruhi skor?
Steven H.
1
Saya tidak sepenuhnya yakin apa yang terjadi. Apakah y(Q) = L(y(Q-1)), per se?
Simply Beautiful Art
1
Saya pikir kita akan lebih beruntung melakukan ini di chatroom .
Steven H.
@SimplyBeautifulArt Mungkin sebaiknya tidak menggunakan notasi hierarki yang tumbuh cepat untuk ini, karena jenisnya kecil.
PyRulez
3

Pyth, f 3 + σ -1 + ω 2 (256 26 )

Di mana σ m [n] adalah fungsi Sibuk Berang Σ dari urutan yang mdipanggil n: σ m [n] = Σ m (n). Perintahnya -1adalah untuk menunjukkan bahwa Berang-berang Sibuk di sini tidak dipanggil pada Mesin Turing yang sebenarnya, melainkan perkiraan dengan pita pembungkus Qelemen yang terbatas . Ini memungkinkan masalah penghentian untuk dipecahkan untuk program-program ini.

=QCGM.x-Hlhf!-/T4/T5.__<GH0M.x+Hlhf!-/T4/T5._>GHlGL=.<QC`m.uX@[XN2%h@N2l@N1XN2%t@N2l@N1XN1X@N1@N2%h@@N1@N2l@N1XN1X@N1@N2%t@@N1@N2l@N1XW!@@N1@N2N2nFKtPNXW@@N1@N2N2gFK)@hNeN3%heNlhNd)bLym*F[]d^UQQUQUld)^U6QJ"s*].v*\mQ"
.v+PPPP*JQ"+*\mQ\'

TL; DR adalah bahwa ini menciptakan semua kemungkinan program BrainF ** k panjang Q, menjalankannya dalam lingkungan di mana nilai maksimum bilangan bulat adalah Q dan panjang pita adalah Q, dan mengkompilasi semua status dari operasi ini bersama-sama untuk tambahkan (itu adalah 3+) ke Q, ulangi di atas pada skala f ω 2 .

Saya masih memiliki ~ setengah karakter untuk dikerjakan jika saya ingin melakukan sesuatu yang lebih, tetapi sampai kita mengetahui di mana ini saya akan membiarkannya apa adanya.

Steven H.
sumber
Saya membuat penjelasan yang lebih baik tentang σ di leaderboard,
Simply Beautiful Art
4
Bagiku itu tidak terlihat seperti fungsi Sibuk Berang yang sedang tumbuh cepat. Dengan batas bilangan bulat Q antara 0 dan Q, hanya ada (Q + 1) ^ Q kemungkinan kaset, dan Q kemungkinan posisi dalam program, sehingga paling banyak Q * (Q + 1) ^ Q kemungkinan menyatakan program yang sedang berjalan. Jadi suatu program harus berhenti dalam Q * (Q + 1) ^ Q langkah atau tidak sama sekali. Jumlah program yang mungkin juga dibatasi oleh batas atas eksponensial. Jadi bagi saya sepertinya fungsi Beaver yang Sibuk ini memiliki batas atas yang eksponensial, dan fungsi terakhir akan berada di urutan $ f _ {\ omega ^ 2} $.
Deedlit
2

python, f 3 (f 3 (141)), 512 byte

import math
def f(x):
    return math.factorial(x)  
x=9
for j in range(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(x))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))):
    x=f(x)
print x

Ini sebenarnya bukan jawaban yang valid, tetapi saya tetap ingin mempostingnya. Ikhtisar cepat:

import math # imports the factorial function
def f(x):
    return math.factorial(x) # shortens the factorial operation
x=9 # sets x to highest available number
for j in range(f(...f(x)...)): # repeats * A LOT *
    x=f(x) # does the factorial of x
print x # outputs the result

Lagi pula, saya tidak tahu apakah jawaban ini secara teknis sah, tetapi menyenangkan untuk menulis. Jangan ragu untuk mengedit kesalahan yang Anda temukan dalam kode.

saya..
sumber
Saya pikir ini f_3 (9), dan sudah pasti legal. Anda akan mendapatkan jumlah yang jauh lebih besar dengan menyarangkan genapfor j in range(f(x)): for j in range(f(x)): x = f(x) sekalipun. Bergabunglah bersama kami dalam obrolan untuk membahas alasannya!
Steven H.
Mengapa ini bukan jawaban yang valid?
Simply Beautiful Art
Saya tidak cukup mendapatkan pertanyaan, jadi saya hanya membuat apa yang saya pikir benar.
saya ..
1

Ruby, mungkin ~ f ω + 35 (9 9 99 )

G=->n,k{n<1?k:(f=->b,c,d{x=[]
c<G[b,d]?b-=1:(x<<=b;c-=G[b,d])while c>=d
x<<[c]}
x=f[n-1,k,b=1]
(b+=1;*u,v=x;x=v==[0]?u:v==[*v]?u<<[v[0]-1]:u+f[n-1,G[v,b]-1,b])while x[0]
b)};(n=9**9**99).times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n=G[n,n]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}};p n

Cobalah online!

Perkiraan Penjelasan Matematika:

Di bawah ini kira-kira sama dengan program di atas, tetapi disederhanakan sehingga lebih mudah dimengerti.

G(0,k) = k adalah fungsi dasar kami.

Untuk mengevaluasi G(n,k), kami mengambil kdan menuliskannya sebagaiG(n-1,1) + ... + G(n-2,1) + ... + G(0,1) .

Kemudian ubah semua G(x,1)menjadi G(x,2)dan kurangi1 dari seluruh hasil.

Tulis ulang dalam bentuk di atas menggunakan G(x,2), di mana x<n, dan biarkan sisanya di akhir. Ulangi, ubah G(x,2)ke G(x,3), dll.

Ketika hasilnya mencapai -1, kembalikan pangkalan ( byang akan masuk G(x,b).)

Contoh:

G (1,1):

1: 1 = G(0,1)
2: G(0,2) - 1 = 1
3: 1 - 1 = 0
4: 0 - 1 = -1      <----- G(1,1) = 4

G (1,2):

1: 2 = G(0,1) + G(0,1)
2: G(0,2) + G(0,2) - 1 = G(0,2) + 1
3: G(0,3) + 1 - 1 = G(0,3)
4: G(0,4) - 1 = 3
5: 3 - 1 = 2
6: 2 - 1 = 1
7: 1 - 1 = 0
8: 0 - 1 = -1      <----- G(1,2) = 8

G (1,3):

1: 3 = G(0,1) + G(0,1) + G(0,1)
2: G(0,2) + G(0,2) + G(0,2) - 1 = G(0,2) + G(0,2) + 1
3: G(0,3) + G(0,3)
4: G(0,4) + 3
5: G(0,5) + 2
6: G(0,6) + 1
7: G(0,7)
8: 7
9: 6
10:5
11:4
12:3
13:2
14:1
15:0
16:-1      <----- G(1,3) = 16

G (2,5):

1: 5 = G(1,1) + G(0,1)
2: G(1,2) + 1
3: G(1,3)
4: G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + 3
5: G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + 2
6: G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + 1
...
1024: -1      <----- G(2,5) = 1024

Melakukan matematika, saya menemukan itu

G(1,n-1) = 2ⁿ
G(2,n+6) ~ 2^G(2,n),  large enough n.

Dan di luar itu cenderung menjadi sedikit berbulu.

Secara umum, kita punya

G(n,k+G(n-1,1)) ~ G(n-1,G(n,k)), large enough n.
Seni Cukup Indah
sumber
1

Python 3, f ω ω + ω * ω (9 9 9 99 )

from functools import*
h=lambda a,x,b:h(h(a,x,b-1),x-1,a)if x*b else a+b
def f(*x):
    if(any(x[:2]):return reduce(lambda y,z:h(z,y,f(x[0],x[1]-1,*x[2:])),x[::-1])if x[0]*x[1]else(f(x[0]-1,f(x[0]-1,x[0],*x[2:]))if x[0]>x[1]else(f(x[1]-1,f(*([x[1]-1]*2+x[2:])),*x[2:])))
    for a,k in enumerate(x):if k:return f(*[f(*[k]*a,k-1,*x[a+1:])]*a,k-1,*x[a+1:])
    return 0
x,s,g,e,r,z=9**9**9**99,"f(*[%s]*%s)",lambda a,b:a%((b,)*a.count("%")),"x*=eval(\"%s\");","x","x=g(e,g(reduce(g,[s]*x,s),r));"
print(exec(z*x)or eval(r))

Saya akan segera mendapatkan penjelasan.

Steven H.
sumber
1

Python 3 , ~ f ε 0 (9 9 9 )

N=9**9**9
def f(a,n):
 if a[0]==[]:return a[1:]
 if a[0][0]==[]:return[a[0][1:]]*n+a[1:]
 return [f(a[0],n)]+a[1:]
a=eval("["*N+"]"*N)
n=2
while a:a=f(a,n);n+=1
print(n)

Cobalah online!

Biarawati Bocor
sumber
N = 9 ** 9e99 harus sedikit lebih besar
fejfo
daripada jawaban siapa?
Leaky Nun
Maksud saya, jika Anda mengganti yang pertama seperti dengan N = 9 ** 9e99 output harus sedikit lebih besar karena 9e99> 9 ** 9. Tentu ini masih jawaban Anda.
fejfo
@ fejfo maksud saya itu tidak akan mengubah peringkat saya.
Leaky Nun
2
Apakah itu penting?
fejfo
1

Python 3, 323 byte, g 9e9 (9)

exec("""a=`x:9**x
n=`a,f:`x:a and n(a-1,f)(f(x))or x
c=`n:`l:l[~n](l)
e=`x:n(x,c(0))([x,`l:[a(l[0]),n(*l)],c(0),`l:[a(l[0]),l[2](l[:2])[1]]+map(`i:l[1]((l[0],i))[1],l[2:])]+list(map(c,range(a(x),1,-1))))[1]
f=`l:[l[1](l[0]),e(l[1](l[0]))(l)[1]]
g=`x:e(x)((x,f))[1]((x,a))[1](x)
print(n(9e9,g)(9))""".replace('`','lambda '))

Cobalah online!

Penjelasan

Python 3 adalah bahasa yang benar-benar rekursif, ini berarti bahwa tidak hanya fungsi dapat memanggil dirinya sendiri, suatu fungsi juga dapat mengambil fungsi lain sebagai fungsi input atau output. Menggunakan fungsi untuk membuat diri mereka lebih baik adalah dasar dari program saya.

f = lambda x, a: [a (x), e (x) ((x, a)) [1]]

Definisi

a(x)=9^x
b(x,f)=a(x), f^x
c(n)(*l)=l[~n](l)
c(0)=c0 <=> c0(…,f)=f(…,f)
d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in l
e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1] 
f(x,a)=a(x),e(a(x))(x,a)[1](x)
g(x)=e(x)(x,f)[1](x,a)[1](x)
myNumber=g^9e9(9)

Definisi dijelaskan

a(x)=9^x a adalah fungsi dasar, saya memilih fungsi ini karena x> 0 => a (x)> x` yang menghindari titik tetap.

b(x,f)=a(x), f^xb adalah fungsi peningkatan umum, dibutuhkan dalam fungsi apa pun dan mengeluarkan versi yang lebih baik. b bahkan dapat diterapkan pada dirinya sendiri:b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

tetapi untuk sepenuhnya menggunakan kekuatan buntuk meningkatkan bAnda perlu mengambil output dari b dan menggunakannya sebagai b baru, inilah yang dilakukan c0:

c0(…,f)=f(…,f)
c0(x,b^x)=b^x(x,b^x)[1]>b^(9↑↑x)

fungsi c (n) yang lebih umum mengambil n argumen terakhir (mulai dari 0) jadi c(1)(…,f,a)=f(…,f,a)dan c(2)(…,f,a,b)=f(…,f,a,b). *lberarti l adalah array dan l[~n]mengambil argumen terakhir

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in l d menggunakan c0 untuk memutakhirkan b dan b untuk memutakhirkan semua fungsi input lainnya (yang jumlahnya bisa berapa saja karena daftar)
d(x,b,c,d)>9^x,b^x,c^x,d^x dand²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

tetapi d menjadi lebih baik jika Anda menggabungkannya dengan c:
c0²(x,b,c0,d)=d^x(9^x,b^x,c0^x,d^x)=… c0(x,b,c0,d,c1)=c1(x,b,c0,d,c1)=d(x,b,c0,d,c1)=9^x,b^x,c0^x,d^x,c1^x c0²(x,b,c0,d,c1)=c0(9^x,b^x,c0^x,d^x,c1^x)=c1^x(9^x,b^x,c0^x,d^x,c1^x)=…

semakin banyak c (x) yang Anda tambahkan di akhir semakin kuat jadinya. C0 pertama selalu tetap d: c0(x,b,c0,d,c4,c3,c2,c1)=c1(…)=c2(…)=c3(…)=c4(…)=d(x,b,c0,d,cX,cX-1,…,c3,c2,c1)=…
Tetapi yang kedua meninggalkan versi berulang di belakang:

c0²(x+1,b,c0,d,c4,c3,c2,c1)
=c0(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)
=c1^x(c2^x(c3^x(c4^x(d^x(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)))))

Ketika d^xakhirnya dihitung c4akan mengambil versi yang lebih banyak diulang dari dwaktu berikutnya. Ketika c4^xakhirnya dihitung c3akan mengambil versi iterasi yang lebih banyak c4, ...
Ini menciptakan versi iterasi yang sangat kuat karena d:

  1. Meningkatkan bpenggunaanc0
  2. Meningkatkan c0penggunaanb
  3. Memperbaiki semua lapisan sarang menggunakan b Semakin meningkatkan diri, ini berarti d menjadi lebih kuat ketika iterasi lebih banyak.

Menciptakan rantai panjang c ini adalah apa yang e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1]dilakukannya.
Ini digunakan c0^xuntuk memotong yang c0hanya akan memberi d.
The [1]berarti bahwa pada akhirnya akan kembali output kedua d^…. Begitub^… .

Pada titik ini saya tidak bisa memikirkan apa pun yang berkaitan dengan e (x) untuk secara signifikan meningkatkan outputnya kecuali meningkatkan input.

Jadi f(x,a)=a(x),e(a(x))(x,a)[1](x)gunakan yang b^…dihasilkan oleh e(x)untuk menghasilkan fungsi basis yang lebih baik dan menggunakan fungsi basis itu untuk memanggil e(x)dengan input yang lebih besar.

g(x)=e(x)(x,f)[1](x,a)[1](x)menggunakan final e(x)ke sarangf dan menghasilkan fungsi yang sangat kuat.

Perkiraan Fgh

Saya perlu bantuan perkiraan angka ini dengan segala macam fgh.

Versi lama : f ω ω 6 (f ω ω 5 (9e999)), Coba online! Revisi riwayat penjelasan

fejfo
sumber
Sebenarnya, f_1(x) = x+xtetapi dalam jangka panjang, ini tidak terlalu menjadi masalah.
Simply Beautiful Art
Bisakah Anda menjelaskan urutan fundamental Anda sedikit lebih banyak?
Simply Beautiful Art
@SimplyBeautifulArt ow ya saya lupa memperbarui itu setelah saya mengubahnya x*x.
fejfo
@SimplyBeautifulArt Jawaban saya tidak menggunakan tata cara apa pun sehingga sulit bagi saya untuk menjelaskannya dengan tata cara. Yang bisa saya lakukan hanyalah memberikan definisi fungsi saya dan perkiraan efek di fgh. Contoh:a2(f_n)~=f_{n+1}
fejfo
1

Ruby, f ε 0 2 (5), 271 byte

m=->n{x="";(0..n).map{|k|x+="->f#{k}{"};x+="->k{"+"y=#{n<1??k:"f1"};k.times{y=f0[y]};y";(2..n).map{|l|x+="[f#{l}]"};eval x+(n<1?"":"[k]")+"}"*(n+2)}
g=->z{t="m[#{z}]";(0...z).map{|j|t+="[m[#{z-j-1}]]"};eval t+"[->n{n+n}][#{z}]"}
p m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]

Cobalah online!

Ini didasarkan pada peta m (n) .

Penjelasan:

m[0][f0][k] = f0[f0[...f0[k]...]]dengan kiterasi dari f0.

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]dengan kiterasi dari f0.

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]dengan kiterasi dari f0.

Secara umum, m[n]mengambil n+2argumen, iterates argumen pertama f0,k kali ke argumen kedua, dan kemudian menerapkan fungsi yang dihasilkan ke argumen ketiga (jika ada), lalu menerapkan fungsi yang dihasilkan ke argumen keempat (jika ada), dll.

Contohnya

m[0][n↦n+1][3] = (((3+1)+1)+1 = 6

Secara umum m[0][n↦n+1] = n↦2n,.

m[0][m[0][n↦n+1]][3] = m[0][n↦2n][3] = 2(2(2(3))) = 24

Secara umum m[0][m[0][n↦n+1]] = n↦n*2^n,.

m[1][m[0]][3]
= m[0][m[0][m[0][n↦n+1]]][3]
= m[0][m[0][n↦2n]][3]
= m[0][n↦n*2^n][3]
= (n↦n*2^n)[(n↦n*2^n)[n↦n*2^n(3)]]
= (n↦n*2^n)[(n↦n*2^n)[24]]
= (n↦n*2^n)[402653184]
= 402653184*2^402653184

Secara umum, m[1][m[0]][n↦n+1] = f_ωdalam hierarki yang tumbuh cepat.


g[z] = m[z][m[z-1]][m[z-2]]...[m[1]][m[0]][n↦2n][z]

dan hasil akhirnya adalah

m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]
Seni Cukup Indah
sumber