목표는 단 10 자 코드를 사용하여 가능한 한 많은 숫자를 표준 출력으로 인쇄하는 것입니다.

• 내장 지수 함수를 제외한 언어의 모든 기능을 사용할 수 있습니다.
  • 마찬가지로 과학적 표기법을 사용하여 숫자를 입력 할 수 없습니다. (그래서 안돼 9e+99.)
• 프로그램은 사용자의 입력없이 번호를 인쇄해야합니다. 마찬가지로 다른 파일이나 웹 등에서 읽지 않아도됩니다.
• 프로그램은 단일 숫자를 계산하여 인쇄해야합니다. 문자열을 인쇄 할 수 없으며 같은 숫자를 수천 번 인쇄 할 수도 없습니다.
• 인쇄에 필요한 코드를 10 자 제한에서 제외 할 수 있습니다. 예를 들어, print x구문 을 사용하는 Python 2에서는 프로그램에 최대 16자를 사용할 수 있습니다.
• 프로그램은 실제로 출력에서 ​​성공해야합니다. 세계에서 가장 빠른 컴퓨터에서 실행하는 데 1 시간 이상 걸리면 유효하지 않습니다.
• 출력은 어떤 형식으로 할 수있다 (인쇄 할 수 있도록 999, 5e+100등)
• 무한대는 숫자 가 아닌 추상적 인 개념 입니다. 따라서 올바른 출력이 아닙니다.

볼프람 언어

ack(9!,9!)

ack (9!, 9!) =

출력은 화살표 표기법입니다.

펄,> 1.96835797883262e + 18

time*time

오늘 가장 큰 답이 아닐 수도 있습니다 ... 오늘! 그러나 충분히 천년을 기다리면 그렇게 될 것입니다!

"충분한 밀레니아"에 의해 일부 의견을 다루기 위해, 나는 실제로 n ¹⁰⁰ 년을 의미 합니다.

공평하게 말하면, 우주의 큰 동결 / 열 사망이 우주가 어떻게 끝나는가 (약 ¹⁰¹⁰⁰ 년으로 추정 됨 ), "최종"값은 ~ 10 ²¹⁴ 이 될 것입니다. 다른 반응들 ( "무작위 양자 변동 또는 양자 터널링은 10 ^{10 56} 년 안에 또 다른 빅뱅을 생성 할 수있다 "). 보다 낙관적 인 접근 방식 (예 : 순환 또는 다중 모델)을 취하면 시간이 무한정 지속될 수 있으며, 언젠가는 일부 우주, 일부 고 비트 아키텍처에서는 대답이 다른 것보다 뛰어납니다.

반면에 지적한 바와 같이 time실제로 정수 / 길이의 크기에 의해 제한되므로 실제로 ~0는 항상 더 많은 수를 생성합니다 time(즉 time아키텍처에서 지원 하는 최대 값 ).

이것은 가장 진지한 대답은 아니지만, 여러분들이 그것을 즐기기를 바랍니다!

볼프람 ≅ 2.003529930 × 10 ¹⁹⁷²⁸

예, 언어입니다! 인기있는 Wolfram Alpha 사이트의 백엔드를 구동합니다. Ackermann 함수가 내장되어 있고 6 자 미만으로 축약 된 곳에서 찾은 유일한 언어 입니다.

여덟 글자로 :

$ ack(4,2)

200352993...719156733

또는 2.00 2.003529930 × 10 ¹⁹⁷²⁸

ack(4,3), ack(5,2)등 훨씬 더 큰,하지만 너무 큽니다. ack(4,2)한 시간 안에 완전히 계산할 수있는 것보다 아마도 가장 큰 Ackermann 수일 것입니다.

큰 숫자는 다음과 같은 기호 형식으로 렌더링됩니다.

$ ack(4,3)

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

규칙에 따르면 모든 출력 형식이 허용되므로 유효 할 수 있습니다. 이것은 10 ^{10 19727} 보다 크며 , 이는 반복 계승을 제외하고는 여기의 다른 어떤 항목보다 큽니다.

