Amacınız, yalnızca on karakter kod kullanarak mümkün olan en yüksek sayıyı (standart çıktıya) yazdırmaktır.

• Yerleşik üs işlevleri dışında, dilinizin herhangi bir özelliğini kullanabilirsiniz.
  • Benzer şekilde, bir sayı girmek için bilimsel gösterimi kullanamazsınız. (Böylece, hayır 9e+99.)
• Program, kullanıcıdan herhangi bir giriş yapmadan numarayı yazdırmalıdır. Benzer şekilde, diğer dosyalardan veya Web'den okuma, vb.
• Programınız tek bir sayıyı hesaplamalı ve yazdırmalıdır. Bir dizeyi yazdıramazsınız ya da aynı rakamı binlerce kez yazdıramazsınız.
• Herhangi bir şeyi yazdırmak için gereken kodu 10 karakterlik sınırın dışında tutabilirsiniz. Örneğin, print xsözdizimini kullanan Python 2'de , programınız için 16 karaktere kadar kullanabilirsiniz.
• Program aslında çıktıda başarılı olmalı. Dünyanın en hızlı bilgisayarında çalıştırmak bir saatten uzun sürerse, geçersizdir.
• Çıktı herhangi bir biçimde olabilir (eğer yazdırma yapabilmek için 999, 5e+100vs.)
• Sonsuzluk soyut bir kavramdır , sayı değil. Bu yüzden geçerli bir çıktı değil.

Wolfram Dili

ack(9!,9!)

ack (9!, 9!) =

Çıktı, Ok Notasyonundadır.

Perl,> 1.96835797883262e + 18

time*time

Bugün en büyük cevap olmayabilir ... Ama yeterince bin yıl bekleyin ve olacak!

Bazı açıklamalara değinmek için, "yeterli millenia" derken, aslında ¹⁰⁰ yıl demek istiyorum .

Adil olmak gerekirse, evrenin büyük donma / sıcaklık ölümü, evrenin nasıl sona ereceği (~ 10 ¹⁰⁰ yıl olacağı tahmin edilir ) ise, "nihai" değer , kesinlikle bazılarının çok altında olan ~ 10 ²¹⁴ olacaktır . diğer cevaplar (olsa da, "rastgele kuantum dalgalanmalar veya kuantum tünel 10 başka bir büyük Bang üretebilir ^{10 56} yıl"). Daha iyimser bir yaklaşım izlersek (örneğin döngüsel veya çok boyutlu bir model), o zaman zaman sonsuza kadar devam edecek ve bu nedenle bazı evrende bir gün, bazı yüksek bit mimaride, cevap diğerlerinden biraz daha fazla olacaktır.

Öte yandan, belirtildiği gibi time, tamsayı / uzunluğun büyüklüğü ile sınırlıdır, yani gerçekte bir şey ~0her zaman daha büyük bir sayı üretecektir time(yani timemimarinin desteklediği maksimum ).

Bu en ciddi cevap değildi, ama umarım beğenmişsinizdir!

Wolfram ≅ 2,003529930 × 10 ¹⁹⁷²⁸

Evet, bu bir dil! Popüler Wolfram Alpha sitesinin arka ucunu kullanıyor. Ackermann işlevinin yerleşik olduğu ve 6 karakterden daha kısa olduğunu bulduğum tek dil .

Sekiz karakterde:

$ ack(4,2)

200352993...719156733

Veya ≅ 2.003529930 × 10 ¹⁹⁷²⁸

ack(4,3), ack(5,2)vb çok daha büyük, ama çok büyük. ack(4,2)Muhtemelen bir saat içinde tamamen hesaplanabilen en büyük Ackermann sayısıdır.

Büyük sayılar sembolik formda, örneğin:

$ ack(4,3)

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

Kurallar herhangi bir çıktı formatına izin verildiğini söylüyor, bu yüzden bu geçerli olabilir. Bu 10'dan fazla olduğu ^{10 19727} tekrarlanan faktöriyele haricinde burada diğer girişler hepsinden daha büyüktür.

