Największy numer do wydrukowania

113

Twoim celem jest napisanie programu, który wypisze liczbę. Im większa liczba, tym więcej punktów otrzymasz. Ale bądź ostrożny! Długość kodu jest zarówno ograniczona, jak i ważona w funkcji oceniania. Twój wydrukowany numer zostanie podzielony przez sześcian liczby bajtów użytych do rozwiązania .

Powiedzmy, że wydrukowałeś, 10000000a twój kod ma 100długość bajtów. Twój końcowy wynik to 10000000 / 100^3 = 10.

Aby uczynić to wyzwanie nieco trudniejszym, należy przestrzegać innych zasad.

  • Nie możesz używać cyfr w swoim kodzie (0123456789);
  • Państwo może używać matematyczne / fizyczne / etc. stałe, ale tylko jeśli są mniejsze niż 10. (np. Możesz użyć Pi ~ = 3,14, ale nie możesz użyć stałej Avogadro = 6e23)
  • Rekurencja jest dozwolona, ale wygenerowana liczba musi być skończona (więc nieskończoność nie jest akceptowana jako rozwiązanie. Twój program musi zakończyć się poprawnie, przy założeniu nieograniczonego czasu i pamięci oraz wygenerować żądany wynik);
  • Nie można używać operacji *(mnożenie), /(dzielenie), ^(moc) ani w żaden inny sposób do ich wskazania (np. 2 div 2Nie jest dozwolone);
  • Twój program może wypisać więcej niż jedną liczbę, jeśli jest to potrzebne . Tylko najwyższy będzie liczył się do punktacji;
  • Można jednak łączyć łańcuchy: oznacza to, że każda sekwencja sąsiadujących cyfr będzie traktowana jako pojedyncza liczba;
  • Twój kod będzie działał bez zmian. Oznacza to, że użytkownik końcowy nie może edytować żadnego wiersza kodu ani nie może wprowadzić liczby ani niczego innego;
  • Maksymalna długość kodu wynosi 100 bajtów.

Tabela liderów

  1. Steven H. , Pyth ≈ f φ (1,0,0) +7 (256 26 ) / 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, 20 (1) / 99 3 [1]
  9. Fraxtil , dc, ≈ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 3 [3]
  10. Magenta , Python, (ack (126 126) / 100 3 ≈ 10 ↑ 124 129
  11. Kendall Frey , ECMAScript 6 ≈ 10 3 ↑ 4 3 /100 3 [1]
  12. Ilmari Karonen , GolfScript, ≈ 10 ↑ 3 10 377 /18 3 [1]
  13. BlackCap , Haskell, ≈ 10 ↑↑ 65503/100 3
  14. rekurencyjny , Python, ≈ 2↑↑ 11/95 3 ≈ 10 ↑↑ 8.63297 [1] [3]
  15. nm , Haskell, ≈ 2↑↑ 7/100 3 ≈ 10 ↑↑ 4.63297 [1]
  16. David odchylenia , C ≈ 10 10 4 X 10 22 /83 3 ≈ 10 ↑↑ 4,11821 [2]
  17. Primo , Perl ≈ 10 (12750684161!) 5 x 2 27 /100 3 ≈ 10 ↑↑ 4,11369
  18. Sztuki , C ≈ 10 10 2 x 10 6 /98 3 ≈ 10 ↑↑ 3,80587
  19. Robert Sørlie , x86, ≈ 10 2 2 19 +32 / 100 3 ≈ 10 ↑↑ 3,71585
  20. Tobia , APL ≈ 10 10 353 /100 3 ≈ 10 ↑↑ 3,40616
  21. Darren Stone , C, ≈ 10 10 97,61735 / 98 3 ≈ 10 ↑↑ 3.29875
  22. ecksemmess , C ≈ 10 2 320 /100 3 ≈ 10 ↑↑ 3,29749
  23. Adam Speight , vb.net, ≈ 10 5000 x (2 64 ) 4 /100 3 ≈ 10 ↑↑ 3,28039
  24. Joshua , bash, ≈ 10 10 15 /86 3 ≈ 10 ↑↑ 3,07282

Przypisy

  1. Gdyby każdy elektron we wszechświecie był kubitem, a każda jego superpozycja mogłaby być z korzyścią wykorzystywana do przechowywania informacji (co, o ile tak naprawdę nie trzeba wiedzieć, co jest przechowywane, jest teoretycznie możliwe), program ten wymaga więcej pamięci niż mógłby być może istnieją i dlatego nie można ich uruchomić - teraz ani w żadnym możliwym punkcie w przyszłości. Jeśli autor zamierzał wydrukować wartość większą niż ↑3 ↑↑ 3.28 jednocześnie, warunek ten ma zastosowanie.
  2. Ten program wymaga więcej pamięci niż obecnie, ale nie tak bardzo, że teoretycznie nie mógłby być przechowywany na skąpej liczbie kubitów, dlatego też może kiedyś istnieć komputer, który mógłby uruchomić ten program.
  3. Wszyscy obecnie dostępni tłumacze zgłaszają błąd w czasie wykonywania lub program nie działa inaczej, jak zamierzał autor.
  4. Uruchomienie tego programu spowoduje nieodwracalne uszkodzenie systemu.

Edytuj @primo : Zaktualizowałem część tablicy wyników, używając, mam nadzieję, łatwiejszego do porównania zapisu, z ułamkami dziesiętnymi, które oznaczają logarytmiczną odległość do następnej wyższej mocy. Na przykład 10 ↑↑ 2,5 = 10 10 √10 . Zmieniłem również niektóre wyniki, jeśli uważałem, że analiza użytkownika jest wadliwa, możesz zakwestionować którąkolwiek z nich.

Objaśnienie tego zapisu:

Jeśli 0 ≤ b < 1tak .a↑↑b = ab

Jeśli b ≥ 1tak .a↑↑b = aa↑↑(b-1)

Jeśli b < 0tak .a↑↑b = loga(a↑↑(b+1))

Vereos
źródło
16
Czy ktoś już wyraźnie powiedział „baza 10”?
keshlam
1
Czy duża liczba ma znaczenie, jeśli jest powiedziane 12e10(12 * 10 ^ 10) jako 12*10^10?
hichris123
4
Wydaje mi się, że lepszym ograniczeniem zamiast zakazu *, / i ^ byłoby zezwolenie tylko na operacje liniowe , np. +, -, ++, -, + =, - = itd. W przeciwnym razie kodery mogą skorzystać funkcji strzałki w górę / biblioteki Ackermanna Knutha, jeśli zostały udostępnione w wybranym języku, co wydaje się oszustwem.
Andrew Cheong,
14
Nadal czekam, aż ktoś zarobi przypis [4].
Brian Minton
1
Powiedz, jeśli mój program drukuje 500b, czy to jest nieprawidłowe? To znaczy, czy możemy zignorować wszystkie nienumeryczne rzeczy drukowane przez program? A jeśli tak, czy coś takiego może się 50r7liczyć 507?
Po prostu piękna sztuka

Odpowiedzi:

20

GolfScript; ocena co najmniej f ε_0 + ω + 1 (17) / 1000

Zgodnie z sugestią Res , aby użyć odpowiedzi Lifetime robaka na to pytanie, przedstawiam dwa programy, które znacznie poprawiły jego pochodzenie rozwiązania Howarda.

Dzielą wspólny przedrostek, modulo nazwę funkcji:

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

oblicza, g(g(1)) = g(5)gdzie g(x) = worm_lifetime(x, [x])rośnie w przybliżeniu jako f ε 0 (co oznacza, że ​​„funkcja w szybko rosnącej hierarchii, która rośnie mniej więcej w tym samym tempie, co funkcja Goodsteina”).

Nieco łatwiej (!) Do analizy jest

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

.{foo}*mapy xdo foo^x x.

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

w ten sposób daje g^(g(5)) ( g(5) ); kolejne 8 poziomów iteracji jest podobne do tworzenia łańcuchów strzałek. Wyrażając się w prosty sposób: czy h_0 = gi h_{i+1} (x) = h_i^x (x)wtedy obliczamy h_10 (g(5)).

Myślę, że ten drugi program prawie na pewno osiąga znacznie lepsze wyniki. Tym razem etykieta przypisana do funkcji gjest znakiem nowej linii (sic).

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

Tym razem lepiej wykorzystam ^jako inną funkcję.

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

bierze xstos i opuszcza xciąg zawierający xkopie, .{a gnastępnie xkopie }*; następnie ocenia ciąg. Ponieważ miałem lepsze miejsce do wypalania zapasowych postaci, zaczynamy od j_0 = g; jeśli j_{i+1} (x) = j_i^x (x)to pierwsza ocena ^obliczeń j_{g(5)} (g(5))(co jestem prawie pewien, że już wygrywa z poprzednim programem). Następnie wykonuję jeszcze ^16 razy; więc jeśli k_0 = g(5)i k_{i+1} = j_{k_i} (k_i)to się liczy k_17. Jestem wdzięczny (ponownie) res za oszacowanie tego k_i>> f ε_0 + ω + 1 (i).

Peter Taylor
źródło
Jeśli się nie mylę, liczbę, którą program oblicza (nazwij to n), można zapisać n = f ^ 9 (g (3)), gdzie f (x) = g ^ (4x) (x) i g ( x) to czas życia robaka [x]. Jeśli traktujemy g jako mniej więcej taki sam jak f_eps_0 w szybko rosnącej hierarchii, to moje obliczenia z tyłu koperty pokazują, że f_ (eps_0 + 2) (9) <n <f_ (eps_0 + 2) (10 ). Oczywiście to obecny zwycięzca - zdecydowanie.
res
@res, myślę, że to bardzo nie docenia. .{foo}*mapy xdo foo^x (x). Jeśli weźmiemy pod uwagę h_0 (x) = g^4 (x), a h_{i+1} (x) = h_i^x (x)następnie obliczana jest wartość h_9 (g(3)). Twój f(x) = g^(4x) (x) = h_0^x (x) = h_1 (x).
Peter Taylor
(To dotyczy twojego oryginalnego programu - właśnie zobaczyłem, że wprowadziłeś kilka zmian.) Ohhh ... źle zrozumiałem, jak to *działa. Można śmiało powiedzieć, że h_0 (x) = g ^ 4 (x) >> f_eps_0 (x); w konsekwencji relacja h_ {i + 1} (x) = h_i ^ x (x) skutecznie definiuje „przyspieszoną” szybko rosnącą hierarchię taką, że h_i (x) >> f_ (eps_0 + i) (x). To znaczy, obliczona liczba h_9 (g (3)) jest z pewnością znacznie większa niż f_ (eps_0 + 9) (g (3)). Jeśli chodzi o g (3), myślę, że mogę pokazać, że jest większa niż g_4, czwarta liczba w sekwencji g_i użyta do zdefiniowania liczby Grahama (czyli g_64).
res
@res, więc j_i ~ f_{eps_0 + i}; czy to czyni k_i ~ f_{eps_0 + i omega + i^2}?
Peter Taylor
Biorąc pod uwagę to, co napisałeś, rozumiem k_i ~ f_{ε_0 + ω}^i (k_0). Oto uzasadnienie: k_ {i + 1} = j_ {k_i} (k_i) = j_ω (k_i) ~ f_ {ε_0 + ω} (k_i) ~ f_ {ε_0 + ω} ^ 2 (k_ {i-1}) ... ~ f_ {ε_0 + ω} ^ {i + 1} (k_0), więc k_i ~ f_ {ε_0 + ω} ^ i (k_0). Jest wtedy bardzo konserwatywna dolna granica k_i, całkowicie pod względem szybko rosnącej hierarchii k_i >> f_{ε_0 + ω}^i (i) = f_{ε_0 + ω + 1} (i).
res
91

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

UWAGA: NIE URUCHAMIAJ TEGO!

Zapisz następujące elementy w pliku wsadowym i uruchom go jako Administrator.

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

Wyjście jest uruchamiane na napędzie 4 TB z pierwszym wydrukowanym numerem pogrubionym drukiem.

Włóż nowy dysk do napędu D:
i naciśnij klawisz ENTER, gdy będzie gotowy ... Typ systemu plików to NTFS.
Nowym systemem plików jest FAT.
Szybkie formatowanie 3907172M
Głośność jest za duża dla FAT16 / 12.

Hand-E-Food
źródło
19
Czysty, nieskalany geniusz!
WallyWest
7
Myślę, że powinieneś obliczyć długość rozwiązania, w której otrzymuję wynik około 321Your printed number will be divided for the number of bytes you used for your solution^3.
Cruncher
1
77 głosów pozytywnych, a jednak ... Zauważyłem, że wynik to 321 ...
Po prostu piękna sztuka
3
@SimplyBeautifulArt, to nie wynik, ale podróż. :-D
Hand-E-Food
4
Najwyraźniej taki, który rozśmieszył wielu. Teraz, gdybyśmy tylko mogli dostać się do tabeli liderów ... ktoś musi zdobyć tag „nieodwracalne obrażenia”;)
Po prostu piękna sztuka
87

