Tujuan Anda adalah mencetak (ke output standar) sebanyak mungkin, menggunakan hanya sepuluh karakter kode.

• Anda dapat menggunakan fitur apa pun dari bahasa Anda, kecuali fungsi eksponensial bawaan.
  • Demikian pula, Anda tidak boleh menggunakan notasi ilmiah untuk memasukkan nomor. (Jadi, tidak 9e+99.)
• Program harus mencetak nomor tanpa masukan dari pengguna. Demikian pula, tidak ada bacaan dari file lain, atau dari Web, dan sebagainya.
• Program Anda harus menghitung satu nomor dan mencetaknya. Anda tidak dapat mencetak string, atau mencetak digit yang sama ribuan kali.
• Anda dapat mengecualikan dari batas 10 karakter kode apa pun yang diperlukan untuk mencetak apa pun. Misalnya, dalam Python 2 yang menggunakanprint x sintaks, Anda dapat menggunakan hingga 16 karakter untuk program Anda.
• Program harus benar-benar berhasil dalam output. Jika perlu waktu lebih dari satu jam untuk berjalan di komputer tercepat di dunia, itu tidak valid.
• Output mungkin dalam format apapun (sehingga Anda dapat mencetak 999, 5e+100dll)
• Infinity adalah konsep abstrak , bukan angka. Jadi ini bukan output yang valid.

Bahasa Wolfram

ack(9!,9!)

ack (9!, 9!) =

Output dalam Notasi Panah.

Perl,> 1.96835797883262e + 18

time*time

Mungkin bukan jawaban terbesar ... hari ini! Tapi tunggu cukup ribuan tahun dan itu akan terjadi!

Untuk menjawab beberapa komentar, dengan "millenia yang cukup," sebenarnya saya maksud dengan n ^100s tahun.

Agar adil, jika kematian besar pembekuan / panas alam semesta adalah bagaimana alam semesta akan berakhir (diperkirakan terjadi ~ 10 ¹⁰⁰ tahun), nilai "final" adalah ~ 10 ²¹⁴ , yang tentu saja jauh lebih sedikit daripada beberapa tanggapan lain (meskipun, "fluktuasi kuantum acak atau penerowongan kuantum dapat menghasilkan Ledakan Besar lainnya di 10 ^{10 56)} tahun"). Jika kita mengambil pendekatan yang lebih optimis (misalnya model siklik atau multiverse), maka waktu akan berlangsung tanpa batas, dan suatu hari nanti di beberapa alam semesta, pada beberapa arsitektur bit tinggi, jawabannya akan melebihi beberapa yang lain.

Di sisi lain, seperti yang ditunjukkan, timememang dibatasi oleh ukuran bilangan bulat / panjang, sehingga dalam kenyataannya sesuatu seperti ~0selalu akan menghasilkan jumlah yang lebih besar daripada time(yaitu maks yang timedidukung oleh arsitektur).

Ini bukan jawaban yang paling serius, tapi saya harap kalian menikmatinya!

Wolfram ≅ 2.003529930 × 10 ¹⁹⁷²⁸

Ya, itu bahasa! Ini mendorong back-end situs Wolfram Alpha yang populer. Ini satu-satunya bahasa yang saya temukan di mana fungsi Ackermann terintegrasi dan disingkat menjadi kurang dari 6 karakter.

Dalam delapan karakter:

$ ack(4,2)

200352993...719156733

Atau ≅ 2.003529930 × 10 ¹⁹⁷²⁸

ack(4,3), ack(5,2)dll. jauh lebih besar, tetapi terlalu besar. ack(4,2)mungkin nomor Ackermann terbesar daripada yang dapat sepenuhnya dihitung dalam waktu kurang dari satu jam.

Angka yang lebih besar diberikan dalam bentuk simbolis, misalnya:

$ ack(4,3)

2↑²6 - 3 // using Knuth's up-arrow notation

