Estoy interesado en ver programas que no soliciten ninguna entrada, imprima una copia en Google de alguna cadena que no esté vacía, nada menos, nada más, y luego pare. Un googol se define como 10 ^ 100, es decir, 1 seguido de cien 0 en decimal.

Salida de ejemplo:

111111111111111111111111111111111111111111111111111111111111111111111111...

o

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

La cadena también puede estar completamente compuesta de espacios en blanco o símbolos especiales. La única excepción a las copias idénticas de una cadena fija es si su idioma decora la salida de alguna manera que no se puede evitar, pero que se puede deshacer trivialmente en un script de envoltura, como anteponer un número de línea a cada línea. No es necesario proporcionar el script de envoltura en tales casos.

Puede suponer que su computadora nunca se quedará sin tiempo, pero aparte de eso, su programa debe tener una demanda razonable de recursos. Además, debe respetar las restricciones que plantea el lenguaje de programación que elija, por ejemplo, no puede exceder un valor máximo permitido para sus tipos enteros, y en ningún momento se deben necesitar más de 4 GB de memoria.

En otras palabras, el programa debería poder probarse en principio ejecutándolo en su computadora. Pero debido a la extensión de este número, se espera que demuestre que el número de copias de la cadena que genera es exactamente 10 ^ 100 y que el programa se detiene después. La detención puede ser salir o detenerse o incluso terminar debido a un error, pero si es así, el error no debe producir ninguna salida que no pueda separarse fácilmente de la salida del programa.

Este es el código de golf , por lo que gana la solución con la menor cantidad de bytes.

Solución de ejemplo (C, sin golf, 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;
}

Jalea , 6 4 bytes

³Ȯ*¡

Este es un enlace niládico (función sin argumentos) que imprime 10 ²⁰⁰ copias de la cadena 100 , lo que significa que imprime 10 ¹⁰⁰ copias de la cadena que consta de 10 ¹⁰⁰ copias de la cadena 100 .

Pruébalo en línea!

Tenga en cuenta que el intérprete en línea corta la salida a 100 KB por razones prácticas. El código también funciona como un programa completo, pero debido a la salida implícita, ese programa imprime demasiadas copias.

Cómo funciona

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

Explicación:

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. 

Muestra de la cabra impresa:

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

Python, 28 bytes

-1 byte gracias a Jonathan Allan!

Python 2:

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

Python 3 (30 bytes):

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

Haskell, 28 bytes

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

Concatena 10 ^ 100 copias de la cadena "1"y la imprime.

Brainfuck 480 188 114 106 98 bytes

Solo porque hay que hacerlo.

Asume celdas de 8 bits con envoltura. Imprime 250 ²⁵⁵ bytes NUL, que es 10 ¹⁰⁰ veces 10 ¹⁵⁵ veces 25 ²⁵⁵ bytes NUL.

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

Explicación:

>>>>>> es necesario para dejar un poco de espacio de trabajo

- produce 255.

[[->>>+<<<]------>>>-] convierte esto en 255 copias del valor 250, dando una cinta que se parece a:

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

<<<[<<<]+ mueve el puntero de datos hacia atrás y termina los datos iniciales:

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

Luego viene el ciclo: [+...-]inicialmente establece el 1 en un 2, que se vuelve a establecer en 1 al final del ciclo. El ciclo termina cuando el cuerpo del ciclo ya está configurado de 2 a 1.

Ahora, los números 2 250 250 250 ... 250 representan un contador, en la base 250, con cada número uno mayor que el dígito que representa.

• [>>>]<<<se mueve todo hacia la derecha. Como cada dígito está representado por un número distinto de cero, esto es trivial.

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-disminuye el contador en 1. Comenzando con el último dígito: el dígito se reduce. Si sigue siendo positivo, hemos terminado. Si se pone a cero, ajústelo a 250 y continúe con el dígito anterior.

• [<<<].>>>mueve el puntero hacia atrás antes del dígito más a la izquierda, y este es un buen momento para imprimir un byte NUL. Luego vuelva a colocar exactamente el dígito más a la izquierda, para ver si hemos terminado.

Para verificar la corrección, cambie la inicial -a +para imprimir 250 ¹ bytes NUL, ++para 250 ² , etc.

C, 51 bytes