GolfScript, wynik: droga zbyt dużo

OK, jak dużą liczbę możemy wydrukować w kilku znakach GolfScript?

Zacznijmy od następującego kodu ( dzięki, Ben! ), Który drukuje 126:

'~'(

Następnie powtórzmy to 126 razy, dając nam liczbę równą około 1,26126 × 10 377 :

'~'(.`*

(To powtarzanie ciągów, a nie mnożenie, więc zgodnie z zasadami powinno być OK.)

Powtórzmy teraz 378-cyfrową liczbę nieco ponad 10 377 razy:

'~'(.`*.~*

Nigdy nie zobaczysz zakończenia tego programu, ponieważ próbuje on obliczyć liczbę z około 10 380 ≈ 2 1140 cyfr. Żaden komputer, który kiedykolwiek zbudowano, nie byłby w stanie pomieścić tak dużej liczby, ani taki komputer nigdy nie mógłby zostać zbudowany przy użyciu znanej fizyki; liczba atomów w obserwowalnego Wszechświata szacuje się na około 10 80 , więc nawet jeśli moglibyśmy jakoś wykorzystać całą materię we Wszechświecie przechowywać tę ogromną liczbę, byśmy nadal jakoś trzeba napełnić około 10 380 /10 80 = 10 300 cyfr w każdym atomie!

Załóżmy jednak, że mamy własnego Boskiego interpretera GolfScript, który jest w stanie przeprowadzić takie obliczenia i że nadal nie jesteśmy zadowoleni. OK, zróbmy to jeszcze raz!

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

Dane wyjściowe tego programu, jeśli mogłyby zostać ukończone, miałyby około 10 10 383 cyfr, a więc byłyby równe około 10 10 10 383 .

Ale poczekaj! Ten program zaczyna się powtarzać ... dlaczego nie zmienimy go w pętlę?

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

Tutaj ciało pętli biegnie około 10 377 razy, dając nam teoretyczny wynik składający się z około 10 10⋰ 10 377 cyfr lub więcej, gdzie wieża o iterowanych mocach 10 ma około 10 377 kroków. (W rzeczywistości jest to rażące niedoszacowanie, ponieważ zaniedbuję fakt, że powtarzana liczba również się wydłuża za każdym razem, ale mówiąc relatywnie rzecz biorąc, jest to niewielki problem.)

Ale jeszcze nie skończyliśmy. Dodajmy kolejną pętlę!

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

Nawet prawidłowe zapisanie przybliżenia takich liczb wymaga ezoterycznej notacji matematycznej. Na przykład, w notacji Knutha , liczba (teoretycznie) wynikająca z powyższego programu powinna wynosić około 10 ↑ 3 10 377 , dać lub wziąć kilka (lub 10 377 ) potęg dziesięciu, zakładając, że zrobiłem matematykę poprawnie.

Liczby takie jak ta przekraczają po prostu „niewiarygodnie ogromne” i wkraczają w sferę „niepojętych”. Podobnie jak w przypadku, nie tylko nie można policzyć ani zapisać takich liczb (przekroczyliśmy ten punkt już w trzecim przykładzie powyżej), ale dosłownie nie mają one żadnego możliwego zastosowania ani istnienia poza abstrakcyjną matematyką. Możemy udowodnić, z aksjomatów matematyki , że istnieją takie liczby, jak możemy udowodnić ze specyfikacji GolfScript tego programu ponad byłoby je obliczyć, jeśli granice rzeczywistości i dostępnej przestrzeni magazynowej nie interweniować), ale nie ma dosłownie nic w fizyczny wszechświat, którego moglibyśmy użyć do policzenia lub pomiaru w dowolnym sensie.

Mimo to matematycy czasami używają jeszcze większych liczb . (Teoretycznie) obliczanie tak dużych liczb wymaga nieco więcej pracy - zamiast po prostu zagnieżdżać więcej pętli jeden po drugim, musimy użyć rekurencji do teleskopowania głębokości zagnieżdżonych pętli. Jednak w zasadzie powinno być możliwe napisanie krótkiego programu GolfScript (spodziewałbym się, że poniżej 100 bajtów) (teoretycznie) obliczy dowolną liczbę możliwą do wyrażenia, powiedzmy, w notacji łańcuchowej Conwaya ; szczegóły pozostawia się jako ćwiczenie. ;-)

Ilmari Karonen
źródło
9
"...No computer ever built could store a number that big...Popraw mnie, jeśli się mylę, ale nie sądzę, żeby miało to tutaj zastosowanie. Czy to nie tylko wielokrotne „przechowywanie” i drukowanie 3 cyfr na raz (?), Więc nie ma potrzeby przechowywania końcowego wyniku.
Kevin Fegan
12
@KevinFegan: To prawda - liczba jest niezwykle powtarzalna, więc łatwo byłoby ją skompresować. Ale tak naprawdę nie przechowujemy już samej liczby, ale raczej abstrakcyjną formułę, na podstawie której można teoretycznie obliczyć liczbę; w rzeczywistości jedną z najbardziej kompaktowych takich formuł jest prawdopodobnie program GolfScript powyżej, który je generuje. Ponadto, gdy przejdziemy o krok dalej do następnego programu, nawet „drukowanie” cyfr pojedynczo przed ich odrzuceniem staje się niepraktyczne - po prostu nie ma znanego sposobu na przeprowadzenie tak wielu kroków klasycznego obliczenia we wszechświecie.
Ilmari Karonen
@ GolfScript IlmariKaronen właśnie dał Googolowi wedgie!
WallyWest
5
A co powiesz na maksymalne zwiększenie tego limitu i zobacz, jak dokładnie możesz naprawdę zrobić to w GolfScript w obrębie 100 znaków? W tej chwili twój wynik jest mniejszy niż liczba Grahama (którą moje rozwiązanie Haskell „przybliża”), ale jak mówisz, GolfScript może pójść jeszcze dalej.
przestał obracać przeciwnie do zegara
3
@leftaroundabout: Udało mi się napisać ewaluator notacji strzałek Conwaya w 80 znakach GolfScript, chociaż nie spełnia on wszystkich wymagań tego wyzwania (wykorzystuje stałe numeryczne i operatory arytmetyczne). Prawdopodobnie można to poprawić, ale pomyślałem, że może to stanowić nowe wyzwanie.
Ilmari Karonen
42