Aturan mengatakan format output apa pun diizinkan, jadi ini mungkin valid. Ini lebih besar dari 10 ^{10 19727} , yang lebih besar dari salah satu entri lain di sini kecuali untuk faktorial yang diulang.

Namun,

$ ack(9,9)

2↑⁷12 - 3

lebih besar dari faktorial berulang. Jumlah terbesar yang bisa saya dapatkan dalam sepuluh karakter adalah:

$ ack(99,99)

2↑⁹⁷102 - 3

Ini luar biasa besar, Semesta tidak cukup besar untuk mewakili porsi signifikan dari digit-digitnya, bahkan jika Anda mengambil log berulang-ulang dari angka tersebut.

Shell Python2, 3.010.301 digit

9<<9999999

Menghitung panjang: Python akan menambahkan "L" ke angka-angka panjang ini, sehingga ia melaporkan 1 karakter lebih dari hasil yang memiliki digit.

>>> len(repr( 9<<9999999 ))
3010302

20 digit pertama dan terakhir:

40724177878623601356... ...96980669011241992192

CJam, 2 × 10 ^268.435.457

A28{_*}*K*

Ini menghitung b , didefinisikan sebagai berikut:

• a ₀ = 10

• a _n = a _{n - 1} ²

• b = 20 × a ₂₈

$ time cjam <(echo 'A28{_*}*K*') | wc -c
Real    2573.28
User    2638.07
Sys     9.46
268435458

Latar Belakang

Ini mengikuti ide yang sama dengan jawaban Claudiu , tetapi tidak berdasarkan itu. Saya punya ide serupa yang saya posting hanya beberapa menit setelah dia mempostingnya , tetapi saya membuangnya karena tidak mendekati batas waktu.

Namun, saran aditsu untuk meng-upgrade ke Java 8 dan ide saya untuk menggunakan kekuatan 10 memungkinkan CJam untuk menghitung angka di luar jangkauan GolfScript, yang tampaknya disebabkan oleh beberapa bug / batasan Bignum Ruby.

Bagaimana itu bekerja

A    " Push 10.                                                          ";
28{  " Do the following 28 times:                                        ";
  _* " Duplicate the integer on the stack and multiply it with its copy. ";
}*   "                                                                   ";
K*   " Multiply the result by 20.                                        ";

CJam, ≈ 8,1 × 10 ^1,826,751

KK,{)*_*}/

Butuh waktu kurang dari lima menit pada mesin saya, jadi masih ada ruang untuk perbaikan.

Ini menghitung ₂₀ , didefinisikan sebagai berikut:

• a ₀ = 20

• a _n = (n × a _{n - 1} ) ²

Bagaimana itu bekerja

KK,   " Push 20 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ]. ";
{     " For each integer in the array:                                 ";
  )*  " Increment it and compute the its product with the accumulator. ";
  _*  " Multiply the result with itself.                               ";
}/

Python 3, 9 * 2 ^ (7 * 2 ^ 33)> 10 ^ 18.100.795.813

9 * 2 ^ (2 ^ 35)> 10 ^ 10.343.311.894

Sunting: Jawaban baru saya adalah:

9<<(7<<33)

Jawaban lama, untuk anak cucu:

9<<(1<<35)

Tepatnya sepuluh karakter.

Saya mencetak nomor dalam hex, dan

Anda dapat mengecualikan dari batas 10 karakter kode apa pun yang diperlukan untuk mencetak apa pun. Misalnya, dalam Python 2 yang menggunakan cetak x sintaks, Anda dapat menggunakan hingga 16 karakter untuk program Anda.

Karena itu, kode saya yang sebenarnya adalah:

print(hex(9<<(7<<33)))

Bukti bahwa itu berjalan dalam waktu yang ditentukan dan menghasilkan sejumlah ukuran yang ditentukan:

time python bignum.py > bignumoutput.py

