入力を要求せず、空でない文字列のgoogolコピーを印刷し、それ以上、それ以上、そして停止するプログラムを見ることに興味があります。グーゴルは 10 ^ 100、すなわちとして定義され、1は小数で百0の続きます。

出力例：

111111111111111111111111111111111111111111111111111111111111111111111111...

または

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

文字列は、完全に空白または特別な記号で構成することもできます。固定文字列の同一のコピーに対する唯一の例外は、言語が何らかの方法で出力を装飾する場合で、それは防止できませんが、各行に行番号を追加するなど、ラッパースクリプトで簡単に元に戻すことができます。このような場合のラッパースクリプトを提供する必要はありません。

コンピューターが時間切れになることはないと想定できますが、それ以外の点では、プログラムには適切なリソースが必要です。また、選択したプログラミング言語が課す制限を尊重する必要があります。たとえば、整数型に許可されている最大値を超えることはできず、4 GBを超えるメモリは必要ありません。

言い換えれば、プログラムは原則としてコンピューター上で実行することでテスト可能でなければなりません。しかし、この数の範囲により、出力する文字列のコピー数が正確に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機能）niladicリンクで10の²⁰⁰文字列のコピー100を、それが印刷することを意味する、10の¹⁰⁰から構成された文字列のコピー10の¹⁰⁰文字列のコピー100。

オンラインでお試しください！

実際の理由により、オンラインインタープリターは出力を100 KBにカットすることに注意してください。コードは完全なプログラムとしても機能しますが、暗黙的な出力のために、そのプログラムは1つのコピーを多く印刷しすぎます。

使い方

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

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"印刷します。

Brainfuck、 480 188 114 106 98バイト

それが行われる必要があるという理由だけで。

折り返しのある8ビットセルを想定しています。250 ²⁵⁵ NULバイトを印刷します。これは、10 ¹⁰⁰ × 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に設定すると、ループは終了します。

現在、2 250 250 250 ... 250という数字は、ベース250のカウンターを表しており、各数字はそれが表す数字よりも1つ大きくなっています。

• [>>>]<<<ずっと右に移動します。各数字はゼロ以外の数字で表されるため、これは簡単です。

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-カウンターを1減らします。最後の桁から開始します：桁が減ります。肯定的なままであれば、完了です。ゼロになったら、250に設定し、前の数字で続行します。

• [<<<].>>>ポインターを左端の数字の前に戻します。これは、NULバイトを出力する良い機会です。次に、左端の桁に正確に移動して、完了したかどうかを確認します。

正確性を確認するには、250 ²に対して250 ¹ NULバイトを印刷-する+ようにイニシャルを変更します。++

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のすべてのバージョンで動作することが保証されていないというi2番目のパラメーターとしての宣言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（2回出現）がベース（100）です。（2から127の値が機能するはずです）
• 0x32は指数（50）（ゼロ以外の値（1〜255）が機能するはずです）
• 100 ^ 50 = 10 ^ 100; プログラムを100 ^ 50回実行すると、10 ^ 100回実行するよりもRAM効率が高くなります。
• 0x31は印刷されるASCII文字です

また、4 GBを超えるメモリは必要ありません。

これは入力ミスですか？

1981年です。

一般的な家庭用コンピュータは、1〜16があるK RAMのBを！また、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個の改行を出力します。（理論的には、代わりに10 ^1の改行を出力100し1てテストします。）

これiは、文字列に設定することで機能します

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

（100のゼロと1、グーグルが逆転）、文字列がすべてゼロになるまで、正規表現で「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

ルビー、20バイト

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

1に続いて改行を1E100回印刷します。

1E100 任意の精度の整数ではなく、floatに評価されるため、機能しません。

///、36 ASCII文字（4つの異なる）

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

出力.には、3 * 10 ^ 25回の繰り返しからなる文字列を出力することを意味し、文字3 * 10 ^ 125回の.文字、10 ^ 100回。

説明：

1. /t./.ttttt/：交換するt.と.tttttのインスタンスまで繰り返し、プログラムの残りの部分でt.残っています。これはt...、...125 t秒に置き換えられます。
2. /.t/t\........../：交換する.tとt..........のインスタンスまで繰り返し、プログラムの残りの部分で.t残っています。これは、...その後に125 が続き、それを125 tに変換し、tその後に10 ^ 125のオカレンスが続き...ます。
3. /t//：残りtのすべてを削除します。
4. t...：これは3 * 10 ^ 125に置き換えられ.ます。それらを出力します。

現在、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 .秒に置き換えられます。それらを出力します。

最後に、.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

ターリングターピットは、特に簡単な乗算や指数がない場合に楽しいです。一方、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)

バッチ、574 242バイト

@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-Basic、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はそれを行いません。完全バッファリングでパイプに書き込むか、行バッファリングで端末に書き込みます。Ubuntu 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個の改行の別の係数を取得するために、再帰最大深度を1増やす必要があることを意味します。99と100は両方とも符号拡張された8ビットの即値で表すことができるため、push 1002バイトのみです。

さらに良いことに10は、レジスタに入れると、改行とループカウンタの両方として機能し、バイトを節約できます。

バイトを節約するためのアイデア

32ビットバージョンではのバイトを節約できますdec ediが、スタック引数呼び出し規則（putcharなどのライブラリ関数の場合）を使用すると、末尾呼び出しの動作が簡単になり、おそらくより多くの場所でより多くのバイトが必要になります。private f()にregister-arg規則を使用することはできますが、呼び出されるのg()はputcharだけです（f（）とputchar（）は異なる数のstack- argを使用するため）。

呼び出し元で保存/復元を行う代わりに、f（）に呼び出し元の状態を保存させることができます。ただし、ブランチの両側で個別に取得する必要があり、テールコールとの互換性がないため、これはおそらく面倒です。私はそれを試しましたが、貯金は見つかりませんでした。

（ループ内でrcxをプッシュ/ポップする代わりに）ループカウンターをスタックに保持することも助けにはなりませんでした。putを使用したバージョンでは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

パイク、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スペースを印刷するだけです。3つの命令ですが、googol定数は2バイトです。

（バージョン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に置き換えてみましょう。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

を含む行のグーグルを印刷します

          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回の繰り返し）を再帰的に呼び出すと、1つの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の1つのループ（9765625）内の2 * 10 ^ 9の10個のネストされたループは、合計10 ^ 100の繰り返しに等しくなります。

どのバージョンも、オブジェクトコード自体、カウンター、出力文字列の1つのコピー、および再帰バージョンでは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行は、基本19 ¹ループカウントを生成する80の異なる状態です6EC1BCF4688309GH806H932ADCC44EEG6DE0FE9FAHDE66DGH108C9G3623E045A0H7A95AB594CE99A。

次の19行のコードはカウンター状態で、文字が印刷されるたびにカウントが減ります。

次の6行はプリンターの状態で、が追加されます=。

最後に、最後の2行はクリーナー状態です。これは、唯一の出力がであることを確認するために必要です=====...=====。前後のスペースは避けられない副作用であるため、出力としてカウントされません。

その後、プログラムは停止します。

^{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)]

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;@

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回印刷されるはずです。

p31343（Maltysen）が言ったように、何らかの理由で、これは不要でした。