JavaScript 44 znaki

To może wydawać się trochę oszukiwane:

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

Wynik = 31415926535897932718281828459045/44 ^ 3 ≈ 3,688007904758867e + 26 ≈ 10 ↑↑ 2,1536134004

WallyWest
źródło
9
Żadne reguły nie są wygięte:;) * Nie można użyć 0123456789 [sprawdź] * Użyj dowolnego języka, w którym cyfry są poprawnymi znakami; [sprawdź] * Możesz użyć matematyki / fizyki / itp. stałe <10. [sprawdź, wykorzystano 2] * Rekurencja jest dozwolona, ​​ale wygenerowana liczba musi być skończona; [sprawdź, brak rekurencji] Nie można użyć *, /, ^; [sprawdź] Twój program może wypisać więcej niż jedną liczbę; [sprawdź] Możesz łączyć łańcuchy; [sprawdź] Twój kod będzie działał bez zmian; [sprawdź] Maksymalna długość kodu: 100 bajtów; [sprawdź] Potrzebuje zakończyć w / i 5 sekund [sprawdź]
WallyWest
Ogol 2 znaki, przekazując "."zamiast/\./g
gengkev
1
@gengkev Niestety, tylko użycie .replace („.”, „”) usuwa tylko pierwszy. postać; I mieć do korzystania z globalnej wymienić wymienić wszystkie. znaki z ciągu ...
WallyWest,
Możesz m=Math,p=m.PI,e=m.E,s="",alert((p*p*p+s+e*e*e).replace(/\./g,s))zamiast tego zrobić , twój wynik to 3100627668029981620085536923187664/63 ^ 3 = 1,240017943838551e + 28
AMK
1
@Cory Po pierwsze, nie zamierzam powtarzać stałej, inaczej wszyscy by jej
użyli
28

C, wynik = 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);}

Doceniam pomoc w punktacji. Wszelkie spostrzeżenia i poprawki są mile widziane. Oto moja metoda:

n = konkatenacja każdej liczby od 1 do 2 64 -1, powtórzona (2 64 -1) 4 razy . Po pierwsze, oto w jaki sposób szacuję (małą) łączną liczbę cyfr od 1 do 2 64 -1 („podsekwencja”): Ostateczna liczba w sekwencji podsekwencji wynosi 2 64 -1 = 18446744073709551615z 20 cyframi. Tak więc ponad 90% liczb w podsekwencji (te zaczynające się od 1.. 9) ma 19 cyfr. Załóżmy, że pozostałe 10% to średnio 10 cyfr. Będzie to znacznie więcej, ale jest to niska ocena dla łatwej matematyki i bez oszukiwania. Ta podsekwencja jest powtarzana (2 64 -1) 4 razy, więc długośćz n będzie wynosić co najmniej (0,9 × (2 64 -1) × 19 + 0,1 × (2 64 -1) × 10) × (2 64 -1) 4 = 3,86613 × 10 97 cyfr. W poniższych komentarzach @primo potwierdza, że n wynosi 4,1433x10 97 . Zatem n samo będzie miało 10 do tej potęgi, czyli 10 10 97,61735 .

l = 98 znaków kodu

wynik = n / l 3 = 10 10 97,61735 / 98 3

Wymagania: Musi działać na komputerze 64-bitowym, gdzie sizeof(long) == 8. Mac i Linux to zrobią.

Darren Stone
źródło
2
W C 'z'jest wartością stałą 122. Dobrze?
primo
1
myślę, printf("%d",n)że sprawi, że liczba będzie znacznie większa. Również 64-bitowy komputer nie oznacza 64-bitowych długości, na przykład Windows używa modelu LLP64, więc nadal ma 32 bity
phuclv
3
to nie powinno mieć znaczenia . Przepełnienie liczbami całkowitymi ze znakiem jest zachowaniem niezdefiniowanym w C, więc nie można przewidzieć, co się stanie po wykonaniu kodu. Może to naruszać wymóg skończoności.
Dennis
1
Myślę, że analiza może być nieco odległa. Konkatenacją 0..2^64-1ma długość dokładnie 357823770363079921190 cyfr. Powtarzane (2^64-1)^4czasy to 4,1433x10 ^ 97. Weź 10 do tej mocy is 10^10^97.6173510 ↑↑ 3.29875. Myślę, że żądasz mocy dziesięciu, której nie masz (zwróć uwagę, gdzie się 3.866×10^97stał 3.866^10^97.
primo
2
Cześć @primo. Dziękujemy za poświęcenie czasu na sprawdzenie tego. Doceniam to. Rozumiem co mówisz. Mój ostatni wykładnik jest zły. Powinno być 2.0zamiast 97. 10^10^10^2.00= 10^10^97.6. Odzwierciedlę to teraz w moim wyniku.
Darren Stone
19

Python 3 - 99 znaków - (najprawdopodobniej) znacznie większy niż liczba Grahama

Wymyśliłem szybciej rosnącą funkcję opartą na rozszerzeniu funkcji Ackermanna.

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('~')))

Inspiruje mnie http://fora.xkcd.com/viewtopic.php?f=17&t=31598 , ale nie musisz tam szukać, aby zrozumieć mój numer.

Oto zmodyfikowana wersja funkcji ackermann, której będę używać w mojej analizie:

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

Moja funkcja Aw powyższym kodzie nie jest technicznie taka sama, ale w rzeczywistości jest silniejsza, z następującą instrukcją zastępującą trzeci wiersz powyższej definicji:

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

(a musi wynosić co najmniej 1, więc musi być silniejsze)

Ale dla moich celów założę, że jest taki sam jak ten prostszy, ponieważ analiza jest już częściowo wykonana dla funkcji Ackermanna, a zatem dla tej funkcji, gdy ma dwa argumenty.

Moja funkcja ostatecznie przestanie się powtarzać, ponieważ zawsze albo: usuwa argument, zmniejsza pierwszy argument, albo zachowuje ten sam pierwszy argument i zmniejsza drugi argument.

Analiza wielkości

Numer Grahama, AFAIK, można przedstawić jako G(64):

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

Gdzie ↑^(n)b jest notacją Knutha skierowaną w górę.

Także:

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)

Liczba wyrażona w powyższym programie to A(0,1,2,3,4,...,123,124,125).

Ponieważ g^64(4)jest to liczba Grahama i przy założeniu, że moja matematyka jest poprawna, to jest mniejsza niż A(1,64,100), moja liczba jest znacznie większa niż liczba Grahama.

Proszę wskazać wszelkie błędy w mojej matematyce - chociaż jeśli nie ma, powinna to być największa jak dotąd liczba obliczona, aby odpowiedzieć na to pytanie.

Cel Skeggs
źródło
4
Wygląda świetnie; najwyraźniej twój „zmodyfikowany Ackermann” jest dokładnie ewaluatorem łańcucha Conwaya .
przestał obracać przeciwnie do zegara
1
@leftaroundabout Niezupełnie, ale myślę, że ma mniej więcej taką samą rekurencyjną siłę. Ponadto - zera nie są prawidłowe w łańcuchach, więc zrzuć zero z łańcucha Conwaya na liście wyników.
Cel Skeggs
1
Dlaczego to zrobiłeś range(ord('~'))? Czy nie mógłbyś zrobić range(125)dla mniejszej ilości bajtów, co pozwoliłoby ci wycisnąć większą liczbę jak range(A(9,9,9))?
Esolanging Fruit
1
@ Challenger5: reguła 1 mówi „Nie możesz używać cyfr w swoim kodzie (0123456789)”
Cel Skeggs
@CelSkeggs: Oh, zapomniałem o tym.
Esolanging Fruit
18

Perl - wynik ≈ 10 ↑↑ 4.1

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

Po raz kolejny nadużywam silnika wyrażeń regularnych Perla do mielenia niewyobrażalnej ilości kombinacji, tym razem przy użyciu rekurencyjnego zejścia.

W wewnętrznej części wyrażenia mamy dość, .aby zapobiec nieskończonej rekurencji, a tym samym ograniczyć poziomy rekurencji do długości łańcucha.

Skończymy z tym:

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

... powtórzyłem 671088640 razy, w sumie 12750684161 zagnieżdżeń - co całkiem dokładnie zawstydza moją poprzednią próbę 23 zagnieżdżeń. Co dziwne, perl nawet się nie dusi (po raz kolejny zużycie pamięci utrzymuje się na stałym poziomie około 1,3 GB), chociaż upłynie sporo czasu, zanim wydane zostanie pierwsze polecenie wydruku.