하나,

$ ack(9,9)

2↑⁷12 - 3

반복 계승보다 큽니다. 열 개의 문자로 얻을 수있는 가장 큰 숫자는 다음과 같습니다.

$ ack(99,99)

2↑⁹⁷102 - 3

이것은 엄청나게 크며, 우주는 당신이 그 숫자의 반복 된 로그를 가져도 숫자의 상당 부분을 나타낼만큼 충분히 크지 않습니다.

Python2 셸, 3,010,301 자리

9<<9999999

길이 계산 : Python은이 긴 숫자에 "L"을 추가하므로 결과에 숫자보다 1자를 더 많이보고합니다.

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

처음과 마지막 20 자리 :

40724177878623601356... ...96980669011241992192

CJam, 2 × 10 ^268,435,457

A28{_*}*K*

이는 다음과 같이 정의 된 b를 계산 합니다.

• a ₀ = 10

• a _n = a _n-1 ²

• b = 20 × a ₂₈

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

배경

이것은 Claudiu의 답변 과 같은 아이디어를 따르지만 그것을 기반으로하지는 않습니다. 나는 그가 그의 게시물을 게시 한 후 몇 분 만에 게시 한 비슷한 아이디어를 가지고 있었지만 시간 제한 근처에 오지 않았기 때문에 버렸습니다.

그러나 aditsu의 Java 8 로의 업그레이드 제안 과 10의 거듭 제곱 사용에 대한 아이디어 는 CJam이 GolfScript의 범위를 벗어난 숫자를 계산할 수있게 해주었습니다. 이는 Ruby의 Bignum의 일부 버그 / 제한으로 인한 것 같습니다.

작동 원리

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

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

KK,{)*_*}/

내 컴퓨터에서 5 분도 걸리지 않으므로 여전히 개선의 여지가 있습니다.

다음과 같이 정의 된 _20을 계산 합니다.

• a ₀ = 20

• a _n = (n × a _n-1 ) ²

작동 원리

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

파이썬 3, 9 * 2 ^ (7 * 2 ^ 33)> 10 ^ 18,100,795,813

9 * 2 ^ (2 ^ 35)> 10 ^ 10,343,311,894

편집 : 내 새로운 대답은 다음과 같습니다

9<<(7<<33)

후손에 대한 오래된 대답 :

9<<(1<<35)

정확히 10 자.

16 진수로 숫자를 인쇄하고 있습니다.

인쇄에 필요한 코드를 10 자 제한에서 제외 할 수 있습니다. 예를 들어 print x 구문을 사용하는 Python 2에서는 프로그램에 최대 16자를 사용할 수 있습니다.

따라서 실제 코드는 다음과 같습니다.

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

지정된 시간에 실행되고 지정된 크기의 수를 생성한다는 증거입니다.

time python bignum.py > bignumoutput.py

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

내 번호> 10 ^ (15032385538 * log (16))> 10 ^ 18100795813

초기 값으로 인해 위의 wc 출력보다 16 진수가 적습니다 0x9.

파이썬 2는 파이썬 2에서 7<<33길고, <<입력 으로 오래 걸리지 않기 때문에 필요 합니다.

대신 9 << (1 << 36)을 사용할 수 없습니다.

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

따라서 이것은 a<<(b<<cd)내 컴퓨터에서 인쇄 할 수있는 가장 큰 양식 수입니다 .

어쩌면 세상에서 가장 빠른 컴퓨터는 내가하는 것보다 더 많은 메모리를 가지고 있기 때문에 대체 대답은 다음과 같습니다.

9<<(9<<99)

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

그러나 내 현재 답변은 제출 한 사람 중 가장 큰 답변이므로 충분할 것입니다. 또한 비트 시프 팅이 허용된다고 가정합니다. 그것을 사용하는 다른 답변에서 나온 것처럼 보입니다.

상수 이름이 짧고 약 18 자리 인 언어

99/sin(PI)

