Ich bin daran interessiert, Programme zu sehen, die keine Eingabe verlangen, eine Googol- Kopie einer nicht leeren Zeichenfolge drucken , nicht weniger, nicht mehr und dann anhalten. Ein Googol ist definiert als 10 ^ 100, dh 1 gefolgt von hundert Nullen als Dezimalzahl.

Beispielausgabe:

111111111111111111111111111111111111111111111111111111111111111111111111...

oder

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

Die Zeichenfolge kann auch vollständig aus Leerzeichen oder speziellen Symbolen bestehen. Die einzige Ausnahme zu identischen Kopien einer festen Zeichenfolge besteht darin, dass Ihre Sprache die Ausgabe auf eine Weise dekoriert, die nicht verhindert werden kann, die jedoch in einem Wrapper-Skript trivial rückgängig gemacht werden kann, z. B. indem jeder Zeile eine Zeilennummer vorangestellt wird. Das Wrapper-Skript muss in solchen Fällen nicht bereitgestellt werden.

Sie können davon ausgehen, dass Ihrem Computer niemals die Zeit ausgeht. Ansonsten muss Ihr Programm einen angemessenen Ressourcenbedarf aufweisen. Außerdem müssen Sie alle Einschränkungen beachten, die die Programmiersprache Ihrer Wahl mit sich bringt. Sie können beispielsweise einen für die Ganzzahltypen zulässigen Maximalwert nicht überschreiten und es dürfen zu keinem Zeitpunkt mehr als 4 GB Arbeitsspeicher erforderlich sein.

Mit anderen Worten, das Programm sollte grundsätzlich testbar sein, indem es auf Ihrem Computer ausgeführt wird. Aufgrund des Umfangs dieser Zahl wird jedoch erwartet , dass Sie nachweisen, dass die Anzahl der Kopien des ausgegebenen Strings genau 10 ^ 100 beträgt und das Programm danach stoppt. Das Anhalten kann ein Beenden oder Anhalten oder sogar ein Beenden aufgrund eines Fehlers sein. In diesem Fall darf der Fehler jedoch keine Ausgabe erzeugen, die nicht einfach von der Programmausgabe getrennt werden kann.

Das ist Code-Golf , also gewinnt die Lösung mit den wenigsten Bytes.

Beispiellösung (C, ungolfed, 3768 Bytes)

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

Gelee , 6 4 Bytes

³Ȯ*¡

Dies ist eine Niladic-Verknüpfung (Funktion ohne Argumente), die 10 ²⁰⁰ Kopien der Zeichenfolge 100 ausgibt. Dies bedeutet, dass 10 ¹⁰⁰ Kopien der Zeichenfolge gedruckt werden , die aus 10 ¹⁰⁰ Kopien der Zeichenfolge 100 besteht .

Probieren Sie es online!

Beachten Sie, dass der Online-Interpreter die Ausgabe aus praktischen Gründen auf 100 KB reduziert. Der Code funktioniert auch als vollständiges Programm, aber aufgrund der impliziten Ausgabe druckt dieses Programm eine Kopie zu viel.

Wie es funktioniert

³Ȯ*¡  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 Guacamole, 13 12 11 10 Bytes

9+ddpp![g] 

Erläuterung:

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. 

Muster der gedruckten Ziege:

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

Python, 28 Bytes

-1 Byte Danke an Jonathan Allan!

Python 2:

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

Python 3 (30 Byte):

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

Haskell, 28 Bytes

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

Verkettet 10 bis 100 Kopien der Zeichenfolge "1"und druckt sie aus.

Brainfuck, 480 188 114 106 98 Bytes

Nur weil es getan werden muss.

Nimmt 8-Bit-Zellen mit Umbruch an. Druckt 250 bis ²⁵⁵ NUL-Bytes, dh 10 bis ¹⁰⁰ mal 10 bis ¹⁵⁵ mal 25 bis ²⁵⁵ NUL-Bytes.

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

Erläuterung:

>>>>>> wird benötigt, um etwas Arbeitsraum zu lassen.

- produziert 255.

[[->>>+<<<]------>>>-] verwandelt dies in 255 Kopien des Werts 250 und ergibt ein Band, das wie folgt aussieht:

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

<<<[<<<]+ Bewegt den Datenzeiger zurück und beendet die ursprünglichen Daten:

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

Dann kommt die Schleife: Setzt [+...-]zunächst die 1 auf eine 2, die am Ende der Schleife wieder auf 1 gesetzt wird. Die Schleife wird beendet, wenn der Schleifenkörper bereits 2 auf 1 gesetzt hat.