Ancak,

$ ack(9,9)

2↑⁷12 - 3

tekrarlanan faktörlemeden daha büyük. On karakterde alabileceğim en büyük sayı:

$ ack(99,99)

2↑⁹⁷102 - 3

Bu delicesine çok büyük, evrenin sayının kayıtlarını tekrarlamış olsanız bile rakamlarının önemli bir kısmını temsil edecek kadar büyük değil.

Python2 kabuğu, 3,010,301 basamak

9<<9999999

Uzunluğun hesaplanması: Python bu uzun sayılara bir "L" ekleyeceği için sonucun rakamlarından 1 karakter daha fazla olduğunu bildirir.

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

İlk ve son 20 hane:

40724177878623601356... ...96980669011241992192

CJam, 2 × 10 ^268,435,457

A28{_*}*K*

Bu , aşağıdaki gibi tanımlanan b'yi hesaplar :

• bir ₀ = 10

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

• b = 20 × ₂₈

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

Arka fon

Bu, Claudiu'nun cevabıyla aynı fikri takip ediyor , ancak buna dayanmıyor . Kendisini gönderdikten birkaç dakika sonra yayınladığıma benzer bir fikrim vardı , ancak zaman sınırına yakın bir yere gelmediği için atmıştım.

Ancak, aditsu önerisi Java 8'e yükseltme ve benim fikrim CJam bazı hatalar / Ruby'nin bignum sınırlamaları nedeniyle görünmektedir GolfScript, ötesinde sayıları hesaplamak için izin 10 yetkilerini kullanma.

Nasıl çalışır

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,{)*_*}/

Makinemde beş dakikadan az zaman alıyor, bu yüzden hala geliştirmeye yer var.

Bu , aşağıdaki gibi tanımlanan bir ₂₀ değerini hesaplar :

• bir ₀ = 20

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

Nasıl çalışır

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

Düzenleme: Yeni cevabım:

9<<(7<<33)

Eskiler için eski cevap:

9<<(1<<35)

Tam olarak on karakter.

Sayıyı hex olarak basıyorum ve

Herhangi bir şeyi yazdırmak için gereken kodu 10 karakterlik sınırın dışında tutabilirsiniz. Örneğin, x baskı sözdizimini kullanan Python 2'de, programınız için 16 karaktere kadar kullanabilirsiniz.

Bu nedenle, gerçek kodum:

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

Belirtilen sürede çalıştığını ve belirtilen boyutta bir sayı ürettiğini kanıtlar:

time python bignum.py > bignumoutput.py

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

Numaram> 10 ^ (15032385538 * log (16))> 10 ^ 18100795813

İlki nedeniyle yukarıdaki wc çıktısından 3 daha az altıgen basamak 0x9.

Python 3 gereklidir, çünkü python 2'de 7<<33uzun <<sürecektir ve girdi olarak uzun sürmez.

Bunun yerine 9 << (1 << 36) kullanamıyorum çünkü:

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

Bu, a<<(b<<cd)bilgisayarımda yazdırılabilecek en olası form sayısı .

Her durumda, dünyanın en hızlı makinesi benden daha fazla belleğe sahip, bu yüzden alternatif cevabım:

9<<(9<<99)

9 * 2 ^ (9 * 2 ^ 99)> 10 ^ (1,7172038461 * 10 ^ 30)

Ancak şu anki cevabım, kimsenin gönderdiği en büyüğüdür, bu yüzden muhtemelen yeterince iyi. Ayrıca, bunların tümü bit kaydırmanın izin verilebileceğini varsayar. Kullanarak diğer cevaplardan anlaşılıyor.

Yeterince kısa sabit adlara sahip herhangi bir dil, yaklaşık 18 hane.

99/sin(PI)

Bunu bir PHP cevabı olarak gönderirdim ama ne yazık ki M_PIbu biraz fazla uzun sürüyor! Ancak PHP bunun için 8.0839634798317E + 17 verir. Temel olarak, PI'da mutlak hassasiyet eksikliğini kötüye kullanır: p