나는 이것을 PHP 답변으로 게시하지만 슬프게도 M_PI이것을 너무 길게 만듭니다! 그러나 PHP는 이것을 위해 8.0839634798317E + 17을 산출합니다. 기본적으로 PI : p의 절대 정밀도 부족을 남용합니다.

하스켈

트릭없이 :

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

아무 것도 계산하지 않고 :

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

Niet의 답변 적응 :

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

파워 쉘-1.12947668480335E + 42

99PB*9E9PB

99 페비 바이트에 9,000,000,000 페비 바이트를 곱합니다.

제이 (((((((((9)!)!)!)!)!)!)!)! )

예, 많이입니다. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))매우 정확하지 않습니다.

!!!!!!!!9x

K / Kona : 8.977649e261 1.774896e308

*/1.6+!170

• !170 0에서 169까지의 숫자로 구성된 벡터를 만듭니다.
• 1.6+ 벡터의 각 요소에 1을 더하고 실수로 변환합니다 (범위는 1.6 ~ 170.6).
• */ 배열의 각 요소를 곱합니다

Kona가 쿼드 정밀도를 지원 */9.+!999하면 약 1e2584를 얻을 수 있습니다. 슬프게도, 그렇지 않으며 배가 정밀도가 떨어졌습니다.

오래된 방법

*/9.*9+!99

• !99 0에서 98 사이의 숫자로 구성된 벡터를 만듭니다.
• 9+ 벡터의 각 요소에 9를 더합니다 (현재 범위 9-107)
• 9.* 각 요소에 9.0을 곱합니다 (암시 적으로 실수로 변환하므로 81.0-963.0)
• */ 벡터의 각 요소를 곱합니다

HTML, 9999999999

9999999999

.. 그것을 못 박았다.

Python-Varies, 최대 13916486568675240 (지금까지)

완전히 진지한 것은 아니지만 다소 재미있을 것이라고 생각했습니다.

print id(len)*99

내가 시도한 모든 것 len중에서 가장 일관되게 큰 ID를 얻었습니다.

내 컴퓨터에서 13916486568675240 (17 자리) 및 이 사이트 에서 13842722750490216 (17 자리)을 생성 했습니다 . 나는 이것이 당신에게 0을 줄 수 있다고 생각하지만, 더 높아질 수도 있습니다.

골프 스크립트, 1e + 33,554,432

10{.*}25*

10 ^ (2 ^ 25)지수를 사용하지 않고 계산 은 96 초 안에 실행됩니다.

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

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

9 ^ (2 ^ 9999)충분한 시간이 주어지면 최대 계산할 수 있지만 내부 지수를 1 씩 늘리면 시간이 세 배가 걸리므로 한 시간 제한에 곧 도달합니다.

설명 :

같은 생각으로 이전 버전 사용하기 :

8{.*}25*

세분화 :

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

각 블록의 시작 부분에있는 스택은 현재 숫자 인 하나의 숫자로 구성됩니다. 로 시작합니다 8. 그때:

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

따라서 스택은 단계별로 다음과 같습니다.

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

... 등. 수학 표기법으로 작성된 진행률은 다음과 같습니다.

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

wxMaxima ~ 3x10 ^49,948 (또는 10 ^{8,565,705,514} )

999*13511!

출력

269146071053904674084357808139[49888 digits]000000000000000000000000000000

그것이 사양 (특히 출력 형식 1)에 맞는지 확실하지 않지만 더 크게 칠 수 있습니다.

bfloat(99999999!)

출력

9.9046265792229937372808210723818b8565705513

대략 10 ^{8,565,705,514} 로 대부분의 최고 답변보다 훨씬 크고 약 2 초 안에 계산되었습니다. 이 bfloat함수는 임의의 정밀도를 제공합니다 .

하스켈, 4950

Aww man, 그다지 많지 않습니다! 달러 기호 다음에 10자가 시작됩니다.

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

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

정확히 10 자.

파이썬 셸, 649539 999890001

Haskell을 친다. 정말로 정답은 아니다.

99999*9999

Wolfram Alpha (웹 사이트는 언어로 간주됩니까?)

9! ! ! ! !

