Estou interessado em ver programas que não solicitam entrada, imprima uma cópia do googol de uma sequência não vazia, nem menos, nem mais, e depois pare. Um googol é definido como 10 ^ 100, ou seja, 1 seguido de cem zeros em decimal.

Exemplo de saída:

111111111111111111111111111111111111111111111111111111111111111111111111...

ou

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

A string também pode ser totalmente composta por espaços em branco ou símbolos especiais. A única exceção para cópias idênticas de uma sequência fixa é se o seu idioma decorar a saída de alguma forma que não possa ser evitada, mas possa ser desfeita trivialmente em um script de wrapper, como anexar um número de linha a cada linha. O script do wrapper nesses casos não precisa ser fornecido.

Você pode assumir que seu computador nunca ficará sem tempo, mas, além disso, seu programa deve ter uma demanda razoável de recursos. Além disso, você deve respeitar as restrições impostas pela linguagem de programação de sua escolha, por exemplo, não pode exceder um valor máximo permitido para seus tipos inteiros e em nenhum momento mais do que 4 GB de memória devem ser necessários.

Em outras palavras, o programa deve, em princípio, ser testável executando-o no seu computador. Mas, devido à extensão desse número, você deverá provar que o número de cópias da sequência de caracteres que ele gera é exatamente 10 ^ 100 e que o programa é interrompido posteriormente. A parada pode ser encerrada, interrompida ou até finalizada devido a um erro, mas, se for o caso, o erro não deve produzir nenhuma saída que não possa ser facilmente separada da saída do programa.

Isso é código-golfe , então a solução com o menor número de bytes vence.

Solução de exemplo (C, sem 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;
}

Geléia , 6 4 bytes

³Ȯ*¡

Este é um link niládico (função sem argumentos) que imprime 10 ²⁰⁰ cópias da sequência 100 , o que significa que imprime 10 ¹⁰⁰ cópias da sequência que consiste em 10 ¹⁰⁰ cópias da sequência 100 .

Experimente online!

Observe que o intérprete online reduz a saída em 100 KB por motivos práticos. O código também funciona como um programa completo, mas devido à saída implícita, esse programa imprime uma cópia a mais.

Como 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] 

Explicação:

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. 

Amostra da cabra impressa:

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

Python, 28 bytes

-1 byte graças 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 cópias da sequência "1"e a imprime.

Brainfuck, 480 188 114 106 98 bytes

Só porque precisa ser feito.

Assume células de 8 bits com quebra automática. Imprime 250 bytes NUL ²⁵⁵ , ou seja, 10 ¹⁰⁰ vezes 10 ¹⁵⁵ vezes 25 ²⁵⁵ bytes NUL.

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

Explicação:

>>>>>> é necessário para deixar um pouco de espaço de trabalho.

- produz 255.

[[->>>+<<<]------>>>-] transforma isso em 255 cópias do valor 250, fornecendo uma fita parecida com:

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

<<<[<<<]+ move o ponteiro dos dados para trás e termina os dados iniciais:

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

Em seguida, vem o loop: [+...-]inicialmente define 1 como 2, que volta a 1 no final do loop. O loop termina quando o corpo do loop já está definido como 2 como 1.

Agora, os números 2 250 250 250 ... 250 representam um contador, na base 250, com cada número um maior que o dígito que representa.

• [>>>]<<<move todo o caminho para a direita. Como cada dígito é representado por um número diferente de zero, isso é trivial.

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-diminui o contador em 1. Começando com o último dígito: o dígito é diminuído. Se continuar positivo, terminamos. Se for zero, defina-o como 250 e continue com o dígito anterior.

• [<<<].>>>move o ponteiro para trás antes do dígito mais à esquerda, e este é um bom momento para imprimir um byte NUL. Em seguida, reposicione exatamente no dígito mais à esquerda, para ver se terminamos.

Para verificar a correção, altere a inicial -para +imprimir 250 ¹ NUL bytes, ++para 250 ² , etc.

C, 51 bytes

A função g()chama a função recursiva f()para a profundidade 99.