Haskell

Hile olmadan:

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

Muhtemelen hiçbir şey hesaplamadan:

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

Niet'in cevabını uyarlamak :

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

Güç Kabuğu - 1.12947668480335E + 42

99PB*9E9PB

99 Çakıl çarpı 9.000.000.000 çarpı.

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

Evet, bu çok fazla. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))çok kesin olmamak.

!!!!!!!!9x

K / Kona : 8.977649e261 1,774896e308

*/1.6+!170

• !170 0 ila 169 arasında bir sayılar vektörü oluşturur
• 1.6+ vektörün her bir elemanına bir tane ekler ve gerçeklere dönüştürür (aralık 1.6 ila 170.6 arasındadır)
• */ dizinin her bir elemanını birlikte çarpar

Kona dörtlü hassasiyeti destekliyorsa, */9.+!9991e2584 civarında yapabilirim. Ne yazık ki, değil ve ben çifte kesinlik sınırlıdır.

eski yöntem

*/9.*9+!99

• !99 0 ila 98 arasında bir sayılar vektörü oluşturur
• 9+ vektörün her bir öğesine 9 ekler (şimdi 9 ila 107 arasında değişiyor)
• 9.* her bir öğeyi 9.0 ile çarparak (dolaylı olarak gerçeklere dönüştürmek, yani 81.0 ile 963.0 arasında)
• */ vektörün her bir elemanını birlikte çoğaltır

HTML, 9999999999

9999999999

.. başarmak.

Python - 13916486568675240 değerine kadar değişir (şimdiye kadar)

Tamamen ciddi değil ama biraz eğlenceli olacağını düşündüm.

print id(len)*99

Çalıştığım her şeyden, lentutarlı bir şekilde beni büyük kimlikleri alıyordum.

Bilgisayarımda 13916486568675240 (17 basamak) ve bu sitede 13842722750490216 (ayrıca 17 basamak) vermiştir . Sanırım bunun size 0'a kadar düşmesi mümkün, ama daha da yükselebilir.

Golfscript, 1e + 33,554,432

10{.*}25*

Üstler 10 ^ (2 ^ 25)kullanmadan hesaplar , 96 saniyede çalışır:

$ 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

Sadece 9 ^ (2 ^ 9999)yeterli zaman verilirse hesaplanabilir , ancak iç üssü birer birer arttırmak, zamanı üç katına çıkarır, böylece bir saat sınırına çok kısa sürede ulaşılır.

Açıklama :

Aynı fikri kullanarak önceki bir sürümü kullanmak:

8{.*}25*

Yıkılıyor:

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

Her bloğun başındaki yığın, bir sayıdan, geçerli sayıdan oluşur. Bu olarak başlar 8. Sonra:

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

Yani, adım adım yığın şöyle gözüküyor:

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

... vb Matematik gösterimi ile yazılan ilerleme:

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 (veya ^{10,5,5,705,514} )

999*13511!

Çıktı

269146071053904674084357808139[49888 digits]000000000000000000000000000000

Özelliklere tam olarak uyup uymadığından emin değilim (özellikle çıktı formatı bir), ancak daha da büyük vuruşlar yapabilirim:

bfloat(99999999!)

Çıktı

9.9046265792229937372808210723818b8565705513

Yani kabaca 10 var ^8565705514 olan belirgin üst cevapların çoğu daha büyük ve yaklaşık 2 saniye içinde hesaplanmıştır. bfloatFonksiyon verir Keyfi hassas .

Haskell, 4950

Aww dostum, o kadar değil! Dolar işaretinden sonra 10 karakter başlar.

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

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

Tam olarak on karakter.

Python kabuğu, 649539 999890001

Beats Haskell, gerçekten ciddi bir cevap değil.

99999*9999

Wolfram Alpha (bir web sitesi dil olarak sayılır)?

9! ! ! ! !

çıktılar

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

