我感兴趣的是看到不需要任何输入的程序，打印一些非空字符串的googol副本，不少不多，然后停止。甲固高被限定为10 ^ 100，即1后面一百0的以十进制。

输出示例：

111111111111111111111111111111111111111111111111111111111111111111111111...

要么

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

该字符串也可以完全由空格或特殊符号组成。固定字符串的相同副本的唯一例外是，如果您的语言以某种无法避免的方式装饰输出，但可以在包装脚本中微不足道地撤消该输出，例如在每行前添加行号。在这种情况下，无需提供包装脚本。

您可以假设您的计算机永远不会用完时间，但是除此之外，您的程序必须对资源有合理的需求。另外，您必须遵守您选择的编程语言所施加的任何限制，例如，您不能超过其整数类型所允许的最大值，并且在任何时候都不需要多于4 GB的内存。

换句话说，该程序原则上应该可以通过在计算机上运行来进行测试。但是由于这个数字的范围，您应该证明它输出的字符串的副本数恰好是10 ^ 100，并且程序随后会停止。停止可能由于错误而退出，停止甚至终止，但如果是这样，则错误一定不能产生无法轻易与程序输出分离的输出。

这是代码高尔夫球，因此以字节数最少的解决方案为准。

解决方案示例（C，未填充，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 字节

³Ȯ*¡

这是一个niladic链接（不带参数的函数），它打印10 ²⁰⁰个字符串100副本，这意味着它打印10 ¹⁰⁰个字符串副本，其中包括10 ¹⁰⁰字符串100副本。

在线尝试！

请注意，出于实际原因，在线解释器会将输出削减为100 KB。该代码也可以作为完整程序使用，但是由于隐式输出，该程序打印的副本太多。

这个怎么运作

³Ȯ*¡  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. 

Fuzzy Octo鳄梨酱，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/

Python，28个字节

-1字节感谢乔纳森·艾伦！

Python 2：

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

Python 3（30字节）：

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

Haskell，28个字节

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

连接字符串的10 ^ 100副本"1"并打印。

笨蛋， 480 188 114 106 98字节

仅因为它需要完成。

假定8位单元带有换行。打印250个²⁵⁵ NUL字节，这是10 ¹⁰⁰倍10 ¹⁵⁵倍25个²⁵⁵ NUL字节。

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

说明：

>>>>>> 需要留一点工作空间。

- 产生255。

[[->>>+<<<]------>>>-] 将其转换为255个值250的副本，得到如下所示的磁带：

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时，循环终止。

现在，数字2 250 250 250 ... 250以基数250表示一个计数器，每个数字都比它所表示的数字大一。

• [>>>]<<<一直向右移动。由于每个数字都由非零数字表示，因此这是微不足道的。

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-将计数器减1。从最后一位开始：该位递减。如果仍然是积极的，我们就完成了。如果变为零，则将其设置为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换行符。

宣言i的第二个参数f()不能保证在测试我自己的机器（在Cygwin GCC）上和ideone.com（我相信他们也跑GCC）下的所有版本中工作，但达不到F（99）为明显原因！

Commodore VIC 20机器代码（40字节）

...此处显示为十六进制：

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）（任何非零值（1-255）都应起作用）
• 注意100 ^ 50 = 10 ^ 100; 运行程序100 ^ 50次比执行程序10 ^ 100次具有更高的RAM效率
• 0x31是要打印的ASCII字符

并且在任何时候都不需要超过4 GB的内存。

这是打字错误吗？

我们有1981年。

典型的家用计算机具有1到16 K B的RAM！而且，您几乎找不到具有1 M 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个换行符。（从理论上讲，即通过替换100为1进行测试，以输出10 ^1个换行符。）

通过设置i为字符串可以工作

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

（100个零和一个1； googol反转了），然后使用正则表达式重复“减去1”并输出换行符，直到字符串全为零为止。

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

Ruby，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.依然存在。这将替换t...与...之后125 t秒。
2. /.t/t\........../：更换.t与t..........整个程序的其余部分，重复，直到没有的情况.t依然存在。这需要花费...125 ts，然后变成125 ts，然后出现10 ^ 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整个节目的其余部分。替换TTTTTTTTTT为的100次重复t。
2. /.t/t........../：更换.t与t..........整个节目的其余部分。这需要.100 t秒，然后变成100 t秒，然后是10 ^ 100.秒。
3. /t//：删除所有剩余t的。
4. .TTTTTTTTTT：将替换为10 ^ 100 .s。输出它们。

最后，这是一个折衷程序，该程序.使用40个字符输出2 * 10 ^ 100次字符：

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

Befunge 93，33个字节

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

不幸的是，Befunge没有幂函数，因此几乎所有代码都是我对幂函数的实现。我还在努力。