Nun stellen die Zahlen 2 250 250 250 ... 250 einen Zähler in der Basis 250 dar, wobei jede Zahl um eins größer ist als die Ziffer, die sie darstellt.

• [>>>]<<<bewegt sich ganz nach rechts. Da jede Ziffer durch eine Zahl ungleich Null dargestellt wird, ist dies trivial.

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-verringert den Zähler um 1. Beginnend mit der letzten Ziffer: Die Ziffer wird dekrementiert. Wenn es positiv bleibt, sind wir fertig. Wenn es zu Null wird, setzen Sie es auf 250 und fahren Sie mit der vorherigen Ziffer fort.

• [<<<].>>>Bewegt den Zeiger vor die am weitesten links stehende Stelle zurück. Dies ist ein guter Moment, um ein NUL-Byte zu drucken. Positionieren Sie dann genau auf die Stelle ganz links, um festzustellen, ob wir fertig sind.

Ändern Sie zur Überprüfung der Richtigkeit die Initiale -in +, um 250 ¹ NUL-Bytes ++für 250 ² usw. zu drucken .

C, 51 Bytes

Die Funktion g()ruft die rekursive Funktion f()für die Tiefe 99 auf.

Schließt unnötige Zeilenumbrüche zwischen f()und g()aus Gründen der Übersichtlichkeit aus.

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

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

Druckt 1E100 Zeilenumbrüche.

Deklaration von ials zweitem Parameter für f()nicht garantiert funktionierend in allen Versionen von C. Getestet auf meinem eigenen Computer (GCC auf CygWin) und auf ideone.com (ich glaube, sie führen auch GCC aus), aber nicht bis zu f (99) für offensichtlich Gründe dafür!

Commodore VIC 20 Maschinencode (40 Bytes)

... hier hexadezimal dargestellt:

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

(Gestartet mit: SYS 4160)

Bedeutung der Bytes in Klammern

• 0x64 (kommt zweimal vor) ist die Basis (100); (Werte von 2 bis 127 sollten funktionieren)
• 0x32 ist der Exponent (50) (jeder Wert ungleich Null (1-255) sollte funktionieren)
• Beachten Sie, dass 100 ^ 50 = 10 ^ 100; Das Programm 100 bis 50 Mal auszuführen ist effizienter als 10 bis 100 Mal
• 0x31 ist das zu druckende ASCII-Zeichen

und zu keinem Zeitpunkt dürfen mehr als 4 GB Speicher benötigt werden.

Ist das ein Tippfehler?

Wir haben das Jahr 1981.

Ein typischer Heimcomputer hat 1 bis 16 KB RAM! Und es gibt kaum professionelle Modelle mit 1 MB oder mehr.

(Ok. Nur ein Witz.)

Mit anderen Worten, das Programm sollte grundsätzlich testbar sein, indem es auf Ihrem Computer ausgeführt wird. Aufgrund des Umfangs dieser Zahl wird jedoch erwartet, dass Sie nachweisen, dass die Anzahl der Kopien des ausgegebenen Strings genau 10 ^ 100 beträgt und das Programm danach stoppt.

Das Programm wurde mit anderen Basen und Exponenten getestet. Ich habe keinen Zweifel, es wird auch mit 100 und 50 funktionieren.

Zumindest stürzt es mit diesen Zahlen nicht ab (endet aber auch nicht in messbarer Zeit).

Die Speichergröße ist ausreichend für einen Exponenten von 50 und 100 ist kleiner als 127, so dass eine Basis von 100 kein Problem darstellen sollte.

Die Grundidee

Es gibt einen 50-stelligen Zähler, der im 100-System zählt. Die Bytes 0x01-0x64 repräsentieren die Ziffern 0-99. Das erste Byte im Zähler ist die niedrigste Ziffer. Auf das letzte Byte im Zähler (höchste Ziffer) folgt ein Byte mit dem Wert 0x00.

Der Zähler hat den Anfangswert 100 ^ 50.

Eine äußere Schleife schreibt ein Byte in den "aktuellen Kanal" ("Standardausgabe" bei modernen Systemen; normalerweise der Bildschirm) und dekrementiert dann den Zähler.

Die Dekrementierung erfolgt durch eine innere Schleife: Sie dekrementiert eine Ziffer und rückt bei einem Unterlauf von 1 auf 99 zur nächsten Ziffer vor. Wird das Byte 0x00 am Ende des Zählers dekrementiert, stoppt das Programm.