Od mojej poprzedniej analizie poniżej, można stwierdzić, że liczba cyfr wyjściem będzie rzędu (! 12750684161) 671088640 , gdzie ! K jest Lewy Silnia z k (patrz A003422 ). Możemy to przybliżać jako (k-1)! , który jest ściśle mniejszy, ale tego samego rzędu wielkości.

A jeśli zapytamy wolframalpha :

... co ledwo zmienia mój wynik. Myślałem na pewno, że będzie to co najmniej 10 ↑↑ 5 . Myślę, że różnica między 10 ↑↑ 4 a 10 ↑↑ 4.1 jest znacznie większa, niż mogłoby się wydawać.


Perl - wynik ≈ 10 ↑↑ 4

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

Nadużywanie silnika wyrażeń regularnych Perla, aby zrobić dla nas kombinatorykę. Osadzony blok kodu
(??{print})wstawi wynik bezpośrednio do wyrażenia regularnego. Ponieważ $_składa się wyłącznie z 2s (a wynikiem printjest zawsze 1), to nigdy nie może się równać, i wysyła perl wirujący przez wszystkie możliwe kombinacje, z których jest całkiem sporo.

Zastosowane stałe

  • $^F- zazwyczaj maksymalny uchwyt pliku systemowego 2.
  • $]- numer wersji perla, podobny do 5.016002.

$_jest wówczas ciągiem zawierającym cyfrę 2powtórzoną 671088640 razy. Zużycie pamięci jest stałe przy około 1,3 GB, wyjście rozpoczyna się natychmiast.

Analiza

Zdefiniujmy P k (n) jako liczbę wykonań instrukcji print, gdzie k jest liczbą zagnieżdżeń, a n jest długością ciągu plus jeden (tylko dlatego, że nie mam ochoty pisać n + 1 wszędzie).

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

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

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

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

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

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

itp. Ogólnie formułę można uogólnić w następujący sposób:

gdzie

Oznacza to, że lewa Silnia od k , czyli sumy wszystkich silni mniej niż k (patrz A003422 ).


Byłem w stanie określić, zamknięte formy dla D K i E k , ale to nie ma znaczenia zbyt wiele, jeśli widzimy, że

i

Przy 23 zagnieżdżeniach daje nam to przybliżony wynik:

To powinno być prawie dokładne.

Ale aby umieścić to w notacji, która jest nieco łatwiejsza do wizualizacji, możemy przybliżyć podstawę wewnętrznego wykładnika:

a następnie sam wykładnik:

a następnie zapytaj wolframalpha :

który równie dobrze możesz po prostu zadzwonić 10 ↑↑ 4 i skończyć z tym.

primo
źródło
1
Czy to będzie prawidłowe rozwiązanie, dopóki numer wersji pozostanie niższy niż 10?
Pan Lister
3
@MrLister Tak. Na szczęście nie istnieje żadna większa wersja wyższa niż 6, a nawet ta nie jest uważana za w pełni „gotową”, mimo że została pierwotnie ogłoszona w 2000 roku.
primo
@primo Zdajesz sobie sprawę, że będziesz musiał zrewidować tę odpowiedź, gdy Perl przejdzie do numeru wersji> 10, prawda? ;)
WallyWest
3
@ Eliseod'Annunzio Jeśli nadal żyję, kiedy ten dzień nadejdzie - jeśli w ogóle - obiecuję wrócić i naprawić to.
primo
2
Działające rozwiązanie, które przekracza 10 ↑↑ 4. Imponujące. Brawo!
Tobia,
16

JavaScript, 10 ↑↑↑↑ 210

100 znaków:

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)

Opierając się na spostrzeżeniu, że foptymalnym rozwiązaniem jest maksymalne iterowanie , zastąpiłem 13 wywołań f3 poziomami wywoływania zagnieżdżonych pętli f, zrazy za każdym razem ( fciągle się zwiększając z).

Oceniłem wynik analitycznie na kartce papieru - napiszę go, jeśli ktoś będzie zainteresowany jego zobaczeniem.


Poprawiony wynik: 10 ↑↑ 13

JavaScript, dokładnie w 100 znakach, znowu:

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)

To poprawia moją pierwotną odpowiedź na trzy sposoby -

  1. Zdefiniowanie zzakresu globalnego pozwala nam uniknąć konieczności pisania za o.zkażdym razem.

  2. Możliwe jest zdefiniowanie gettera w zasięgu globalnym (okno) i wpisanie fzamiast o.f.

  3. Posiadanie większej liczby iteracji fjest warte więcej niż rozpoczynanie od większej liczby, więc zamiast (Math.E+'').replace('.','')(= 2718281828459045, 27 znaków) lepiej jest użyć ~~Math.E+''(= 2, 11 znaków) i używać uratowanych znaków, aby dzwonić fwiele razy.

Ponieważ, jak przeanalizowano poniżej, każda iteracja daje, z liczby w rzędzie wielkości M , większą liczbę w rzędzie wielkości 10 M , kod ten powstaje po każdej iteracji

  1. 210 ∼ O (10 2 )
  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)

Wynik: ∼10 10 10 10 10 16 ≈ 10 ↑↑ 6.080669764

JavaScript, dokładnie 100 znaków:

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)

Każde o.fwywołuje pętlę while, co daje w sumie 5 pętli. Już po pierwszej iteracji wynik jest już ponad 10 42381398144233621 . W drugiej iteracji Mathematica nie był w stanie obliczyć nawet liczby cyfr w wyniku.

Oto przewodnik po kodzie:

W tym

Zacznij od 2718281828459045, usuwając przecinek dziesiętny z Math.E.

Iteracja 1

Połącz malejącą sekwencję liczb,

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

aby utworzyć nowy (gigantyczny) numer,

  • 271828182845904527182818284590442718281828459043 ... 9876543210.

Ile cyfr jest w tym numerze? Cóż, to jest konkatenacja

  • 1718281828459046 16-cyfrowe liczby
  • 900000000000000 15-cyfrowe numery
  • 90000000000000 14-cyfrowe numery,
  • 9000000000000 13-cyfrowe numery
  • ...
  • 900 3-cyfrowych liczb
  • 90 2-cyfrowych liczb
  • 10 1-cyfrowych liczb

W Mathematica

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

Innymi słowy, jest to 2,72⋅10 42381398144233625 .

Robiąc mój wynik, już po pierwszej iteracji, 2.72⋅10 42381398144233619 .

Iteracja 2

Ale to dopiero początek. Teraz powtórz kroki, zaczynając od gigantycznej liczby ! To znaczy, łączymy malejącą sekwencję liczb,

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

Jaki jest mój nowy wynik, 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[]

Iteracja 3

Powtarzać.

Iteracja 4

Powtarzać.

Iteracja 5

Powtarzać.


Wynik analityczny

W pierwszej iteracji obliczono liczbę cyfr w konkatenacji malejącej sekwencji rozpoczynającej się od 2718281828459045, zliczając liczbę cyfr w

  • 1718281828459046 16-cyfrowe liczby
  • 900000000000000 15-cyfrowe numery
  • 90000000000000 14-cyfrowe numery,
  • 9000000000000 13-cyfrowe numery
  • ...
  • 900 3-cyfrowych liczb
  • 90 2-cyfrowych liczb
  • 10 1-cyfrowych liczb

Suma ta może być reprezentowana przez wzór,

        wprowadź opis zdjęcia tutaj

gdzie Z oznacza liczbę początkową ( np. 2718281828459045), a O Z oznacza jego rząd wielkości ( np. 15, ponieważ Z ∼ 10 15 ). Używając równoważników dla sum skończonych , powyższe można wyrazić wprost jako

        wprowadź opis zdjęcia tutaj

co, jeśli weźmiemy 9 ≈ 10, zmniejsza się jeszcze bardziej do

        wprowadź opis zdjęcia tutaj

i wreszcie, poszerzanie warunków i porządkowanie ich poprzez zmniejszanie rzędu wielkości, otrzymujemy

        wprowadź opis zdjęcia tutaj

Ponieważ interesuje nas tylko rząd wielkości wyniku, zastąpmy Z „liczbą w rzędzie wielkości O Z ”, tj. 10 O Z -

        wprowadź opis zdjęcia tutaj

Wreszcie, drugi i trzeci termin zostają anulowane, a ostatnie dwa terminy można usunąć (ich rozmiar jest trywialny), co pozostawia nam

        wprowadź opis zdjęcia tutaj

od którego wygrywa pierwszy semestr.

Przekształcone, fprzyjmuje liczbę rzędu wielkości M i daje liczbę w przybliżeniu rzędu wielkości M (10 M ).

Pierwszą iterację można łatwo sprawdzić ręcznie. 2718281828459045 to liczba rzędu wielkości 15 - dlatego fpowinna dać liczbę rzędu wielkości 15 (10 15 ) ∼ 10 16 . Rzeczywiście, wyprodukowana liczba wynosi z góry 2,72⋅10 42381398144233625 - czyli 10 42381398144233625 6 10 10 16 .