real    10m6.606s
user    1m19.183s
sys    0m59.171s
wc -c bignumoutput.py 
15032385541 bignumoutput.py

Nomor saya> 10 ^ (15032385538 * log (16))> 10 ^ 18100795813

3 digit hex kurang dari cetakan wc di atas karena inisial 0x9.

Python 3 diperlukan karena dalam python 2, 7<<33akan menjadi panjang, dan <<tidak butuh waktu lama sebagai input.

Saya tidak dapat menggunakan 9 << (1 << 36) sebagai gantinya karena:

Traceback (most recent call last):
  File "bignum.py", line 1, in <module>
    print(hex(9<<(1<<36)))
MemoryError

Dengan demikian, ini adalah jumlah formulir yang paling besar a<<(b<<cd) dapat dicetak di komputer saya.

Dalam semua kemungkinan, mesin tercepat di dunia memiliki lebih banyak memori daripada saya, jadi jawaban alternatif saya adalah:

9<<(9<<99)

9 * 2 ^ (9 * 2 ^ 99)> 10 ^ (1.7172038461 * 10 ^ 30)

Namun, jawaban saya saat ini adalah yang terbesar yang dikirimkan siapa pun, jadi mungkin cukup baik. Juga, ini semua dengan asumsi bit-shifting diperbolehkan. Tampaknya, dari jawaban lain yang menggunakannya.

Bahasa apa pun dengan nama konstan yang cukup pendek, kira-kira 18 digit.

99/sin(PI)

Saya akan memposting ini sebagai jawaban PHP tapi sayangnya M_PImembuat ini terlalu lama! Tetapi PHP menghasilkan 8.0839634798317E + 17 untuk ini. Pada dasarnya, itu menyalahgunakan kurangnya presisi absolut dalam PI: p

Haskell

Tanpa trik:

main = print -- Necessary to print anything
    $9999*9999 -- 999890001

Dapat diperdebatkan tanpa menghitung apa pun:

main = print
    $floor$1/0 -- 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216

Mengadaptasi jawaban Niet :

main = print
    $99/sin pi -- 8.083963479831708e17

Powershell - 1.12947668480335E + 42

99PB*9E9PB

Gandakan 99 Pebibytes kali 9.000.000.000.000 Pebibytes.

J ( ((((((((9)!)!)!)!)!)!)!)!)

Ya, itu banyak. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))menjadi tidak terlalu tepat.

!!!!!!!!9x

K / Kona : 8.977649e261 1.774896e308

*/1.6+!170

• !170 membuat vektor angka dari 0 hingga 169
• 1.6+ menambahkan satu ke setiap elemen vektor & mengonversi ke real (kisaran 1,6 hingga 170,6)
• */ mengalikan setiap elemen array menjadi satu

Jika Kona mendukung presisi quad, saya bisa melakukan */9.+!999dan berkeliling 1e2584. Sayangnya, itu tidak dan saya dibatasi hingga presisi ganda.

metode lama

*/9.*9+!99

• !99 membuat vektor angka dari 0 hingga 98
• 9+ menambahkan 9 ke setiap elemen vektor (sekarang berkisar 9 hingga 107)
• 9.* mengalikan setiap elemen dengan 9.0 (secara implisit mengkonversi ke real, jadi 81.0 hingga 963.0)
• */ mengalikan setiap elemen vektor bersama-sama

HTML, 9999999999

9999999999

.. berhasil.

Python - Bervariasi, hingga 13916486568675240 (sejauh ini)

Tidak sepenuhnya serius tapi saya pikir itu akan menyenangkan.

print id(len)*99

Dari semua yang saya coba, lenpaling konsisten membuat saya id besar.

Menghasilkan 13916486568675240 (17 digit) di komputer saya dan 13842722750490216 (juga 17 digit) di situs ini . Saya kira ini mungkin untuk memberi Anda serendah 0, tetapi bisa juga lebih tinggi.