출력

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

공간이 잘 작동하고 끝이 뾰족한 팁에 대한 Cory 덕분에

베 펀지 -93 (1,853,020,188,851,841)

기뻐하는 사람은 아직 Befunge를하지 않았지만 (내 틈새 시장), 숫자를 늘리는 영리한 속임수를 찾지 못했습니다.

9:*:*:*:*.

9 ^ 16입니다.

:*

기본적으로 스택 상단의 값에 자체를 곱합니다. 따라서 스택 상단의 값은 다음과 같습니다.

9
81
6561
43046721
1853020188851841

과

.

최종 값을 출력합니다. 더 좋은 아이디어를 가진 사람이 있는지 알고 싶습니다.

오히려 위의 의견으로 이것을 게시하고 싶지만 멍청한 놈이기 때문에 분명히 할 수 없습니다.

파이썬 :

9<<(2<<29)

더 큰 비트 시프트를 사용하지만 Python은 시프트의 올바른 피연산자가 정수가 아닌 정수를 원하는 것으로 보입니다. 나는 이것이 이론적 최대치에 가까워 진다고 생각한다.

9<<(7<<27)

이것의 유일한 문제점은 규칙 5를 충족시키지 못할 수 있다는 것입니다.

MATLAB (1.7977e + 308)

Matlab은 최대 (배정 밀도) 부동 소수점 숫자의 값을이라는 변수에 저장합니다 realmax. 명령 창에서 (또는 명령 행에서) 호출하면 해당 값이 인쇄됩니다.

>> realmax

ans =

  1.7977e+308

파이썬, ca. 1.26e1388

9<<(9<<9L)

제공합니다 :

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L

Python 3.5.0 (64 비트) 이상, 10 ^ 242944768872896860 이상

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

이상적인 세계에서는 이것이 9<<(1<<63)-1되지만 바이트가 충분하지 않습니다. 이 숫자는 너무 커서 메모리를 보유하는 데 거의 1EiB의 메모리가 필요합니다. 컴퓨터에있는 것보다 조금 더 큽니다. 운 좋게도 세계 저장 공간의 약 0.2 % 만 스왑으로 사용하면됩니다. 이진수 값 1001뒤에는 8070450532247928832 0이옵니다.

128 비트 컴퓨터에서 Python이 나오면 최대 값은 9<<(9<<99)1MiYiB 미만의 메모리가 필요합니다. 파이썬 인터프리터와 운영 체제를 저장할 충분한 주소 공간이 충분하기 때문에 이것은 좋습니다.

Cubix , 9.670457478596419e + 147 (비경쟁)

****"///**

Cubix가이 과제보다 최신이기 때문에 비경쟁입니다. 여기 에서 온라인으로 테스트 할 수 있지만 실제로 숫자를 인쇄하지는 않습니다. 당신은 마지막 두 후 프로그램을 일시 중지해야합니다*스택에서 값을 보려면 를 실행 .

작동 원리

Cubix는 코드가 큐브를 감싸는 2 차원 esolang입니다. 이 코드는 다음 큐브 네트와 정확히 동일합니다.. .

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

그런 다음 명령 포인터 (IP)가 가장 왼쪽면의 왼쪽 상단에서 시작하여 오른쪽을 향하도록 코드가 실행됩니다. "다음 문자까지 모든 문자가있는 문자열 모드를 켭니다." 스택으로 푸시 합니다. IP는 코드 전체를 감싸면서 3 /초 (47), 2 초* 초 (42), 초. 문자열 모드를 다시 종료하기 전에 초 (46)를 스택으로 넣습니다.

여기 흥미로운 곳이 있습니다. 첫 번째 거울/ 는 IP를 반영하므로 위를 향합니다. 그런 다음 큐브 주위를 회전하여 다음 문자를칩니다.

           
    * *
  /     *      
  .     .      
    . .

세 * 은 스택의 상위 2 개 항목을 곱합니다. 이제 산술 연산자가 인수를 표시하는 대부분의 스택 기반 언어와 달리 Cubix는 이전 값을 스택에 그대로 둡니다. 그래서 이것은 계산합니다46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976 합니다.