Exclui nova linha desnecessária adicionada entre f()e g()para maior clareza.

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

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

Imprime novas linhas 1E100.

Declaração icomo segundo parâmetro de f()não garantido que funcione em todas as versões do C. Testado em minha própria máquina (GCC no CygWin) e em ideone.com (acredito que eles também executam o GCC), mas não até f (99) por óbvio razões!

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

... aqui mostrado 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

(Iniciado usando: SYS 4160)

Significado dos bytes entre colchetes

• 0x64 (ocorre duas vezes) é a base (100); (valores de 2 a 127 devem funcionar)
• 0x32 é o expoente (50) (qualquer valor diferente de zero (1-255) deve funcionar)
• Observe que 100 ^ 50 = 10 ^ 100; executar o programa 100 ^ 50 vezes é mais eficiente em RAM do que fazê-lo 10 ^ 100 vezes
• 0x31 é o caractere ASCII a ser impresso

e em nenhum momento devem ser necessários mais de 4 GB de memória.

Isso é um erro de digitação?

Temos o ano de 1981.

Um computador doméstico típico tem 1 a 16 KB de RAM! E você dificilmente encontrará modelos profissionais com 1 MB ou mais.

(Ok. Apenas uma piada.)

Em outras palavras, o programa deve, em princípio, ser testável executando-o no seu computador. Mas, devido à extensão desse número, você deverá provar que o número de cópias da sequência de caracteres que ele gera é exatamente 10 ^ 100 e que o programa é interrompido posteriormente.

O programa foi testado com outras bases e expoentes. Não tenho dúvida de que também funcionará com 100 e 50.

Pelo menos não trava com esses números (mas também não termina em tempo mensurável).

O tamanho da memória é suficiente para um expoente de 50 e 100 é menor que 127, portanto, uma base de 100 não deve ser um problema.

A ideia básica

Há um contador de 50 dígitos que conta no sistema 100. Os bytes 0x01-0x64 representam os dígitos de 0 a 99. O primeiro byte no contador é o dígito mais baixo. O último byte no contador (dígito mais alto) é seguido por um byte com o valor 0x00.

O contador tem o valor inicial 100 ^ 50.

Um loop externo está gravando um byte no "canal atual" ("saída padrão" em sistemas modernos; geralmente na tela) e depois diminui o contador.

A redução é feita por um loop interno: diminui um dígito e, no caso de um subfluxo de 1 a 99, avança para o próximo dígito. Se o byte 0x00 no final do contador for diminuído, o programa será interrompido.

O código de montagem é

    ; 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

O programa também roda no Commodore C64!

Nó, 89 bytes

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

Emite 10 ¹⁰⁰ novas linhas. (Teoricamente, isto é; teste substituindo 100por 1para gerar 10 ¹ novas linhas).

Isso funciona configurando ia string

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

(100 zeros e um 1; um googol invertido) e, em seguida, "subtraindo 1" repetidamente com uma expressão regular substitui e produz uma nova linha até que a sequência esteja com todos os zeros.

Uma porta da resposta C ++ seria 49 bytes:

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

05AB1E , 6 bytes

Tn°F1?

Explicação

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

Ruby, 20 bytes

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

Imprime 1 seguido de uma nova linha 1E100 vezes.

1E100 não funciona conforme é avaliado como flutuante, não como um número inteiro de precisão arbitrário.

/// , 36 caracteres ASCII (4 distintos)

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

Emite o .caractere 3 * 10 ^ 125 vezes, o que significa que emite a sequência que consiste em 3 * 10 ^ 25 repetições do .caractere, 10 ^ 100 vezes.

Explicação:

1. /t./.ttttt/: Substitua t.por .ttttttodo o restante do programa, repetindo até que não haja mais instâncias t.. Isso substitui t...por ...seguido por 125 ts.
2. /.t/t\........../: Substitua .tpor t..........todo o restante do programa, repetindo até que não haja mais instâncias .t. Isso leva o ...seguido por 125 ts e o transforma em 125 ts, seguido por 10 ^ 125 ocorrências de ....
3. /t//: Remova todos os ts restantes .
4. t...: Isso é substituído por 3 * 10 ^ 125 .s. Saída eles.