Golfscript, 1e + 33.554.432

10{.*}25*

Menghitung 10 ^ (2 ^ 25), tanpa menggunakan eksponen, berjalan dalam 96 detik:

$ time echo "10{.*}25*" | ruby golfscript.rb  > BIG10

real    1m36.733s
user    1m28.101s
sys     0m6.632s
$ wc -c BIG10
 33554434 BIG10
$ head -c 80 BIG10
10000000000000000000000000000000000000000000000000000000000000000000000000000000
$ tail -c 80 BIG10
0000000000000000000000000000000000000000000000000000000000000000000000000000000

Ia dapat menghitung hingga 9 ^ (2 ^ 9999), jika hanya diberikan waktu yang cukup, tetapi menambahkan eksponen dalam dengan satu membuatnya membutuhkan ~ tiga kali lipat waktu, sehingga batas satu jam akan segera tercapai.

Penjelasan :

Menggunakan versi sebelumnya dengan ide yang sama:

8{.*}25*

Hancurkan:

8         # push 8 to the stack
{...}25*  # run the given block 25 times

Tumpukan di awal setiap blok terdiri dari satu nomor, nomor saat ini. Ini dimulai sebagai8 . Kemudian:

.         # duplicate the top of the stack, stack is now | 8 | 8 |
*         # multiply top two numbers, stack is now       | 64 |

Jadi tumpukan, langkah demi langkah, terlihat seperti ini:

8
8 8
64
64 64
4096
4096 4096
16777216
16777216 16777216

... dll. Ditulis dalam notasi matematika progresnya adalah:

n=0, 8                     = 8^1  = 8^(2^0)
n=1, 8*8                   = 8^2  = 8^(2^1)
n=2, (8^2)*(8^2) = (8^2)^2 = 8^4  = 8^(2^2)
n=3,               (8^4)^2 = 8^8  = 8^(2^3)
n=4,               (8^8)^2 = 8^16 = 8^(2^4)

wxMaxima ~ 3x10 ^49.948 (atau 10 ^{8.565.705.514} )

999*13511!

Output adalah

269146071053904674084357808139[49888 digits]000000000000000000000000000000

Tidak yakin apakah itu cukup sesuai dengan spesifikasi (terutama format output satu), tapi saya dapat menekan lebih besar:

bfloat(99999999!)

Output adalah

9.9046265792229937372808210723818b8565705513

Itu kira-kira 10 ^{8.565.705.514} yang secara signifikan lebih besar dari sebagian besar jawaban teratas dan dihitung dalam waktu sekitar 2 detik. The bfloatFungsi memberikan presisi sewenang-wenang .

Haskell, 4950

Aww man, itu tidak banyak! 10 karakter dimulai setelah tanda dolar.

main=putStr.show$sum[1..99]

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

Tepatnya sepuluh karakter.

Shell python, 649539 999890001

Beats Haskell, bukan jawaban yang serius.

99999*9999

Wolfram Alpha (apakah situs web dianggap sebagai bahasa)?

9! ! ! ! !

output

