Tujuan Anda adalah menulis program yang mencetak angka. Semakin besar angkanya, semakin banyak poin yang akan Anda dapatkan. Tetapi berhati-hatilah! Panjang kode dibatasi dan sangat tertimbang dalam fungsi penilaian. Nomor cetak Anda akan dibagi dengan kubus jumlah byte yang Anda gunakan untuk solusi Anda .

Jadi, katakanlah Anda mencetak 10000000dan kode Anda 100panjang byte. Skor akhir Anda akan menjadi 10000000 / 100^3 = 10.

Ada aturan lain yang harus diikuti, untuk membuat tantangan ini sedikit lebih sulit.

• Anda tidak dapat menggunakan angka dalam kode Anda (0123456789);
• Anda dapat menggunakan matematika / fisik / dll. konstanta, tetapi hanya jika mereka kurang dari 10. (mis. Anda dapat menggunakan Pi ~ = 3.14 tetapi Anda tidak dapat menggunakan konstanta Avogadro = 6e23)
• Rekursi diperbolehkan tetapi nomor yang dihasilkan harus terbatas (sehingga tak terbatas tidak diterima sebagai solusi. Program Anda harus berakhir dengan benar, dengan asumsi waktu dan memori tidak terbatas, dan menghasilkan output yang diminta);
• Anda tidak dapat menggunakan operasi *(gandakan), /(membagi), ^(daya) atau cara lain untuk menunjukkannya (misalnya 2 div 2tidak diizinkan);
• Program Anda dapat menampilkan lebih dari satu nomor, jika Anda memerlukannya . Hanya yang tertinggi yang akan dihitung untuk penilaian;
• Namun, Anda dapat menyatukan string: ini berarti bahwa setiap urutan digit yang berdekatan akan dianggap sebagai angka tunggal;
• Kode Anda akan dijalankan apa adanya. Ini berarti bahwa pengguna akhir tidak dapat mengedit baris kode apa pun, atau ia dapat memasukkan nomor atau apa pun;
• Panjang kode maksimum adalah 100 byte.

Papan peringkat

1. Steven H. , Pyth ≈ f _{φ (1,0,0) +7} (256 ²⁶ ) / 1000000 ^[1]
2. Simply Beautiful Art , Ruby ≈ f _{φ 121 (ω)} (126) ^[1]
3. Peter Taylor , GolfScript ≈ f _{ε 0 + ω + 1} (17) / 1000 ^[1]
4. res , GolfScript ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126))))))))))))))) ^[1]
5. Simply Beautiful Art , Ruby ≈ f _{ω ^ω2 +1} (1983)
6. eaglgenes101 , Julia ≈ f _ω3 (127)
7. col6y , Python 3, ≈ (127 → 126 → ... → 2 → 1) / 99 ^{3 [1] [3]}
8. Toeofdoom , Haskell, ≈ a ₂₀ (1) / 99 ^{3 [1]}
9. Fraxtil , dc, ≈ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 ^{3 [3]}
10. Magenta , Python, ≈ ack (126.126) / 100 ³ ≈ 10 ↑ ¹²⁴ 129
11. Kendall Frey , ECMAScript 6, ≈ 10 ^{3 ↑ 4 3} /100 ^{3 [1]}
12. Ilmari Karonen , GolfScript, ≈ 10 ↑ ³ 10 ³⁷⁷ /18 ^{3 [1]}
13. BlackCap , Haskell, ≈ 10 ↑↑ 65503/100 ³
14. rekursif , Python, ≈ 2↑↑ 11/95 ³ ≈ 10 ↑↑ 8.63297 ^{[1] [3]}
15. nm , Haskell, ≈ 2↑↑ 7/100 ³ ≈ 10 ↑↑ 4.63297 ^[1]
16. David Yaw , C, ≈ 10 ^{10 4 × 10 22} /83 ³ ≈ 10 ↑↑ 4,11821 ^[2]
17. primo , Perl, ≈ 10 ^{(12750684161!) 5 × 2 27} /100 ³ ≈ 10 ↑↑ 4,11369
18. Seni , C, ≈ 10 ^{10 2 × 10 6} /98 ³ ≈ 10 ↑↑ 3,80587
19. Robert Sørlie , x86, ≈ 10 ^{2 2 19 +32} / 100 ³ ≈ 10 ↑↑ 3.71585
20. Tobia , APL, ≈ 10 ^{10 353} /100 ³ ≈ 10 ↑↑ 3,40616
21. Darren Stone , C, ≈ 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 3.29875
22. ecksemmess , C, ≈ 10 ^{2 320} /100 ³ ≈ 10 ↑↑ 3,29749
23. Adam Speight , vb.net, ≈ 10 ^{5000 × (2 64 ) 4} /100 ³ ≈ 10 ↑↑ 3,28039
24. Joshua , bash, ≈ 10 ^{10 15} /86 ³ ≈ 10 ↑↑ 3,07282

_{Catatan kaki}

1. ^{Jika setiap elektron di alam semesta adalah qubit, dan setiap superposisi darinya dapat secara menguntungkan digunakan untuk menyimpan informasi (yang, selama Anda tidak benar-benar perlu tahu apa yang disimpan secara teori dimungkinkan), program ini membutuhkan lebih banyak memori daripada yang bisa mungkin ada, dan karena itu tidak dapat dijalankan - sekarang, atau pada titik apa pun di masa depan. Jika penulis bermaksud untuk mencetak nilai yang lebih besar dari ≈3 ↑↑ 3.28 sekaligus, kondisi ini berlaku.}
2. ^{Program ini membutuhkan lebih banyak memori daripada yang ada saat ini, tetapi tidak begitu banyak sehingga secara teoritis tidak dapat disimpan pada sejumlah qubit yang sedikit, dan karena itu suatu hari komputer mungkin ada yang dapat menjalankan program ini.}
3. ^{Semua penerjemah yang ada saat ini mengeluarkan kesalahan runtime, atau program lain gagal untuk mengeksekusi sebagaimana yang dimaksudkan penulis.}
4. ^{Menjalankan program ini akan menyebabkan kerusakan yang tidak dapat diperbaiki pada sistem Anda.}

Sunting @primo : Saya telah memperbarui sebagian papan skor menggunakan notasi yang mudah-mudahan lebih mudah untuk dibandingkan, dengan desimal untuk menunjukkan jarak logaritmik ke kekuatan yang lebih tinggi berikutnya. Misalnya 10 ↑↑ 2,5 = 10 ^{10 √10} . Saya juga telah mengubah beberapa skor jika saya percaya analisis pengguna salah, silakan membantah semua ini.

Penjelasan dari notasi ini:

Jika 0 ≤ b < 1demikian .a↑↑b = ab

Jika b ≥ 1demikian .a↑↑b = aa↑↑(b-1)

Jika b < 0demikian .a↑↑b = loga(a↑↑(b+1))

GolfScript; skor setidaknya f _{ε_0 + ω + 1} (17) / 1000

Mengikuti saran res untuk menggunakan Lifetime of a worm answer untuk pertanyaan ini, saya menyajikan dua program yang jauh lebih baik pada turunannya dari solusi Howard.

Mereka berbagi awalan umum, modulo nama fungsi:

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g

menghitung di g(g(1)) = g(5)mana g(x) = worm_lifetime(x, [x])tumbuh kira-kira sebagai f _{ε 0} (yang catatan res adalah "fungsi dalam hierarki yang tumbuh cepat yang tumbuh pada tingkat yang kira-kira sama dengan fungsi Goodstein").

(!) Yang sedikit lebih mudah untuk dianalisis adalah

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*

.{foo}*peta xke foo^x x.

,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*

