나는 입력을 요구하지 않는 프로그램을보고, 비어 있지 않은 문자열 의 구골 사본을 인쇄하고 , 더 이상, 더 이상, 더 이상 멈추지 않는 프로그램에 관심이 있습니다 . 구골은 십진수 백 0의 다음 예 10 ^ (100), 1로 정의된다.

출력 예 :

111111111111111111111111111111111111111111111111111111111111111111111111...

또는

Hello world
Hello world
Hello world
Hello world
Hello world
Hello world
...

문자열은 공백 또는 특수 기호로 완전히 구성 될 수도 있습니다. 고정 문자열의 동일한 사본에 대한 유일한 예외는 언어가 방지 할 수없는 방식으로 출력을 장식하지만 각 행에 행 번호를 추가하는 것과 같이 랩퍼 스크립트에서 사소하게 취소 할 수있는 경우입니다. 이러한 경우 랩퍼 스크립트를 제공 할 필요가 없습니다.

컴퓨터의 시간이 절대로 없어지지 않는다고 가정 할 수 있지만 그 외에는 프로그램에 적절한 리소스가 필요합니다. 또한 선택한 프로그래밍 언어가 정하는 제한을 존중해야합니다. 예를 들어 정수 유형에 허용되는 최대 값을 초과 할 수 없으며 4GB를 초과하는 메모리가 필요하지 않습니다.

다시 말해, 프로그램은 원칙적 으로 컴퓨터에서 실행하여 테스트 할 수 있어야 합니다. 그러나이 수의 범위 때문에 출력하는 문자열의 사본 수가 정확히 10 ^ 100이고 프로그램이 나중에 중지됨 을 증명 해야합니다. 오류로 인해 중지가 종료되거나 중지되거나 종료 될 수 있지만, 오류가 있으면 프로그램의 출력에서 ​​쉽게 분리 할 수없는 출력이 생성되지 않아야합니다.

이것은 code-golf 이므로 바이트 수가 가장 적은 솔루션이 승리합니다.

솔루션 예 (C, ungolfed, 3768 바이트)

#include <stdio.h>

int main() {
  int a00, a01, a02, a03, ..., a99;
  for(a00 = 0; a00 < 10; a00++)
  for(a01 = 0; a01 < 10; a01++)
  for(a02 = 0; a02 < 10; a02++)
  for(a03 = 0; a03 < 10; a03++)
  ...
  for(a99 = 0; a99 < 10; a99++)
    puts("1");
  return 0;
}

젤리 , 6 4 바이트

³Ȯ*¡

이것은 출력 (인자 O / w 함수)를 무항 링크 인 10 개 ²⁰⁰ 문자열의 복사본 (100) 가 인쇄 즉, 10 ⁽¹⁰⁰⁾ 로 구성된 스트링의 복사본 10 개 ¹⁰⁰ 문자열의 복사본 (100) .

온라인으로 사용해보십시오!

온라인 인터프리터는 실제적인 이유로 출력을 100KB로 줄입니다. 이 코드는 전체 프로그램으로도 작동하지만 암시 적 출력으로 인해 해당 프로그램이 하나의 사본을 너무 많이 인쇄합니다.

작동 원리

³Ȯ*¡  Niladic link. No arguments.

³     Set the left argument and initial return value to 100.
 Ȯ    Print the current return value.
  *   Compute 100 ** 100 = 1e200.
   ¡  Call Ȯ 1e200 times. 

퍼지 옥토 과카 몰리, 13 12 11 10 바이트

9+ddpp![g] 

설명:

9+ddpp![g]
9+           # push 9 and increment, giving 10
  dd         # duplicate, twice. now you have [10,10,10]
    pp       # raise a 10 to the 10th power, then raise that to the 10th again. That ends up being 10^100.
      ![ ]   # for loop, `!` sets the counter to the top of stack
        g    # prints an ASCII art goat. 

