Amacınız, sayı yazdıran bir program yazmaktır. Sayı büyüdükçe, daha fazla puan alırsınız. Ama dikkat et! Kod uzunluğu, puanlama işlevinde hem sınırlıdır hem de çok ağırdır. Basılı numaranız, çözümünüz için kullandığınız bayt sayısının küpü ile bölünür .

Diyelim ki yazdırdınız 10000000ve kodunuz 100bayt uzunluğunda. Son puanınız olacak 10000000 / 100^3 = 10.

Bu zorluğu biraz zorlaştırmak için izlenmesi gereken başka kurallar var.

• Kodunuzdaki rakamları kullanamazsınız (0123456789);
• Sen edebilir etc / fiziksel / matematiksel kullanın. sabitler, ancak yalnızca 10'dan küçüklerse (ör. Pi ~ = 3.14 kullanabilirsiniz, ancak Avogadro sabitini kullanamazsınız = 6e23)
• Özyinelemeye izin verilir, ancak oluşturulan sayının sınırlı olması gerekir (bu nedenle sınırsız bir çözüm olarak kabul edilmez.
• İşlemleri *(çarpma), /(bölme), ^(güç) veya bunları belirtmek için başka hiçbir şekilde 2 div 2kullanamazsınız (örn. İzin verilmez);
• Buna ihtiyaç duyarsanız, programınız birden fazla numara çıkarabilir . Sadece en yüksek puanlama için sayılır;
• Bununla birlikte, olabilir dizeleri bitiştirmek Bu komşu basamak herhangi bir dizi tek bir numara olarak kabul edilecektir anlamına gelir;
• Kodunuz olduğu gibi çalıştırılacak. Bu, son kullanıcının herhangi bir kod satırını düzenleyemeyeceği veya bir sayı veya başka bir şey giremeyeceği anlamına gelir;
• Maksimum kod uzunluğu 100 bayttır.

Liderler Sıralaması

1. Steven H. , Pyth ≈ f _{φ (1,0,0) +7} (256 ²⁶ ) / 1000000 ^[1]
2. Basitçe Güzel Sanatlar , Yakut ≈ 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. Basitçe Güzel Sanat , Yakut ≈ f _{omega ^{© 2} 1} (1983)
6. eaglgenes101 , Julia ≈ f _ω3 (127)
7. col6y , Python 3, ≈ (127 → 126 → ... → 2 → 1) / 99 ^{3 [1] [3]}
8. Toeofdoom , Haskell'in ≈ bir ₂₀ (1) / 99 ^{3 [1]}
9. Fraxtil , dc, ≈ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 ^{3 [3]}
10. Macenta , 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. özyinelemeli , Python, ≈ 2 ↑↑ 11/95 ³ ≈ 10 ↑↑ 8.63297 ^{[1] [3]}
15. nm , Haskell, ≈ 2 ↑↑ 7/100 ³ ≈ 10 ↑↑ 4.63297 ^[1]
16. David Sapma , C ≈ 10 ^{10 4 x 10 22} /83 ³ ≈ 10 ↑↑ 4,11821 ^[2]
17. primo , Perl, ≈ 10 ^{(12750684161!) 5 x 2 27} /-100 ³ ≈ 10 ↑↑ 4,11369
18. Resimler , Cı ≈ 10 ^{10 2 x 10 6} /98 ³ ≈ 10 ↑↑ 3,80587
19. Robert Sørlie , x86, 10 ^{2 2 19 +32} / 100 ^{3 3} 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 x (2 64 ) 4} /-100 ³ ≈ 10 ↑↑ 3,28039
24. Joshua , deneme, ≈ 10 ^{10 15} /86 ³ ≈ 10 ↑↑ 3,07282

_Dipnotlar