dengan demikian memberi g^(g(5)) ( g(5) ); 8 level lebih lanjut dari iterasi mirip dengan rantai panah. Untuk mengungkapkan dalam istilah sederhana: jika h_0 = gdan h_{i+1} (x) = h_i^x (x)kemudian kita hitung h_10 (g(5)).

Saya pikir program kedua ini hampir pasti skornya jauh lebih baik. Kali ini label yang ditugaskan untuk berfungsi gadalah baris baru.

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^

Kali ini saya menggunakan lebih baik ^sebagai fungsi yang berbeda.

.['.{
}*'n/]*zip n*~

mengambil xtumpukan, dan daun xdiikuti oleh string yang berisi xsalinan .{diikuti oleh gdiikuti oleh xsalinan }*; kemudian mengevaluasi string. Karena saya memiliki tempat yang lebih baik untuk membakar karakter cadangan, kami mulai dengan j_0 = g; jika j_{i+1} (x) = j_i^x (x)kemudian evaluasi pertama ^menghitung j_{g(5)} (g(5))(yang saya yakin sudah mengalahkan program sebelumnya). Saya kemudian mengeksekusi ^16 kali lebih banyak; jadi jika k_0 = g(5)dan k_{i+1} = j_{k_i} (k_i)kemudian menghitung k_17. Saya bersyukur (lagi) untuk res untuk memperkirakan bahwa k_i>> f _{ε_0 + ω + 1} (i).

Windows 2000 - Windows 8 (3907172 / 23³ = 321)

CATATAN: JANGAN MENCARI KERJA INI!

Simpan yang berikut ini ke file batch dan jalankan sebagai Administrator.

CD|Format D:/FS:FAT/V/Q

Output saat dijalankan pada drive 4TB dengan angka yang dicetak pertama dalam huruf tebal.

Masukkan disk baru untuk drive D:
dan tekan ENTER saat siap ... Jenis sistem file adalah NTFS.
Sistem file baru adalah FAT.
QuickFormatting 3907172M
Volume terlalu besar untuk FAT16 / 12.

GolfScript, skor: cara terlalu banyak

OK, seberapa besar angka yang bisa kita cetak dalam beberapa karakter GolfScript?

Mari kita mulai dengan kode berikut ( terima kasih, Ben! ), Yang mencetak 126:

'~'(

Selanjutnya, mari kita ulangi 126 kali, memberi kita angka sama dengan sekitar 1,26126 × 10 ³⁷⁷ :

'~'(.`*

(Itu pengulangan string, bukan perkalian, jadi itu harus OK di bawah aturan.)

Sekarang, mari kita ulangi bahwa jumlah 378-digit sedikit lebih dari 10 ³⁷⁷ kali:

'~'(.`*.~*

Anda tidak akan pernah benar-benar melihat program ini selesai, karena mencoba menghitung angka dengan sekitar 10 ³⁸⁰ ≈ 2 ¹¹⁴⁰ angka. Tidak ada komputer yang pernah dibangun dapat menyimpan angka sebesar itu, juga komputer seperti itu tidak akan dapat dibangun menggunakan fisika yang dikenal; yang jumlah atom di alam semesta teramati diperkirakan sekitar 10 ⁸⁰ , bahkan jika kita entah bagaimana bisa menggunakan semua materi di alam semesta untuk menyimpan sejumlah besar ini, kita akan masih entah harus menjejalkan sekitar 10 ³⁸⁰ /10 ⁸⁰ = 10 ³⁰⁰ digit ke dalam setiap atom!

Tetapi mari kita asumsikan bahwa kita memiliki juru bahasa GolfScript milik Tuhan sendiri, yang mampu menjalankan perhitungan seperti itu, dan kita masih belum puas. Oke, ayo lakukan itu lagi!

'~'(.`*.~*.~*

Output dari program ini, jika bisa selesai, akan memiliki sekitar 10 ^{10 383} digit, dan akan sama dengan sekitar 10 ^{10 10 383} .

Tapi tunggu! Program itu semakin berulang ... mengapa kita tidak mengubahnya menjadi satu lingkaran?

'~'(.`*.{.~*}*

Di sini, tubuh loop akan dijalankan sekitar 10 ³⁷⁷ kali, memberikan kita output teoritis yang terdiri dari sekitar 10 ^{10⋰ 10 377} digit atau lebih, di mana menara kekuatan iterasi dari 10 adalah sekitar 10 ³⁷⁷ langkah panjang. (Sebenarnya, itu adalah perkiraan yang terlalu rendah, karena saya mengabaikan fakta bahwa jumlah yang diulang juga semakin lama, tetapi secara relatif itu adalah masalah kecil.)

Tapi kita belum selesai. Mari tambahkan loop lain!

'~'(.`*.{.{.~*}*}*

Bahkan untuk menuliskan perkiraan angka-angka tersebut dengan benar diperlukan notasi matematika esoterik. Sebagai contoh, dalam notasi panah atas Knuth , jumlah (secara teoritis) output oleh program di atas harus sekitar 10 ↑ ³ 10 ³⁷⁷ , memberi atau mengambil beberapa (atau 10 ³⁷⁷ ) kekuatan sepuluh, dengan asumsi saya melakukan matematika dengan benar.

Angka-angka seperti ini melampaui "luar biasa besar", dan masuk ke ranah "tak terbayangkan". Seperti dalam, tidak hanya tidak mungkin untuk menghitung hingga atau menuliskan angka-angka seperti itu (kami sudah melewati titik itu pada contoh ketiga di atas), tetapi mereka benar-benar tidak memiliki penggunaan atau keberadaan yang mungkin di luar matematika abstrak. Kita dapat membuktikan, dari aksioma matematika , bahwa angka-angka seperti itu ada, sama seperti kita dapat membuktikan dari spesifikasi GolfScript bahwa program di atas akan menghitungnya, jika batas-batas realitas dan ruang penyimpanan yang tersedia tidak campur tangan), tetapi secara harfiah tidak ada dalam alam semesta fisik yang dapat kita gunakan untuk menghitung atau mengukur dalam arti apa pun.

Meski begitu, ahli matematika terkadang menggunakan angka yang bahkan lebih besar . (Secara teoritis) angka komputasi yang besar membutuhkan sedikit lebih banyak pekerjaan - alih-alih hanya mengumpulkan lebih banyak loop satu demi satu, kita perlu menggunakan rekursi untuk mengukur kedalaman loop loop yang bersarang. Namun, pada prinsipnya, mungkin untuk menulis sebuah program GolfScript pendek (jauh di bawah 100 byte, saya harapkan) untuk (secara teoritis) menghitung angka yang dapat diekspresikan dalam, katakanlah, notasi notasi panah dirangkai Conway ; detail dibiarkan sebagai latihan. ;-)

JavaScript 44 karakter

Ini mungkin tampak sedikit curang:

alert((Math.PI+''+Math.E).replace(/\./g,""))

Nilai = 31415926535897932718281828459045/44 ^ 3 ≈ 3.688007904758867e + 26 ≈ 10 ↑↑ 2.1536134004

C, skor = 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 2.29874984

unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}

Saya menghargai bantuan dalam mencetak gol. Setiap wawasan atau koreksi sangat dihargai. Inilah metode saya:

n = penggabungan setiap angka dari 1 hingga 2 ⁶⁴ -1, diulangi (2 ⁶⁴ -1) ⁴ kali . Pertama, inilah cara saya memperkirakan (rendah) jumlah kumulatif digit dari 1 hingga 2 ⁶⁴ -1 ("urutan"): Angka terakhir dalam urutan urutan adalah 2 ⁶⁴ -1 = 18446744073709551615dengan 20 digit. Dengan demikian, lebih dari 90% dari angka di bagian selanjutnya (yang dimulai dengan 1.. 9) memiliki 19 digit. Mari kita asumsikan sisa 10% rata-rata 10 digit. Ini akan menjadi lebih dari itu, tetapi ini adalah perkiraan rendah untuk matematika mudah dan tidak ada kecurangan. Selanjutnya akan diulangi (2 ⁶⁴ -1) ⁴ kali, jadi panjangnya dari n akansetidaknya (0,9 × (2 ⁶⁴ -1) × 19 + 0,1 × (2 ⁶⁴ -1) × 10) × (2 ⁶⁴ -1) ⁴ = 3,86613 × 10 ⁹⁷ digit. Dalam komentar di bawah ini, @primo mengonfirmasi panjang n menjadi 4,1433x10 ⁹⁷ . Jadi n itu sendiri akan 10 pangkat itu, atau 10 ^{10 97.61735} .

l = 98 karakter kode

skor = n / l ³ = 10 ^{10 97.61735} / 98 ³

Persyaratan: Harus dijalankan di komputer 64-bit di mana sizeof(long) == 8. Mac dan Linux akan melakukannya.

Python 3 - 99 karakter - (kemungkinan besar) secara signifikan lebih besar dari jumlah Graham

Saya datang dengan fungsi yang lebih cepat meningkat berdasarkan perluasan fungsi Ackermann.

A=lambda a,b,*c:A(~-a,A(a,~-b,*c)if b else a,*c)if a else(A(b,*c)if c else-~b);A(*range(ord('~')))

http://fora.xkcd.com/viewtopic.php?f=17&t=31598 menginspirasi saya, tetapi Anda tidak perlu melihat ke sana untuk memahami nomor saya.

Ini adalah versi modifikasi dari fungsi ackermann yang akan saya gunakan dalam analisis saya:

A(b)=b+1
A(0,b,...)=A(b,...)
A(a,0,...)=A(a-1,1,...)
A(a,b,...)=A(a-1,A(a,b-1,...),...)

Fungsi saya Adalam kode di atas secara teknis tidak sama, tetapi sebenarnya lebih kuat, dengan pernyataan berikut untuk menggantikan baris ketiga dari definisi di atas:

A(a,0,...)=A(a-1,a,...)

(a harus minimal 1, jadi itu harus lebih kuat)

Tetapi untuk tujuan saya, saya akan berasumsi bahwa itu sama dengan yang lebih sederhana, karena analisisnya sudah sebagian dilakukan untuk fungsi Ackermann, dan karena itu untuk fungsi ini ketika memiliki dua argumen.

Fungsi saya dijamin untuk akhirnya berhenti berulang karena selalu: menghilangkan argumen, mengurangi argumen pertama, atau mempertahankan argumen pertama yang sama dan mengurangi argumen kedua.

Analisis ukuran

Nomor Graham, AFAIK, dapat direpresentasikan dengan G(64)menggunakan:

G(n) = g^n(4)
g(n) = 3 ↑^(n) 3

Dimana a ↑^(n)adalah not panah atas knuth.

Demikian juga:

A(a,b) = 2 ↑^(a-2) (b+3) - 3
A(a,0) ≈ 2 ↑^(a-2) 3
g(n) ≈ A(n+2,0) // although it will be somewhat smaller due to using 2 instead of 3. Using a number larger than 0 should resolve this.
g(n) ≈ A(n+2,100) // this should be good enough for my purposes.

g(g(n)) ≈ A(A(n+2,100),100)

A(1,a+1,100) ≈ A(0,A(1,a,100),100) = A(A(1,a,100),100)

g^k(n) ≈ A(A(A(A(...(A(n+2,100)+2)...,100)+2,100)+2,100)+2,100) // where there are k instances of A(_,100)
A(1,a,100) ≈ A(A(A(A(...(A(100+2),100)...,100),100),100),100)

g^k(100) ≈ A(1,k,100)
g^k(4) < A(1,k,100) // in general
g^64(4) < A(1,64,100)

Angka yang dinyatakan dalam program di atas adalah A(0,1,2,3,4,...,123,124,125) .

Karena g^64(4)itu nomor Graham, dan anggaplah matematika saya benar maka itu kurang dari A(1,64,100), angka saya jauh lebih besar dari angka Graham.

Tolong tunjukkan kesalahan dalam matematika saya - meskipun jika tidak ada, ini harus menjadi jumlah terbesar yang dihitung sejauh ini untuk menjawab pertanyaan ini.

Perl - skor ≈ 10 ↑↑ 4.1

$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Sekali lagi menyalahgunakan mesin regex perl untuk menggiling melalui jumlah kombinasi yang tak terbayangkan, kali ini menggunakan keturunan rekursif.

Di dalam sebagian besar ekspresi, kita memiliki yang telanjang . untuk mencegah rekursi tak terbatas, dan dengan demikian membatasi tingkat rekursi dengan panjang tali.

Yang akan kita akhiri adalah:

/((((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*/
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                    .                                      \
                       .
                       .

... diulang 671088640 kali, dengan total 12750684161 bersarang - yang cukup menyeluruh menempatkan upaya saya sebelumnya 23 bersarang menjadi malu. Hebatnya, perl bahkan tidak tersedak ini (sekali lagi, penggunaan memori tetap stabil di sekitar 1.3GB), meskipun akan memakan waktu cukup lama sebelum pernyataan cetak pertama bahkan dikeluarkan.

Dari analisis saya sebelumnya di bawah ini, dapat disimpulkan bahwa jumlah output digit akan berada di urutan (! 12750684161) ^671088640 , di mana ! K adalah ^Faktor Kiri dari k (lihat A003422 ). Kami dapat memperkirakan ini sebagai (k-1)! , Yang benar-benar lebih kecil, tetapi pada urutan yang sama besarnya.

Dan jika kita bertanya pada wolframalpha :

... yang nyaris tidak mengubah skor saya sama sekali. Saya pikir pasti itu setidaknya 10 ↑↑ 5 . Saya kira perbedaan antara 10 ↑↑ 4 dan 10 ↑↑ 4.1 jauh lebih besar dari yang Anda kira.

Perl - skor ≈ 10 ↑↑ 4

$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Menyalahgunakan mesin perl regex untuk melakukan beberapa kombinatorik untuk kita. Codeblock yang tertanam
(??{print})akan memasukkan hasilnya langsung ke regex. Karena $_seluruhnya terdiri dari 2s (dan hasilnya printselalu 1), ini tidak pernah bisa cocok, dan mengirim perl berputar melalui semua kombinasi yang mungkin, yang ada beberapa.

Konstanta digunakan

• $^F- pegangan file sistem maksimum, biasanya 2.
• $]- nomor versi perl, mirip dengan 5.016002.

$_kemudian string berisi digit yang 2diulang 671088640 kali. Penggunaan memori konstan pada sekitar 1,3GB, output dimulai segera.

Analisis

Mari kita mendefinisikan P _k (n) menjadi berapa kali pernyataan cetak dieksekusi, di mana k adalah jumlah sarang, dan n adalah panjang dari string ditambah satu (hanya karena saya tidak merasa ingin menulis n + 1 dimana mana).

(.*.*)*
P ₂ (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

((.*.*)*)*
P ₃ (n) = [ 3, 18, 123, 900, 6693, 49926, 372615, 2781192, ... ]

(((.*.*)*)*)*
P ₄ (n) = [ 4, 56, 1044, 20272, 394940, 7696008, 149970676, 2922453344, ... ]

((((.*.*)*)*)*)*
P ₅ (n) = [ 5, 250, 16695, 1126580, 76039585, 5132387790, 346417023515, 23381856413800, ... ]

(((((.*.*)*)*)*)*)*
P ₆ (n) = [ 6, 1452, 445698, 137050584, 42142941390, 12958920156996, ... ]

((((((.*.*)*)*)*)*)*)*
P ₇ (n) = [ 7, 10094, 17634981, 30817120348, 53852913389555, ... ]

dll. Secara umum, rumus dapat digeneralisasi sebagai berikut:

dimana

Yaitu, Faktor Kiri dari k , yaitu jumlah semua faktorial kurang dari k (lihat A003422 ).

Aku sudah tidak dapat menentukan bentuk tertutup untuk D _k dan E _k , tapi ini tidak peduli terlalu banyak, jika kita mengamati bahwa

dan

Dengan 23 sarang, ini memberi kami skor perkiraan:

Ini seharusnya hampir tepat, sebenarnya.

Tetapi untuk menempatkan ini ke dalam notasi yang sedikit lebih mudah untuk divisualisasikan, kita dapat memperkirakan basis eksponen dalam:

dan kemudian eksponen itu sendiri:

dan kemudian bertanya wolframalpha :

yang Anda mungkin juga hanya memanggil 10 ↑↑ 4 dan selesai dengan itu.

Javascript, 10 ↑↑↑↑ 210

100 karakter:

z=~~Math.E+'';o={get f(){for(i=z;i--;)z+=i}};o.f;for(i=z;i--;)for(j=z;j--;)for(k=z;k--;)o.f;alert(z)

Berdasarkan pengamatan bahwa iterasi maksimal fadalah cara optimal untuk pergi, saya mengganti 13 panggilan fdengan 3 level panggilan bersarang f, zsetiap kali (sambil fterus meningkatz ).

Saya memperkirakan skor secara analitis pada selembar kertas — saya akan mengetiknya jika ada yang tertarik melihatnya.

Skor yang ditingkatkan: 10 ↑↑ 13

Javascript, persis 100 karakter, lagi:

z=~~Math.E+'';__defineGetter__('f',function(){for(i=z;i--;)z+=i});f;f;f;f;f;f;f;f;f;f;f;f;f;alert(z)

Ini meningkatkan jawaban asli saya dalam tiga cara—

1. Menentukan zruang lingkup global menyelamatkan kita dari keharusan mengetik o.zsetiap waktu.

2. Dimungkinkan untuk menentukan pengambil pada lingkup global (jendela) dan mengetik falih-alih o.f.

3. Memiliki lebih banyak iterasi fbernilai lebih dari memulai dengan angka yang lebih besar, jadi daripada (Math.E+'').replace('.','')(= 2718281828459045, 27 karakter), lebih baik menggunakan ~~Math.E+''(= 2, 11 karakter), dan menggunakan karakter yang diselamatkan untuk menelepon fberkali-kali.

Karena, sebagaimana dianalisis lebih lanjut di bawah, setiap iterasi menghasilkan, dari angka dalam urutan magnitudo M , angka yang lebih besar dalam urutan magnitudo 10 ^M , kode ini menghasilkan setelah setiap iterasi

1. 210 ∼ O (10 ² )
2. O (10 ^{10 2} ) ∼ O (10 ↑↑ 2)
3. O (10 ^{10 ↑↑ 2} ) = O (10 ↑↑ 3)
4. O (10 ^{10 ↑↑ 3} ) = O (10 ↑↑ 4)
5. O (10 ^{10 ↑↑ 4} ) = O (10 ↑↑ 5)
6. O (10 ^{10 ↑↑ 5} ) = O (10 ↑↑ 6)
7. O (10 ^{10 ↑↑ 6} ) = O (10 ↑↑ 7)
8. O (10 ^{10 ↑↑ 7} ) = O (10 ↑↑ 8)
9. O (10 ^{10 ↑↑ 8} ) = O (10 ↑↑ 9)
10. O (10 ^{10 ↑↑ 9} ) = O (10 ↑↑ 10)
11. O (10 ^{10 ↑↑ 10} ) = O (10 ↑↑ 11)
12. O (10 ^{10 ↑↑ 11} ) = O (10 ↑↑ 12)
13. O (10 ^{10 ↑↑ 12} ) = O (10 ↑↑ 13)

Nilai: ∼10 ^{10 10 10 10 16} ≈ 10 ↑↑ 6.080669764

Javascript, persis 100 karakter:

o={'z':(Math.E+'').replace('.',''),get f(){i=o.z;while(i--){o.z+=i}}};o.f;o.f;o.f;o.f;o.f;alert(o.z)

Masing-masing o.fmemanggil loop sementara, dengan total 5 loop. Setelah hanya iterasi pertama, skor sudah lebih dari 10 ^{42381398144233621} . Dengan iterasi kedua, Mathematica tidak dapat menghitung bahkan jumlah digit dalam hasil.

Berikut panduan kode:

Init

Mulai dengan 2718281828459045 dengan menghapus titik desimal dari Math.E.

Iterasi 1

Menggabungkan urutan penurunan angka,

• 2718281828459045
• 2718281828459044
• 2718281828459043
• ...
• 3
• 2
• 1
• 0

untuk membentuk nomor (raksasa) baru,

• 271828182845904527182818284590442718281828459043 ... 9876543210.

Berapa angka dalam angka ini? Yah, ini adalah gabungan dari

• 1718281828459046 angka 16 digit
• 90000000000000000 15 digit angka
• 90000000000000 nomor 14 digit,
• 900000000000000 nomor 13 digit
• ...
• 900 angka 3 digit
• 90 angka 2 digit
• 10 angka 1 digit

Dalam Mathematica,

In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626

Dengan kata lain, ini adalah 2.72⋅10 ^{42381398144233625} .

Membuat skor saya, setelah hanya iterasi pertama, 2.72⋅10 ^{42381398144233619} .

Iterasi 2

Tapi itu baru permulaan. Sekarang, ulangi langkahnya, dimulai dengan angka raksasa ! Artinya, merangkai urutan angka yang menurun,

• 271828182845904527182818284590442718281828459043 ... 9876543210
• 271828182845904527182818284590442718281828459043 ... 9876543209
• 271828182845904527182818284590442718281828459043 ... 9876543208
• ...
• 3
• 2
• 1
• 0

Jadi, berapa skor baruku, Mathematica?

In[2]:= 1.718281828459046*10^42381398144233624*42381398144233625 + Sum[9*10^i*(i + 1), {i, -1, 42381398144233623}] + 1

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

Out[2]= Overflow[]

Iterasi 3

Ulangi.

Iterasi 4

Ulangi.

Iterasi 5

Ulangi.

Skor Analitik

Dalam iterasi pertama, kami menghitung jumlah digit dalam rangkaian urutan menurun mulai dari 2718281828459045, dengan menghitung jumlah digit dalam

• 1718281828459046 angka 16 digit
• 90000000000000000 15 digit angka
• 90000000000000 nomor 14 digit,
• 900000000000000 nomor 13 digit
• ...
• 900 angka 3 digit
• 90 angka 2 digit
• 10 angka 1 digit

Jumlah ini dapat direpresentasikan dengan rumus,

di mana Z menunjukkan angka awal ( mis. 2718281828459045) dan O _Z menunjukkan urutan besarnya ( misalnya 15, karena Z ∼ 10 ¹⁵ ). Menggunakan kesetaraan untuk jumlah terbatas , hal di atas dapat dinyatakan secara eksplisit sebagai

yang, jika kita ambil 9 ≈ 10, semakin berkurang

dan, akhirnya, memperluas persyaratan dan memesannya dengan mengurangi urutan besarnya, kami dapatkan

Sekarang, karena kita hanya tertarik pada urutan besarnya hasil, mari gantikan Z dengan "angka dalam urutan besarnya O _Z ," yaitu 10 ^{O _Z} -

Akhirnya, persyaratan ke-2 dan ke-3 dibatalkan, dan dua istilah terakhir dapat dibatalkan (ukurannya sepele), sehingga kami

dari mana istilah pertama menang.

Disajikan kembali, fambil angka dalam urutan besarnya M dan menghasilkan angka kira-kira dalam urutan besarnya M (10 ^M ).

Iterasi pertama dapat dengan mudah diperiksa dengan tangan. 2718281828459045 adalah angka dalam urutan besarnya 15 — oleh karena itu fharus menghasilkan angka dalam urutan besarnya 15 (10 ¹⁵ ) ∼ 10 ¹⁶ . Memang, jumlah yang dihasilkan adalah, dari sebelumnya, 2.72⋅10 ^{42381398144233625} —yaitu, 10 ^{42381398144233625} ∼ 10 ^{10 16} .

Memperhatikan bahwa M bukan merupakan faktor yang signifikan dalam M (10 ^M ), urutan besarnya hasil setiap iterasi, kemudian, mengikuti pola sederhana tetrasi:

1. 10 ¹⁶
2. 10 ^{10 16}
3. 10 ^{10 10 16}
4. 10 ^{10 10 10 16}
5. 10 ^{10 10 10 10 16}

Sumber LaTeX

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\sum_{k=0}^{\mathcal{O}_Z-1}{(9\cdot10^k(k+1))}+1

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\frac{10-\mathcal{O}_Z10^{\mathcal{O}_Z}+(\mathcal{O}_Z-1)10^{\mathcal{O}_Z+1}}{9}+10^{\mathcal{O}_Z}

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+1

Z\mathcal{O}_Z+Z-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}+10^{\mathcal{O}_Z}-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}

APL, 10 ↑↑ 3.4

Inilah upaya saya yang telah direvisi:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

Program 100 char / byte *, berjalan pada perangkat keras saat ini (menggunakan jumlah memori yang dapat diabaikan dan variabel int 32-bit biasa) meskipun akan membutuhkan waktu yang sangat lama untuk diselesaikan.

Anda benar-benar dapat menjalankannya pada penerjemah APL dan itu akan mulai mencetak angka. Jika dibiarkan selesai, nomor itu akan dicetak dengan 10 × 123456789 ⁴⁴ digit.

Oleh karena itu nilai adalah 10 ^{10 × 123456789 44} /100 ³ ≈ 10 ^{10 353} ≈ 10 ↑↑ 3,406161

Penjelasan

• ⎕D adalah string konstan standar yang sama dengan '0123456789'
• n←⍎⎕Dmendefinisikan n menjadi angka yang diwakili oleh string itu: 123456789 (yang <2 ³¹ dan karenanya dapat digunakan sebagai variabel kontrol loop)
• {⍞←⎕D} akan mencetak 10 digit ke output standar, tanpa baris baru
• {⍞←⎕D}⍣nakan melakukannya n kali ( ⍣adalah "operator daya": itu bukan *, /, atau ^, karena itu bukan operasi matematika, itu semacam loop)
• {⍞←n}⍣n⍣nakan mengulangi operasi sebelumnya n kali, oleh karena itu mencetak 10 digit n ² kali
• {⍞←n}⍣n⍣n⍣nakan melakukannya n ³ kali
• Saya bisa memasukkan 44 ⍣ndi sana, sehingga mencetak n ⁴⁴ kali string '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL dapat ditulis dalam charset byte tunggal (lama) yang memetakan simbol APL ke nilai 128 byte atas. Oleh karena itu, untuk tujuan penilaian, program karakter N yang hanya menggunakan karakter ASCII dan simbol APL dapat dianggap sebagai panjang N byte.}

Haskell, skor: (2 ^{2 2 65536} -3) / 1000000 ≈ 2 ↑↑ 7 ≈ 10 ↑↑ 4.6329710779

o=round$sin pi
i=succ o
q=i+i+i+i
m!n|m==o=n+i
 |n==o=(m-i)!i
 |True=(m-i)!(m!(n-i))
main=print$q!q

Program ini persis 100 byte kode Haskell murni. Ini akan mencetak angka Ackermann keempat, yang pada akhirnya menghabiskan semua energi, materi, dan waktu Semesta yang tersedia dan seterusnya dalam proses (sehingga sedikit melebihi batas lunak 5 detik).

Python, 2 ↑↑ 11/830584 ≈ 10 ↑↑ 8.632971 (Notasi panah naik)

print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))

Mungkin tidak ada komputer yang memiliki cukup memori untuk berhasil menjalankan ini, tapi itu bukan kesalahan program. Dengan terpenuhinya persyaratan sistem minimum, itu berhasil.

Ya, ini melakukan sedikit pergeseran pada nilai boolean. Truedipaksa 1dalam konteks ini. Python memiliki bilangan bulat panjang yang berubah-ubah.

GolfScript 3.673e + 374

'~'(.`*

Saya pikir *ini diperbolehkan karena ini menunjukkan pengulangan string, bukan perkalian.

Penjelasan: '~'(akan meninggalkan 126 (nilai ASCII "~") di stack. Kemudian salin nomornya, konversikan menjadi string, dan lakukan pengulangan string sebanyak 126 kali. Ini memberi 126126126126...yang kira-kira 1.26 e+377. Solusinya adalah 7 karakter, jadi bagi dengan 7^3, untuk skor sekitar3.673e+374

Ruby, probabilistically infinite, 54 karakter

x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x

x diinisialisasi ke 97. Kami kemudian mengulangi prosedur berikut: Menghasilkan angka acak x antara 0 dan 1. Jika semuanya sama, maka akhiri dan cetak x. Jika tidak, gandakan x dan ulangi. Karena angka acak Ruby memiliki 17 digit presisi, peluang terminasi pada langkah apa pun adalah 1 in (10e17) ^ x. Karena itu, kemungkinan untuk mengakhiri dalam n langkah adalah jumlah untuk x = 1 hingga n dari (1 / 10e17) ^ (2 ^ n), yang konvergen ke 1 / 10e34. Ini berarti bahwa untuk angka berapa pun, tidak peduli seberapa besar, sangat tidak mungkin bahwa program ini menghasilkan angka yang lebih rendah.

Sekarang, tentu saja, pertanyaan filosofisnya adalah apakah suatu program yang memiliki peluang kurang dari 1 dalam 10 ^ 34 untuk diakhiri dengan langkah n untuk setiap n dapat dikatakan pernah berakhir. Jika kita mengasumsikan tidak hanya waktu dan tenaga yang tak terbatas, tetapi bahwa program tersebut diberikan kemampuan untuk berjalan pada kecepatan yang meningkat pada tingkat yang melebihi tingkat di mana probabilitas terminasi menurun, kita dapat, saya percaya, pada kenyataannya membuat probabilitas berakhir pada saat t sewenang-wenang mendekati 1.

GolfScript, ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126) ₀ (126))))))))))))))