Cory, mekanların hem ebeveynlerin hem de işyerlerinin çalıştığı bahşiş için teşekkürler.

Befunge-93 (1,853,020,188,851,841)

Kimse henüz Befunge'yi yapmadığı için sevindi (benim nişim), ama kahretsin, sayıyı artırmak için akıllıca bir numara bulamıyorum.

9:*:*:*:*.

Öyleyse saat 9 ^ 16.

:*

Temelde yığının en üstündeki değeri kendisi ile çarpar. Böylece, yığının en üstündeki değer şöyle olur:

9
81
6561
43046721
1853020188851841

ve

.

Son değeri çıkarır. Herhangi birisinin daha iyi bir fikri olup olmadığını görmek isterim.

Bunu yukarıdaki bir yorum olarak göndermeyi tercih ederim, ama görünüşe göre noob olduğumdan beri yapamam.

Python:

9<<(2<<29)

Daha büyük bir bit kayması ile giderdim, ancak Python bir kaymanın doğru işlenenin uzun olmayan bir tamsayı olmasını istiyor gibi görünüyor. Bence bu teorik max'a yaklaşıyor:

9<<(7<<27)

Bunlarla ilgili tek sorun, kural 5’i yerine getirememeleridir.

Matlab (1.7977e + 308)

Matlab, adlandırılan bir değişkende en büyük (çift kesinlikli) kayan nokta sayısının değerini saklar realmax. Komut penceresinde (veya komut satırında) çağırmak değerini yazdırır:

>> realmax

ans =

  1.7977e+308

Python, ca. 1.26e1388

9<<(9<<9L)

verir:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L

En az Python 3.5.0 (64 bit), 10'dan fazla ^ 242944768872896860

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

İdeal bir dünyada, bu olurdu 9<<(1<<63)-1, ama bunun için yeterli bayt yok. Bu sayı o kadar büyük ki, bilgisayarımda sahip olduğumdan biraz daha fazla olması için neredeyse 1 EiB bellek gerektiriyor. Neyse ki, onu tutmak için yalnızca dünyadaki depolama alanının yaklaşık% 0,2'sini kullanmanız gerekir. İkili değerdeki değerleri 10018070450532247928832 sıfırlarla takip eder.

Python 128-bit makineler için çıkarsa, en 9<<(9<<99)fazla 1 MiYiB bellek gerektirecek şekilde olacaktır . Bu iyidir, çünkü Python yorumlayıcısını ve işletim sistemini saklamak için yeterli adrese sahip olacaksınız.

Cubix , 9.670457478596419e + 147 (yarışma dışı)

****"///**

Rekabet etmiyor çünkü Cubix bu mücadeleden daha yeni. Burada çevrimiçi olarak test edebilirsiniz , ancak numarayı gerçekten yazdırmadığını unutmayın; *Yığındaki değeri görmek için son iki saniye çalıştırıldıktan sonra programı duraklatmanız gerekir .

Nasıl çalışır

Cubix, kodun bir küpün etrafına sarıldığı 2 boyutlu bir esolangdır. Bu kod tam olarak aşağıdaki .no'lu küp netine eşdeğerdir, burada no-op'dur:

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

Ardından, kod çalıştırılır ve talimat göstericisi (IP) en sol yüzün sol üst köşesinden başlayarak sağa bakar. "dize modunu "açar, bir sonraki tarihe kadar karşılaşılan tüm karakterlerin karakter kodlarını yığına iter. IP, kod dizisini tamamen sararken, sicim modundan tekrar çıkmadan önce üç /s (47), iki *s (42) ve iki .s (46) yığına iter .

İşte ilginçleştiği yer. İlk ayna /IP'yi yansıtır, böylece yukarı bakar; daha sonra bu karakterleri vurarak küpün etrafında döner:

           
    * *
  /     *      
  .     .      
    . .

Üç *s, yığındaki ilk iki öğeyi çarpar. Şimdi, aritmetik operatörlerin argümanlarını belirttiği yığın tabanlı dillerin aksine, Cubix önceki değerleri yığında bırakır. Yani bu hesaplar demek 46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976.