10^(10^(10^(10^(10^(6.27...))))

terima kasih kepada Cory untuk tip bahwa ruang bekerja dan juga parens.

Befunge-93 (1.853.020.188.851.841)

Senang belum ada yang melakukan Befunge (ini ceruk saya), tapi sial saya tidak bisa menemukan trik pintar untuk menambah jumlahnya.

9:*:*:*:*.

Jadi 9 ^ 16.

:*

Pada dasarnya mengalikan nilai di bagian atas tumpukan dengan dirinya sendiri. Jadi, nilai di atas tumpukan berlaku:

9
81
6561
43046721
1853020188851841

dan

.

Menghasilkan nilai akhir. Saya akan tertarik untuk melihat apakah ada yang punya ide yang lebih baik.

Saya lebih suka memposting ini sebagai komentar di atas, tetapi ternyata saya tidak bisa karena saya seorang noob.

Python:

9<<(2<<29)

Saya akan menggunakan bit shift yang lebih besar, tetapi Python tampaknya menginginkan operan yang tepat dari pergeseran menjadi bilangan bulat yang tidak panjang. Saya pikir ini semakin mendekati teori max:

9<<(7<<27)

Satu-satunya masalah dengan ini adalah bahwa mereka mungkin tidak memenuhi aturan 5.

Matlab (1.7977e + 308)

Matlab menyimpan nilai angka floating-point terbesar (presisi ganda) dalam variabel yang disebut realmax. Memintanya di jendela perintah (atau di baris perintah) mencetak nilainya:

>> realmax

ans =

  1.7977e+308

Python, ca. 1.26e1388

9<<(9<<9L)

Memberi:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L37634036313038859977295626367160619139675145747597185726573351363864334560386886632464140309991451407124759119111193096530653065303030303030303030303030 bahwa dengan meningkatnya masa depan37634036313038859977295626367160619139675145747597185726573351363864334560386886632464140309991451407124759119111193096530653065303030303030303030303030 bahwa dengan meningkatnya masa depan

Setidaknya Python 3.5.0 (64-bit), lebih dari 10 ^ 242944768872896860

print("{:x}".format( 9<<(7<<60) ))

Di dunia yang ideal, ini akan terjadi 9<<(1<<63)-1, tetapi tidak ada cukup byte untuk itu. Jumlah ini sangat besar sehingga membutuhkan hampir 1 EiB memori untuk menampungnya, yang sedikit lebih banyak daripada yang saya miliki di komputer saya. Untungnya, Anda hanya perlu menggunakan sekitar 0,2% dari ruang penyimpanan dunia sebagai swap untuk menahannya. Nilai dalam biner adalah1001 diikuti oleh 8070450532247928832 nol.

Jika Python keluar untuk mesin 128-bit, maksimumnya adalah 9<<(9<<99), yang membutuhkan memori kurang dari 1 MiYiB. Ini bagus, karena Anda akan memiliki ruang alamat yang cukup untuk menyimpan interpreter Python dan sistem operasi.

Cubix , 9.670457478596419e + 147 (tidak bersaing)

****"///**

Non-bersaing karena Cubix lebih baru dari tantangan ini. Anda dapat mengujinya secara online di sini , tetapi perhatikan bahwa itu tidak benar-benar mencetak nomornya; Anda harus menjeda program setelah dua yang terakhir *dijalankan untuk melihat nilai pada stack.

Bagaimana itu bekerja

Cubix adalah esolang 2 dimensi di mana kode tersebut dililitkan di sekitar kubus. Kode ini persis sama dengan jaring kubus berikut, di mana .adalah no-op:

    * *
    * *
" / / / * * . .
. . . . . . . .
    . .
    . .

Kemudian kode dijalankan, dengan penunjuk instruksi (IP) dimulai di sudut kiri atas wajah paling kiri, menghadap ke kanan. "Mengaktifkan mode string, di mana semua karakter ditemui hingga berikutnya "mendorong kode karakter mereka ke stack. IP membungkus semua jalan di sekitar kode, mendorong tiga /s (47), dua *s (42), dan dua. s (46) ke stack, sebelum keluar dari mode string lagi.

Di sinilah mulai menarik. Cermin pertama /memantulkan IP sehingga menghadap ke atas; kemudian berputar di sekitar kubus, memukul karakter ini:

           
    * *
  /     *      
  .     .      
    . .

Tiga *s mengalikan dua item teratas di tumpukan. Sekarang, tidak seperti kebanyakan bahasa berbasis stack di mana operator aritmatika mengeluarkan argumen mereka, Cubix meninggalkan nilai sebelumnya pada stack. Jadi itu berarti ini menghitung 46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976.

Ketika IP mencapai /lagi, itu berbelok ke kanan. Kemudian menyentuh cermin berikutnya dan mengikuti jalan ini:

    *  
    *  
    /         .
    .         .
    .  
    .  

Dua tanda bintang melipat dua item teratas sekali lagi. Kemudian mirror mengarahkan IP lagi, dan mirror ketiga mengulangi proses sekali lagi:

      *
      *
      /     .  
      .     .  
      .
      .

Akhirnya, IP meninggalkan bagian cermin menuju ke timur. Dua tanda bintang akhirnya berlipat ganda dua kali, meninggalkan hasil 9,670457478596419e + 147 pada tumpukan. Ini bisa dicetak dengan O, tetapi tidak ada cara mudah untuk melakukannya karena praktis setiap tempat di kubus sudah digunakan.

Scala, 2 ⁶³ -1

Miskin, miskin Scala. Membutuhkan setidaknya 8 karakter untuk mendapatkan aBigInt nilai, yang tidak meninggalkan cukup ruang untuk benar-benar menjadi besar.

Tetapi dengan hanya 7 karakter kode (dihitung), kami dapat mencetak positif semaksimal mungkin Long:

print(-1L>>>1)

Brainf ** k 256 - 2147483647

>+[<+>+]<.

_{Jika Anda mengabaikan fakta bahwa sebagian besar kompiler & penerjemah mengeluarkan data sebagai ascii yang setara (lebih ramping, ini adalah apa adanya;))} , ini akan mengembalikan nilai maksimum dari datatype juru / kompiler.