1. ^{Eğer evrendeki her elektron bir alışkanlıktıysa ve her bir süperpozisyonu bilgiyi depolamak için kazançlı bir şekilde kullanılabilirdi (ki, gerçekte ne depolandığını teorik olarak mümkün olduğunu bilmeniz gerekmediği sürece ), bu program mümkün olandan daha fazla bellek gerektirir. muhtemelen var ve bu nedenle çalıştırılamaz - ya da gelecekte akla gelebilecek herhangi bir noktada. Yazar aynı anda ≈3 ↑↑ 3.28'den daha büyük bir değer yazdırmayı amaçladıysa, bu koşul geçerlidir.}
2. ^{Bu program şu anda var olandan daha fazla bellek gerektiriyor, ancak o kadar fazla değil, teorik olarak az sayıdaki qubitte depolanamıyordu ve bu nedenle bir gün bu programı çalıştırabilecek bir bilgisayar var olabilir.}
3. ^{Şu anda mevcut olan tüm tercümanlar bir çalışma zamanı hatası veriyor veya program aksi takdirde yazarın istediği şekilde çalışamıyor.}
4. ^{Bu programın çalıştırılması sisteminizde onarılamaz bir hasara neden olur.}

Edit @primo : Ben bir sonraki daha yüksek güce logaritmik mesafe belirtmek için ondalık ile, notasyonu karşılaştırmak için bir umutla daha kolay kullanarak çetele bir bölümünü güncelledik. Örneğin, 10 ↑↑ 2.5 = 10 ^{10 √10} . Ayrıca, kullanıcının analizinin hatalı olduğuna inanıyorsam, bunlardan herhangi birini tartışmaktan çekinmediğim için bazı puanları değiştirdim.

Bu gösterimin açıklaması:

Eğer 0 ≤ b < 1öyleyse .a↑↑b = ab

Eğer b ≥ 1öyleyse .a↑↑b = aa↑↑(b-1)

Eğer b < 0öyleyse .a↑↑b = loga(a↑↑(b+1))

GolfScript; en az puan f _{ε_0 + ω + 1} (17) / 1000

Res 'in bu soru için solucan cevabının Yaşam Boyu'nu kullanması yönündeki önerisini takiben , Howard'ın çözümünü çıkarması üzerine büyük ölçüde iyileşen iki program sunuyoruz.

Ortak bir ön ek paylaşırlar, işlev adını modulo:

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

f _{ε 0} olarak kabaca g(g(1)) = g(5)nerede g(x) = worm_lifetime(x, [x])büyüdüğünü hesaplar (bu, "notların" Goodstein işleviyle kabaca aynı oranda büyüyen hızlı büyüyen hiyerarşideki işlev "olduğunu belirtir).

Analiz edilmesi biraz kolay (!)

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

.{foo}*haritalar xiçin foo^x x.

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

Böylece verir g^(g(5)) ( g(5) ); diğer 8 yineleme seviyesi de ok zincirlemeye benzer. Basit terimlerle ifade etmek için: eğer h_0 = gve h_{i+1} (x) = h_i^x (x)sonra hesaplarız h_10 (g(5)).

Sanırım bu ikinci program neredeyse kesinlikle çok daha iyi puan alıyor. Bu kez işleve atanan etiket gyeni bir satırdır (sic).

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

Bu sefer ^farklı bir işlevi daha iyi kullanıyorum .

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

alır xyığında ve yaprakları xiçeren bir dizi ardından xkopyalarını .{bunu takiben gtakip xkopyaları }*; daha sonra dizeyi değerlendirir. Yedek karakterleri yazmak için daha iyi bir yerim olduğu için j_0 = g; eğer j_{i+1} (x) = j_i^x (x)öyleyse ^hesapların ilk değerlendirmesi j_{g(5)} (g(5))(ki önceki programdan çoktan eminim). Daha sonra ^16 kez daha uygularım; öyleyse k_0 = g(5)ve k_{i+1} = j_{k_i} (k_i)sonra hesaplar k_17. k_i>> f _{to_0 + ω + 1} (i) olduğunu tahmin _ettiğim için tekrar tekrar müteşekkirim .

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

NOT: BU ÇALIŞTIRMAYIN F'ING!

Aşağıdakileri bir toplu iş dosyasına kaydedin ve Yönetici olarak çalıştırın.

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

4TB'lik bir sürücüde ilk yazdırılan numara kalın yazılmış olarak çıktı.

D sürücüsüne yeni disk yerleştirin:
hazır olduğunda ENTER tuşuna basın ... Dosya sisteminin türü NTFS'dir.
Yeni dosya sistemi FAT.
QuickFormatting 3907172M
Ses, FAT16 / 12 için çok büyük.

GolfScript, puan: yol çok fazla

Tamam, birkaç rakam GolfScript ile ne kadar büyük basabiliriz?

Yazdıran aşağıdaki kodla başlayalım ( teşekkürler, Ben! ) 126:

'~'(

Daha sonra, en yaklaşık 1,26126 × 10 eşit bize bir sayı elde bunu 126 kez tekrar edelim ³⁷⁷ :

'~'(.`*

(Bu dize tekrarı, çarpma değil, bu yüzden kurallara uymalı.)

Şimdi bu 378 basamaklı sayıyı 10 ³⁷⁷ defadan biraz daha fazla tekrarlayalım:

'~'(.`*.~*

Bu programın biteceğini asla göremezsiniz, çünkü yaklaşık 10 ³⁸⁰ ≈ 2 ¹¹⁴⁰ hane ile bir sayı hesaplamaya çalışır . Hiç bir bilgisayar inşa edilmemiş büyüklükte bir sayı depolayamaz ve böyle bir bilgisayar bilinen fiziği kullanarak inşa edemez; gözlemlenebilir evrendeki atomların sayısının yaklaşık 10 olduğu tahmin edilmektedir ⁸⁰ , bu yüzden bir türlü kullanabilirsiniz bile evrendeki tüm maddeyi bu büyük sayıda saklamak için, biz hala bir şekilde tıkmak olurdu yaklaşık 10 ³⁸⁰ /10 ⁸⁰ = Her atomun içine 10 ³⁰⁰ hane !

Ancak, böyle bir hesaplama yapabilen, Tanrı'nın kendi GolfScript tercümanına sahip olduğumuzu ve hala tatmin olmadığımızı varsayalım. Tamam, hadi tekrar yapalım!

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

Bu programın çıktısı tamamlandığında yaklaşık 10 ^{10 383} hane sahip olacak ve böylece yaklaşık 10 ^{10 10 383'e} eşit olacaktır .

Fakat bekle! Bu program tekrar ediyor ... neden bir döngüye çevirmiyoruz?

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

Burada, halka gövdesi yaklaşık 10 ³⁷⁷ kez çalıştırılır , bu da bize 10 10 ^{37 10 377} haneden oluşan teorik bir çıktı verir ; burada ^10'lu yinelenmiş güç kulesi yaklaşık 10 ³⁷⁷ adım uzunluğundadır. (Aslında, bu çok büyük bir küçümseme, çünkü tekrarlanan sayının her zaman daha da uzadığı gerçeğini ihmal ediyorum, ama göreceli olarak bunun küçük bir mesele olduğunu düşünüyorum.)

Ama henüz bitmedi. Başka bir döngü ekleyelim!

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

Düzgün bir şekilde bu sayıların yaklaşık bir değerinin yazılması ezoterik matematiksel gösterimi gerektirir. Örneğin, Knuth yukarı ok gösterimi , program tarafından numarası (teorik olarak) çıkış yukarıdaki yaklaşık 10 ↑ olmalıdır ³ 10 ³⁷⁷ , vermek veya birkaç (veya 10 almak ³⁷⁷ Birazdan matematik yaptım varsayarak on) yetkilerini.

Bunun gibi sayılar sadece “inanılmaz derecede büyük” ötesi ve “düşünülemez” alemine girerler. Olduğu gibi, sadece bu sayıları saymak ya da yazmak imkansız değildir (yukarıdaki üçüncü örnekte bu noktanın ötesine geçtik), ancak kelimenin tam anlamıyla soyut matematiğin dışında düşünülebilecek bir kullanımı veya varlığı yoktur. Biz gelen, kanıtlayabilirim matematik aksiyomları böyle rakamlar yukarıda programlamak GolfScript şartname gelen kanıtlayabilirim gibi, var olduğunu, olacağını ) gerçeklik ve mevcut depolama alanı sınırları müdahale olmasaydı, onları hesaplamak, ama tam anlamıyla var hiçbir şey de Onları herhangi bir şekilde saymak veya ölçmek için kullanabileceğimiz fiziksel evren.

Yine de, matematikçiler bazen daha büyük sayıları bile kullanırlar . (Teorik) bilgi işlem numaraları o büyük biraz daha fazla iş alır - yerine sadece daha fazla iç içe birer birer, biz içine geçecek şekilde özyineleme kullanmak gerekir döngüler derinliği iç içe döngüler. Yine de, prensipte, Conway zincirli ok gösterimi ile ifade edilebilir herhangi bir sayıyı (teorik olarak) hesaplamak için kısa bir GolfScript programı (100 baytın altında beklediğim gibi) yazmak mümkün olmalıdır ; Detaylar bir egzersiz olarak bırakılmıştır. ;-)

JavaScript 44 karakter

Bu biraz hile görünebilir:

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

Puan = 31415926535897932718281828459045/44 ^ 3 ≈ 3.688007904758867e + 26 ≈ 10 ↑↑ 2,1536134004

C, skor = 10 ^{10 97.61735} / 98 ^3, 10, 2.29874984

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

Puanlamadaki yardımın için teşekkür ederim. Herhangi bir görüş veya düzeltme takdir edilmektedir. İşte benim yöntemim:

n = 1 ile 2 ^{64 -} 1 arasındaki sayıların her biri , ⁴ kez tekrarlandı (2 ^{64 -} 1) . İlk olarak, işte 1 - 2 ⁶⁴ -1 ("alt sıra" ) olan kümülatif basamak sayısını nasıl hesapladığımı (düşük) : Alt sıra sekansındaki son sayı 2 ⁶⁴ -1 = 1844674407370955161520 basamaklı. Bu nedenle, sıradaki sayıların% 90'ından fazlasının ( 1.. ile başlayanlar 9) 19 basamağı vardır. Kalan% 10 ortalama 10 hane varsayalım. Bundan daha fazlası olacak, ama bu kolay matematik için aldatma ve düşük bir tahmin. Bu sıranın ⁴ kez tekrarlanması (2 ⁶⁴ -1) , böylece uzunlukve n olacak en az (0.9 x (2 ⁶⁴ -1) 19 + 0.1 x (2 × ⁶⁴ x (2 1) × 10) ⁶⁴ 1) ⁴ = 3,86613 * 10 ⁹⁷ basamak. Aşağıdaki yorumlarda @primo, n'nin 4.1433x10 ⁹⁷ olduğunu doğrular . Yani n kendisi bu güce 10 veya 10 olacak ^{10 97,61735} .

l = 98 kod karakteri

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

Gereksinim: 64-bit bir bilgisayarda çalışmalı sizeof(long) == 8. Mac ve Linux yapacak.

Python 3 - 99 karakter - (büyük olasılıkla) Graham sayısından çok daha büyük

Ackermann işlevinin bir uzantısına dayanarak daha hızlı bir şekilde artan bir işlev buldum.

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 bana ilham verdi, ancak numaramı anlamak için oraya bakmanıza gerek yok.

İşte analizde kullanacağım ackermann işlevinin değiştirilmiş hali:

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

AYukarıdaki koddaki fonksiyonum teknik olarak aynı değildir, ancak yukarıdaki tanımın üçüncü satırının yerini almak için aşağıdaki ifade ile daha güçlüdür:

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

(a en az 1 olmalı, bu yüzden daha güçlü olmalı)

Ancak benim amaçlarıma göre, basit olanla aynı olduğunu kabul edeceğim, çünkü analiz zaten kısmen Ackermann'ın işlevi için ve bu nedenle iki işlevi olduğunda bu işlev için yapıldı.

Fonksiyonum sonunda tekrarlamayı durdurma garantilidir, çünkü her zaman ya: Bir argümanı kaldırır, ilk argümanı azaltır veya aynı ilk argümanı tutar ve ikinci argümanı azaltır.

Boyut analizi

Graham'ın numarası, AFAIK, aşağıdaki gibi gösterilebilir G(64):

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

Nerede bir ↑^(n)b knuth yukarı ok gösterimi olduğunu.

Ayrıca:

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)

Yukarıdaki programda ifade edilen sayı A(0,1,2,3,4,...,123,124,125).

Yana g^64(4)Graham'ın sayıdır ve benim matematik varsayarak o daha azdır ardından doğrudur A(1,64,100)numaram, önemli ölçüde Graham'ın sayısından daha büyük.

Lütfen matematiğimdeki herhangi bir hatayı işaret edin - eğer olmasa da, bu soruyu cevaplamak için şu ana kadar hesaplanan en büyük sayı olmalıdır.

Perl - puan ≈ 10 ↑↑ 4.1

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

Perl'in regex motorunu, düşünülemez miktarda kombinasyonda öğütmek için bir kez daha kötüye kullanmak, bu sefer özyinelemeli bir iniş kullanarak.

İfadenin iç kısmında, .sonsuz özyinelemeyi önleyen ve dolayısıyla özyineleme düzeylerini dizenin uzunluğuyla sınırlayan bir çıplaklığımız vardır .

Sonunda bulacağımız şey şudur:

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

... toplam 12750684161 yuva için 671088640 kez tekrarlandı ; bu , önceki 23 yuvamı oldukça utandırıyor. Dikkate değer bir şekilde, perl bu konuda boğulmuyor bile (bir kez daha, bellek kullanımı yaklaşık 1.3 GB'da sabit kalıyor), ancak ilk baskı bildiriminin yayınlanmasından önce oldukça uzun sürecek.

Aşağıdaki önceki analizden yola çıkarak, basamak çıktı sayısının sırasına olacağı sonucuna varılabilir (! 12750684161) ^671088640 , k! Olan Sol Faktoriyel ait k (bkz A003422 ). Bunu (k-1) olarak tahmin edebiliriz ! , kesinlikle daha küçüktür, ancak aynı büyüklük sırasına göre.

Ve Wolframalpha'ya sorarsak :

... ki skorumu neredeyse hiç değiştirmiyor. Bunun en az 10 ↑↑ 5 olacağından eminim . Sanırım 10 ↑↑ 4 ile 10 ↑↑ 4.1 arasındaki fark sandığınızdan çok daha büyük.

Perl - puan ≈ 10 ↑↑ 4

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

Perl regex motoru kötüye kullanmak bizim için bazı kombinatorik yapmak. Gömülü kod bloğu
(??{print})sonucu doğrudan regex'e ekler. Yana $_tamamen oluşmaktadır 2s (ve sonucu printher zaman 1), bu maç ve epeyce var olan tüm olası kombinasyonları aracılığıyla iplik perl gönderir asla.

Kullanılan sabitler

• $^F- tipik olarak maksimum sistem dosyası tanıtıcısı 2.
• $]- perl sürüm numarası, benzer 5.016002.

$_daha sonra 671088640 kez 2tekrarlanan basamağı içeren bir dizedir . Hafıza kullanımı yaklaşık 1,3 GB ile sabittir, çıktı hemen başlar.

analiz

P _k (n) ' i print ifadesinin yürütüldüğü sayı olarak tanımlayalım , burada k yuvaların sayısıdır ve n , dizgenin uzunluğu artı bir tanedir (sadece n + 1 yazmak istemiyorum çünkü her yerde).

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

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

(((.*.*)*)*)*
P ₄ (n) = [ 4, 56, 1044, 20272, 394.940, 7.696.008, 149.970.676, 2922453344, ... ]

((((.*.*)*)*)*)*
P ₅ (n) = [ 5, 250, 16695, 1.126.580, 76.039.585, 5132387790, 346.417.023.515, 23381856413800, ... ]

(((((.*.*)*)*)*)*)*
P ₆ , (n) = [ 6, 1452, 445.698, 137.050.584, 42142941390, 12958920156996, ... ]

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

Genel olarak, formül aşağıdaki gibi genelleştirilebilir:

nerede

Yani, Sol Faktoriyel ait k daha az bütün faktöriyellerinin toplamı yani k (bkz A003422 ).

Ben kapalı formlar belirleyemiyor oldum D _k ve E _k , ama bunu gözlemlemek eğer bu da çok önemli değil

ve

İle 23 yerleştirmelerin, bu bize yaklaşık bir puan verir:

Aslında bu neredeyse kesin olmalı.

Ancak bunu görselleştirmesi biraz daha kolay olan bir gösterime yerleştirmek için iç üssün tabanını yaklaştırabiliriz:

ve sonra üs:

ve sonra wolframalpha'ya sor :

ki sadece 10 ↑↑ 4'ü arayabilir ve işiniz bitebilir .

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)

Maksimum yinelemenin fen uygun yol olduğu gözlemine dayanarak , 13 fçağrıyı f, zher biri defalarca ( fartmaya devam ederken z) 3 seviyeli iç içe döngüler çağrısı ile değiştirdim .

Skoru analitik olarak bir kağıda tahmin ettim - eğer görmek isteyenler varsa yazarım.

Geliştirilmiş Puan: 10 ↑↑ 13

Javascript, tam olarak 100 karakter, tekrar:

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)