IP /tekrar ulaştığında, sağa döner. Sonra bir sonraki aynaya çarpar ve şu yolu izler:

    *  
    *  
    /         .
    .         .
    .  
    .  

İki yıldız üst iki maddeyi bir kez daha çarpar. Sonra ayna IP'yi tekrar yönlendirir ve üçüncü ayna işlemi bir kez daha tekrarlar:

      *
      *
      /     .  
      .     .  
      .
      .

Son olarak IP, ayna bölümünü doğuya doğru terk eder. İki final yıldız işareti, iki kez daha çoğalır ve yığın üzerinde 9.670457478596419e + 147'nin bir sonucu kalır. Bu ile basılabilir O, ancak küp üzerindeki her nokta pratik olarak kullanıldığı için bunu yapmanın kolay bir yolu yoktur.

Scala, 2 ⁶³ -1

Zavallı, zavallı Scala. Bir BigIntdeğeri elde etmek için en az 8 karakter gerekir ; bu değerin büyük olması için yeterli yer bırakmaz.

Ancak, yalnızca 7 karakterlik (sayılan) kodla mümkün olan en büyük pozitifleri yazdırabiliriz Long:

print(-1L>>>1)

Brainf ** k 256 - 2147483647

>+[<+>+]<.

_{Derleyicilerin ve tercümanların çoğunun ascii eşdeğeri olarak çıktı verdikleri gerçeğini görmezden gelirseniz (zayıf, ne olduğu;))} , bu tercüman / derleyicinin veri türünün maksimum değerini döndürür.

Bazı sistemlerde bu sadece 256'dır, ancak bazılarında (örneğin mayın) bu 32 bit bir tamsayı için maksimum değerdir, yani 2 147 483 647.

Düzenle:

-.

Aynı şeyi daha az sayıda karaktere yazdıracak

Perl, rakipsiz

Bunu perl'in küçük bir köşesini vurgulamak için kullanıyorum.

Perl bu konuda gerçekten rekabet edemez çünkü yerleşik bignumları yoktur (tabii ki bir bignum kütüphanesi yükleyebilirsin).

Ama herkesin bildiği tam olarak doğru değil. Bir çekirdek işlevi aslında büyük sayıları kaldırabilir.

packBiçimi waslında tabanı arasında herhangi bir boyut doğal sayı dönüştürebilirsiniz 10ve baz 128. Bununla birlikte, baz 128 tamsayı dize bayt olarak temsil edilir. Bit dizgisi xxxxxxxyyyyyyyzzzzzzzbayt haline gelir: 1xxxxxxx 1yyyyyyy 0zzzzzzz(her bayt, sonuncusu hariç 1 ile başlar). Ve böyle bir dizgiyi, paketi açarak üs 10'a dönüştürebilirsiniz. Böylece şöyle bir kod yazabilirsiniz:

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

hangi verir:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

4**4Çok uzun sürdüğünü veya çok fazla bellek kullandığını hissedene kadar, daha büyük değerlerle değiştirebilirsiniz .

Ne yazık ki bu, bu zorluğun sınırı için çok uzun bir süredir ve taban 10 sonucunun sonuç olmadan önce bir dizgeye dönüştürüldüğünü, böylece ifadenin gerçekten bir sayı üretmeyeceğini iddia edebilirsiniz. Ancak dahili olarak perl, girişi her zaman oldukça temiz olduğunu düşündüğüm 10 tabanına dönüştürmek için gereken aritmetiği gerçekten yapar.

TI-36 (84, 36 değil), 10 bayt, yaklaşık. 9.999985426E99

Eski hesap makineleri de bir dereceye kadar programlanabilir;)

69!58.4376

Bu, bir TI hesaplayıcısının gösterebileceği maksimum aralığa çok yakındır:-1E100<x<1E100

Perl 6 , 456,574 basamak

[*] 1..ↈ

TIO yok çünkü çalışması 2 dakika sürüyor.