La función g()llama a la función recursiva f()a profundidad 99.

Excluye nueva línea innecesaria agregada entre f()y g()para mayor claridad.

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

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

Imprime 1E100 líneas nuevas.

Declaración de isegundo parámetro de f()no garantizado para funcionar en todas las versiones de C. Probado en mi propia máquina (GCC en CygWin) y en ideone.com (creo que también ejecutan GCC), pero no hasta f (99) para obvio ¡razones!

Código de máquina Commodore VIC 20 (40 bytes)

... aquí se muestra como hexadecimal:

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

(Empezado a utilizar: SYS 4160)

Significado de los bytes entre paréntesis

• 0x64 (ocurre dos veces) es la base (100); (los valores del 2 al 127 deberían funcionar)
• 0x32 es el exponente (50) (cualquier valor distinto de cero (1-255) debería funcionar)
• Tenga en cuenta que 100 ^ 50 = 10 ^ 100; ejecutar el programa 100 ^ 50 veces es más eficiente en RAM que hacerlo 10 ^ 100 veces
• 0x31 es el carácter ASCII que se imprimirá

y en ningún momento no se necesitan más de 4 G B de memoria.

¿Es esto un error de mecanografía?

Tenemos el año 1981.

¡Una computadora doméstica típica tiene de 1 a 16 K B de RAM! Y difícilmente encontrará modelos profesionales que tengan 1 M B o más.

(Ok. Solo una broma.)

En otras palabras, el programa debería poder probarse en principio ejecutándolo en su computadora. Pero debido a la extensión de este número, se espera que demuestre que el número de copias de la cadena que genera es exactamente 10 ^ 100 y que el programa se detiene después.

El programa ha sido probado con otras bases y exponentes. No tengo dudas de que también funcionará con 100 y 50.

Al menos no se bloquea con estos números (pero tampoco termina en un tiempo medible).

El tamaño de la memoria es suficiente para un exponente de 50 y 100 es menor que 127, por lo que una base de 100 no debería ser un problema.

La idea básica

Hay un contador de 50 dígitos que cuenta en el sistema de 100. Los bytes 0x01-0x64 representan los dígitos 0-99. El primer byte en el contador es el dígito más bajo. El último byte en el contador (dígito más alto) es seguido por un byte con el valor 0x00.

El contador tiene el valor inicial 100 ^ 50.

Un bucle externo está escribiendo un byte en el "canal actual" ("salida estándar" en los sistemas modernos; típicamente la pantalla) y luego disminuye el contador.

La disminución se realiza mediante un bucle interno: disminuye un dígito y, en el caso de un flujo inferior de 1 a 99, avanza al siguiente dígito. Si se disminuye el byte 0x00 al final del contador, el programa se detiene.

El código de ensamblaje es

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

EDITAR

¡El programa también se ejecuta en Commodore C64!

Nodo, 89 bytes

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

Salidas 10 ¹⁰⁰ líneas nuevas. (Teóricamente, es decir; pruebe reemplazando 100con 1para generar 10 ¹ nuevas líneas en su lugar).

Esto funciona configurando ila cadena

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

(100 ceros y un 1; un googol invertido), luego "restando 1" repetidamente con un regex reemplaza y enviando una nueva línea hasta que la cadena sea todos ceros.

Un puerto de la respuesta de C ++ sería de 49 bytes:

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

05AB1E , 6 bytes

Tn°F1?

Explicación

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

Rubí, 20 bytes

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

Imprime 1 seguido de una nueva línea 1E100 veces.

1E100 no funciona ya que se evalúa como flotante, no es un entero de precisión arbitrario.

/// , 36 caracteres ASCII (4 distintos)

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

Emite el .carácter 3 * 10 ^ 125 veces, lo que significa que emite la cadena que consta de 3 * 10 ^ 25 repeticiones del. carácter, 10 ^ 100 veces.

Explicación:

1. /t./.ttttt/: Reemplace t.con .tttttel resto del programa, repitiendo hasta que no t.queden instancias . Esto reemplaza t...con ...seguido por 125t s.
2. /.t/t\........../: Reemplace .tcon t..........el resto del programa, repitiendo hasta que no .tqueden instancias . Esto toma ...125 tsegundos seguidos y lo convierte en 125 tsegundos seguidos de 10 ^ 125 ocurrencias de... .
3. /t//: Eliminar todos los ts restantes .
4. t...: Esto se reemplaza con 3 * 10 ^ 125 .s. Salida de ellos.