Ini tanpa malu-malu diadaptasi dari jawaban lain oleh @Howard, dan menggabungkan saran oleh @Peter Taylor.

[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f

Pemahaman saya tentang GolfScript terbatas, tetapi saya percaya *dan ^operator di atas tidak operator aritmatika yang dilarang oleh OP.

(Saya dengan senang hati akan menghapus ini jika @Howard ingin mengirimkan versinya sendiri, yang tentunya akan lebih baik dari yang ini.)

Program ini menghitung angka yang kira-kira f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} ( f _{ε 0} (126)))))))) ))) - iterasi sembilan kali lipat dari f _{ε 0} - di mana f _{ε 0} adalah fungsi dalam hierarki yang tumbuh cepat yang tumbuh dengan laju yang kira-kira sama dengan fungsi Goodstein. (f _{ε 0}tumbuh sangat cepat sehingga laju pertumbuhan fungsi Friedman n (k) dan panah berantai k-lipat Conway secara virtual tidak signifikan bahkan jika dibandingkan dengan hanya satu non-iterated f _{ε 0.} )

dc, 100 karakter

[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp

Diberi cukup waktu dan memori, ini akan menghitung angka sekitar 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15. Awalnya saya telah menerapkan fungsi hyperoperation , tetapi itu membutuhkan terlalu banyak karakter untuk tantangan ini, jadi saya menghapus n = 2, b = 0dan n >= 3, b = 0kondisinya, memutarn = 1, b = 0 kondisi menjadin >= 1, b = 0 .

Satu-satunya operator aritmatika yang digunakan di sini adalah penjumlahan dan pengurangan.

EDIT: seperti yang dijanjikan dalam komentar, berikut adalah uraian dari apa yang dilakukan kode ini:

[            # start "hyperoperation" macro
lnA A-=i     # if n == 0 call macro i
lbA A-=j     # if b == 0 call macro j
laSa         # push a onto a's stack
lbB A--Sb    # push b-1 onto b's stack
LndB A--SnSn # replace the top value on n with n-1, then push n onto n's stack
lhxlhx       # call macro h twice
]sh          # store this macro in h

[            # start "increment" macro (called when n=0, the operation beneath addition)
LaLnLb       # pop a, b, and n
F+sb         # replace the top value on b with b+15
q            # return
]si          # store this macro in i

[            # start "base case" macro (called when n>0 and b=0)
LbLnLa       # pop b, n, and a
sb           # replace the top value on b with a
q            # return
]sj          # store this macro in j

Fsa          # store F (15) in a
Fsb          # store F (15) in b
FFFFFFsn     # store FFFFFF "base 10" (150000+15000+1500+150+15=1666665) in n
lhx          # load and call macro h
lbp          # load and print b

Seperti dicatat, ini menyimpang dari fungsi hiperoperasi di mana kasus dasar untuk perkalian dan lebih tinggi diganti dengan kasus dasar untuk penambahan. Kode ini berperilaku seolah-olah a*0 = a^0 = a↑0 = a↑↑0 ... = a, bukan matematis yang benar a*0 = 0dana^0 = a↑0 = a↑↑0 ... = 1 . Sebagai hasilnya, ia menghitung nilai yang sedikit lebih tinggi dari yang seharusnya, tapi itu bukan masalah besar karena kami bertujuan untuk angka yang lebih besar. :)