Bu, orjinal cevabımı üç şekilde geliştirir.

1. zKüresel kapsamı tanımlamak bizi o.zher seferinde yazmaktan kurtarır .

2. Küresel kapsamda (pencere) bir alıcı tanımlamak ve fbunun yerine yazmak mümkündür o.f.

3. Daha fazla yinelemeye sahip olmak, daha fbüyük bir sayıyla başlamaktan daha değerlidir; bu nedenle (Math.E+'').replace('.','')(= 2718281828459045, 27 karakter) yerine, ~~Math.E+''(= 2, 11 karakter) yerine kullanmanız ve fdaha fazla kez aramak için kurtarılabilir karakterleri kullanmak daha iyidir .

Aşağıda daha ayrıntılı olarak analiz edildiği gibi, her bir yineleme, M büyüklüğündeki bir sayıdan, 10 ^M büyüklüğündeki bir sayıdan daha büyük bir sayı ürettiğinden, bu kod, her yinelemeden sonra üretir.

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

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

Javascript, tam olarak 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)

Her biri o.f, toplam 5 döngü için while döngüsünü çağırır. Sadece ilk yinelemeden sonra, puan zaten 10 ^{42381398144233621'in} üzerinde . İkinci yinelemeyle Mathematica, sonuçtaki basamak sayısını bile hesaplayamadı .

İşte kodun bir özeti:

İçinde

Ondalık noktayı kaldırarak 2718281828459045 ile başlayın Math.E.

Yineleme 1

Azalan sayı sırasını birleştirmek,

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

yeni (devasa) bir numara oluşturmak,

• 271828182845904527182818284590442718281828459043 ... 9876543210.

Bu rakamda kaç rakam var? Peki, bu birleşme

• 1718281828459046 16 basamaklı sayılar
• 900000000000000 15 basamaklı sayılar
• 90000000000000 14 basamaklı sayılar,
• 9000000000000 13 basamaklı sayılar
• ...
• 900 3 basamaklı sayılar
• 90 2 basamaklı sayılar
• 10 1 basamaklı sayılar

Mathematica'da

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

Başka bir deyişle, 2.72⋅10 ^{42381398144233625} .

Sadece ilk yinelemeden sonra, puanımı ^kazanıyorum , 2.72⋅10 ^{42381398144233619} .

Yineleme 2

Ama bu sadece başlangıç. Şimdi devasa numaradan başlayarak adımları tekrarlayın ! Yani, azalan sayı dizisini birleştirmek,

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

Peki, yeni puanım ne, 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[]

Yineleme 3

Tekrar et.

Yineleme 4

Tekrar et.

Yineleme 5

Tekrar et.

Analitik Puan

İlk yinelemede, 2718281828459045'te başlayan ve azalan dizinin birleşimindeki hane sayısını, içindeki hane sayısını sayarak hesapladık.

• 1718281828459046 16 basamaklı sayılar
• 900000000000000 15 basamaklı sayılar
• 90000000000000 14 basamaklı sayılar,
• 9000000000000 13 basamaklı sayılar
• ...
• 900 3 basamaklı sayılar
• 90 2 basamaklı sayılar
• 10 1 basamaklı sayılar

Bu toplam, formülle gösterilebilir.

burada Z, bir başlangıç numarasını belirtir ( örneğin, 2718281828459045) ve O _{, Z} büyüklük sırasını ifade eder ( örneğin, 15, çünkü , Z ~ 10 ^{, 15} ). Sonlu toplamlar için denklikleri kullanarak , yukarıdakiler açıkça ifade edilebilir.

9, 10 alırsak, daha da azalır

ve, nihayet, terimlerin genişletilmesi ve büyüklük sırasının azaltılmasıyla sıralanması

Şimdi, sadece sonucun büyüklüğü ile ilgilendiğimiz için, Z'yi " O _Z'nin büyüklüğünde bir sayı" ile değiştirelim , yani 10 ^{O _Z} -

Son olarak, 2. ve 3. terimler iptal edilir ve son iki terim bırakılabilir (boyutları önemsizdir) ve bizi bırakarak

ilk terimin kazandığı terim.

Yeniden düzenlenirse, M'ninf büyüklüğü sırasına göre bir sayı alır ve yaklaşık olarak M (10 ^M ) büyüklüğüne göre bir sayı üretir .

İlk yineleme elle kolayca kontrol edilebilir. 2718281828459045, 15 büyüklüğünde fbir sayıdır; bu nedenle , 15 (10 ¹⁵ ) ∼ 10 ¹⁶ büyüklüğünde bir sayı üretmelidir . Aslında, üretilen sayı, daha önce 2.72⋅10 ^{42381398144233625'tir} - bu, 10 ^{42381398144233625} ∼ 10 ^{10 16'dır} .

Belirten M önemli bir faktör değildir M (10 ^M ), her yineleme sonucunun büyüklük sırası daha sonra, tetrasyon basit bir yol izler:

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

LaTeX kaynakları

(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

İşte benim gözden geçirme girişim:

{⍞←⎕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

100 char / byte * programı, şu anki donanımda çalışıyor (ihmal edilebilir miktarda bellek ve normal 32 bit int değişkenleri kullanıyor), ancak tamamlanması çok uzun sürüyor.

Aslında bir APL tercüman üzerinde çalıştırabilirsiniz ve rakam basmaya başlayacaktır. Tamamlanmasına izin verilirse, 10 × 123456789 ⁴⁴ basamaklı bir sayı yazacaktır .

Bu nedenle, bir puan 10 ^{10 x 123456789 44} /-100 ³ ≈ 10 ^{10 353} ≈ 10 ↑↑ 3,406161

açıklama

• ⎕D eşittir önceden tanımlanmış bir sabit dize '0123456789'
• n←⍎⎕Dn'nin bu dizgenin temsil ettiği sayı olduğunu tanımlar : 123456789 (<2 ³¹ ve bu nedenle bir döngü kontrol değişkeni olarak kullanılabilir)
• {⍞←⎕D} 10 haneyi yeni satır olmadan standart çıktıya yazdıracak
• {⍞←⎕D}⍣nn kez yapacak ( ⍣"güç operatörü" dür: ne *, /, ne de ^ çünkü matematiksel bir işlem değildir, bir tür döngüdür)
• {⍞←n}⍣n⍣nönceki işlem tekrar eder , n , bu nedenle 10 basamak baskı, kere n- ² kez
• {⍞←n}⍣n⍣n⍣nn ³ kez yapacak
• Oraya 44 tane sığdırabilirim ⍣n, böylece dizginin n ⁴⁴ katı '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL, APL sembollerini üst 128 byte değerine eşleyen kendi (eski) tek baytlık karakter kümesi ile yazılabilir. Bu nedenle, puanlama amacıyla, yalnızca ASCII karakterlerini ve APL sembollerini kullanan bir N karakter programı N bayt uzunluğunda kabul edilebilir.}

Haskell, puan: (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

Bu program tam 100 byte saf Haskell kodudur. Dördüncü Ackermann sayısını yazdıracak ve sonunda evrenin ve sürecin tüm mevcut enerjisini, zamanını ve sürecini tüketecek (5 saniyenin yumuşak sınırını biraz aşacak şekilde) tüketecektir .

Python, 2 ↑↑ 11/830584 ≈ 10 ↑↑ 8.632971 (Hızlı ok gösterimi)

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

Muhtemelen hiçbir bilgisayar bunu başarılı bir şekilde çalıştırmak için yeterli belleğe sahip değildir, ancak bu gerçekten programın hatası değildir. Minimum sistem gereksinimleri karşılandığında işe yarıyor.

Evet, bu, boole değerlerinde biraz kayma yapıyor. bu bağlamda Truezorlanır 1. Python isteğe bağlı uzunluk tam sayılarına sahiptir.

GolfScript 3.673e + 374

'~'(.`*

Bence *dize tekrarıdır, çarpım değil.

Açıklama: '~'(yığında 126 ("~" ASCII değeri) bırakacaktır. Ardından numarayı kopyalayın, bir dizeye dönüştürün ve dize tekrarını 126 kez yapın. Bu 126126126126...yaklaşık olarak verir 1.26 e+377. Çözüm 7 karakterdir, yani 7^3yaklaşık olarak bir puan için bölün3.673e+374

Yakut, olasılıkla sonsuz, 54 karakter

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

x 97'ye sıfırlanır. Daha sonra aşağıdaki prosedürü yineleriz: 0 ile 1 arasında x rasgele sayılar üretin. Eğer hepsi aynıysa, sonlandırın ve x'i yazdırın. Aksi takdirde, x'i çiftleyin ve tekrarlayın. Ruby'nin rastgele sayıları 17 basamak hassasiyete sahip olduğundan, herhangi bir adımda sonlandırma oranları 1'de (10e17) ^ x şeklindedir. Bu nedenle n adımda sonlandırma olasılığı, 1 / 10e34'e yakınsayan (1 / 10e17) ^ (2 ^ n) 'in x = 1 ila n toplamıdır. Bu, herhangi bir sayı için, ne kadar büyük olursa olsun, bu programın daha az sayı üretmesi büyük olasılıkla düşüktür.

Şimdi, elbette, felsefi mesele, 10 ^ 34'te 1'den az olan bir programın, herhangi bir n için n adımında fesih yapma ihtimalinin sona erdiği söylenebilir. Sadece sonsuz zaman ve güç sağlamakla kalmaz, aynı zamanda programa, sonlandırma olasılığının düşme hızını aşan bir hızda artan hızda çalıştırma kabiliyeti verildiğini varsayarsak, aslında, tarafından sona t 1'e keyfi yakındır.

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

Bu, @Howard tarafından başka bir cevaptan utanmadan uyarlanır ve @Peter Taylor'ın önerilerini içerir.

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

GolfScript anlayışım sınırlı, ancak yukarıdaki *ve ^operatörlerinin OP tarafından yasaklanan aritmetik operatörler olmadığına inanıyorum .

(@Howard kendi versiyonunu göndermek istiyorsa bunu sileceğim, ki bu yine de bundan daha üstün olacaktır.)

Bu program yaklaşık olarak f _{ε 0} olan bir sayı hesaplar (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))))) ))) - f _{ε 0'ın} dokuz katı yineleme - burada f _{ε 0} , Goodstein işleviyle kabaca aynı oranda büyüyen hızlı büyüyen hiyerarşideki işlevdir. (f _{ε 0}o kadar hızlı büyür ki Friedman'ın n (k) işlevi ve k-kat Conway zincir oklarının büyüme oranları, sadece tek bir yinelenmemiş f _{ε 0} değerine kıyasla bile önemsizdir .)

dc, 100 karakter

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

Yeterli zaman ve bellek göz önüne alındığında, bu 15 Başlangıçta gerçeklestirmislerdir ↑ ¹⁶⁶⁶⁶⁶⁵ 15. etrafında bir dizi hesaplar hiperişlem fonksiyonunu, ancak bu meydan okuma için çok fazla karakter gerekli, bu yüzden kaldırıldı n = 2, b = 0ve n >= 3, b = 0dönüm, koşullarını n = 1, b = 0içine koşulu n >= 1, b = 0.

Burada kullanılan tek aritmetik işleçler toplama ve çıkarma.

EDIT: yorumlarda da belirtildiği gibi, bu kodun yaptığı şeyin bir dökümü:

[            # 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

Belirtildiği gibi, bu, çarpma ve daha yüksek olan temel durumların, ilave edilmek üzere olan temel durumla değiştirilmeleri durumunda, hiper-işlem fonksiyonundan sapmaktadır. Bu kod a*0 = a^0 = a↑0 = a↑↑0 ... = amatematiksel olarak doğru a*0 = 0ve yerine sanki davranır a^0 = a↑0 = a↑↑0 ... = 1. Sonuç olarak, olması gerekenden biraz daha yüksek olan değerleri hesaplar, ancak daha büyük sayıları hedeflediğimiz için bu büyük bir mesele değildir. :)

DÜZENLEME: Sadece bir rakamı, art arda gerçekleşen makroda kodun yanlışlıkla kaydığını fark ettim n=0. Her bir artırma işlemini 15'le ölçeklemenin yan etkisi olan 'F' (15) ile değiştirerek çıkardım. Son sonucu ne kadar etkilediğinden emin değilim, ama muhtemelen şimdi çok daha büyük.

Çalışma süresinde limit yok mu? Tamam ozaman.

Programın modern bilgisayarlarda çalıştırılabilir olması gerekiyor mu?

64 bit derleme kullanan her iki çözüm de long64 bit tam sayıdır.

C: 10'dan daha büyük ^{(2 64 -1) 2 64} , kendisi 10'dan daha büyük olan ^{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.

Bu formülleri kolaylaştırmak için kullanacağım t = 2^64-1 = 18446744073709551615.

mainarayacak fbir parametreye sahiptir ve tdöngü olacak t, her kat değerinin baskı tve çağrı fbir parametreye sahiptir t-1.

Toplam basamak baskılı: 20 * t.

Bu çağrıların her biri fbir parametresiyle yapılan çağrıları t-1tekrar teder, değeri yazdırır tve f parametresini içeren bir çağrı yapar t-2.

Yazdırılan toplam rakam: 20 * (t + t*t)

Bu programı 3-bit tamsayıları kullanarak denedim (ayarladım i = 8ve ana arama yaptım f(7)). 6725600 kez baskı deyimini vurdu. Bu 7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7nedenle çalışır , bunun tam program için son sayım olduğuna inanıyorum:

Yazdırılan toplam rakam: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

Nasıl hesaplanacağını bilmiyorum (2 ⁶⁴ -1) ^{2 64} . Bu toplam (2 ⁶⁴ ) ^{2 64'ten} küçüktür ve bu hesaplamayı yapabilmek için iki güce ihtiyacım var. Bu nedenle (2 ⁶⁴ ) ^{2 64 -1} hesaplayacağım . Gerçek sonuçtan daha küçük, ancak ikisinin gücü olduğundan, diğer sonuçlarla karşılaştırmak için onu 10 gücüne dönüştürebilirim.

Bu toplamanın nasıl yapıldığını ya da nasıl dönüştürüleceğini bilen var mı (2 ⁶⁴ -1) ^{2 64} ila 10 ⁿ ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
üssün tabanını 10'luk güçlere dönüştürmek için bu üssünü 10 taban kütüğünün 2'ye bölün.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

Fakat unutmayın, bu basılan rakamların sayısıdır. Tamsayının değeri bu güce 10 yükseltilir, bu nedenle 10 ^ 10 ^ 355393490465494856447

Bu program 2 ^ 64 yığın derinliğine sahip olacaktır. Bu sadece döngü sayaçlarını saklamak için 2 ^ 72 byte hafızadır. Bu 4 Milyar Terabayt loop sayacı. Yığın üzerinde 2 ^ 64 tekrarlama seviyeleri için olacak diğer şeylerden bahsetmiyorum bile.

Düzenleme: Bir çift yazım hatası düzeltildi ve log2 için daha kesin bir değer kullanıldı (10).

Düzenleme 2: Bekle bir saniye, printf'in dışında olduğu bir döngüye sahibim. Bunu düzeltelim. Başlatılıyor eklendi i.

Düzenleme 3: Dang, önceki düzenlemede matematiği berbat ettim. Sabit.

Bu, modern bilgisayarlarda çalışacak, ancak yakında bitmeyecek.

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 Karakterler.

Bu, her yineleme için sıfırın tersini, 2 ^ 64-1'i ters çevirir. 2 ^ 64-1, 20 basamaklı bir sayıdır.

Basamak sayısı = 20 * (2^64-1)^7= 1453677448591213780547019529026486359825087615481303750744349513987271378009622757102790327068067244563877561877830370570580542187500

Programın uzunluğunu 100 karaktere yuvarlamak, Puan = basılı sayı / 1.000.000

Puan = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705702042800542187494

R - 49 41 kod karakteri, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348

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

[Burada sadece başlangıç ​​üretiliyor] yazılacak:

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6 - 10 ^ 3, 3/884736

(3↑↑↑↑3, G (1) dir, burada G (64), Graham’ın numarasıdır)

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)

Çıktı: 10 ^ 3 ↑↑↑↑ 3

İpuçları:

GG'nin (64) Graham'ın numarası olduğu fonksiyondur. Giriş bir tamsayıdır. Çıktı, 0 ile yazılmış, tek bir dizedir .

KKnuth yukarı ok işlevi ↑ olan ⁿ bir, örtük 3. Giriş n bir tek terimli dize ve b bir tek terimli dizedir b. Çıktı tek bir dizedir.

u "1" dir.

v "0000" veya G (0)

e "000" dır.

C

(Darren Stone'a özür dileriz)

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

n = 2 ^ 64 basamaklı sayı (9 ...)

l = 100 kod kodu

puan: 1e + 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 ≈ 10 ↑↑ 3,2974890744

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

Bu cevap için acımasızca kırılmayı hak ettiğimi, ancak direnemediğimi unutmayın. Belli nedenlerden ötürü stackexchange'te benim gibi davranmayı önermiyorum. :-P

EDIT: Gibi bir şeyle gitmek için günaha direnmek daha zor olurdu

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

... ancak amaçlanan ancak belirtilmemiş bir kuralın, numarayı oluşturan tüm rakam dizisinin basılması gerektiği yönündeydi.

Yeni Ruby mı ~ f _{co ^{© 2} + 1} (126 ² 2 ¹²⁶ )

f _α (n) hızlı büyüyen hiyerarşidir.

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

Çevrimiçi deneyin!

*nSadece string ve dizi çarpma, bu nedenle iyi olmalı.

Ungolfed kod:

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]}

burada b.-b<=>0bir tamsayıyı döndürür 1yakın 0daha b.

Açıklama:

nHer çağrı başlangıcında yazdırılır H.

H[[]]iki katına n( nkez), yani n = n<<n.

H[[0,a,b,c,...,z]]Aramalar H[[a,b,c,...,z]]( nkere).

H[[k+1,a,b,c,...,z]]çağrılar H[[k]*n+[a,b,c,...,z]]( nkez), [k]*n = [k,k,...,k].

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

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

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

Programım başlatılıyor n = 126, ardından H[-n-1]126 ² 2 ¹²⁶ defa çağrılıyor.

Örnekler:

H[[0]]H[[]]geçerli olanı arayacak n = n<<n( nkez).

H[[0,0]]arayacak H[[0]]( nkez).

H[[1]]arayacak H[[0]*n]( nkez).

H[[-1]]arayacak H[[n]*n]( nkez).

H[[-1,-1]]arayacak H[[n]*n+[-1]]( nkez).

H[[-3]]arayacak H[[-2]*n]( nkez).

Çevrimiçi deneyin!

Diğer güzel şeyler için revizyonlara bakın .

Haskell - Ackermann işlevi 20 defa sonuçlandırıldı - 99 karakter

Bu, ackermann işlevine dayanarak bulabileceğim en iyi haskell çözümü - nm'nin çözümüyle ilgili bazı benzerlikler olduğunu fark edebilirsiniz, i = round $ log pi buradan ilham aldı ve gerisi tesadüf oldu: 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

Ackermann işlevini 20 kez kendiliğinden çalıştırır, birinden başlayarak, dizi

• 1,
• 3,
• 61,
• bir (61,61),
• a (a (61,61), a (61,61)) --- buna ₂ (61) veya ₄ (1) diyeceğiz ---
• bir ₃ (61)
• ...
• bir ₁₈ (61) veya bir ₂₀ (1). Bunun yaklaşık g ₁₈ olduğunu düşünüyorum (aşağıya bakınız).

Tahmini gelince, wikipedia diyor ki:

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

Bundan, a3 (1) = a (61,61) = 2 ↑ ⁵⁹ 64 + 3'ü görebiliyoruz, ki başlangıçtaki 3 sandığımdan çok daha önemli değilse , açıkça g1 = 3 ↑ ⁴ 3'ten büyük. Bundan sonra, her seviye aşağıdakileri yapar (bir _n'deki önemsiz sabitleri atmak ):

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

Bu yaklaşık olarak eşdeğer olan, daha sonra bir ₂₀ (1) '= g ₁₈ . Bir son terim _n , (bir _n-1 ) 3 den çok daha büyük olduğu, bu yüzden g daha potansiyel olarak daha yüksek olduğu ₁₈ . Tek bir yinelemeyi bile arttırıp arttırmayacağını çözüp çözemeyeceğimi görüp bakarım.

x86 makine kodu - 100 bayt (MSDOS .com dosyası olarak birleştirildi)

Not: kuralları biraz bükebilir

Bu program , skoru (10 ^{2 524320} -1) / 1000000 seviyesine getirecek 2 ^{(65536 * 8 + 32)} dokuz ^{üretecektir.}

Bir sayaç olarak bu program tüm yığını (64kiB) ve iki adet 16bit yazmaç kullanır

Birleştirilmiş kod:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Montaj:

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

Dosya boyutu 45 bayttır.

Program:

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

Ve üretilen sayı 10 ^ (10 ^ (10 ^ 1.305451600608433) 'den büyük.

Yönlendirdiğim std dosyasını şu anda 16 Gb'nin üzerinde ve hala büyüyor.

Daha iyi bir bilgisayarım olsaydı, program makul bir süre içinde sona erecekti.

Puanım çift duyarlıklı kayan nokta ile hesaplanamaz.

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 herhangi bir makul sistemde. SHLVL küçük bir pozitif tamsayıdır (/ bin / sh'ın bash olup olmamasına bağlı olarak genellikle 1 veya 2'dir).

Yalnızca 64 bit UNIX:

Puan: ~ 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];);}

258048 işaretsiz tamsayı dizisi oluştururuz. Programı çok uzun yaptı çünkü imzasız uzun olamazdı. Belirsiz davranışı kullanmak istemediğim için imzasızlar, bu kod uygun C (main () 'ten dönüş olmaması dışında) ve herhangi bir normal makinede derlenip çalıştırılacak, uzun süre çalışacak . Ascii olmayan karakterler kullanmadan yasal olarak ifade edebileceğimiz en büyük boyut bu boyut.

Son elemandan başlayarak dizi boyunca döngü yapıyoruz. Rakamlar 2^32-10'a basılmadıysa , rakamlarını basar, elementi artırır ve döngüyü bırakırız. Bu şekilde (2^32 - 1)^254048 = 2^8257536, her seferinde 10 rakam basan zaman döngüleri elde edeceğiz .

İşte prensibi daha sınırlı bir veri aralığında gösteren örnek kod:

#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");
        }
}

Sonuç, kabaca 10 ^ 10 ^ 2485766 olan ve hala kabaca 10 ^ 10 ^ 2485766 olan bir milyona bölünür.

Güç Kabuğu (2.53e107976 / 72³ = 6.78e107970 ≈ 10 ↑↑ 1.701853371)

Bu işlem 5 saniyeden uzun sürüyor.

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

Geçerli sürücünüzdeki her dosyanın bayt uzunluğunu alır ve birleştirir. Regex, rakam olmayan karakterleri atar.

Python 3, puan = teyp (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))

F işlevi çağırmak için yeterli alana sahip olduğum ackermann işlevidir.

Düzenleme: Daha önce Simply Beautiful Art'a meydan okuyan kuralları ihlal eden "else n + 1".

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)

2.718e + 239622337 ≈ 10 ↑↑ 2,9232195202 üretir

2.718e'den biraz fazla puan için + 239622331 ≈ 10 ↑↑ 2.9232195197

Bu tarayıcı çökmesini olmadan yapabileceğim en büyük olanı.

(console.log (a) tam çıktısını gösterir)

Bunları çalıştırma:

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)

daha uzun cevap ile karşılaştırmak için 2.718 + e121333054704 ≈ 10 ↑↑ 3.0189898069 (aka 2.718 * 10 ^ (1.213 * 10 ^ 12) çıktı verir:

eğer tarayıcınızı çökertmediyse daha zor versiyonlar: (80 karakter)

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

bu, e * 10 ^ (10 ^ 19) ≈ 10 ↑↑ 3.106786869689 ile aynı boyutta bir sayı oluşturur

Düzenleme: güncellenmiş kod orijinal çözümü sadece 2.718e + 464 üretti

Python 3: 98 karakter, ≈ 10 ↑↑ 256

Değişken bağımsız değişken işlevini kullanarak:

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

Etkili olarak E, argümanların geri kalanını arttırırken ilk argümanı azaltır, ancak argümanlara -1 koymak yerine, argümanı bırakır. Her döngü ilk argümanı düşürdüğü veya argüman sayısını azalttığı için, bunun sonlandırılması garanti edilir. Kullanılan artan fonksiyon int ("% d% d"% (k, k)) 'dir ve bu da k ** 2 + 2 * k ve 10 * k ** 2 + k arasında sonuç verir. Kodum * sembolünü kullanır - ancak çarpma olarak değil. Kuralların açık noktası, sembollerin kendilerini değil belirli işlemleri kısıtlamak olduğu için kurallara uyması gerektiğini düşündüğüm değişken sayıdaki argümanlarla çalışmak için kullanılır.

E'nin ne kadar hızlı büyüdüğüne dair bazı örnekler:

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)

Bunlardan yalnızca ilk ikisi bilgisayarımda makul bir süre içerisinde çalıştırılabilir.

Ardından, E tarafından çağrılır E(*range(ord('~')))- bunun anlamı:

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

Bunun ne kadar büyük olduğundan tam olarak emin değilim (boşuna uğramaya çalışıyorum) - ama bunun gerçekten çok büyük olduğu açık.

Bir örnek olarak, yaklaşık on iki döngü içinde, sonuç şudur: (teknik olarak biraz daha fazla)

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)

Sonuç tahmini:

Artan adımı yaklaşık olarak hesaplarsak lambda k: 10 * k**2, işlev şu şekilde tanımlanabilir:

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₁²ⁿ), ... )

Burada yaptığımız ilgili şey, on kişilik bir güç kulesi oluşturmaktır, dolayısıyla nihai puan 10 ↑↑ 256 olarak tahmin edilebilir.

Daha iyi (kısmi olmasına rağmen) sonuç tahmini:

Bu 10 * k**2, diğer tahminlerle aynı şekilde kullanılır.

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

Önceki tahmine göre, şöyle olurdu:

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

Hangi kullandığı beri gerçek değerinin önemli ölçüde küçüktür a**2yerine 2**a10 için ve kullandığı a*2yerine 2**ab.

C (10 20 20 000 000 000 ≈ 10 ↑↑ 3,005558275 puan)

• ~ 20 GB çıkış
• 41 karakter (41 ^ 3 hiçbir şey ifade etmez)

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

Çıktıya rağmen rand()deterministiktir çünkü tohum işlevi yoktur.