Agora, produzir 10 ^ 100 repetições de 3 * 10 ^ 25 repetições de algo meio que parece trapaça. Este programa gera o .caractere exatamente 10 ^ 100 vezes, usando 45 caracteres ASCII:

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

Explicação deste:

1. /T/tttttttttt/: Substitua Tpor tttttttttttodo o restante do programa. Isso substitui TTTTTTTTTTpor 100 repetições de t.
2. /.t/t........../: Substitua .tpor t..........todo o restante do programa. Isso leva o .seguido de 100 ts e o transforma em 100 ts, seguido de 10 ^ 100 .s.
3. /t//: Remova todos os ts restantes .
4. .TTTTTTTTTT: Isso é substituído por 10 ^ 100 .s. Saída eles.

Finalmente, aqui está um programa de compromisso, que gera o .caractere 2 * 10 ^ 100 vezes, usando 40 caracteres:

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

Abaixo 93, 33 bytes

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

Infelizmente, o Befunge não tem uma função de poder, então quase todo esse código é minha implementação de uma função de poder. Eu ainda estou trabalhando nisso.

Explicação:

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

1: Comece 1no canto superior esquerdo para que, quando nos multiplicamos, não o façamos 0todas as vezes.

01g: obtém o caractere na posição (0, 1), ou seja d, cujo código ASCII é 100.