EDIT: Saya baru saja memperhatikan bahwa satu digit masuk ke kode secara tidak sengaja, di makro yang melakukan peningkatan n=0. Saya telah menghapusnya dengan menggantinya dengan 'F' (15), yang memiliki efek samping dari penskalaan setiap operasi penambahan dengan 15. Saya tidak yakin seberapa besar ini mempengaruhi hasil akhir, tetapi mungkin jauh lebih besar sekarang.

Tidak ada batasan lagi pada runtime? Baiklah kalau begitu.

Apakah program harus dapat dijalankan pada komputer modern?

Kedua solusi menggunakan kompilasi 64-bit, sehingga long merupakan integer 64-bit.

C: lebih besar dari 10 ^{(2 64 -1) 2 64} , yang dengan sendirinya lebih besar dari 10 ^{10 355393490465494856447} ≈ 10 ↑↑ 4.11820744

long z;void f(long n){long i=z;while(--i){if(n)f(n+~z);printf("%lu",~z);}}main(){f(~z);}

88 karakter.

Untuk membuat formula ini lebih mudah, saya akan gunakan t = 2^64-1 = 18446744073709551615 .

mainakan memanggil fdengan parameter t, yang akan mengulang tkali, setiap kali mencetak nilai t, dan memanggil fdengan parametert-1 .