Pada beberapa sistem ini hanya 256, meskipun pada beberapa (misalnya tambang), ini adalah nilai maksimum integer 32 bit, yaitu 2 147 483 647.

Sunting:

-.

Akan mencetak hal yang sama dalam banyak karakter lebih sedikit

Perl, tidak bersaing

Saya menggunakan ini untuk menyoroti sudut sedikit tahu perl.

Perl tidak dapat benar-benar bersaing dalam hal ini karena tidak memiliki builtin bignum (tentu saja Anda dapat memuat perpustakaan bignum).

Tapi apa yang diketahui semua orang tidak sepenuhnya benar. Satu fungsi inti sebenarnya bisa menangani angka besar.

The packFormat wbenar-benar dapat mengkonversi ukuran nomor alam antara basis 10dan basis 128. Namun, integer basis 128 direpresentasikan sebagai byte string. Bitstring ituxxxxxxxyyyyyyyzzzzzzz menjadi byte: 1xxxxxxx 1yyyyyyy 0zzzzzzz(setiap byte dimulai dengan 1 kecuali yang terakhir). Dan Anda dapat mengonversi string seperti itu ke basis 10 dengan membongkar. Jadi Anda bisa menulis kode seperti:

unpack w,~A x 4**4 .A

pemberian yang mana:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

Anda dapat mengganti 4**4dengan nilai yang lebih besar hingga Anda merasa itu terlalu lama atau menggunakan terlalu banyak memori.

Sayangnya ini terlalu panjang untuk batas dari tantangan ini, dan Anda dapat berargumen bahwa hasil basis 10 dikonversi ke string sebelum menjadi hasilnya sehingga ekspresi tidak benar-benar menghasilkan angka. Tetapi secara internal perl benar-benar melakukan aritmatika yang diperlukan untuk mengubah input ke basis 10 yang saya selalu anggap agak rapi.

TI-36 (bukan 84, 36), 10 byte, kira-kira. 9.999985426E99

Kalkulator yang lebih tua juga dapat diprogram sampai batas tertentu;)

69!58.4376

Ini sangat dekat dengan rentang maksimum yang dapat ditampilkan oleh kalkulator TI:-1E100<x<1E100

Perl 6 , 456.574 digit

[*] 1..ↈ

Tidak ada TIO karena butuh 2 menit untuk berjalan.