Ahora, generar 10 ^ 100 repeticiones de 3 * 10 ^ 25 repeticiones de algo parecido a una trampa. Este programa genera el .carácter exactamente 10 ^ 100 veces, utilizando 45 caracteres ASCII:

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

Explicación de este:

1. /T/tttttttttt/: Reemplace Tcon ttttttttttel resto del programa. Esto reemplaza TTTTTTTTTTcon 100 repeticiones de t.
2. /.t/t........../: Reemplace .tcon t..........el resto del programa. Esto toma .100 tsegundos seguidos y los convierte en 100 tsegundos seguidos de 10 ^ 100 .segundos.
3. /t//: Eliminar todos los ts restantes .
4. .TTTTTTTTTT: Esto se reemplaza con 10 ^ 100 .s. Salida de ellos.

Finalmente, aquí hay un programa de compromiso, que genera el .carácter 2 * 10 ^ 100 veces, usando 40 caracteres:

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

Befunge 93, 33 bytes

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

Desafortunadamente, Befunge no tiene una función de potencia, por lo que casi todo ese código es mi implementación de una función de potencia. Todavía estoy trabajando en esto.

Explicación:

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

1: Comience con 1en la parte superior izquierda para que cuando multipliquemos, no obtengamos 0todo el tiempo.

01g: obtiene el carácter en la posición (0, 1), que es d, cuyo código ASCII es 100.