Jumlah digit yang dicetak: 20 * t .

Masing-masing panggilan fdengan parameter t-1akan mengulangi tkali, mencetak nilait , dan memanggil f dengan parametert-2 .

Jumlah digit yang dicetak: 20 * (t + t*t)

Saya mencoba program ini menggunakan yang setara dengan bilangan bulat 3-bit (saya mengatur i = 8dan memiliki panggilan utama f(7)). Itu mencapai pernyataan cetak 6725600 kali. Itu berhasil7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7 Oleh karena itu, saya percaya bahwa ini adalah perhitungan akhir untuk program lengkap:

Jumlah digit yang dicetak: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

Saya tidak yakin bagaimana cara menghitung (2 ⁶⁴ -1) ^{2 64} . Penjumlahan itu lebih kecil dari (2 ⁶⁴ ) ^{2 64} , dan saya membutuhkan kekuatan dua untuk melakukan perhitungan ini. Karena itu, saya akan menghitung (2 ⁶⁴ ) ^{2 64 -1} . Ini lebih kecil dari hasil sebenarnya, tetapi karena kekuatan dua, saya dapat mengubahnya menjadi kekuatan 10 untuk perbandingan dengan hasil lainnya.

Adakah yang tahu bagaimana melakukan penjumlahan itu, atau bagaimana mengkonversi (2 ⁶⁴ -1) ^{2 64} hingga 10 ⁿ ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
bagi eksponen dengan basis log 2 dari 10 untuk mengalihkan basis eksponen ke pangkat 10.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

Tapi ingat, itu angka digit yang dicetak. Nilai integer adalah 10 dinaikkan ke kekuatan itu, jadi 10 ^ 10 ^ 355393490465494856447

Program ini akan memiliki kedalaman tumpukan 2 ^ 64. Itu 2 ^ 72 byte memori hanya untuk menyimpan loop counters. Itu adalah 4 Miliar Terabyte penghitung loop. Belum lagi hal-hal lain yang akan terjadi pada stack untuk tingkat rekursi 2 ^ 64.

Sunting: Mengoreksi sepasang kesalahan ketik, dan menggunakan nilai yang lebih tepat untuk log2 (10).

Sunting 2: Tunggu sebentar, saya punya loop bahwa printf berada di luar. Mari kita perbaiki itu. Menambahkan inisialisasi i.

Sunting 3: Sial, saya mengacaukan matematika pada edit sebelumnya. Tetap.

Yang ini akan berjalan di komputer modern, meskipun tidak akan selesai dalam waktu dekat.

C: 10 ^ 10 ^ 136 ≈ 10 ↑↑ 3.329100567

#define w(q) while(++q)
long a,b,c,d,e,f,g,x;main(){w(a)w(b)w(c)w(d)w(e)w(f)w(g)printf("%lu",~x);}

98 Karakter.

Ini akan mencetak bitwise-kebalikan dari nol, 2 ^ 64-1, sekali untuk setiap iterasi. 2 ^ 64-1 adalah angka 20 digit.

Jumlah digit = 20 * (2^64-1)^7= 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500

Membulatkan panjang program hingga 100 karakter, Score = angka tercetak / 1.000.000

Nilai = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

Kode karakter R - 49 41, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348

set.seed(T)
cat(abs(.Random.seed),sep="")

akan mencetak [mereproduksi di sini hanya permulaan]:

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6 - 10 ^ 3 ↑↑↑↑ 3/884736

(3 ↑↑↑↑ 3 adalah G (1) di mana G (64) adalah nomor Graham)

u=-~[v=+[]+[]]+[];v+=e=v+v+v;D=x=>x.substr(u);K=(n,b)=>b[u]?n?K(D(n),K(n,D(b))):b+b+b:e;u+K(v,e)

Output: 10 ^ 3 ↑↑↑↑ 3

Petunjuk:

Gadalah fungsi di mana G (64) adalah nomor Graham. Input adalah bilangan bulat. Output adalah string unary yang ditulis dengan 0. Dihapus untuk singkatnya.

Kadalah fungsi Knuth up-panah a ↑ ⁿ b di mana a secara implisit 3. Input adalah n, string unary, dan b, string unary. Output adalah string unary.

u adalah "1".

v adalah "0000", atau G (0)

e adalah "000".

C

(Dengan permintaan maaf kepada Darren Stone)

long n,o,p,q,r;main(){while(--n){while(--o){while(--p){while(--q){while(--r){putchar('z'-'A');}}}}}}

n = 2 ^ 64 digit angka (9 ...)