Biorąc pod uwagę, że M nie jest znaczącym czynnikiem w M (10 M ), rząd wielkości wyniku każdej iteracji następuje zatem według prostego wzoru tetracji:

  1. 10 16
  2. 10 10 16
  3. 10 10 10 16
  4. 10 10 10 10 16
  5. 10 10 10 10 10 16

Źródła 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}
Andrew Cheong
źródło
Moje obliczenia dotyczące twojego wyniku oparte są na spostrzeżeniu, które w pewnym sensie podbija fliczbę zdo własnej mocy. To coś w stylu ↑↑↑. Oczywiście wynik nie jest 2↑↑↑2, przepraszam ... bardziej 2↑↑↑5+1wydaje się. Zgadzasz się, czy powinienem umieścić to w tabeli wyników?
przestał obracać przeciwnie do zegara
@leftaroundabout - Dziękujemy za ponowne przyjrzenie się temu. Nie czuję się wystarczająco dobrze z notacją ze strzałką w górę, aby powiedzieć, czy twoja sugestia brzmi dobrze, czy nie, ale obliczyłem rząd wielkości mojego wyniku (patrz edycja), jeśli chcesz zaktualizować tabelę wyników.
Andrew Cheong
Doskonały! W ogóle nie jestem zdecydowany na strzały w górę. Więc właściwie masz „tylko” wieżę mocy; Obawiam się, że stawia cię dwa miejsca niżej w rankingu. Wyrazy uznania za prawidłową analizę wyniku; moje szacunki mają prawdopodobnie jeszcze więcej wad, ale czułem, że ktoś powinien przynajmniej spróbować uporządkować odpowiedzi.
przestał obracać przeciwnie do zegara
1
Twój wynik jest zły. Za każdym razem, gdy uruchamiasz pętlę i=o.z;while(i--)..., nie wykonujesz czasów pętli o.z, ponieważ pętla jest oparta na zmiennej całkowitej i o.zzawiera ciąg większy niż największa reprezentatywna liczba całkowita, w zależności od wielkości słowa tłumacza. Przypuśćmy, że dla twojej korzyści, że Twój interpreter nie zablokuje się przy konwersji takiego ciągu na int, izacznie się za każdym razem od największej reprezentatywnej wartości całkowitej, powiedzmy 2 ^ 63, a nie od bieżącej wartości o.z.
Tobia,
2
@ acheong87 Nie usuwaj się, wystarczy ponownie obliczyć swój wynik, ograniczając zmienne pętli do 2 ^ 63 lub podobnych. PS: zostaw swój wynik analityczny opublikowany tutaj, to bardzo pouczające!
Tobia,
14

APL, 10 ↑↑ 3.4

Oto moja zmieniona próba:

{⍞←⎕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 znaków / bajt *, działający na bieżącym sprzęcie (zużywa niewielką ilość pamięci i zwykłe 32-bitowe zmienne int), chociaż jego ukończenie zajmie bardzo dużo czasu.

Możesz go uruchomić na interprecie APL i zacznie drukować cyfry. Jeśli pozwolisz na wypełnienie, wydrukuje liczbę z 10 × 123456789 44 cyframi.

Dlatego wynik wynosi 10 10 x 123456789 44 /100 3 ≈ 10 10 353 ≈ 10 ↑↑ 3,406161

Wyjaśnienie

  • ⎕D jest predefiniowanym ciągiem ciągłym równym '0123456789'
  • n←⍎⎕Ddefiniuje n jako liczbę reprezentowaną przez ten ciąg: 123456789 (która jest <2 31 i dlatego może być używana jako zmienna sterująca pętli)
  • {⍞←⎕D} wypisze 10 cyfr na standardowe wyjście, bez nowego wiersza
  • {⍞←⎕D}⍣nzrobi to n razy ( jest „operatorem mocy”: to nie jest *, /, ani ^, ponieważ nie jest to operacja matematyczna, to rodzaj pętli)
  • {⍞←n}⍣n⍣npowtórzy poprzednią operację n razy, dlatego drukuje 10 cyfr n 2 razy
  • {⍞←n}⍣n⍣n⍣nzrobi to n 3 razy
  • Mógłbym tam zmieścić 44 ⍣n, więc drukuje n 44 razy ciąg '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
*: APL można zapisać we własnym (starszym) jednobajtowym zestawie znaków, który odwzorowuje symbole APL na górne 128 bajtów. Dlatego do celów oceniania program N znaków, który używa tylko znaków ASCII i symboli APL, może zostać uznany za N-bajtowy.

Tobia
źródło
Wydrukowana liczba zostanie podzielona na liczbę bajtów użytą do rozwiązania ^ 3. , dzielisz teraz przez 100.
ToastyMallows
2
@ToastyMallows - dla mnie wygląda jak 100 cubed(100 ^ 3).
Kevin Fegan
1
Wiem, ale to bajty, a nie znaki.
ToastyMallows
1
@ToastyMallows Przeczytaj uwagi końcowe odpowiedzi.
Po prostu piękna sztuka
Zmiana {⍞←⎕D}na ⍞←który oszczędza trzy bajty, których można użyć, aby dodać jeszcze jeden ⍣ni czynią ⊢n←⍎⎕Dna ⌽⍕n←⍎⎕Dna 80-krotny wzrost. Jeśli pozwalasz na bieganie, ⎕PP←17użyj ×⍨zamiast tego ⌽⍕prawie dwukrotnie więcej drukowanych cyfr.
Adám
12

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

Ten program ma dokładnie 100 bajtów czystego kodu Haskell. Wypisze czwartą liczbę Ackermanna, ostatecznie zużywając w tym procesie całą dostępną energię, materię i czas Wszechświata (i dalej) ( nieznacznie przekraczając miękki limit 5 sekund).

nm
źródło
o=length[]dostaje dodatkowe !qna końcu i oszczędza dodatkowo bajt.
Khuldraeseth na'Barya
9

Python, 2 ↑↑ 11/830584 ≈ 10 ↑↑ 8.632971 (Notacja strzałki w górę Knutha)

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

Prawdopodobnie żaden komputer nie ma wystarczającej ilości pamięci, aby pomyślnie to uruchomić, ale tak naprawdę nie jest to wina programu. Przy spełnieniu minimalnych wymagań systemowych działa.

Tak, to trochę przesuwa wartości logiczne. Truezostaje do 1tego zmuszony . Python ma liczby całkowite o dowolnej długości.

rekurencyjny
źródło
Twój kod nie działa. Tylko print True<<(True<<(True<<(True<<True<<True)))robi, a to daje ciąg 19k.
Gabe,
Jakie są minimalne wymagania systemowe?
Danubian Sailor
8
Czy nie możesz go skrócić, definiując, t=Truea następnie używając tpo?
Bob
1
Jeszcze lepiej, po prostu zrób pętlę, która wykona te zagnieżdżenia dla Ciebie.
Po prostu piękna sztuka
To mi się nie udaje:$python -c 'print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))' Traceback (most recent call last): File "<string>", line 1, in <module> OverflowError: long int too large to convert to int
Brian Minton
8

GolfScript 3.673e + 374

'~'(.`*

Myślę, że *jest to dozwolone, ponieważ oznacza powtarzanie ciągów, a nie mnożenie.

Objaśnienie: '~'(pozostawi 126 (wartość ASCII „~”) na stosie. Następnie skopiuj liczbę, przekonwertuj ją na ciąg i powtórz ciąg 126 razy. To daje w 126126126126...przybliżeniu 1.26 e+377. Rozwiązanie składa się z 7 znaków, więc podziel przez 7^3, aby uzyskać wynik około3.673e+374

Ben Reich
źródło
7

Rubinowy, probabilistycznie nieskończony, 54 znaki

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

x jest inicjowany na 97. Następnie iterujemy następującą procedurę: Wygeneruj x liczb losowych od 0 do 1. Jeśli wszystkie są takie same, zakończ i wypisz x. W przeciwnym razie dwukrotnie x i powtórz. Ponieważ losowe liczby Ruby mają 17 cyfr dokładności, szanse na zakończenie każdego kroku wynoszą 1 na (10e17) ^ x. Prawdopodobieństwo zakończenia w ciągu n kroków jest zatem sumą dla x = 1 do n (1 / 10e17) ^ (2 ^ n), która jest zbieżna do 1 / 10e34. Oznacza to, że dla dowolnej liczby, bez względu na to, jak duże, jest w przeważającej mierze mało prawdopodobne, że ten program wyświetli mniejszą liczbę.

Oczywiście, filozoficznym pytaniem jest, czy program, który ma mniej niż 1 na 10 ^ 34 szansę na zakończenie kroku n dla dowolnego n, można powiedzieć, że kiedykolwiek się zakończy. Jeśli założymy nie tylko nieskończony czas i moc, ale że program ma możliwość działania z rosnącą prędkością z prędkością przekraczającą szybkość, z którą maleje prawdopodobieństwo zakończenia, możemy, jak sądzę, faktycznie ustalić prawdopodobieństwo kończące się w czasie t arbitralnie bliskie 1.

histocrat
źródło
3
zależy to od generatora liczb, który w większości języków nie jest w stanie wygenerować 97 razy tej samej liczby
maniak zapadkowy
1
Dobra uwaga, więc oprócz zakładania stale rosnącej mocy obliczeniowej, muszę również założyć idealne źródło losowości i implementację Ruby, która z niej korzysta.
histokrata
7

GolfScript, ≈ f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (126)))))))))

Jest to bezwstydnie dostosowane z innej odpowiedzi @Howard i zawiera sugestie @Peter Taylor.

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

Moje rozumienie GolfScript jest ograniczone, ale uważam, że powyższe operatory *i nie^ są operatorami arytmetycznymi zabronionymi przez OP.

(Z przyjemnością usunę to, jeśli @Howard chce przesłać własną wersję, która i tak bez wątpienia byłaby lepsza od tej.)

Ten program oblicza liczbę w przybliżeniu f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (f ε 0 (126)))))) ))) - dziewięciokrotna iteracja f ε 0 - gdzie f ε 0 jest funkcją w szybko rosnącej hierarchii, która rośnie mniej więcej w tym samym tempie co funkcja Goodsteina. (f ε 0rośnie tak szybko, że tempo wzrostu funkcji n (k) Friedmana i k-krotnych strzały łańcuchowe Conwaya są praktycznie nieistotne, nawet w porównaniu z pojedynczym nie iterowanym f ε 0. )

res
źródło
'',:o;'oo',:t;po prostu przypisuje wartości 0do oi 2do t; jeśli ma to na celu obejście braku cyfr, można to znacznie skrócić ,:o)):t;, z wyjątkiem tego, że nie ma powodu, aby go usuwać, tponieważ można pisać expr:t;{...}:f;[[[t]f]f]fjako [[[expr:t]{...}:f~]f]fzapisywanie kolejnych 3 znaków.
Peter Taylor
Nadal nie trzeba strzelać o: jestem pewien, że [0 126]fbędzie on większy niż, [126]fwięc zapisujesz znak i podbijasz wynik. Chociaż zostawiasz tam pusty ciąg, który prawdopodobnie psuje rzeczy: lepiej zacząć[[,:o'~'=]
Peter Taylor
Aha, i [są niepotrzebne, ponieważ nie masz nic na stosie.
Peter Taylor
Ha ... przewijam te odpowiedzi, a potem to widzę ... a potem zauważam przyjętą odpowiedź ... hm ......
Po prostu piękna sztuka
@SimplyBeautifulArt Nie jestem pewien, co masz na myśli, ale przyjęta odpowiedź oblicza znacznie większą liczbę niż ta (zakładając, że obie są zgodne z twierdzeniem).
res
7

dc, 100 znaków

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

Biorąc pod uwagę wystarczającą ilość czasu i pamięci, obliczymy liczbę około 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15. Pierwotnie zaimplementowałem funkcję hiperoperacji , ale wymagało to zbyt wielu znaków do tego wyzwania, więc usunąłem warunki n = 2, b = 0i n >= 3, b = 0, zamieniając n = 1, b = 0warunek n >= 1, b = 0.

Jedynymi używanymi tutaj operatorami arytmetycznymi są dodawanie i odejmowanie.

EDYCJA: zgodnie z obietnicą w komentarzach, oto podział tego, co robi ten kod:

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

Jak zauważono, różni się to od funkcji hiperoperacji tym, że podstawowe przypadki mnożenia i wyższe są zastępowane przez podstawowe przypadki dodawania. Ten kod zachowuje się tak, jakby a*0 = a^0 = a↑0 = a↑↑0 ... = azamiast matematycznie poprawnego a*0 = 0i a^0 = a↑0 = a↑↑0 ... = 1. W rezultacie oblicza wartości, które są nieco wyższe niż powinny, ale to nie jest wielka sprawa, ponieważ dążymy do większych liczb. :)

EDYCJA: Właśnie zauważyłem, że cyfra przypadkowo wślizgnęła się do kodu w makrze, które wykonuje przyrosty n=0. Usunąłem go, zastępując go „F” (15), co powoduje efekt uboczny skalowania każdej operacji przyrostowej o 15. Nie jestem pewien, jak bardzo wpływa to na końcowy wynik, ale prawdopodobnie jest teraz znacznie większy.

Fraxtil
źródło
Nie mam pojęcia, co robi ten kod ... mogę tylko założyć, że jest poprawny. Może mógłbyś trochę wyjaśnić?
przestał obracać przeciwnie do zegara
Wyjaśnię kod po kawałku, kiedy będę miał czas później tej nocy.
Fraxtil,
Cóż, rozłożyłem to wyjaśnienie, ale dodałem je teraz. Mam nadzieję, że to wszystko wyjaśni.
Fraxtil
dc-1.06.95-2 kończy się natychmiast, nic nie drukując.
primo
1
Nie spodziewałbym się, że zadziała na żadnej istniejącej maszynie, biorąc pod uwagę wielkość wartości, którą będzie próbował wygenerować. Mam tę samą wersję dc i po kilku sekundach zaczyna działać poprawnie. Zakładam, że „teoretycznie poprawne” odpowiedzi są tutaj dozwolone, ponieważ nie ma kryteriów zużycia zasobów.
Fraxtil
6

Nie ma już limitu czasu działania? OK.

Czy program musi być uruchamiany na nowoczesnych komputerach?

Oba rozwiązania wykorzystują 64-bitową kompilację, więc longjest to 64-bitowa liczba całkowita.

C: większa niż 10 (2 64 -1) 2 64 , która sama jest większa niż 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 znaków.

Aby ułatwić te formuły, użyję t = 2^64-1 = 18446744073709551615.

mainbędzie wywoływał fz parametrem t, który zapętli tczasy, za każdym razem drukując wartość ti wywołując fz parametrem t-1.

Wszystkich cyfry wydrukowane: 20 * t.

Każde z tych wywołań fz parametrem t-1iteruje tczasy, wypisuje wartość ti wywołuje f z parametrem t-2.

Liczba wydrukowanych cyfr: 20 * (t + t*t)

Wypróbowałem ten program, używając odpowiednika 3-bitowych liczb całkowitych (ustawiłem i = 8i miałem wywołanie główne f(7)). Uderzył w drukowany wyciąg 6725600 razy. To się sprawdza, 7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7dlatego uważam, że jest to ostateczna liczba dla pełnego programu:

Liczba wydrukowanych cyfr: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

Nie jestem pewien, jak obliczyć (2 64 -1) 2 64 . To sumowanie jest mniejsze niż (2 64 ) 2 64 , a do obliczeń potrzebuję potęgi dwóch. Dlatego obliczę (2 64 ) 2 64 -1 . Jest mniejszy niż rzeczywisty wynik, ale ponieważ jest potęgą dwóch, mogę przekonwertować go na potęgę 10 dla porównania z innymi wynikami.

Czy ktoś wie, jak wykonać to sumowanie lub jak przekonwertować (2 64 -1) 2 64 na 10 n ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
podziel ten wykładnik przez logarytmiczną podstawę 2 z 10, aby przełączyć podstawę wykładnika na potęgi 10.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

Pamiętaj jednak, że to liczba wydrukowanych cyfr. Wartość liczby całkowitej wynosi 10 podniesiona do tej potęgi, więc 10 ^ 10 ^ 355393490465494856447

Ten program będzie miał głębokość stosu 2 ^ 64. To 2 ^ 72 bajty pamięci tylko do przechowywania liczników pętli. To 4 miliardy terabajtów liczników pętli. Nie wspominając o innych rzeczach, które trafiłyby na stos dla 2 ^ 64 poziomów rekurencji.

Edycja: Poprawiono parę literówek i użyłem bardziej precyzyjnej wartości dla log2 (10).

Edycja 2: Zaczekaj sekundę, mam pętlę, której printf jest poza. Naprawmy to. Dodano inicjalizację i.

Edycja 3: Cholera, zepsułem matematykę z poprzedniej edycji. Naprawiony.


Ten będzie działał na nowoczesnych komputerach, ale wkrótce się nie skończy.

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 znaków.

Spowoduje to wydrukowanie odwrotności bitowej zera, 2 ^ 64-1, raz dla każdej iteracji. 2 ^ 64-1 to 20 cyfr.

Liczba cyfr = 20 * (2^64-1)^7= 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500

Zaokrąglenie długości programu do 100 znaków, Wynik = liczba wydrukowana / 1 000 000

Wynik = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

David Yaw
źródło
Może. %udrukowałem liczby 32-bitowe nawet przy kompilacji 64-bitowej, więc po prostu przestałem llprzyzwyczajać się do pisania w 32-bitowym kompilatorze.
David Yaw
Myślę, że %llubyłoby long longi %lubyłoby słuszne long.
tomlogic
Naprawiony. Siła przyzwyczajenia: %uzawsze jest 32-bitowa, %lluzawsze jest 64-bitowa, bez względu na to, czy jest kompilowana jako 32- czy 64-bitowa. Jednak tutaj rozwiązanie wymaga wersji long64-bitowej, więc masz rację, %luwystarczy.
David Yaw
Nie można zagwarantować, że twoje zmienne na stosie zostaną zainicjowane na 0. W drugim programie po prostu umieść je poza jakąkolwiek funkcją. W pierwszym będziesz musiał zainicjować i.
Art.
Również długie przepełnienie jest niezdefiniowanym zachowaniem, a wiele nowoczesnych kompilatorów po prostu je zoptymalizuje, jeśli je wykryją, prawdopodobnie chcesz używać długiego bez znaku.
Art.
5

R - 49 41 znaków kodu, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348

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

wydrukuje [powielając tutaj dopiero początek]:

403624169270483442010614603558397222347416148937479386587122217348........
lebatsnok
źródło
2
Nie sądzę, że musisz podać numer w poście. Zajmuje również dużo miejsca na urządzeniach mobilnych.
całkowicieludzki
@totallyhuman Zgadzam się, może pierwsze 100 cyfr, max
tuskiomi
@ totalniehuman ok dzięki zrobione :)
lebatsnok
catjest dziwną funkcją, ponieważ pierwszym argumentem jest .... Tak więc wszystko przed pierwszym argumentem o nazwie idzie do ...(i będzie cat'ed), dlatego sepnależy go nazwać - inaczej można by go skrócić jakocat(abs(.Random.seed),,"")
lebatsnok
5

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

(3 ↑↑↑↑ 3 to G (1) gdzie G (64) to liczba Grahama)

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)

Wyjście: 10 ^ 3 ↑↑↑↑ 3

Poradnik:

Gto funkcja, w której G (64) jest liczbą Grahama. Dane wejściowe są liczbami całkowitymi. Dane wyjściowe to ciąg jednoargumentowy zapisany za pomocą 0. Usunięty dla zwięzłości.

Kto funkcja strzałki w górę Knutha a ↑ n b, gdzie a jest niejawnie 3. Dane wejściowe to n, łańcuch jednoargumentowy ib, łańcuch jednoargumentowy. Dane wyjściowe to ciąg jednoargumentowy.

u to „1”.

v to „0000” lub G (0)

e to „000”.

Kendall Frey
źródło
Maximum code length is 100 bytes;W przeciwnym razie jest to prawie nie do pobicia
Cruncher
@Cruncher Aaah, tęskniłem za tym
Kendall Frey
Achh, nienawidzę cię teraz. Za każdym razem, gdy próbuję zrozumieć rozmiar liczby Grahama, boli mnie głowa.
Cruncher
również, czy liczba Grahama nie liczy się jako stała> 10?
serakfalcon
1
Teraz ustalimy, czy moja pokonała Ilmari.
Kendall Frey
5

do

(Z przeprosinami dla Darrena Stone'a)

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

n = 2 ^ 64 cyfry (9 ...)

l = 100 znaków kodu

wynik ≈ 1e + 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 ≈ 10 ↑↑ 3.2974890744

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

Zauważ, że zasługuję na to, by bezlitośnie chłostać się za tę odpowiedź, ale nie mogłem się oprzeć. Z oczywistych powodów nie polecam zachowywać się tak jak ja podczas wymiany stosów. :-P


EDYCJA: Jeszcze trudniej oprzeć się pokusie pójścia z czymś takim

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

... ale przypuszczam, że zamierzoną, ale nieokreśloną zasadą było, że cały ciąg cyfr tworzących liczbę musi zostać wydrukowany.

ekksemizm
źródło
1
#DEFINE C while (- long n, o, p, q, r, s, t; main () {Cn) {Co) {Cp) {Cq) {Cr {Cs {Ct) {putchar ('z' -'A ');}}}}}}}}
RobAu
@RobAu Jesteś geniuszem! Uczyń to odpowiedzią. Jestem pewien, że to byłby zwycięzca. Myślę, że zapomniałeś pary ), ale nie ma sprawy, ponieważ masz teraz tylko 96 znaków.
Andrew Larsson
Dla wszystkich, którzy nie dostali sarkazmu: patrz codegolf.stackexchange.com/a/18060/7021, aby uzyskać jeszcze lepsze rozwiązanie;)
RobAu
5

Nowy Rubin: wynik ~ f ω ω2 +1 (126 2 2 126 )

gdzie f α (n) jest szybko rosnącą hierarchią.

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

Wypróbuj online!

*nto tylko mnożenie łańcuchów i tablic, więc powinny być w porządku.

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

gdzie b.-b<=>0zwraca liczbę całkowitą 1bliższą 0niż b.


Wyjaśnienie:

Drukuje nna początku każdego połączenia H.

H[[]]podwaja się n( nrazy), tj n = n<<n.

H[[0,a,b,c,...,z]]połączenia H[[a,b,c,...,z]]( nczasy).

H[[k+1,a,b,c,...,z]]połączenia H[[k]*n+[a,b,c,...,z]]( nczasy), gdzie [k]*n = [k,k,...,k].

H[[-1,a,b,c,...,z]]połączenia H[[n]*n+[a,b,c,...,z]]( nczasy).

H[[-(k+1),a,b,c,...,z]]połączenia H[[-k]*n+[a,b,c,...,z]]( nczasy).

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

Mój program inicjuje się n = 126, a następnie wywołuje H[-n-1]126 2 2 126 razy.


Przykłady:

H[[0]]zadzwoni, H[[]]co dotyczy n = n<<n( nrazy).

H[[0,0]]zadzwoni H[[0]]( nrazy).

H[[1]]zadzwoni H[[0]*n]( nrazy).

H[[-1]]zadzwoni H[[n]*n]( nrazy).

H[[-1,-1]]zadzwoni H[[n]*n+[-1]]( nrazy).

H[[-3]]zadzwoni H[[-2]*n]( nrazy).

Wypróbuj online!


Zobacz wersje innych fajnych rzeczy.

Po prostu piękna sztuka
źródło
Daj nam kontynuować tę dyskusję w czacie .
HyperNeutrino
To w rzeczywistości 103 bajty, myślę, że miałeś ostatni znak nowej linii.
Rɪᴋᴇʀ
@Riker Wierzę, że skopiowałeś i wkleiłeś stąd. Uwaga: w drugim wierszu powinien znajdować się znak niedrukowalny, a więc 104 bajty.
Po prostu piękna sztuka
@SimplyBeautifulArt ah, w porządku. Myślałem, że skopiowałem postać. Przepraszam.
Rɪᴋᴇʀ
@Riker Nah, nie ma go nawet ze względu na Stackexchange, który nie pozwala mi ukrywać wszędzie niewidzialnych postaci.
Po prostu piękna sztuka
4

Haskell - funkcja Ackermanna zastosowana do jej wyniku 20 razy - 99 znaków

Jest to najlepsze rozwiązanie Haskell, jakie mogę wymyślić w oparciu o funkcję ackermann - możesz zauważyć pewne podobieństwa do rozwiązania nm, zainspirowany został i = round $ log pi, a reszta to zbieg okoliczności: 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

Działa na sobie funkcję ackermann 20 razy, zaczynając od jednego, przy czym sekwencja jest

  • 1,
  • 3,
  • 61,
  • a (61,61),
  • a (a ( 61, 61), a (61, 61) ) --- nazwiemy to 2 (61) lub 4 (1) ---
  • a 3 (61)
  • ...
  • 18 (61), lub 20 (1). Myślę, że jest to w przybliżeniu g 18 (patrz poniżej).

Jeśli chodzi o szacunki, wikipedia mówi:

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

Z tego wynika, że ​​a3 (1) = a (61,61) = 2 ↑ 59 64 + 3, co jest wyraźnie większe niż g1 = 3 ↑ 4 3, chyba że 3 na początku jest znacznie ważniejsze niż myślę. Następnie, każdy poziom nie następuje (odrzucając nieznacznych stałych w a n )

  • g n = 3 ↑ g n-1 3
  • a n ~ = 2 ↑ a n-1 (a n-1 )

Jeśli są one w przybliżeniu równoważne, wówczas 20 (1) ~ = g 18 . Ostateczny składnik w n , (a n-1 ) jest znacznie większy niż 3, więc potencjalnie jest wyższy niż g 18 . Zobaczę, czy uda mi się dowiedzieć, czy to przyspieszy choćby jedną iterację, i przekażę raport.

Toeofdoom
źródło
Twoja analiza jest poprawna, a g <sub> 18 </sub> jest dobrym przybliżeniem.
Po prostu piękna sztuka,
length"a"oszczędza kilka bajtów i pozwala ci kolejny.a
Khuldraeseth na'Barya
4

kod maszynowy x86 - 100 bajtów (złożony jako plik MSDOS .com)

Uwaga: może nieco zgiąć reguły

Ten program wyświetli 2 (65536 * 8 + 32) dziewiątek, co dałoby wynik na (10 2 524320 -1) / 1000000

Jako licznik ten program wykorzystuje cały stos (64 kB) oraz dwa rejestry 16-bitowe

Zmontowany kod:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Montaż:

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'
Robert Sørlie
źródło
Oczywiście nigdy tego nie prowadziłeś. Nadpisuje kod i ulega awarii.
Joshua
4

do

Rozmiar pliku to 45 bajtów.

Program to:

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

Wyprodukowana liczba jest większa niż 10 ^ (10 ^ (10 ^ 1.305451600608433)).

Plik, do którego przekierowałem standardowe wyjście, ma obecnie ponad 16 Gb i wciąż rośnie.

Program zakończyłby się w rozsądnym czasie, gdybym miał lepszy komputer.

Mój wynik jest niepoliczalny z zmiennoprzecinkową podwójną precyzją.

iWiggins
źródło
4

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 w dowolnym rozsądnym systemie. SHLVL jest małą dodatnią liczbą całkowitą (zwykle 1 lub 2 w zależności od tego, czy / bin / sh to bash, czy nie).

Tylko 64-bitowy system UNIX:

Wynik: ~ 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'
Jozuego
źródło
SHLVL to poziom bash jako subbash:bash -c 'bash -c "echo \$SHLVL"'
F. Hauri
stat --printfnie działa. Spróbujstat -c %s
F. Hauri
@ F.Hauri: --printf działa dla mnie, ale tak samo działa z -c, więc ogoliłem kilka bajtów. Dzięki.
Joshua
4

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

Tworzymy tablicę 258048 liczb całkowitych bez znaku. Nie mogło być długo niepodpisanych, ponieważ to spowodowało, że program był zbyt długi. Są niepodpisane, ponieważ nie chcę używać niezdefiniowanego zachowania, ten kod jest poprawny C (poza brakiem powrotu z main ()) i będzie się kompilował i działał na każdym normalnym komputerze, ale będzie działał przez długi czas . Ten rozmiar jest największy, jaki możemy legalnie wyrazić bez użycia znaków innych niż ascii.

Pętlimy przez tablicę, zaczynając od ostatniego elementu. Drukujemy cyfry 2^32-1, zwiększamy element i upuszczamy pętlę, jeśli element nie jest zawinięty do 0. W ten sposób będziemy zapętlać (2^32 - 1)^254048 = 2^8257536czasy, drukując 10 cyfr za każdym razem.

Oto przykładowy kod, który pokazuje zasadę w bardziej ograniczonym zakresie danych:

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

Wynik wynosi około 10 ^ 10 ^ 2485766 podzielony przez milion, który wciąż wynosi około 10 ^ 10 ^ 2485766.

Sztuka
źródło
Jak dotąd najlepsza implementacja C. Po co używać 5 zmiennych, skoro można użyć tablicy 258048 ?
primo
4

PowerShell (2,53e107976 / 72³ = 6,78e107970 ≈ 10 ↑↑ 1.701853371)

Uruchomienie zajmuje znacznie więcej niż 5 sekund.

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

Pobiera i konkatenuje długość bajtów każdego pliku na bieżącym dysku. Regex usuwa wszelkie znaki inne niż cyfry.

Hand-E-Food
źródło
Zasada 1 mówi, że żadne cyfry nie są dozwolone, masz 0tam.
Kyle Kanos
Cholera, ja też. Oto liczba moich postaci.
Hand-E-Food
Możesz użyć, -ea(+'')aby zmniejszyć rozmiar ( ''przeliczony na liczbę 0, której wartość wyliczana jest SilentlyContinue). Możesz użyć \Ddo wyrażenia regularnego, który jest taki sam jak [^\d]. I możesz po prostu użyć %{$_.Length}zamiast tego, aby select Lengthpozbyć się nagłówków kolumn. A potem można się pozbyć -spliti -replacejak dobrze, dzięki czemu można z -join(gci \ -ea(+'')-r|%{$_.Length})którym jest 37 znaków krótszy (ja też kolejność parametrów ponieważ nawiasy są konieczne w każdym razie z powodu +'').
Joey
4

Python 3, wynik = 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))

Funkcja f to funkcja ackermann, do której wywołania mam wystarczająco dużo miejsca.

Edycja: poprzednio „else n + 1”, co było niezgodne z regułami wyzwań - uznanie dla Simply Beautiful Art.

Magenta
źródło
Możesz zwiększyć swój numer, zmieniając f(m-g,g)na f(m-g,m).
Po prostu piękna sztuka
lub f(m-g,i). Ponadto na końcu pierwszego wiersza używasz liczby. Wierzę, że chciałeś użyć n+g, po czym wskazuję, że będzie n+nwiększy.
Po prostu piękna sztuka
Możesz zaoszczędzić kilka bajtów, zmieniając len („”) dla True
Brian Minton
I użyj ord ('^?') (Gdzie ^? Jest znakiem DEL, ASCII 127) dla większej liczby. EDYCJA nieważne, to nie jest „do druku”.
Brian Minton
@BrianMinton Kto powiedział, że musi być do wydruku?
Po prostu piękna sztuka
4

JavaScript 98 znaków

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)

generuje 2,718e + 239622337 ≈ 10 ↑↑ 2.9232195202

Za wynik nieco ponad 2,718e + 239622331 ≈ 10 ↑↑ 2.9232195197

co jest największym, jaki mogę zrobić bez awarii przeglądarki.

(console.log (a) pokaże pełne wyjście)

Nie uruchamiaj tych:

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)

wyniesie 2,718 + e121333054704 ≈ 10 ↑↑ 3.0189898069 (alias 2,718 * 10 ^ (1,213 * 10 ^ 12), aby porównać do dłuższej odpowiedzi:

bardziej ekstremalna wersja, jeśli nie spowodowała awarii przeglądarki: (80 znaków)

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

co stworzyłoby liczbę mniej więcej tego samego rozmiaru co e * 10 ^ (10 ^ 19) ≈ 10 ↑↑ 3.106786869689

Edycja: zaktualizowane oryginalne rozwiązanie kodu wygenerowało tylko 2,718e + 464

serakfalcon
źródło
3

Python 3: 98 znaków, ≈ 10 ↑↑ 256

Za pomocą funkcji argumentu zmiennej:

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

Skutecznie, E zmniejsza pierwszy argument, jednocześnie zwiększając pozostałe argumenty, z tym wyjątkiem, że zamiast wstawiania -1 w argumentach, upuszcza argument. Ponieważ każdy cykl zmniejsza pierwszy argument lub zmniejsza liczbę argumentów, gwarantuje to, że zostanie zakończony. Zastosowaną funkcją rosnącą jest int („% d% d”% (k, k)), co daje wynik między k ** 2 + 2 * k a 10 * k ** 2 + k. Mój kod używa symbolu * - ale nie jako mnożenia. Służy do pracy ze zmienną liczbą argumentów, które moim zdaniem powinny być zgodne z regułami, ponieważ wyraźnym celem reguł było ograniczenie określonych operacji, a nie samych symboli.

Kilka przykładów tego, jak duże E szybko dostaje się:

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)

Tylko dwa pierwsze z nich można uruchomić na moim komputerze w rozsądnym czasie.

Następnie E wywoływane jest przez E(*range(ord('~')))- co oznacza:

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

Nie jestem do końca pewien, jak duży jest (próbowałem go przybliżyć bezskutecznie) - ale oczywiste jest, że jest ~ naprawdę ~ duży.

Na przykład, około dwunastu cykli, wynik jest około: (technicznie nieco więcej niż)

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)

Oszacowanie wyniku:

Jeśli przybliżymy rosnący krok o lambda k: 10 * k**2, funkcję można opisać jako

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

Istotną rzeczą, którą tutaj robimy, jest zbudowanie dziesięcioosobowej wieży, więc ostateczny wynik można oszacować jako 10 ↑↑ 256.

Lepsze (choć częściowe) oszacowanie wyniku:

Wykorzystuje to to samo, 10 * k**2co inne oszacowania.

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

Zgodnie z poprzednim szacunkiem byłoby to:

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

Który jest znacznie mniejszy niż rzeczywista wartość, ponieważ używa a**2zamiast 2**adla 10 i używa a*2zamiast 2**adla b.

Cel Skeggs
źródło
Oszacowałem twój wynik, nie krępuj się.
przestał się obracać przeciwnie do zegara
Nie mogę się zgodzić z tym wynikiem. Chwilkę, gdy wpisuję swoje rozumowanie.
Cel Skeggs,
No to jedziemy. Jak powiedziałem w aktualizacji, twoje oszacowanie wydaje się znacznie mniejsze niż rzeczywista wartość.
Cel Skeggs,
W porządku, ale w każdym razie potrzebujemy oszacowania rekursywno-indukcyjnego / naraz, a nie tylko jednego kroku, aby uwzględnić tę odpowiedź na liście wyników. Jestem pewien, że twój wynik jest lepszy niż rekurencyjny , ale też całkiem pewny, że nie lepszy niż wynik Ilmari Karonena (który i tak można bardzo rozszerzyć, używając w tej chwili tylko 18 znaków), więc uważam, że moje oszacowanie jest wystarczające dla cel punktacji.
przestał obracać przeciwnie do zegara
Zgadzam się. Zobaczę, czy mogę nad tym popracować i przynajmniej wymyślę dokładniejszą dolną granicę dla wyniku.
Cel Skeggs,
3

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

  • ~ 20 GB mocy wyjściowej
  • 41 znaków (41 ^ 3 nic nie znaczy)
main(){for(;rand();printf("%d",rand()));}

Pomimo rand()wyniku jest deterministyczny, ponieważ nie ma funkcji początkowej.

Ybeltukov
źródło
Jeśli masz pecha, Twój program zatrzymuje się po jednej iteracji, a wywołanie rand()warunku zakończenia powoduje, że nie jest on deterministyczny. Ponadto wywoływanie rand()każdej iteracji powinno być strasznie wolne. Zamiast tego użyj czegoś takiego, jak LONG_MAXzdefiniowano w limits.h.
klingt.net
Ok, cofam non deterministicsię, bo nie ma takiego ziarna, jak napisałeś.
klingt.net
1
Co powiesz na ~' 'zamiast z rand()nadrukiem %u? Dwa bajty mniej źródła i wyższa wartość.
MSalters