Der Assembler-Code lautet

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

BEARBEITEN

Das Programm läuft auch auf Commodore C64!

Knoten, 89 Bytes

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

Gibt 10 ¹⁰⁰ Zeilenumbrüche aus. (Theoretisch dh; Test durch Ersetzen 100mit 1dem Ausgang 10 ¹ newlines statt.)

Dies funktioniert, indem Sie idie Zeichenfolge festlegen

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

(100 Nullen und eine 1; ein Googol umgekehrt), dann wiederholt "1 subtrahieren" mit einem regulären Ausdruck ersetzen und eine neue Zeile ausgeben, bis die Zeichenfolge nur noch Nullen enthält.

Ein Port der C ++ - Antwort wäre 49 Bytes:

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

05AB1E , 6 Bytes

Tn°F1?

Erläuterung

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

Ruby, 20 Bytes

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

Druckt 1, gefolgt von einem Zeilenumbruch 1E100 mal.

1E100 funktioniert nicht, da es einen Gleitkommawert ergibt, keine Ganzzahl mit willkürlicher Genauigkeit.

/// , 36 ASCII-Zeichen (4 verschiedene)

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

Gibt das .Zeichen 3 * 10 ^ 125-mal aus, was bedeutet, dass die Zeichenfolge aus 3 * 10 ^ 25 Wiederholungen des .Zeichens 10 ^ 100-mal ausgegeben wird.

Erläuterung:

1. /t./.ttttt/Ersetzen: t.mit für .tttttden Rest des Programms, zu wiederholen , bis keine Instanzen t.bleiben. Dies ersetzt t...durch ...gefolgt von 125 ts.
2. /.t/t\........../Ersetzen: .tmit für t..........den Rest des Programms, zu wiederholen , bis keine Instanzen .tbleiben. Dies dauert die ...folgenden 125 ts und macht sie zu 125 ts, gefolgt von 10 ^ 125 Vorkommen von... .
3. /t//: Entfernen Sie alle verbleibenden ts.
4. t...: Dies wird durch 3 * 10 ^ 125 .s ersetzt. Gib sie aus.

Das Ausgeben von 10 ^ 100 Wiederholungen von 3 * 10 ^ 25 Wiederholungen von etwas fühlt sich wie Schummeln an. Dieses Programm gibt das .Zeichen genau 10 bis 100 Mal mit 45 ASCII-Zeichen aus:

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

Erklärung von diesem:

1. /T/tttttttttt/: Ersetzen Sie Tmit für ttttttttttden Rest des Programms. Dies ersetzt TTTTTTTTTTmit 100 Wiederholungen vont .
2. /.t/t........../: Ersetzen Sie .tmit für t..........den Rest des Programms. Dies dauert die .folgenden 100 ts und macht sie zu 100 ts, gefolgt von 10 ^ 100. s.
3. /t//: Entfernen Sie alle verbleibenden ts.
4. .TTTTTTTTTT: Dies wird durch 10 ^ 100 .s ersetzt. Gib sie aus.

Schließlich ist hier ein Kompromissprogramm, das das .Zeichen 2 * 10 ^ 100 mal mit 40 Zeichen ausgibt :

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

Befunge 93, 33 Bytes

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

Leider hat Befunge keine Power-Funktion, so dass fast der gesamte Code meine Implementierung einer Power-Funktion ist. Daran arbeite ich noch.

Erläuterung:

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

1: Beginnen mit 1 links oben, damit wir bei der Multiplikation nicht erhalten0 jedes Mal erhalten.

01g: Holen Sie sich das Zeichen an der Position (0, 1), die ist d , dessen ASCII-Code 100 ist.