l = 100 karakter kode

skor ≈ 1e + 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 ≈ 10 ↑↑ 3.2974890744

[Nilai = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1) / (10 ^ 6)

Perhatikan bahwa saya layak dicambuk tanpa ampun untuk jawaban ini, tetapi tidak bisa menolak. Saya tidak merekomendasikan bertingkah seperti saya di stackexchange, untuk alasan yang jelas. :-P

EDIT: Akan lebih sulit untuk menahan godaan untuk pergi dengan sesuatu seperti

long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}

... tapi saya mengira bahwa aturan yang dimaksudkan tetapi tidak ditentukan adalah bahwa seluruh angka yang membentuk angka harus dicetak.

Ruby Baru: skor ~ f _{ω ^ω2 +1} (126 ² 2 ¹²⁶ )

di mana f _α (n) adalah hierarki yang tumbuh cepat.

n=?~.ord;H=->a{b,*c=a;eval"b ?H[b==$.?c:[b==~$.?n:b-(b<=>$.)]*n+c]:p(n+=n);"*n};eval"H[~n];".*n*n<<n

Cobalah online!

Ini *nhanyalah perkalian string dan array, jadi semuanya harus baik-baik saja.

Kode tidak dikunci:

n = 126
H =-> a {
    b, *c = a
    n.times{
        case b
        when nil
            puts(n += n)
        when 0
            H[c]
        when -1
            H[[n]*n+c]
        else
            H[[b.-b<=>0]*n+c]
        end
    }
}
(n*n<<n).times{H[~n]}

di mana b.-b<=>0mengembalikan integer yang 1lebih dekat 0daripada b.

Penjelasan:

Mencetak npada awal setiap panggilan H.

H[[]]ganda n( nkali), yaitu n = n<<n.

H[[0,a,b,c,...,z]]panggilan H[[a,b,c,...,z]]( nkali).

H[[k+1,a,b,c,...,z]]panggilan H[[k]*n+[a,b,c,...,z]]( nwaktu), di mana [k]*n = [k,k,...,k].

H[[-1,a,b,c,...,z]]panggilan H[[n]*n+[a,b,c,...,z]]( nkali).

H[[-(k+1),a,b,c,...,z]]panggilan H[[-k]*n+[a,b,c,...,z]]( nkali).

H[k] = H[[k]].

Program saya diinisialisasi n = 126, kemudian memanggil H[-n-1]126 ² 2 ¹²⁶ kali.

Contoh:

H[[0]]akan memanggil H[[]]yang berlaku n = n<<n(n kali).

H[[0,0]]akan menelepon H[[0]]( nkali).

H[[1]]akan menelepon H[[0]*n]( nkali).

H[[-1]]akan menelepon H[[n]*n]( nkali).

H[[-1,-1]]akan menelepon H[[n]*n+[-1]]( nkali).

H[[-3]]akan menelepon H[[-2]*n]( nkali).

Cobalah online!

Lihat revisi untuk hal keren lainnya.

Fungsi Haskell - Ackermann diterapkan pada hasilnya 20 kali - 99 karakter

Ini adalah solusi haskell terbaik yang dapat saya buat berdasarkan pada fungsi ackermann - Anda mungkin melihat beberapa kesamaan dengan solusi nm, i = round $ log pi diinspirasi dari sana dan sisanya adalah kebetulan: D

i=round$log pi
n?m|m<i=n+i|n<i=i?(m-i)|True=(n-i)?m?(m-i)
a n=n?n
b=a.a.a.a
main=print$b$b$b$b$b$i

Ini menjalankan fungsi ackermann pada dirinya sendiri 20 kali, mulai dari satu, urutannya

• 1,
• 3,
• 61,
• a (61,61),
• a (a (61,61), a (61,61)) --- kami akan menyebut ini ₂ (61), atau ₄ (1) ---
• a ₃ (61)
• ...
• a ₁₈ (61), atau ₂₀ (1). Saya pikir ini kira-kira g ₁₈ (lihat di bawah).

Adapun estimasi, wikipedia mengatakan:

a (m, n) = 2 ↑ ^m-2 (n + 3) - 3

Dari sini kita dapat melihat a3 (1) = a (61,61) = 2 ↑ ⁵⁹ 64 + 3, yang jelas lebih besar dari g1 = 3 ↑ ⁴ 3, kecuali 3 pada awalnya jauh lebih penting daripada yang saya pikirkan. Setelah itu, setiap level melakukan hal berikut (membuang konstanta yang tidak signifikan dalam _n ):

• g _n = 3 ↑ ^{g _n-1} 3
• a _n ~ = 2 ↑ ^{a _n-1} (a _n-1 )

Jika ini kira-kira setara, maka a ₂₀ (1) ~ = g ₁₈ . Istilah terakhir dalam _n , (a _n-1 ) jauh lebih besar dari 3, sehingga berpotensi lebih tinggi dari g ₁₈ . Saya akan melihat apakah saya bisa mencari tahu apakah itu akan meningkatkannya bahkan iterasi tunggal dan melaporkan kembali.

kode mesin x86 - 100 byte (Dirakit sebagai file MSDOS .com)

Catatan: mungkin sedikit membengkokkan aturan

Program ini akan menghasilkan 2 ^{(65536 * 8 + 32)} sembilan yang akan menempatkan skor di (10 ^{2 524320} -1) / 1000000

Sebagai penghitung program ini menggunakan seluruh tumpukan (64kiB) ditambah dua register 16bit

Kode yang dirakit:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Majelis:

ORG 0x100

SECTION .TEXT
            mov bh, [b_ss]
            mov dx, ss
            mov [b_ss], dx
            mov [b_sp], sp
            mov ss, bx
            xor sp, sp
            mov bx, inthackdst
            inc bx
            mov ah, [inthacksrc]
            mov [bx], ah
            mov al, [nine]
            xor ah, ah
            inc ah
            inc ah
            inc ah
inthacksrc: adc ah, ah
            inc ah
            add ah, ah
            xor cx, cx
fillstack:  push cx
nine:       cmp sp, cx
            jnz fillstack
regloop:    xor dx, dx
dxloop:     xor cx, cx
cxloop:     xor bx, bx
inthackdst: int '?'
            inc cx
            jnz cxloop
            inc dx
            jnz dxloop
            pop cx
            inc cx
            jnz restack
popmore:    cmp sp, dx
            jz end
            pop cx
            inc cx
            jz popmore
restack:    push cx
            xor cx, cx
            cmp sp, dx
            jnz restack
            jmp regloop
end:        mov sp, [b_sp]
            mov ax, [b_ss]
            mov ss, ax
            ret

b_ss:       dw 'SX'
b_sp:       db 'X'

C

Ukuran file adalah 45 byte.

Programnya adalah:

main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}

Dan jumlah yang dihasilkan lebih besar dari 10 ^ (10 ^ (10 ^ 1.305451600608433)).

File yang saya arahkan std out saat ini lebih dari 16 Gb, dan masih terus bertambah.

Program ini akan berakhir dalam jumlah waktu yang wajar jika saya memiliki komputer yang lebih baik.

Skor saya tidak dapat dihitung dengan floating point presisi ganda.

GNU Bash, 10 ^ 40964096² / 80 ^ 3 ≈ 10 ↑↑ 2.072820169

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C count=$C$C|tr \\$((C-C)) $SHLVL'

C = 4096 pada sistem yang masuk akal. SHLVL adalah bilangan bulat positif kecil (biasanya 1 atau 2 tergantung pada apakah / bin / sh adalah bash atau tidak).

UNIX 64 bit saja:

Nilai: ~ 10 ^ (40964096409640964096 * 40964096409640964096) / 88 ^ 3

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C$C$C$C count=$C$C$C$C$C|tr \\$((C-C)) $SHLVL'