0`: ver si el valor almacenado en (0, 1) es mayor que 0; Este valor cambiará.

#@!# _: No es lógico !el valor que obtenemos del último paso (0 o 1), de modo que si fuera 1, ahora tenemos 0, y observamos que eso #significa que omite el siguiente carácter en el código.

01g 1- 01p: Tome el valor almacenado en (0, 1) nuevamente, reste 1 de él y almacene este nuevo valor en (0, 1)

25**: multiplica el valor superior de la pila por 10

1.: imprime 1cada vez que este bucle

1 se imprime (en teoría) tiempos de googol, pero eso rápidamente se sale de la página en la que probé esto.

Puede ejecutar el código Befunge 93 aquí . Por alguna razón, el valor superior de la pila es 1.0000000000000006e+100cuando debería ser 1.0e+100. No sé de dónde 6vino eso , pero no creo que deba estar allí y que pueda ser un error de redondeo o algo así.

ABCR , 56 bytes

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

Las lonas de Turing son divertidas, especialmente cuando no tienen multiplicaciones o exponentes fáciles. Por otro lado, ¡solo necesitaba usar dos de las tres colas!

Explicación:

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

Lote, 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

Cada ciclo se cae, por lo tanto, ejecuta una iteración adicional. Los bucles están limitados a ~ 2³² debido al límite de enteros de 32 bits. Los primeros cuatro bucles cuentan cada uno 2²⁵ para un total de 2¹⁰⁰ mientras que los diez bucles restantes cuentan cada 5¹⁰ para un total de 5¹⁰⁰.

Editar: ahorró un 58% inimaginable gracias a @ ConorO'Brien.

TI-Basic, 20 bytes

Sencillo. Solo se muestran ocho líneas a la vez, y las líneas anteriores no permanecen en la memoria. Debido a ᴇ100que no es compatible, debemos recorrer de -ᴇ99a 9ᴇ99. Luego, si I!=0, muestra la cadena (que, por cierto, es 3). De esta manera, lo imprimimos exactamente las ᴇ100veces.

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

Función de código de máquina x86-64, 30 bytes.

Utiliza la misma lógica de la recursividad como la respuesta C por @Level río St . (Profundidad máxima de recursión = 100)

Utiliza la puts(3)función de libc, de la cual se ejecutan los ejecutables normales. Es invocable usando el x86-64 System V ABI, es decir, desde C en Linux u OS X, y no registra ningún registro que no debería.

objdump -drwC -Mintel salida, comentada con explicación

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.

Construido con yasm -felf64 -Worphan-labels -gdwarf2 golf-googol.asm && gcc -nostartfiles -o golf-googol golf-googol.o . Puedo publicar la fuente NASM original, pero eso parecía desordenado ya que las instrucciones asm están ahí en el desmontaje.

putchar@pltestá a menos de 128 bytes de distancia jl, por lo que podría haber usado un salto corto de 2 bytes en lugar de un salto cercano de 6 bytes, pero eso solo es cierto en un pequeño ejecutable, no como parte de un programa más grande. Así que no creo que pueda justificar no contar el tamaño de la implementación de put de libc si también aprovecho una breve codificación jcc para alcanzarla.

Cada nivel de recursión usa 24B de espacio de pila (2 empujes y la dirección de retorno empujada por CALL). Cualquier otra profundidad llamará putcharcon la pila solo alineada por 8, no por 16, por lo que esto viola el ABI. Fallaría una implementación estándar que usara tiendas alineadas para derramar registros xmm a la pila. Pero glibc putcharno hace eso, escribir en una tubería con almacenamiento en búfer completo o escribir en una terminal con almacenamiento en línea. Probado en Ubuntu 15.10. Esto podría solucionarse con un push / pop ficticio en el .loop, para compensar la pila por otros 8 antes de la llamada recursiva.

Prueba de que imprime el número correcto de líneas nuevas:

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

Mi primera versión de esto fue 43B, y usé puts() en un búfer de 9 líneas nuevas (y un byte final de 0), por lo que put agregaría el 10. Ese caso base de recursión estaba aún más cerca de la inspiración C.

Factorizar 10 ^ 100 de una manera diferente podría haber acortado el búfer, tal vez hasta 4 líneas nuevas, ahorrando 5 bytes, pero usar putchar es mucho mejor. Solo necesita un argumento entero, no un puntero, y ningún búfer en absoluto. El estándar C permite implementaciones para las que es una macro putc(val, stdout), pero en glibc existe como una función real a la que puede llamar desde asm.

Imprimir solo una nueva línea por llamada en lugar de 10 solo significa que necesitamos aumentar la profundidad máxima de recursión en 1, para obtener otro factor de 10 nuevas líneas. Como 99 y 100 se pueden representar mediante un signo de 8 bits inmediato,push 100 todavía son solo 2 bytes.

Aún mejor, tener 10un registro funciona como una nueva línea y un contador de bucle, guardando un byte.

Ideas para guardar bytes

Una versión de 32 bits podría guardar un byte para el dec edi, pero la convención de llamadas stack-args (para funciones de biblioteca como putchar) hace que la llamada de cola funcione con menos facilidad y probablemente requerirá más bytes en más lugares. Podría usar una convención de registro-arg para el privado f(), solo llamado por g(), pero luego no pude llamar a putchar (porque f () y putchar () tomarían un número diferente de stack-args).

Sería posible tener f () preservar el estado de la persona que llama, en lugar de guardar / restaurar en la persona que llama. Sin embargo, eso probablemente apesta, porque probablemente necesitaría estar por separado en cada lado de la rama, y ​​no es compatible con las llamadas de cola. Lo intenté pero no encontré ningún ahorro.

Mantener un contador de bucles en la pila (en lugar de presionar / reventar rcx en el bucle) tampoco ayudó. Era 1B peor con la versión que usaba put, y probablemente una pérdida aún mayor con esta versión que configura rcx de manera más económica.

PHP, 44 bytes

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

Este fragmento generará 1tiempos de googol. No se quedará sin memoria, pero es terriblemente lento. Estoy usando BCMath para poder manejar enteros largos.

Un poco mejor rendimiento, pero no tan pequeño (74 bytes):

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

Producirá la letra agoogol veces. Consumirá casi 4 GB de memoria y generará unos 4e9 caracteres a la vez.

Haskell, 45 43 bytes

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

Pyke, 6 5 bytes

TTX^V

Pruébalo aquí!

Sin probar ya que bloquea mi navegador. Los primeros 4 caracteres generan 10 ^ 100 e Vimprimen muchas líneas nuevas. Prueba con100V .

Raqueta 36 bytes

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

Salida:

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

JAISBaL , 4 bytes

˖Q

Chrome no puede leer todos los símbolos, y no estoy seguro acerca de otros navegadores, así que aquí hay una imagen:

Explicación:

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

Bastante simple ... solo imprime un googol espacios. Tres instrucciones, pero la constante googol es de dos bytes.

(Escrito en la versión 3.0.5)

JavaScript ES6, 85 83 bytes

¡Ahorró 2 bytes gracias a ETHproductions!

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

Esto imprime 1e100 líneas nuevas.

La parte interna genera este programa, que luego se evalúa.

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

Ahora, para una prueba de corrección, usaremos alguna inducción. Vamos a sustituir al inicial 100 para otros valores, genéricamente N . Afirmo que insertar N producirá 10 ^N nuevas líneas. Vamos a canalizar el resultado de esto a wc -l, que cuenta el número de líneas nuevas en la entrada. Utilizaremos este script modificado pero equivalente que toma la entrada N :

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

Ahora, aquí hay algo de salida:

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

Podemos ver que esto transforma la entrada N para valores pequeños a 10 ^N líneas nuevas.

Aquí hay un ejemplo de salida para 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,]

Salida:

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

Fortran 95, forma libre, recursiva, 117 bytes

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

Imprime un googol de líneas que contienen

          0

Fortran 90, recursivo, 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     

La invocación recursiva de 100 bucles anidados, cada 10 iteraciones, hace exactamente un googol. N, L y los contadores de bucle encajan en enteros de tamaño byte.

Probado reemplazando 99 con 1, 2, 3, 4, 5 y observando que en cada caso el recuento de líneas resultante de "wc" tiene n + 1 ceros.

Fortran II, IV, 66 o 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

Imprime un googol de nuevas líneas.

Todos estos programas se ejecutarán en máquinas de 32 bits; de hecho, las versiones recursivas funcionarían bien en una máquina de 16 bits. Uno podría usar menos bucles en la versión de fuerza bruta al ejecutar un viejo Cray con sus enteros de 60 bits. Aquí, diez bucles anidados de 2 * 10 ^ 9 dentro de un bucle de 5 ^ 10 (9765625) equivalen a 10 ^ 100 iteraciones totales.

Ninguna de las versiones utiliza memoria para hablar de otra cosa que no sea el código objeto en sí, los contadores, una copia de la cadena de salida y, en la versión recursiva, una pila de retorno de 100 niveles.

Verifique los factores comparando

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

Simulador de máquina de Turing, 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 *

Simulador de máquina de Turing

No sé si esto cuenta como la salida correcta, ya que tiene 82 espacios iniciales.

No sé si esto respeta el límite de 4 GB, por lo que, si no lo hace, entonces no es competitivo y solo para mostrar. La salida es de 1e100 bytes, por lo que debe deducirse del recuento de bytes de memoria. El recuento final de bytes es de 82 bytes.

Aquí hay una explicación:

Las primeras 80 líneas de código son 80 estados diferentes que generan el recuento de bucles base-19 ¹6EC1BCF4688309GH806H932ADCC44EEG6DE0FE9FAHDE66DGH108C9G3623E045A0H7A95AB594CE99A .

Las siguientes 19 líneas de código son el estado del contador, que disminuye el recuento cada vez que se imprime un carácter.

Las siguientes 6 líneas son el estado de la impresora, que agrega un =.

Finalmente, las últimas 2 líneas son el estado más limpio, que son necesarias para asegurarse de que la única salida sea =====...===== . Los espacios iniciales / finales no cuentan como salida, ya que son efectos secundarios inevitables.

El programa luego se detiene.

^{1 Hice los cálculos para eso.}

Pyth, 7 bytes

Nuevo (en competencia)

V^T*TTG

Explicación

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

Antiguo (no competidor) 7 bytes

*G^T*TT

Explicación

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

Python 3, 32 bytes

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

Solución alternativa, 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);}}

Impresiones (x == null?: nullUna cadena que comienza con [La;@o algo así) 10 ¹⁰⁰ veces en el tiempo O (para siempre).

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

Salida: 1e100 1s

Sé que hay otra respuesta de Java que también está bastante cerca. El mío tiene un principal y aún es más corto.

Esta es mi primera entrada de código de golf. Consejos apreciados.

Pyth, 8 7 bytes

V^T100G

Enlazar

La solución se prueba con una salida pequeña, pero debería imprimir abcdefghijklmnopqrstuvwxyz 1e100 veces.

Por alguna razón, el pera innecesaria, ya que 31343 (Maltysen) , dijo .