IP가 / 다시 오른쪽으로 바뀝니다. 그런 다음 다음 미러를 누르고이 경로를 따릅니다.

    *  
    *  
    /         .
    .         .
    .  
    .  

두 개의 별표는 상위 두 항목을 한 번 더 곱합니다. 그런 다음 미러는 IP를 다시 지정하고 세 번째 미러는 프로세스를 한 번 더 반복합니다.

      *
      *
      /     .  
      .     .  
      .
      .

마지막으로 IP는 미러 섹션을 동쪽으로 둡니다. 두 개의 마지막 별표는 두 번 더 곱하여 스택에 9.670457478596419e + 147의 결과를 남깁니다. 이것은로 인쇄 할 수 O있지만 실제로 큐브의 모든 지점이 이미 사용 되었기 때문에 쉬운 방법은 없습니다.

스칼라, 2 ⁽⁶³⁾ -1

가난한, 가난한 스칼라. 최소 8자를 사용하여BigInt값 이 필요하므로 실제로 큰 공간을 확보 할 수 없습니다.

그러나 (계산) 코드의 7 자, 우리는 가능한 가장 큰 양을 인쇄 할 수 있습니다 Long:

print(-1L>>>1)

Brainf ** k 256-2147483647

>+[<+>+]<.

_{대부분의 컴파일러 및 인터프리터가 데이터를 ASCII와 동등한 데이터로 출력한다는 사실을 무시하면 (간결해야합니다.)} 인터프리터 / 컴파일러 데이터 유형의 최대 값을 반환합니다.

일부 시스템에서는이 값이 256에 불과하지만 일부 시스템에서는 (예 : 광산) 32 비트 정수의 최대 값, 즉 2147 483 647입니다.

편집하다:

-.

더 적은 문자로 같은 것을 인쇄합니다

펄, 비경쟁

나는 이것을 사용하여 perl의 작은 알고 코너를 강조하고 있습니다.

펄은 내장 빅넘이 없기 때문에 실제로 경쟁 할 수는 없습니다 (물론 빅넘 라이브러리를로드 할 수 있습니다).

그러나 모두가 아는 것은 완전히 사실이 아닙니다. 하나의 핵심 기능은 실제로 큰 숫자를 처리 할 수 ​​있습니다.

pack형식은 w실제로베이스 사이에 어떤 크기의 자연수를 변환 할 수 있습니다 10및 기본 128. 그러나 기본 128 정수는 문자열 바이트로 표시됩니다. 비트 스트링 xxxxxxxyyyyyyyzzzzzzz은 바이트가됩니다 : 1xxxxxxx 1yyyyyyy 0zzzzzzz(모든 바이트는 마지막 1을 제외하고 1로 시작합니다). 그리고 언팩으로 그러한 문자열을 10 진법으로 변환 할 수 있습니다. 따라서 다음과 같은 코드를 작성할 수 있습니다.

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

이것은 다음을 제공합니다.

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

4**4시간이 오래 걸리거나 너무 많은 메모리를 사용할 때까지 값을 더 큰 값으로 바꿀 수 있습니다 .

불행히도 이것은이 도전의 한계에 비해 너무 길며, 결과가되기 전에 기본 10 결과가 문자열로 변환되어 표현식이 실제로 숫자를 생성하지 않는다고 주장 할 수 있습니다. 그러나 내부적으로 perl은 실제로 항상 깔끔한 것으로 간주되는 10을 입력으로 변환하는 데 필요한 산술을 수행합니다.

TI-36 (84, 36 아님), 약 10 바이트 9.999985426E99

구형 계산기는 어느 정도까지 프로그래밍 할 수 있습니다.)

69!58.4376

TI 계산기가 표시 할 수있는 최대 범위에 매우 가깝습니다.-1E100<x<1E100

Perl 6 , 456,574 자리

[*] 1..ↈ

실행하는 데 2 ​​분이 걸리므로 TIO가 없습니다.