0`: veja se o valor armazenado em (0, 1) é maior que 0; esse valor mudará.

#@!# _: Lógico não !para o valor que obtemos da última etapa (0 ou 1), de modo que, se fosse 1, agora temos 0 e observamos que isso #significa que você pula o próximo caractere no código.

01g 1- 01p: Pegue o valor armazenado em (0, 1) novamente, subtraia 1 dele e armazene esse novo valor em (0, 1)

25**: multiplique o valor superior da pilha por 10

1.: imprima 1sempre que isso faz um loop

1 é impresso (em teoria) nos tempos do googol, mas rapidamente sai da página em que eu testei isso.

Você pode executar o código Befunge 93 aqui . Por alguma razão, o valor mais alto da pilha é 1.0000000000000006e+100quando deveria ser 1.0e+100. Não sei de onde 6veio isso , mas acho que não deveria estar lá e que pode haver algum erro de arredondamento ou algo assim.

ABCR , 56 bytes

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

Tarpits de Turing são divertidos, especialmente quando eles não têm multiplicação fácil ou expoentes. Por outro lado, eu só precisava usar duas das três filas!

Explicação:

++++++++++                                             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 loop passa, portanto, executando uma iteração adicional. Os loops são limitados a ~ 2³² devido ao limite inteiro de 32 bits. Cada um dos quatro primeiros loops conta 2²⁵ para um total de 2¹⁰⁰, enquanto os dez loops restantes contam 5¹⁰ para um total de 5¹⁰⁰.

Edit: Salvo 58% inimaginável graças a @ ConorO'Brien.

TI-Basic, 20 bytes

Direto. Apenas oito linhas são exibidas de uma vez e as linhas anteriores não ficam na memória. Como ᴇ100não há suporte, precisamos fazer um loop de -ᴇ99para 9ᴇ99. Em seguida, se I!=0exibir a sequência (que, a propósito, é 3). Dessa forma, imprimimos exatamente as ᴇ100vezes.

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

função de código de máquina x86-64, 30 bytes.

Usa a mesma lógica recursividade como a resposta C por @Level River St . (Profundidade máxima de recursão = 100)

Usa a puts(3)função da libc, à qual os executáveis ​​normais estão vinculados de qualquer maneira. É possível chamar usando o x86-64 System V ABI, ou seja, do C no Linux ou OS X, e não derruba nenhum registro que não deveria.

objdump -drwC -Mintel saída, comentada com explicação

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.

Construído com yasm -felf64 -Worphan-labels -gdwarf2 golf-googol.asm && gcc -nostartfiles -o golf-googol golf-googol.o . Posso postar a fonte NASM original, mas isso pareceu uma bagunça, pois as instruções asm estão ali na desmontagem.

putchar@pltestá a menos de 128 bytes do jl, então eu poderia ter usado um salto curto de 2 bytes em vez de um salto próximo de 6 bytes, mas isso é verdade apenas em um pequeno executável, não como parte de um programa maior. Portanto, acho que não posso justificar não contar o tamanho da implementação de libc's puts se eu também tirar proveito de uma codificação jcc curta para alcançá-la.

Cada nível de recursão usa 24B de espaço na pilha (2 pushs e o endereço de retorno pressionado por CALL). Qualquer outra profundidade pagará putcharcom a pilha alinhada apenas por 8, e não 16, portanto isso viola a ABI. Uma implementação stdio que usasse armazenamentos alinhados para derramar registros xmm na pilha falharia. Mas o glibc putcharnão faz isso, gravando em um pipe com buffer completo ou gravando em um terminal com buffer de linha. Testado no Ubuntu 15.10. Isso pode ser corrigido com um push / pop fictício no .loop, para compensar a pilha em mais 8 antes da chamada recursiva.

Prova de que imprime o número certo de novas linhas:

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

Minha primeira versão disso foi 43B e usada puts()em um buffer de 9 novas linhas (e um byte final de 0), portanto, o put acrescentaria o décimo. Esse caso base de recursão foi ainda mais próximo da inspiração em C.

Fatorar 10 ^ 100 de uma maneira diferente pode ter reduzido o buffer, talvez até 4 novas linhas, economizando 5 bytes, mas o uso de putchar é de longe o melhor. Ele só precisa de um argumento inteiro, não um ponteiro e nenhum buffer. O padrão C permite implementações para as quais é uma macro putc(val, stdout), mas na glibc existe como uma função real que você pode chamar do asm.

Imprimir apenas uma nova linha por chamada em vez de 10 significa apenas que precisamos aumentar a profundidade máxima da recursão em 1, para obter outro fator de 10 novas linhas. Como 99 e 100 podem ser representados por um imediato de 8 bits com extensão de sinal, push 100ainda há apenas 2 bytes.

Melhor ainda, ter 10um registro funciona como uma nova linha e um contador de loop, economizando um byte.

Ideias para salvar bytes

Uma versão de 32 bits pode salvar um byte para o dec edi, mas a convenção de chamada stack-args (para funções de biblioteca como putchar) faz com que a chamada de cauda funcione com menos facilidade e provavelmente exigiria mais bytes em mais locais. Eu poderia usar uma convenção register-arg para o privado f(), apenas chamado por g(), mas não poderia chamar putchar (porque f () e putchar () levariam um número diferente de stack-args).

Seria possível ter f () preservar o estado do chamador, em vez de salvar / restaurar o chamador. Isso provavelmente é péssimo, porque provavelmente precisaria ficar separadamente em cada lado do galho e não é compatível com o chamado. Eu tentei, mas não encontrei nenhuma economia.

Manter um contador de loop na pilha (em vez de empurrar / colocar rcx no loop) também não ajudou. Foi 1B pior com a versão que usou puts, e provavelmente ainda mais com esta versão que configura o rcx mais barato.

PHP, 44 bytes

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

Esse snippet produzirá 1tempos de googol. Não ficará sem memória, mas é terrivelmente lento. Estou usando o BCMath para poder lidar com números inteiros longos.

Um desempenho um pouco melhor, mas não tão pequeno (74 bytes):

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

Irá gerar a letra agoogol times. Ele consumirá quase 4 GB de memória, produzindo cerca de 4e9 caracteres por vez.

Haskell, 45 43 bytes

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

Pyke, 6 5 bytes

TTX^V

Experimente aqui!

Não testado, pois trava meu navegador. Os 4 primeiros caracteres geram 10 ^ 100 e Vimprimem muitas novas linhas. Teste com 100V.

Raquete 36 bytes

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

Resultado:

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

JAISBaL , 4 bytes

˖Q

O Chrome não consegue ler todos os símbolos e não tenho certeza sobre outros navegadores, então aqui está uma figura:

Explicação:

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

Bastante simples .... apenas imprime um espaço googol Três instruções, mas a constante googol é de dois bytes.

(Escrito na versão 3.0.5)

JavaScript ES6, 85 83 bytes

Economizou 2 bytes graças ao ETHproductions!

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

Isso imprime 1e100 novas linhas.

A parte interna gera esse programa, que é posteriormente avaliado.

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

Agora, para uma prova de correção, usaremos alguma indução. Vamos substituir a inicial 100 para outros valores, genericamente N . I afirmam que a inserção de N irá produzir 10 ^N novas linhas. Vamos canalizar o resultado disso para wc -l, que conta o número de novas linhas na entrada. Usaremos esse script modificado, mas equivalente, que recebe a entrada N :

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

Agora, aqui estão alguns resultados:

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 isso transforma a entrada N para valores pequenos em 10 ^N novas linhas.

Aqui está um exemplo de saída 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,]

Resultado:

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

Fortran 95, de forma livre, recursivo, 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 um googol de linhas contendo

          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     

Chamar recursivamente 100 loops aninhados, a cada 10 iterações, cria exatamente um googol. N, L e os contadores de loop se encaixam em números inteiros do tamanho de bytes.

Testado substituindo 99 por 1, 2, 3, 4, 5 e observando que, em cada caso, a contagem de linhas resultante de "wc" possui n + 1 zeros.

Fortran II, IV, 66 ou 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 um googol de novas linhas.

Todos esses programas serão executados em máquinas de 32 bits; de fato, as versões recursivas funcionariam bem em uma máquina de 16 bits. Pode-se usar menos loops na versão de força bruta executando em um Cray antigo com seus números inteiros de 60 bits. Aqui, dez loops aninhados de 2 * 10 ^ 9 dentro de um loop de 5 ^ 10 (9765625) são iguais a 10 ^ 100 no total de iterações.

Nenhuma das versões usa qualquer memória para falar que não seja o próprio código do objeto, os contadores, uma cópia da sequência de saída e, na versão recursiva, uma pilha de retorno de 100 níveis.

Verifique os fatores 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

Não sei se isso conta como a saída correta, pois possui 82 espaços à esquerda.

Eu não sei se isso respeita o limite de 4 GB, então, se não, é não competitivo e apenas para demonstração. A saída é de 1e100 bytes, pelo que deve ser deduzido da contagem de bytes da memória. A contagem final de bytes é de 82 bytes.

Aqui está uma explicação:

As primeiras 80 linhas de código são 80 estados diferentes que geram a contagem de loop de base 19 ¹6EC1BCF4688309GH806H932ADCC44EEG6DE0FE9FAHDE66DGH108C9G3623E045A0H7A95AB594CE99A .

As próximas 19 linhas de código são o estado do contador, que diminui a contagem toda vez que um caractere é impresso.

As próximas 6 linhas são o estado da impressora, que anexa um =.

Finalmente, as duas últimas linhas são o estado mais limpo, necessário para garantir que a única saída seja =====...=====. Os espaços à esquerda / à direita não contam como saída, pois são efeitos colaterais inevitáveis.

O programa então pára.

^{1 Eu fiz as contas para isso.}

Pyth, 7 bytes

Novo (Competindo)

V^T*TTG

Explicação

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

Antigos (não concorrentes) 7 bytes

*G^T*TT

Explicação

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

Python 3, 32 bytes

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

Solução 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);}}

Imprime ( x== null?: nullUma sequência que começa com [La;@algo assim) 10 ¹⁰⁰ vezes em O (para sempre).

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

Saída: 1e100 1s

Eu sei que há outra resposta Java que também é bem próxima. A mina tem um cano principal e ainda é mais curto.

Esta é a minha primeira entrada de código de golfe. Dicas apreciadas.

Pitão, 8 7 bytes

V^T100G

Ligação

A solução é testada com saída pequena, mas deve imprimir abcdefghijklmnopqrstuvwxyz1e100 vezes.

Por alguma razão, isso não pera necessário, como 31343 (Maltysen) disse .