C, 10 ^ 10 ^ 2485766 ≈ 10 ↑↑ 3.805871804

unsigned a['~'<<'\v'],l='~'<<'\v',i,z;main(){while(*a<~z)for(i=l;printf("%u",~z),i--&&!++a[i];);}

Kami membuat array 258048 bilangan bulat yang tidak ditandatangani. Tidak mungkin rindu yang tidak ditandatangani karena itu membuat program terlalu lama. Mereka tidak ditandatangani karena saya tidak ingin menggunakan perilaku yang tidak terdefinisi, kode ini adalah C yang tepat (selain kurangnya pengembalian dari main ()) dan akan mengkompilasi dan berjalan pada mesin normal, itu akan tetap berjalan untuk waktu yang lama. . Ukuran ini adalah yang terbesar yang dapat kami ekspresikan secara hukum tanpa menggunakan karakter non-ascii.

Kami mengulang-ulang array mulai dari elemen terakhir. Kami mencetak digit 2^32-1, menambah elemen dan menjatuhkan loop jika elemen belum membungkus ke 0. Dengan cara ini kami akan mengulang (2^32 - 1)^254048 = 2^8257536kali, mencetak 10 digit setiap kali.

Berikut ini contoh kode yang menunjukkan prinsip dalam rentang data yang lebih terbatas:

#include <stdio.h>
unsigned int a[3],l=3,i,f;

int
main(int argc, char *argc){
        while (*a<4) {
        for (i = l; i-- && (a[i] = (a[i] + 1) % 5) == 0;);
            for (f = 0; f < l; f++)
                printf("%lu ", a[f]);
            printf("\n");
        }
}

Hasilnya kira-kira 10 ^ 10 ^ 2485766 dibagi dengan satu juta yang masih kira-kira 10 ^ 10 ^ 2485766.

Powershell (2.53e107976 / 72³ = 6.78e107970 ≈ 10 ↑↑ 1.701853371)

Ini membutuhkan waktu lebih dari 5 detik untuk berjalan.

-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"

Ini mengambil dan menyatukan panjang byte setiap file pada drive Anda saat ini. Regex menghapus semua karakter non-digit.

Python 3, skor = ack (126.126) / 100 ^ 3

g=len('"');i=ord('~');f=lambda m,n:(f(m-g,f(m,n-g))if n else f(m-g,g))if m else n+g
print(f(i,i))

Fungsi f adalah fungsi ackermann, yang saya punya cukup ruang untuk menjalankan.

Sunting: sebelumnya "else n +1", yang melanggar aturan tantangan - pujian untuk Simply Beautiful Art.

JavaScript 98 karakter

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(m.E<<k<<k<<k<<m.E);i+=j)a+=k;alert(a)

menghasilkan 2.718e + 239622337 ≈ 10 ↑↑ 2.9232195202

Untuk skor hanya sedikit lebih dari 2,718e + 239622331 ≈ 10 ↑↑ 2,9232195197

yang merupakan yang terbesar yang bisa saya buat tanpa browser mogok.

(console.log (a) akan menampilkan kepada Anda output penuh)

Jangan jalankan ini:

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(k<<k<<k<<k<<k<<k<<k);i+=j)a+=k;alert(a)

akan menampilkan 2.718 + e121333054704 ≈ 10 ↑↑ 3.0189898069 (alias 2.718 * 10 ^ (1.213 * 10 ^ 12) untuk dibandingkan dengan jawaban yang lebih panjang:

versi yang lebih ekstrem, jika tidak merusak browser Anda:

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<k;i+=j)a+=k;alert(a)

yang akan membuat angka dengan ukuran yang sama dengan e * 10 ^ (10 ^ 19) ≈ 10 ↑↑ 3.106786869689

Sunting: solusi asli kode yang diperbarui hanya menghasilkan 2,718e + 464

Python 3: 98 karakter, ≈ 10 ↑↑ 256

Menggunakan fungsi argumen-variabel:

E=lambda n,*C:E(*([~-n][:n]+[int("%d%d"%(k,k))for k in C]))if C else n;print(E(*range(ord('~'))))

Secara efektif, E mengurangi argumen pertama sambil meningkatkan sisa argumen, kecuali bahwa alih-alih menempatkan -1 dalam argumen itu menjatuhkan argumen. Karena setiap siklus mengurangi argumen pertama atau mengurangi jumlah argumen, ini dijamin akan berakhir. Fungsi peningkatan yang digunakan adalah int ("% d% d"% (k, k)), yang memberikan hasil antara k ** 2 + 2 * k dan 10 * k ** 2 + k. Kode saya memang menggunakan simbol * - tetapi tidak sebagai perkalian. Ini digunakan untuk bekerja dengan sejumlah variabel argumen, yang saya pikir harus mengikuti aturan karena titik jelas dari aturan adalah untuk membatasi operasi tertentu, bukan simbol itu sendiri.

Beberapa contoh seberapa besar E dapat dengan cepat:

E(1,1) = 1111
E(0,1,1) = E(11,11) = (approx) 10^8191
E(1,1,1) = E(1111,1111) = (approx) 10^(10^335)
E(2,1,1) = E(11111111,11111111) = (approx) 10^(10^3344779)

Hanya dua yang pertama yang bisa dijalankan di komputer saya dalam jumlah waktu yang wajar.

Kemudian, E dipanggil oleh E(*range(ord('~')))- yang berarti:

E(0,1,2,3,4,5, ... ,121,122,123,124,125)

Saya tidak sepenuhnya yakin seberapa besar ini (saya sudah mencoba untuk memperkirakannya tetapi tidak berhasil) - tetapi jelas bahwa ini ~ sangat ~ besar.

Sebagai contoh, sekitar dua belas siklus, hasilnya sekitar: (secara teknis sedikit lebih dari)

E(2**27211,2**27211,2**27212,2**27212,2**27212,2**27212,2**27213,2**27213,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636)

Estimasi hasil:

Jika kami memperkirakan langkah peningkatannya lambda k: 10 * k**2, fungsi dapat digambarkan sebagai

E(n, C₁, C₂, ... Cᵥ) ≈ E(10^(n²/2) ⋅ C₁²ⁿ, 10^(n²/2) ⋅ C₂²ⁿ, ... 10^(n²/2) ⋅ Cᵥ²ⁿ)
                     ≈ E(10^((10^(n²/2) ⋅ C₁²ⁿ)²/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )
                     ≈ E(10^((10^n² ⋅ C₁⁴ⁿ)/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )

Hal yang relevan yang kami lakukan di sini adalah membangun menara kekuatan sepuluh, sehingga skor akhirnya dapat diperkirakan 10 ↑↑ 256.

Estimasi hasil yang lebih baik (walaupun parsial):

Ini menggunakan yang sama 10 * k**2dengan estimasi lainnya.

E(0, b) = 10 * b**2
E(1, b) = 10 * (10 * b**2)**2 = 10 * 100 * b**4 = 10**3 * b**4
E(2, b) = 10 * (10**3 * b**4)**2 = 10 * (10**6 * b**8) = 10**7 * b**8
E(a, b) = 10**(2**(a+1)-1) * b**(2**(a+1))

Di bawah estimasi sebelumnya, itu akan menjadi:

E(a, b) = 10**(a**2/a) * b**(2*a)

Yang secara signifikan lebih kecil dari nilai sebenarnya karena menggunakan a**2bukan 2**auntuk 10 dan menggunakan a*2bukan 2**auntuk b.

C (skor ≈ 10 ^ 20 000 000 000 ≈ 10 ↑↑ 3,005558275)

• ~ 20 GB output
• 41 karakter (41 ^ 3 tidak berarti apa-apa)

main(){for(;rand();printf("%d",rand()));}

Meskipun rand()outputnya deterministik karena tidak ada fungsi seed.