说明：

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

图灵tarpit很有趣，尤其是当它们没有简单的乘法或指数时。另一方面，我只需要使用三个队列中的两个！

说明：

++++++++++                                             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³²。前四个循环各计2²，合计2 1，而其余十个循环各计5，合计5。

编辑：由于@ ConorO'Brien，节省了不可思议的58％。

TI基本（20字节）

直截了当。一次仅显示八行，并且前几行不保留在内存中。由于ᴇ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，因此我可以使用2字节的短跳转而不是6字节的近跳转，但这仅适用于小型可执行文件，而不是较大程序的一部分。因此，如果我还利用简短的jcc编码来实现它，那么我认为没有理由不计算libc的puts实现的大小。

每个递归级别都使用24B的堆栈空间（两次压入和CALL压入返回地址）。每隔一个深度调用一次putchar，堆栈仅对齐8，而不是16，因此这确实违反了ABI。使用对齐存储将xmm寄存器溢出到堆栈的stdio实现可能会出错。但是glibc putchar不会这样做，而是使用完全缓冲写入管道或使用行缓冲写入终端。在Ubuntu 15.10上测试。可以使用中的虚拟push / pop来解决此问题.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字节）的缓冲区，因此看跌期权将附加在第10个之后。递归的基本情况更接近于C的灵感。

以不同的方式分解10 ^ 100可能会缩短缓冲区，也许减少到4个换行符，节省5个字节，但是到目前为止使用putchar更好。它只需要一个整数arg，不需要指针，也根本不需要缓冲区。C标准允许在其中将其作为宏的实现putc(val, stdout)，但是在glibc中，它作为可从asm调用的真实函数存在。

每个调用仅打印一个换行符而不是10，这意味着我们需要将递归最大深度增加1，以获得另一个10换行符的因子。由于99和100都可以用符号扩展的8位立即数表示，push 100因此仍然只有2个字节。

更好的是，10在寄存器中用作换行符和循环计数器，可以节省一个字节。

保存字节的想法

32位版本可以为节省一个字节dec edi，但是stack-args调用约定（用于putchar之类的库函数）使尾部调用工作变得不那么容易，并且可能在更多地方需要更多字节。我可以使用private的register-arg约定f()，仅由调用g()，但是我不能尾调用putchar（因为f（）和putchar（）会使用不同数量的stack-args）。

f（）可以保留调用者的状态，而不是在调用者中进行保存/恢复。但是，这可能很糟糕，因为它可能需要在分支的每一侧分别获取，并且与尾调用不兼容。我尝试过，但没有发现任何节省。

在堆栈上保留循环计数器（而不是在循环中推送/弹出rcx）也没有帮助。使用puts的版本差了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个字符。

Haskell，45个 43字节

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

Pyke，6个 5字节

TTX^V

在这里尝试！

未经测试，因为它使我的浏览器崩溃。前四个字符生成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空间。三个指令，但是googol常数是两个字节。

（写在版本3.0.5中）

的JavaScript ES6，85 83个字节

ETHproductions节省了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将产生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.

Fortran 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

打印包含以下内容的行的googol

          0

Fortran 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次，恰好完成了一个googol。N，L和循环计数器都适合字节大小的整数。

通过将99替换为1、2、3、4、5进行测试，并注意到在每种情况下，“ wc”产生的行数均具有n + 1个零。

Fortran 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位计算机上就可以正常工作。通过在具有60位整数的旧Cray上运行，可以在暴力版本中使用更少的循环。在这里，一个5 ^ 10（9765625）循环中的10个2 * 10 ^ 9嵌套循环等于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个前导空格。

我不知道这是否符合4 GB的限制，因此，如果不遵守，则不具有竞争力，仅用于展示。输出为1e100字节，因此应从内存字节数中扣除。最终字节数为82个字节。

这里是一个解释：

代码的前80行是80种不同的状态，它们生成以19为底的¹循环计数6EC1BCF4688309GH806H932ADCC44EEG6DE0FE9FAHDE66DGH108C9G3623E045A0H7A95AB594CE99A。

接下来的19行代码是计数器状态，每次打印一个字符时，计数器状态都会减少。

接下来的6行是打印机状态，其后会附加一个=。

最后，最后两行是更清洁的状态，需要使用此状态来确保唯一的输出是=====...=====。前导/后缀空格不能避免作为输出，因为它们是不可避免的副作用。

然后程序停止。

^{1我为此做了数学。}

Pyth，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

Python 3，32个字节

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

替代解决方案，33字节：

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

爪哇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);}}

打印（x== null？null：启动用绳[La;@或类似的东西）10个¹⁰⁰在O次数（永远）的时间。

Java，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次。

p正如31343（Maltysen）所说，由于某种原因，这是不必要的。