0`: Überprüfen Sie, ob der in (0, 1) gespeicherte Wert größer als 0 ist. Dieser Wert ändert sich.

#@!# _: Logisch nicht !zu dem Wert, den wir aus dem letzten Schritt erhalten (0 oder 1), so dass wir, wenn es 1 war, jetzt 0 haben und das notieren# dass Sie das nächste Zeichen im Code überspringen.

01g 1- 01p: Nimm den in (0, 1) gespeicherten Wert erneut, subtrahiere 1 davon und speichere diesen neuen Wert bei (0, 1)

25**: Multipliziere den obersten Wert des Stapels mit 10

1.: drucken 1 Jedes Mal wenn diese Schleife ausgeführt wird

1 wird (theoretisch) mal googol gedruckt, aber das rennt schnell von der seite ab, auf der ich das getestet habe.

Sie können Befunge 93 Code ausführen hier . Aus irgendeinem Grund ist der Spitzenwert des Stapels , 1.0000000000000006e+100wenn es sein sollte 1.0e+100. Ich weiß nicht, woher das kommt 6, aber ich denke nicht, dass es da sein sollte und dass es ein Rundungsfehler oder so sein könnte.

ABCR , 56 Bytes

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

Turing Tarpits machen Spaß, besonders wenn sie keine einfache Multiplikation oder Exponenten haben. Andererseits brauchte ich nur zwei der drei Warteschlangen!

Erläuterung:

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

Batch, 574 242 Bytes

@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

Jede Schleife durchläuft daher die Ausführung einer zusätzlichen Iteration. Aufgrund der 32-Bit-Ganzzahlbeschränkung sind die Schleifen auf ~ 2³² begrenzt. Die ersten vier Schleifen zählen jeweils 2²⁵ für insgesamt 2¹⁰⁰, während die verbleibenden zehn Schleifen jeweils 5¹⁰ für insgesamt 5¹⁰⁰ zählen.

Bearbeiten: Dank @ ConorO'Brien konnten unvorstellbare 58% eingespart werden.

TI-Basic, 20 Bytes

Einfach. Es werden nur acht Zeilen gleichzeitig angezeigt, und vorherige Zeilen bleiben nicht im Speicher. Da dies ᴇ100nicht unterstützt wird, müssen wir eine Schleife von -ᴇ99bis ausführen 9ᴇ99. Dann wird , wenn I!=0die Zeichenfolge anzuzeigen (die, durch die Art und Weise, ist 3). Auf diese Weise drucken wir es genau ᴇ100mal.

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

x86-64-Maschinencodefunktion, 30 Byte.

Verwendet die gleiche Rekursion Logik wie die C - Antwort von @Level River St . (Maximale Rekursionstiefe = 100)

Verwendet die puts(3)Funktion von libc, mit der normale ausführbare Dateien sowieso verknüpft sind. Es kann mit x86-64 System V ABI, dh von C unter Linux oder OS X, aufgerufen werden und staut keine Register, die es nicht sollte.

objdump -drwC -Mintel Ausgabe, kommentiert mit Erklärung

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.

Gebaut mit yasm -felf64 -Worphan-labels -gdwarf2 golf-googol.asm && gcc -nostartfiles -o golf-googol golf-googol.o . Ich kann die Original-NASM-Quelle posten, aber das schien unübersichtlich zu sein, da die ASM-Anweisungen direkt in der Demontage enthalten sind.

putchar@plt ist weniger als 128 Bytes von der jl , also hätte ich einen 2-Byte-Kurzsprung anstelle eines 6-Byte-Kurzsprungs verwenden können, aber das ist nur in einer winzigen ausführbaren Datei wahr, nicht als Teil eines größeren Programms. Daher glaube ich nicht, dass ich es rechtfertigen kann, die Größe der Puts-Implementierung von libc nicht zu zählen, wenn ich auch eine kurze JCC-Codierung nutze, um sie zu erreichen.

Jede Rekursionsebene belegt 24B Stapelspeicher (2 Pushs und die von CALL gepushte Rücksprungadresse ). Jede andere Tiefe wird aufgerufen, putcharwobei der Stapel nur um 8 ausgerichtet ist, nicht um 16, was den ABI verletzt. Eine stdio-Implementierung, bei der ausgerichtete Speicher verwendet wurden, um xmm-Register auf den Stapel zu übertragen, würde einen Fehler verursachen. Aber Glibcs putchartun das nicht, sie schreiben in eine Pipe mit voller Pufferung oder in ein Terminal mit Zeilenpufferung. Getestet unter Ubuntu 15.10. Dies könnte mit einem Dummy-Push / Pop im behoben werden .loop, um den Stapel vor dem rekursiven Aufruf um weitere 8 zu versetzen.

Beweis, dass es die richtige Anzahl von Zeilenumbrüchen druckt:

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

Meine erste Version davon war 43B und wurde puts()in einem Puffer mit 9 Zeilenumbrüchen (und einem abschließenden 0-Byte) verwendet, also würden Puts das 10. anhängen. Dieser Rekursionsgrundfall war noch näher an der C-Inspiration.

Ein anderer Faktor für 10 ^ 100 hätte den Puffer möglicherweise verkürzen können, möglicherweise auf 4 Zeilen für neue Zeilen, wodurch 5 Byte gespart werden. Die Verwendung von Putchar ist jedoch bei weitem besser. Es wird nur ein ganzzahliges Argument, kein Zeiger und überhaupt kein Puffer benötigt. Der C-Standard erlaubt Implementierungen, für die es ein Makro ist putc(val, stdout), aber in glibc existiert es als echte Funktion, die Sie von asm aus aufrufen können.

Das Drucken von nur einer neuen Zeile pro Aufruf anstelle von 10 bedeutet lediglich, dass die maximale Tiefe der Rekursion um 1 erhöht werden muss, um einen weiteren Faktor von 10 neuen Zeilen zu erhalten. Da 99 und 100 beide durch eine vorzeichenerweiterte 8-Bit-Direktdarstellung dargestellt werden können, push 100sind immer noch nur 2 Bytes.

Noch besser ist, dass 10ein Register sowohl als Zeilenvorschub- als auch als Schleifenzähler fungiert und ein Byte spart.

Ideen zum Speichern von Bytes

Eine 32-Bit-Version könnte ein Byte für das speichern dec edi, aber die Aufrufkonvention stack-args (für Bibliotheksfunktionen wie putchar) macht das Aufrufen von Tail-Calls weniger einfach und würde wahrscheinlich mehr Bytes an mehr Stellen erfordern. Ich könnte eine register-arg-Konvention für den privaten f(), nur von aufgerufenen benutzen g(), aber dann könnte ich putchar nicht mit einem Tail-Call aufrufen (weil f () und putchar () eine andere Anzahl von Stack-Args annehmen würden).

Es wäre möglich, f () zu veranlassen, den Status des Aufrufers beizubehalten, anstatt das Speichern / Wiederherstellen im Aufrufer durchzuführen. Das ist aber wahrscheinlich nicht gut, weil es wahrscheinlich auf jeder Seite des Zweigs getrennt werden müsste und mit Tailcalling nicht kompatibel ist. Ich habe es versucht, aber keine Einsparungen gefunden.

Es hat auch nicht geholfen, einen Schleifenzähler auf dem Stapel zu belassen (anstatt rcx in der Schleife zu pushen / poppen). Es war 1B schlechter mit der Version, die Puts verwendete, und wahrscheinlich sogar ein Verlust mit dieser Version, die RCX billiger einrichtet.

PHP, 44 Bytes

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

Dieses Snippet gibt 1Googol-Zeiten aus. Das Gedächtnis wird nicht knapp, aber es ist furchtbar langsam. Ich benutze BCMath, um mit langen ganzen Zahlen umgehen zu können.

Ein bisschen besser, aber nicht so klein (74 Bytes):

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

Gibt den Brief agoogol mal aus. Es verbraucht fast 4 GB Speicher und gibt ungefähr 4e9 Zeichen gleichzeitig aus.

Haskell, 45 43 Bytes

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

Pyke, 6 5 Bytes

TTX^V

Probieren Sie es hier aus!

Ungetestet, da mein Browser abstürzt. Die ersten 4 Zeichen erzeugen 10 ^ 100 und Vgeben so viele Zeilenumbrüche aus. Testen Sie mit 100V.

Schläger 36 Bytes

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

Ausgabe:

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

JAISBaL , 4 Bytes

˖Q

Chrome kann nicht alle Symbole lesen und ich bin mir bei anderen Browsern nicht sicher. Hier ist ein Bild:

Erläuterung:

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

Ziemlich einfach ... druckt einfach ein Google-Leerzeichen. Drei Befehle, aber die Googol-Konstante ist zwei Bytes.

(Geschrieben in Version 3.0.5)

JavaScript ES6, 85 83 Bytes

Dank ETHproductions 2 Bytes gespart!

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

Dies druckt 1e100 Zeilenumbrüche.

Der innere Teil generiert dieses Programm, das anschließend ausgewertet wird.

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

Als Beweis für die Richtigkeit verwenden wir nun eine Induktion. Lassen Sie uns die anfänglichen 100 für andere Werte ersetzen, die allgemein N . Ich behaupte, dass das Einfügen von N 10 ^N Zeilenumbrüche ergibt. Lass uns das Ergebnis von this nach wc -lleiten, das die Anzahl der Zeilenumbrüche in der Eingabe zählt. Wir werden dieses modifizierte, aber äquivalente Skript verwenden, das Eingabe N akzeptiert :

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

Hier ist eine Ausgabe:

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

Wir können sehen, dass dies die Eingabe N für kleine Werte in 10 ^N Zeilenumbrüche umwandelt.

Hier ist eine Beispielausgabe für N = 1:

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











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

Mathematica, 48 30 25 Bytes

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

Ausgabe:

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

Fortran 95, Freiform, rekursiv, 117 Byte

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

Druckt ein Googol von Zeilen mit

          0

Fortran 90, rekursiv, 149 Bytes

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

Durch rekursives Aufrufen von 100 verschachtelten Schleifen zu je 10 Iterationen wird genau ein Googol erstellt. N, L und die Schleifenzähler passen alle in Ganzzahlen mit Byte-Größe.

Getestet durch Ersetzen von 99 durch 1, 2, 3, 4, 5 und Feststellen, dass die resultierende Zeilenzahl von "wc" jeweils n + 1 Nullen hat.

Fortran II, IV, 66 oder 77, 231 Bytes:

      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

Druckt ein googol von Zeilenumbrüchen.

Alle diese Programme werden auf 32-Bit-Computern ausgeführt. Tatsächlich würden die rekursiven Versionen auf einem 16-Bit-Computer einwandfrei funktionieren. In der Brute-Force-Version könnte man weniger Schleifen verwenden, wenn man auf einem alten Cray mit seinen 60-Bit-Ganzzahlen läuft. Hier entsprechen zehn verschachtelte Schleifen von 2 * 10 ^ 9 in einer Schleife von 5 ^ 10 (9765625) 10 ^ 100 Gesamtiterationen.

Keine der Versionen verwendet einen anderen Speicher als den Objektcode selbst, die Zähler, eine Kopie der Ausgabezeichenfolge und in der rekursiven Version einen Rückgabestapel mit 100 Ebenen.

Überprüfen Sie die Faktoren durch Vergleich

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

Turing Maschinensimulator, 1082 Bytes

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 *

Turing Maschinensimulator

Ich weiß nicht, ob dies als die richtige Ausgabe gilt, da es 82 führende Leerzeichen hat.

Ich weiß nicht, ob dies die 4-GB-Grenze einhält. Wenn dies nicht der Fall ist, ist es nicht wettbewerbsfähig und nur für Präsentationszwecke. Die Ausgabe ist 1e100 Byte, daher sollte von der Anzahl der Speicherbytes abgezogen werden. Die endgültige Byteanzahl beträgt 82 Bytes.

Hier ist eine Erklärung:

Die ersten 80 Zeilen des Codes sind 80 verschiedene Zustände, die die Basis-19 erzeugen ¹ Schleifenzählwert 6EC1BCF4688309GH806H932ADCC44EEG6DE0FE9FAHDE66DGH108C9G3623E045A0H7A95AB594CE99A.

Die nächsten 19 Codezeilen sind der Zählerstand, der den Zählerstand jedes Mal verringert, wenn ein Zeichen gedruckt wird.

Die nächsten 6 Zeilen sind der Druckerstatus, an den ein angehängt wird =.

Schließlich sind die letzten 2 Zeilen der Cleaner-Status, der benötigt wird, um sicherzustellen, dass nur die Ausgabe erfolgt =====...===== . Führende / nachfolgende Leerzeichen zählen nicht als Ausgabe, da sie unvermeidbare Nebenwirkungen sind.

Das Programm hält dann an.

^{1 Ich habe das nachgerechnet.}

Pyth, 7 Bytes

Neu (im Wettbewerb)

V^T*TTG

Erläuterung

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

Alt (nicht konkurrierend) 7 Bytes

*G^T*TT

Erläuterung

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

Python 3, 32 Bytes

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

Alternative Lösung, 33 Bytes:

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

Java, 198 179 155 Bytes

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

Gibt ( x== null?: nullEine Zeichenfolge aus, die mit [La;@oder so ähnlich beginnt ) 10 bis ¹⁰⁰ Mal in O-Zeit (für immer).

Java, 153 Bytes

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

Ausgang: 1e100 1s

Ich weiß, dass es eine andere Java-Antwort gibt, die auch ziemlich nah ist. Die Mine hat eine Hauptleitung und ist immer noch kürzer.

Dies ist mein erster Code-Golf-Eintrag. Tipps geschätzt.

Pyth, 8 7 Bytes

V^T100G

Verknüpfung

Die Lösung wurde mit geringer Leistung getestet, sollte jedoch abcdefghijklmnopqrstuvwxyz1e100-mal drucken .

Aus irgendeinem Grund war das pnicht nötig, wie 31343 (Maltysen) sagte .