염소 샘플 인쇄 :

                  ___.
                 //  \\
                ((   ""
                 \\__,
                /6 (%)\,
               (__/:";,;\--____----_
                ;; :";,:";`;,";,;";`,`_
                  ;:,;;";";,;":,";";,-Y\
                   ;,;,;";";,;":;";"; Z/
                   / ;,";";,;";,;";;"
                  / / |";/~~~~~\";;"
                 ( K  | |      || |
                  \_\ | |      || |
                   \Z | |      || |
                      L_|      LL_|
                      LW/      LLW/

파이썬, 28 바이트

Jonathan Allan 덕분에 -1 바이트!

파이썬 2 :

i=10**100
while i:print;i-=1

파이썬 3 (30 바이트) :

i=10**100
while i:print();i-=1

하스켈, 28 바이트

main=putStr$[1..10^100]>>"1"

문자열의 10 ^ 100 복사본을 연결 "1"하고 인쇄합니다.

fuck, 480 188 114 106 98 바이트

그냥해야하기 때문에.

줄 바꿈을 사용하여 8 비트 셀을 가정합니다. 인쇄 250 ²⁵⁵ 10 NUL 바이트, ¹⁰⁰ 배 10 ¹⁵⁵ 배 25 ²⁵⁵ NUL 바이트.

>>>>>>-[[->>>+<<<]------>>>-]<<<[<<<]+[+[>>>]<<<->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-[<<<].>>>-]

설명:

>>>>>> 약간의 작업 공간을 남겨 두어야합니다.

- 255를 생성합니다.

[[->>>+<<<]------>>>-] 이것을 250의 255 복사본으로 바꾸어 다음과 같은 테이프를 만듭니다.

0 0 0 0 0 0 250 0 0 250 0 0 ... 250 0 0 [0]

<<<[<<<]+ 데이터 포인터를 뒤로 이동하고 초기 데이터를 마무리합니다.

0 0 0 [1] 0 0 250 0 0 250 0 0 ...

그런 다음 루프가 온다. [+...-]처음에는 1을 2로 설정하고 루프의 끝에서 1로 다시 설정된다. 루프 본문이 이미 2로 1로 설정되면 루프가 종료됩니다.

이제 숫자 2250250250 ... 250은 기준 250의 카운터를 나타내며 각 숫자는 숫자보다 하나 더 큽니다.

• [>>>]<<<오른쪽으로 끝까지 이동합니다. 각 숫자는 0이 아닌 숫자로 표시되므로 사소합니다.

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-마지막 숫자부터 시작하여 숫자가 감소합니다. 그것이 긍정적이라면, 우리는 끝난 것입니다. 0으로 바뀌면 250으로 설정하고 이전 숫자를 계속하십시오.

• [<<<].>>>포인터를 맨 왼쪽 자리 뒤로 이동하면 NUL 바이트를 인쇄 할 수 있습니다. 그런 다음 정확히 가장 왼쪽 자리로 재배치하여 완료되었는지 확인하십시오.

정확성을 확인하려면 초기 값 -을 +250 ¹ NUL 바이트, ++250 ² 등 으로 인쇄 하도록 변경하십시오 .

C, 51 바이트

함수 g()는 재귀 함수 f()를 깊이 99로 호출합니다 .

제외 불필요한 개행 사이 첨가 f()하고 g()명료.

f(n,i){for(i=10;i--;)n?f(n-1):puts("");}
g(){f(99);}

//call like this
main(){g();}

1E100 줄 바꿈을 인쇄합니다.

C의 모든 버전에서 작동하도록 보장되지 않는 i두 번째 매개 변수 선언 f(). 내 컴퓨터 (CygWin의 GCC)와 ideone.com (GCC를 실행한다고 생각하지만 분명히 f (99)까지는 ​​아닙니다)에서 테스트되었습니다. 원인!

Commodore VIC 20 머신 코드 (40 바이트)

... 여기는 16 진수로 표시됩니다 :

1040   A9[64]A2 00 9D 68 10 E8  E0[32]D0 F8 A9 00 9D 68
1050   10 A9[31]20 D2 FF A2 00  A9[64]DE 68 10 30 08 D0
1060   F0 9D 68 10 E8 D0 F3 60

(:를 사용하여 시작 SYS 4160)

괄호 안의 바이트 의미

• 0x64 (두 번 발생)는 기본 (100)입니다. (2에서 127 사이의 값이 작동해야 함)
• 0x32는 지수 (50)입니다 (0이 아닌 값 (1-255)이 작동해야 함)
• 100 ^ 50 = 10 ^ 100; 프로그램을 100 ^ 50 번 실행하는 것이 10 ^ 100 회 수행하는 것보다 RAM 효율성이 높습니다.
• 0x31은 인쇄 할 ASCII 문자입니다.

그리고 어떤 시점에서 더 이상 4 G 메모리 B가 필요하지 않습니다해야합니다.

타이핑 실수입니까?

우리는 1981 년입니다.

일반적인 가정용 컴퓨터에는 1-16K B RAM이 있습니다! 그리고 1M B 이상의 전문가 용 모델은 거의 찾을 수 없습니다 .

(좋아, 농담이야)

다시 말해, 프로그램은 원칙적으로 컴퓨터에서 실행하여 테스트 할 수 있어야합니다. 그러나이 수의 범위 때문에 출력하는 문자열의 사본 수가 정확히 10 ^ 100이고 프로그램이 나중에 중지됨을 증명해야합니다.

이 프로그램은 다른 염기와 지수로 테스트되었습니다. 의심 할 여지없이 100과 50에서도 작동합니다.

적어도이 숫자들과 충돌하지는 않습니다 (그러나 측정 가능한 시간에도 종료되지는 않습니다).

메모리 크기는 지수가 50이고 100이 127보다 작으므로 100을 밑으로해도 문제가되지 않습니다.

기본 아이디어

100 시스템에는 50 자리 카운터가 있습니다. 바이트 0x01-0x64는 숫자 0-99를 나타냅니다. 카운터의 첫 번째 바이트는 가장 낮은 숫자입니다. 카운터의 마지막 바이트 (가장 높은 숫자) 다음에는 값이 0x00 인 바이트가옵니다.

카운터의 초기 값은 100 ^ 50입니다.

외부 루프는 바이트를 "현재 채널"(현대 시스템의 경우 "표준 출력", 일반적으로 화면)에 쓴 다음 카운터를 줄입니다.

내부 루프에 의해 감소 ​​: 숫자를 감소시키고 1에서 99까지의 언더 플로의 경우 다음 숫자로 진행합니다. 카운터 끝의 0x00 바이트가 감소하면 프로그램이 중지됩니다.

어셈블리 코드는

    ; Some constants
    base=10
    exponent=100
    character=0x32

    ; Initialize the content of the counter to 100^50
    ; (Fill the first 50 bytes with the value 100)
    lda  #base
    ldx  #0
initLoop:
    sta  counter,x
    inx
    cpx  #exponent
    bne  initLoop
    ; (The terminating 0 at the end of the counter)
    lda  #0
    sta  counter,x

    ; Now do the actual job
outerLoop:
    ; Output a character
    lda  #character
    jsr  (0xFFD2)
    ; Prepare for the inner loop
    ldx  #0
    lda  #base
innerLoop:
    ; Decrement one digit
    dec  counter,x
    ; Result is negative -> must have been the terminating
    ; NUL byte -> Exit
    bmi  progEnd
    ; Result is not zero -> Print the next byte
    bne  outerLoop
    ; Result is zero -> Was 0x01 before -> As 0x01 represents
    ; digit 0 this is an underflow -> set the digit to
    ; "exponent" (100) again (which represents digit 99)
    sta  counter,x
    ; Go to the next digit and...
    inx
    ; ... repeat the inner loop (decrement next digit)
    ; (Note that this conditional branch is ALWAYS taken)
    bne  innerLoop

progEnd:
    rts

counter:
    ; The memory used by the counter is here...

편집하다

이 프로그램은 Commodore C64에서도 실행됩니다!

노드, 89 바이트

for(i="0".repeat(100)+1;+i;i=i.replace(/0*./,x=>"9".repeat(x.length-1)+~-x))console.log()

10 ^{100 줄} 바꿈을 출력합니다 . (이론적으로, 대신 10 ¹ 개행 을 출력하도록 대체 100하여 테스트하십시오 .)1

이것은 i문자열 로 설정 하여 작동 합니다

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

(100 개의 0과 1; googol이 반대로 됨), 정규 표현식으로 반복하여 "1을 빼고"문자열이 모두 0이 될 때까지 줄 바꿈을 출력합니다.

C ++ 응답의 포트는 49 바이트입니다.

(f=n=>{for(i=10;i--;)n?f(n-1):console.log()})(99)

05AB1E , 6 바이트

Tn°F1?

설명

Tn°    # push 10^100
   F   # 10^100 times do
    1? # print 1

루비, 20 바이트

(10**100).times{p 1}

1을 인쇄 한 다음 줄 바꿈 1E100 번을 인쇄합니다.

1E100 임의의 정밀도 정수가 아닌 부동 소수점으로 평가되므로 작동하지 않습니다.

/// , 36 개의 ASCII 문자 (4 개의 구별)

/t./.ttttt//.t/t\..........//t//t...

.문자를 3 * 10 ^ 125 번 출력합니다. 즉, 문자의 3 ​​* 10 ^ 25 반복으로 구성된 문자열을 .10 ^ 100 번 출력합니다.

설명:

1. /t./.ttttt/: 바꾸기 t.와 .ttttt의 인스턴스가 될 때까지 반복, 프로그램의 나머지 부분 t.남아. 이것은 125 초로 대체 t...됩니다 ....t
2. /.t/t\........../: 바꾸기 .t와 t..........의 인스턴스가 될 때까지 반복, 프로그램의 나머지 부분 .t남아. 이것은 ...125 초가 걸리고 125 t초로 바뀌고 t10 ^ 125가 발생 ...합니다.
3. /t//: 나머지를 모두 제거하십시오 t.
4. t...: 이것은 3 * 10 ^ 125 .s 로 대체됩니다 . 그것들을 출력하십시오.

이제, 부정 행위 같은 느낌의 3 * 10 ^ 25 반복의 10 ^ 100 반복을 출력합니다. 이 프로그램은 .45 개의 ASCII 문자를 사용하여 문자를 정확히 10 ^ 100 번 출력합니다 .

/T/tttttttttt//.t/t..........//t//.TTTTTTTTTT

이것에 대한 설명 :

1. /T/tttttttttt/: 교체 T와 함께 tttttttttt프로그램의 나머지 부분. 이것은 TTTTTTTTTT100 반복으로 대체 됩니다 t.
2. /.t/t........../: 교체 .t와 함께 t..........프로그램의 나머지 부분. 이것에 .이어 100 t초가 걸리고 100 t초가되고 10 ^ 100 .초가됩니다.
3. /t//: 나머지를 모두 제거하십시오 t.
4. .TTTTTTTTTT: 10 ^ 100 .초로 대체됩니다 . 그것들을 출력하십시오.

마지막으로 .40 문자를 사용하여 문자를 2 * 10 ^ 100 번 출력하는 타협 프로그램이 있습니다 .

/t./.tttttttttt//.t/t\..........//t//t..

Befunge 93, 33 바이트

1>01g0`#@!# _01v
d^.1 **52p10-1g<

불행히도 Befunge에는 power 함수가 없으므로 거의 모든 코드가 power 함수의 구현입니다. 나는 아직도이 일을하고 있습니다.

설명:

1 > 01g 0` #@!# _ 01g 1- 01p 25** 1. v
d ^                                  <

1: 1왼쪽 상단 부터 시작하여 곱할 때 0항상 얻지 못합니다 .

01g: 위치 (0, 1)에서 문자를 가져옵니다. 즉 d, ASCII 코드는 100입니다.

0`: (0, 1)에 저장된 값이 0보다 큰지 확인하십시오. 이 값이 변경됩니다.

#@!# _: !마지막 단계 (0 또는 1)에서 얻은 값에 논리적이지 않으므로 1이면 이제 0이되고 #코드에서 다음 문자를 건너 뜁니다.

01g 1- 01p: (0, 1)에 저장된 값을 다시 가져와 1에서 빼고이 새 값을 (0, 1)에 저장하십시오.

25**: 스택의 최고 값에 10을 곱합니다

1.: 1반복 될 때마다 인쇄

1 googol 시간 (이론적으로)으로 인쇄되지만, 이것을 테스트 한 페이지에서 빨리 실행됩니다.

Befunge 93 코드를 여기서 실행할 수 있습니다 . 어떤 이유로 스택의 최상위 값은 1.0000000000000006e+100언제 입니까 1.0e+100? 나는 그것이 어디에서 6왔는지 모르지만 그것이 있어야한다고 생각하지 않으며 반올림 오류 또는 그와 같은 것일 수 있습니다.

ABCR , 56 바이트

++++++++++AAAAAAAAAA7a*A!(x4bBBBBBBBBBB7b+B@(xa(Ax5b(Box

튜링 타르 핏은 특히 곱셈이나 지수가 쉽지 않은 경우 재미 있습니다. 반면에, 나는 3 개의 대기열 중 2 개만 사용하면됩니다!

설명:

++++++++++                                             Set register to 10
          AAAAAAAAAA                                   Queue 10 to queue A 10 times
                    7a*A!(x                            Sum up all of queue A by:
                    7     x                             While the register is truthy:
                     a*                                 Dequeue two elements of A, sum them...
                       A                                ...and queue the result back to A.
                        !(                              If there's only one element left,
                                                        i.e. !(A.len - 1),
                                                        break from the loop.  A now has 100, our exponent.

                             4                        While A's front is truthy:
                              bBBBBBBBBBB              Clone the front of B 10 (our base) times.  (The first iteration fills it up with ten 1s)
                                         7b+B@(x       Sum up all of queue B like we did with A
                                                a(A    Decrement a (so that the loop actually ends. Runs 101 times like it should) x   

                                                       B now contains 10^100 only.

                                                   5b(B x   10^100 times:
                                                       o     print the front of queue A (0)

배치, 574242 바이트

@echo off
set t=for /l %%a in (2,1,33554432)do call:
set f=for /l %%a in (2,1,9765625)do call:
%t%a
:a
%t%b
:b
%t%c
:c
%t%d
:d
%f%e
:e
%f%f
:f
%f%g
:g
%f%h
:h
%f%i
:i
%f%j
:j
%f%k
:k
%f%l
:l
%f%m
:m
%f%n
:n
echo

각 루프는 추가 반복을 수행합니다. 루프는 32 비트 정수 제한으로 인해 ~ 2³²로 제한됩니다. 처음 4 개의 루프는 총 2¹⁰⁰에 대해 각각 2²⁵를 계산하고 나머지 10 개의 루프는 총 5¹⁰⁰에 대해 5¹⁰를 계산합니다.

편집 : @ ConorO'Brien 덕분에 상상할 수없는 58 %가 절약되었습니다.

TI 기본, 20 바이트

똑바로. 한 번에 8 줄만 표시되며 이전 줄은 메모리에 남아 있지 않습니다. ᴇ100지원되지 않기 때문에 에서 -ᴇ99로 반복해야합니다 9ᴇ99. 그런 다음이면 I!=0문자열을 표시합니다 (그런데 3입니다). 이런 식으로, 우리는 정확하게 ᴇ100시간 을 인쇄합니다 .

For(I,-ᴇ99,9ᴇ99:If I:Disp 3:End

x86-64 기계 코드 기능, 30 바이트

@Level River St의 C 답변 과 동일한 재귀 논리를 사용합니다 . (최대 재귀 깊이 = 100)

puts(3)일반 실행 파일이 어쨌든 연결되는 libc 의 함수를 사용합니다 . x86-64 System V ABI, 즉 Linux 또는 OS X의 C에서 호출 할 수 있으며 원하지 않는 레지스터는 클로버하지 않습니다.

objdump -drwC -Mintel 설명과 함께 주석이 달린 출력

0000000000400340 <g>:  ## wrapper function
  400340:       6a 64                   push   0x64
  400342:       5f                      pop    rdi       ; mov edi, 100  in 3 bytes instead of 5
  ; tailcall f by falling into it.

0000000000400343 <f>:  ## the recursive function
  400343:       ff cf                   dec    edi
  400345:       97                      xchg   edi,eax
  400346:       6a 0a                   push   0xa
  400348:       5f                      pop    rdi       ; mov edi, 10
  400349:       0f 8c d1 ff ff ff       jl     400320 <putchar>   # conditional tailcall
; if we don't tailcall, then eax=--n = arg for next recursion depth, and edi = 10 = '\n'

  40034f:       89 f9                   mov    ecx,edi   ; loop count = the ASCII code for newline; saves us one byte


0000000000400351 <f.loop>:
  400351:       50                      push   rax       ; save local state
  400352:       51                      push   rcx
  400353:       97                      xchg   edi,eax   ; arg goes in rdi
  400354:       e8 ea ff ff ff          call   400343 <f>
  400359:       59                      pop    rcx       ; and restore it after recursing
  40035a:       58                      pop    rax
  40035b:       e2 f4                   loop   400351 <f.loop>
  40035d:       c3                      ret    
# the function ends here

000000000040035e <_start>:

0x040035e - 0x0400340 = 30 bytes

# not counted: a caller that passes argc-1 to f() instead of calling g
000000000040035e <_start>:
  40035e:       8b 3c 24                mov    edi,DWORD PTR [rsp]
  400361:       ff cf                   dec    edi
  400363:       e8 db ff ff ff          call   400343 <f>
  400368:       e8 c3 ff ff ff          call   400330 <exit@plt>    # flush I/O buffers, which the _exit system call (eax=60) doesn't do.

함께 내장 yasm -felf64 -Worphan-labels -gdwarf2 golf-googol.asm && gcc -nostartfiles -o golf-googol golf-googol.o . 원래 NASM 소스를 게시 할 수는 있지만 분해 지침이 asm 명령이기 때문에 혼란스러워 보입니다.

putchar@plt에서 128 바이트 미만 jl이므로 6 바이트 니어 점프 대신 2 바이트 짧은 점프를 사용할 수 있었지만 더 큰 프로그램의 일부가 아닌 작은 실행 파일에서만 유효합니다. 따라서 짧은 jcc 인코딩을 사용하여 libc의 puts 구현 크기를 계산하지 않으면 정당화 할 수 없다고 생각합니다.

각 재귀 수준은 24B의 스택 공간을 사용합니다 (2 개의 푸시 및 CALL에 의해 리턴 된 리턴 주소). 다른 모든 깊이는 putchar스택이 16이 아닌 8로만 정렬되어 호출 되므로 ABI를 위반합니다. 정렬 된 저장소를 사용하여 xmm 레지스터를 스택에 유출하는 stdio 구현은 오류가 발생했습니다. 그러나 glibc putchar는 풀 버퍼링으로 파이프에 쓰거나 라인 버퍼링으로 터미널에 쓰지 않습니다. 우분투 15.10에서 테스트되었습니다. 이것은 .loop재귀 호출 전에 스택을 다른 8만큼 오프셋하기 위해 더미 푸시 / 팝으로 고정 될 수 있습니다 .

올바른 수의 줄 바꿈을 인쇄한다는 증거 :

   # with a version that uses argc-1  (i.e. the shell's $i)  instead of a fixed 100
$ for i in {0..8}; do echo -n "$i: "; ./golf-googol $(seq $i) |wc -c; done
0: 1
1: 10
2: 100
3: 1000
4: 10000
5: 100000
6: 1000000
7: 10000000
8: 100000000
... output = 10^n newlines every time.

이것의 첫 번째 버전은 43B puts()이며 9 줄 바꿈 (및 종료 0 바이트)의 버퍼에서 사용 되므로 puts는 10 번째를 추가합니다. 이 재귀 사례는 C 영감에 더 가깝습니다.

10 ^ 100을 다른 방식으로 고려하면 버퍼가 짧아지고 4 줄 바꿈으로 줄어 5 바이트를 절약 할 수 있지만 putchar를 사용하는 것이 훨씬 좋습니다. 포인터가 아닌 정수 인수 만 필요하며 버퍼는 전혀 필요하지 않습니다. C 표준은에 대한 매크로 인 구현을 허용 putc(val, stdout)하지만 glibc에서는 asm에서 호출 할 수있는 실제 함수로 존재합니다.

10 개 대신 호출 당 하나의 개행 문자 만 인쇄하면 재귀 최대 수심을 1 씩 늘려서 10 개의 개행 문자를 다시 얻을 수 있습니다. 99와 100은 모두 부호 확장 8 비트 즉시로 표현 될 수 있으므로 push 100여전히 2 바이트입니다.

더 좋은 점 10은 레지스터 를 갖는 것이 줄 바꿈 및 루프 카운터로 작동하여 바이트를 절약하는 것입니다.

바이트 절약을위한 아이디어

32 비트 버전은의 바이트를 절약 할 수 dec edi있지만 putchar과 같은 라이브러리 함수의 경우 스택 인수 호출 규칙을 사용하면 테일 호출이 덜 쉬워지고 더 많은 장소에서 더 많은 바이트가 필요할 수 있습니다. private에 대해 register-arg 규칙을 사용할 수 있지만 f()로만 호출 g()할 수 있지만 putchar를 꼬리 호출 할 수는 없습니다 (f () 및 putchar ()는 다른 수의 스택 인수를 사용하기 때문에).

호출자에서 저장 / 복원을 수행하는 대신 f ()가 호출자의 상태를 유지하도록 할 수 있습니다. 분기의 양쪽에서 별도로 가져와야하며 테일 콜링과 호환되지 않기 때문에 아마도 짜증납니다. 나는 그것을 시도했지만 저축을 찾지 못했습니다.

루프에서 푸시 / 팝핑 rcx 대신 스택에 루프 카운터를 유지하는 것도 도움이되지 않았습니다. 사용하는 버전이 1B 나빠졌으며 rcx를보다 저렴하게 설정하는이 버전의 손실이 훨씬 많았습니다.

PHP, 44 바이트

for($i=bcpow(10,1e2);$i=bcsub($i,print 1););

이 스 니펫은 1googol 시간 을 출력 합니다. 메모리가 부족하지는 않지만 매우 느립니다. 긴 정수를 처리 할 수 ​​있도록 BCMath를 사용하고 있습니다.

약간 더 나은 성능이지만 작은 크기 (74 바이트)는 아닙니다.

for($m=bcpow(10,100);$m;$m=bcsub($m,$a))echo str_repeat(a,$a=min(4e9,$m));

agoogol 시간 문자를 출력합니다 . 거의 4GB의 메모리를 소비하여 한 번에 약 4e9 문자를 출력합니다.

하스켈, 45 43 바이트

r 0=[]
r i='1':r(i-1)
main=putStr.r$10^100

파이크, 6 5 바이트

TTX^V

여기 사용해보십시오!

브라우저와 충돌하여 테스트되지 않았습니다. 처음 4 개의 문자는 10 ^ 100을 생성 V하고 많은 줄 바꿈을 인쇄합니다. 로 테스트하십시오 100V.

라켓 36 바이트

(for((i(expt 10 100)))(display "1"))

산출:

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

JAISBaL , 4 바이트

˖Q

Chrome에서 모든 기호를 읽을 수는 없으며 다른 브라우저에 대해서는 잘 모르겠으므로 다음 그림을 참조하십시오.

설명:

# \# enable verbose parsing #\
10^100       \# [0] push 10^100 onto the stack #\
for          \# [1] start for loop #\
    space    \# [2] print a space #\

아주 간단합니다 .. 단지 구골 공간을 인쇄합니다. 세 가지 명령이지만 googol 상수는 2 바이트입니다.

(버전 3.0.5로 작성)

자바 스크립트 ES6, 85 83 바이트

ETH 프로덕션 덕분에 2 바이트가 절약되었습니다!

eval([...Array(i=100)].map(_=>`for($${--i}=0;$${i}++<10;)`).join``+"console.log()")

1e100 줄 바꿈을 인쇄합니다.

내부는이 프로그램을 생성 한 후 평가됩니다.

for($0=0;$0++<10;)for($1=0;$1++<10;)for($2=0;$2++<10;)for($3=0;$3++<10;)for($4=0;$4++<10;)for($5=0;$5++<10;)for($6=0;$6++<10;)for($7=0;$7++<10;)for($8=0;$8++<10;)for($9=0;$9++<10;)for($10=0;$10++<10;)for($11=0;$11++<10;)for($12=0;$12++<10;)for($13=0;$13++<10;)for($14=0;$14++<10;)for($15=0;$15++<10;)for($16=0;$16++<10;)for($17=0;$17++<10;)for($18=0;$18++<10;)for($19=0;$19++<10;)for($20=0;$20++<10;)for($21=0;$21++<10;)for($22=0;$22++<10;)for($23=0;$23++<10;)for($24=0;$24++<10;)for($25=0;$25++<10;)for($26=0;$26++<10;)for($27=0;$27++<10;)for($28=0;$28++<10;)for($29=0;$29++<10;)for($30=0;$30++<10;)for($31=0;$31++<10;)for($32=0;$32++<10;)for($33=0;$33++<10;)for($34=0;$34++<10;)for($35=0;$35++<10;)for($36=0;$36++<10;)for($37=0;$37++<10;)for($38=0;$38++<10;)for($39=0;$39++<10;)for($40=0;$40++<10;)for($41=0;$41++<10;)for($42=0;$42++<10;)for($43=0;$43++<10;)for($44=0;$44++<10;)for($45=0;$45++<10;)for($46=0;$46++<10;)for($47=0;$47++<10;)for($48=0;$48++<10;)for($49=0;$49++<10;)for($50=0;$50++<10;)for($51=0;$51++<10;)for($52=0;$52++<10;)for($53=0;$53++<10;)for($54=0;$54++<10;)for($55=0;$55++<10;)for($56=0;$56++<10;)for($57=0;$57++<10;)for($58=0;$58++<10;)for($59=0;$59++<10;)for($60=0;$60++<10;)for($61=0;$61++<10;)for($62=0;$62++<10;)for($63=0;$63++<10;)for($64=0;$64++<10;)for($65=0;$65++<10;)for($66=0;$66++<10;)for($67=0;$67++<10;)for($68=0;$68++<10;)for($69=0;$69++<10;)for($70=0;$70++<10;)for($71=0;$71++<10;)for($72=0;$72++<10;)for($73=0;$73++<10;)for($74=0;$74++<10;)for($75=0;$75++<10;)for($76=0;$76++<10;)for($77=0;$77++<10;)for($78=0;$78++<10;)for($79=0;$79++<10;)for($80=0;$80++<10;)for($81=0;$81++<10;)for($82=0;$82++<10;)for($83=0;$83++<10;)for($84=0;$84++<10;)for($85=0;$85++<10;)for($86=0;$86++<10;)for($87=0;$87++<10;)for($88=0;$88++<10;)for($89=0;$89++<10;)for($90=0;$90++<10;)for($91=0;$91++<10;)for($92=0;$92++<10;)for($93=0;$93++<10;)for($94=0;$94++<10;)for($95=0;$95++<10;)for($96=0;$96++<10;)for($97=0;$97++<10;)for($98=0;$98++<10;)for($99=0;$99++<10;)console.log()

이제 정확성을 증명하기 위해 약간의 유도를 사용합니다. 초기 값 100을 다른 값 (일반적으로 N )으로 대체합니다 . N 을 삽입 하면 10 ^{N 줄} 바꿈 이 발생 한다고 주장합니다 . 이 결과를로 파이프 wc -l하여 입력의 개행 수를 계산합니다. 우리는 입력 N 을 취하는 수정되었지만 동등한 스크립트를 사용할 것입니다 :

eval([...Array(+process.argv[2])].map(_=>`for($${i}=0;$${i++}++<10;)`,i=0).join``+"console.log()")

이제 다음과 같은 결과가 있습니다.

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 1 | wc -l
10

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 2 | wc -l
100

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 3 | wc -l
1000

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 4 | wc -l
10000

작은 값에 대한 입력 N 을 10 ^{N 줄} 바꿈으로 변환하는 것을 볼 수 있습니다 .

다음은 N = 1에 대한 출력 예입니다 .

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 1











C:\Users\Conor O'Brien\Documents\Programming
λ

Mathematica, 48 30 25 바이트

For[n=1,n++<Echo@1*^100,]

산출:

>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
etc.

포트란 95, 자유 형식, 재귀, 117 바이트

Program M
Call R(99)
END
Recursive Subroutine R(L)
IF(L)3,1,1
1 DO 2 I=1,10
2 Call R(L-1)
RETURN
3 PRINT*,0
END

다음을 포함하는 줄의 구골을 인쇄합니다

          0

포트란 90, 재귀, 149 바이트

     CallR(99)
     END
     RecursiveSubroutineR(L)
     IF(L)3,1,1
   1 DO2I=1,10
   2 CallR(L-1)
     RETURN
   3 PRINT*,0
     END     

반복적으로 100 개의 중첩 루프를 10 번 반복 호출하면 정확히 하나의 구골이됩니다. N, L 및 루프 카운터는 모두 바이트 크기 정수에 맞습니다.

99를 1, 2, 3, 4, 5로 바꾸고 각각의 경우 "wc"의 결과 행 수가 n + 1 0임을 확인하여 테스트했습니다.

포트란 II, IV, 66 또는 77, 231 바이트 :

      N=2*10**9
      DO1I0=1,5**10
      DO1I=1,N
      DO1J=1,N
      DO1K=1,N
      DO1L=1,N
      DO1M=1,N
      DO1I1=1,N
      DO1J1=1,N
      DO1K1=1,N
      DO1L1=1,N
      DO1M1=1,N
1     PRINT2
2     FORMAT(X)
      END

줄 바꿈의 구골을 인쇄합니다.

이러한 모든 프로그램은 32 비트 시스템에서 실행됩니다. 실제로 재귀 버전은 16 비트 시스템에서 제대로 작동합니다. 오래된 Cray에서 60 비트 정수로 실행하여 무차별 대입 버전에서 더 적은 루프를 사용할 수 있습니다. 여기서 5 ^ 10 (9765625)의 한 루프 안에 2 * 10 ^ 9의 10 개의 중첩 루프는 총 반복 횟수의 10 ^ 100과 같습니다.

어떤 버전도 객체 코드 자체, 카운터, 출력 문자열의 사본 하나, 재귀 버전에서는 100 레벨 반환 스택 이외의 메모리를 사용하지 않습니다.

비교하여 요인을 확인하십시오

bc<<<2000000000\^10*5\^10
bc<<<10\^100

튜링 머신 시뮬레이터, 1082 바이트

0 * 6 r 1
1 * E r 2
2 * C r 3
3 * 1 r 4
4 * B r 5
5 * C r 6
6 * F r 7
7 * 4 r 8
8 * 6 r 9
9 * 8 r A
A * 8 r B
B * 3 r C
C * 0 r D
D * 9 r E
E * G r F
F * H r G
G * 8 r H
H * 0 r I
I * 6 r J
J * H r K
K * 9 r L
L * 3 r M
M * 2 r N
N * A r O
O * D r P
P * C r Q
Q * C r R
R * 4 r S
S * 4 r T
T * E r U
U * E r V
V * G r W
W * 6 r X
X * D r Y
Y * E r Z
Z * 0 r a
a * F r b
b * E r c
c * 9 r d
d * F r e
e * A r f
f * H r g
g * D r h
h * E r i
i * 6 r j
j * 6 r k
k * D r l
l * G r m
m * H r n
n * 1 r o
o * 0 r p
p * 8 r q
q * C r r
r * 9 r s
s * G r t
t * 3 r u
u * 6 r v
v * 2 r w
w * 3 r x
x * E r y
y * 0 r z
z * 4 r +
+ * 5 r /
/ * A r =
= * 0 r -
- * H r \
\ * 7 r !
! * A r @
@ * 9 r #
# * 5 r $
$ * A r %
% * B r ^
^ * 5 r &
& * 9 r ?
? * 4 r (
( * C r )
) * E r `
` * 9 r ~
~ * 9 r _
_ * A * .
. 0 I l *
. 1 0 r <
. 2 1 r <
. 3 2 r <
. 4 3 r <
. 5 4 r <
. 6 5 r <
. 7 6 r <
. 8 7 r <
. 9 8 r <
. A 9 r <
. B A r <
. C B r <
. D C r <
. E D r <
. F E r <
. G F r <
. H G r <
. I H r <
. _ * r ]
< _ * r >
< * * r *
> _ = l [
> * * r *
[ _ * l .
[ * * l *
] _ * * halt
] * _ r *

튜링 머신 시뮬레이터

82 개의 선행 공백이 있기 때문에 이것이 올바른 출력으로 계산되는지 알 수 없습니다.

이것이 4GB 제한을 준수하는지 여부를 알 수 없으므로 그렇지 않으면 경쟁이 아니며 쇼케이스입니다. 출력은 1e100 바이트이므로 메모리 바이트 수에서 빼야합니다. 최종 바이트 수는 82 바이트입니다.

여기에 설명이 있습니다 :

코드의 첫 80 줄은 80 개의 서로 다른 상태로 base-19 ¹ 루프 카운트 를 생성합니다 6EC1BCF4688309GH806H932ADCC44EEG6DE0FE9FAHDE66DGH108C9G3623E045A0H7A95AB594CE99A.

다음 19 줄의 코드는 카운터 상태이며, 문자가 인쇄 될 때마다 카운트가 감소합니다.

다음 6 줄은 프린터 상태이며을 추가합니다 =.

마지막으로 마지막 두 줄은 더 깨끗한 상태이며 출력이 유일한 지 확인하는 데 필요합니다 =====...=====. 선행 / 트레일 공간은 피할 수없는 부작용이므로 출력으로 계산되지 않습니다.

그런 다음 프로그램이 중지됩니다.

^{1 나는 그것을 위해 수학을했다.}

피 이스, 7 바이트

신규 (경쟁)

V^T*TTG

설명

G=The alphabet
Repeat 10^(10*10) times
    print(G)

이전 (비경쟁) 7 바이트

*G^T*TT

설명

G=The alphabet
G*(10^(10*10))==G*10^100

파이썬 3, 32 바이트

for i in range(10**100):print()

대체 솔루션, 33 바이트 :

[print()for i in range(10**100)]

Java, 198 179 155 바이트

import java.math.*;class a{void A(a[]x){for(BigInteger b=BigInteger.ZERO;!(b=b.add(BigInteger.ONE)).equals(BigInteger.TEN.pow(100));)System.out.print(x);}}

O (영원히) 시간에 10 ¹⁰⁰ 번 시작하는 문자열 ( x== null? null: 문자열)을 인쇄 합니다.[La;@

자바, 153 바이트

import java.math.*;interface M{static void main(String[]a){for(BigInteger i=BigInteger.ZERO;!i.add(i.ONE).equals(i.TEN.pow(100));)System.out.print(1);}}

출력 : 1e100 1s

꽤 가까운 또 다른 Java 답변이 있다는 것을 알고 있습니다. 내 메인이 있고 여전히 짧습니다.

이것은 내 첫 번째 코드 골프 항목입니다. 팁 감사합니다.

Pyth, 8 7 바이트

V^T100G

링크

해결책은 작은 출력으로 테스트되었지만 abcdefghijklmnopqrstuvwxyz1e100 번 인쇄해야합니다 .

p31343 (Maltysen)이 말한 것처럼 어떤 이유로 인해 필요하지 않았습니다 .