Мне интересно видеть программы, которые не запрашивают какой-либо ввод, печатают googol копии какой-нибудь непустой строки, не меньше, не больше, а затем останавливаются. Гугол определяется как 10 ^ 100, то есть 1 с последующим ста 0 'в десятичной системе .

Пример вывода:

111111111111111111111111111111111111111111111111111111111111111111111111...

или же

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

Строка также может быть полностью составлена ​​из пробела или специальных символов. Единственное исключение из идентичных копий фиксированной строки - это то, что ваш язык каким-то образом украшает вывод, что не может быть предотвращено, но может быть тривиально отменено в скрипте-обертке, например, добавление номера строки к каждой строке. Скрипт-оболочка в таких случаях не требуется.

Вы можете предположить, что на вашем компьютере никогда не закончится время, но кроме этого ваша программа должна иметь разумную потребность в ресурсах. Кроме того, вы должны соблюдать все ограничения, которые накладывает выбранный вами язык программирования, например, вы не можете превышать максимально допустимое значение для его целочисленных типов, и ни в коем случае не требуется более 4 ГБ памяти.

Другими словами, программа должна в принципе быть тестируемой, запустив ее на вашем компьютере. Но из-за размера этого числа вы должны будете доказать, что количество копий строки, которую она выводит, равно 10 ^ 100 и что программа останавливается после этого. Остановка может быть завершением, остановкой или даже прекращением работы из-за ошибки, но если это так, ошибка не должна приводить к выводу, который не может быть легко отделен от вывода программы.

Это код-гольф , поэтому выигрывает решение с наименьшим количеством байтов.

Пример решения (C, ungolfed, 3768 байт)

#include <stdio.h>

int main() {
  int a00, a01, a02, a03, ..., a99;
  for(a00 = 0; a00 < 10; a00++)
  for(a01 = 0; a01 < 10; a01++)
  for(a02 = 0; a02 < 10; a02++)
  for(a03 = 0; a03 < 10; a03++)
  ...
  for(a99 = 0; a99 < 10; a99++)
    puts("1");
  return 0;
}

Желе , 6 4 байта

³Ȯ*¡

Это нильадная ссылка (функция без аргументов), которая печатает 10 ²⁰⁰ копий строки 100 , что означает, что она печатает 10 ¹⁰⁰ копий строки, которая состоит из 10 ¹⁰⁰ копий строки 100 .

Попробуйте онлайн!

Обратите внимание, что онлайн-переводчик сокращает вывод на 100 КБ по практическим соображениям. Код также работает как полная программа, но из-за неявного вывода эта программа печатает одну копию слишком много.

Как это устроено

³Ȯ*¡  Niladic link. No arguments.

³     Set the left argument and initial return value to 100.
 Ȯ    Print the current return value.
  *   Compute 100 ** 100 = 1e200.
   ¡  Call Ȯ 1e200 times. 

Нечеткое окто гуакамоле, 13 12 11 10 байт

9+ddpp![g] 

Объяснение:

9+ddpp![g]
9+           # push 9 and increment, giving 10
  dd         # duplicate, twice. now you have [10,10,10]
    pp       # raise a 10 to the 10th power, then raise that to the 10th again. That ends up being 10^100.
      ![ ]   # for loop, `!` sets the counter to the top of stack
        g    # prints an ASCII art goat. 

Образец козы напечатан:

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

Python, 28 байт

-1 байт благодаря Джонатану Аллану!

Python 2:

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

Python 3 (30 байт):

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

Haskell, 28 байт

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

Объединяет 10 ^ 100 копий строки "1"и печатает ее.

Brainfuck, 480 188 114 106 98 байт

Просто потому, что это нужно сделать.

Предполагает 8-битные ячейки с упаковкой. Печатает 250 ²⁵⁵ NUL байтов, что составляет 10 ¹⁰⁰ раз 10 ¹⁵⁵ раз 25 ²⁵⁵ NUL байтов.

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

Объяснение:

>>>>>> необходимо оставить немного рабочего пространства.

- производит 255.

[[->>>+<<<]------>>>-] превращает это в 255 копий значения 250, давая ленту, которая выглядит следующим образом:

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

<<<[<<<]+ перемещает указатель данных назад и завершает начальные данные:

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

Затем идет цикл: [+...-]первоначально устанавливает 1 в 2, который возвращается в 1 в конце цикла. Цикл завершается, когда тело цикла уже установлено от 2 до 1.

Теперь числа 2 250 250 250 ... 250 представляют счетчик в базе 250, причем каждое число на единицу больше цифры, которую оно представляет.

• [>>>]<<<движется полностью вправо. Поскольку каждая цифра представлена ​​ненулевым числом, это тривиально.

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-уменьшает счетчик на 1. Начиная с последней цифры: цифра уменьшается. Если это останется положительным, мы сделали. Если он обнуляется, установите его на 250 и продолжайте с цифрой раньше.

• [<<<].>>>перемещает указатель назад перед самой левой цифрой, и это хороший момент для печати байта NUL. Затем измените положение на крайнюю левую цифру, чтобы убедиться, что мы закончили.

Для проверки правильности, изменить исходные -для +напечатать 250 ¹ NUL байт, ++для 250 ² , и т.д.

C 51 байт

Функция g()вызывает рекурсивную функцию f()на глубину 99.

Исключает ненужные символы новой строки, добавленные между f()и g()для ясности.

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

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

Печать 1E100 новых строк.

Объявление в iкачестве второго параметра f()не гарантируется для работы во всех версиях C. Протестировано на моей собственной машине (GCC на CygWin) и на ideone.com (я полагаю, они также запускают GCC), но не до f (99) для очевидного причины!

Машинный код Commodore VIC 20 (40 байт)

... здесь показано как шестнадцатеричное:

1040   A9[64]A2 00 9D 68 10 E8  E0[32]D0 F8 A9 00 9D 68
1050   10 A9[31]20 D2 FF A2 00  A9[64]DE 68 10 30 08 D0
1060   F0 9D 68 10 E8 D0 F3 60

(Начало работы с помощью: SYS 4160)

Значение байтов в скобках

• 0x64 (встречается дважды) - основание (100); (значения от 2 до 127 должны работать)
• 0x32 - показатель степени (50) (любое ненулевое значение (1-255) должно работать)
• Обратите внимание, что 100 ^ 50 = 10 ^ 100; запуск программы в 100 ^ 50 раз эффективнее оперативной памяти, чем в 10 ^ 100 раз
• 0x31 - символ ASCII для печати

и ни в коем случае не нужно больше 4 ГБ памяти.

Это опечатка?

У нас есть 1981 год.

Типичный домашний компьютер имеет 1 до 16 K B ОЗУ! И вы вряд ли найдете профессиональные модели, которые имеют 1 M B или больше.

(Хорошо. Просто шутка.)

Другими словами, программа должна в принципе быть тестируемой, запустив ее на вашем компьютере. Но из-за размера этого числа вы должны будете доказать, что количество копий строки, которую она выводит, равно 10 ^ 100 и что программа останавливается после этого.

Программа была протестирована с другими базами и показателями. Я не сомневаюсь, что это также будет работать со 100 и 50.

По крайней мере, он не падает с этими числами (но также не заканчивается в измеримое время).

Объем памяти достаточен для показателя 50, а 100 меньше 127, поэтому основание 100 не должно быть проблемой.

Основная идея

Существует 50-значный счетчик, который считает в 100-системе. Байты 0x01-0x64 представляют цифры 0-99. Первый байт в счетчике является самой младшей цифрой. За последним байтом в счетчике (старшая цифра) следует байт со значением 0x00.

Счетчик имеет начальное значение 100 ^ 50.

Внешний цикл записывает байт в «текущий канал» («стандартный вывод» в современных системах; обычно это экран), а затем уменьшает счетчик.

Уменьшение выполняется внутренним циклом: он уменьшает цифру, а в случае недостаточного значения от 1 до 99 он переходит к следующей цифре. Если байт 0x00 в конце счетчика уменьшается, программа останавливается.

Код сборки

    ; Some constants
    base=10
    exponent=100
    character=0x32

    ; Initialize the content of the counter to 100^50
    ; (Fill the first 50 bytes with the value 100)
    lda  #base
    ldx  #0
initLoop:
    sta  counter,x
    inx
    cpx  #exponent
    bne  initLoop
    ; (The terminating 0 at the end of the counter)
    lda  #0
    sta  counter,x

    ; Now do the actual job
outerLoop:
    ; Output a character
    lda  #character
    jsr  (0xFFD2)
    ; Prepare for the inner loop
    ldx  #0
    lda  #base
innerLoop:
    ; Decrement one digit
    dec  counter,x
    ; Result is negative -> must have been the terminating
    ; NUL byte -> Exit
    bmi  progEnd
    ; Result is not zero -> Print the next byte
    bne  outerLoop
    ; Result is zero -> Was 0x01 before -> As 0x01 represents
    ; digit 0 this is an underflow -> set the digit to
    ; "exponent" (100) again (which represents digit 99)
    sta  counter,x
    ; Go to the next digit and...
    inx
    ; ... repeat the inner loop (decrement next digit)
    ; (Note that this conditional branch is ALWAYS taken)
    bne  innerLoop

progEnd:
    rts

counter:
    ; The memory used by the counter is here...

РЕДАКТИРОВАТЬ

Программа работает на Commodore C64 тоже!

Узел, 89 байт

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

Выходит 10 ¹⁰⁰ новых строк. (Теоретически, то есть, тест, заменив 100с 1на выходе 10 ¹ новой строки вместо этого.)

Это работает путем установки iстроки

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

(100 нулей и 1; гугол в обратном порядке), затем многократно «вычитая 1» с помощью регулярного выражения, заменяйте и выводите новую строку до тех пор, пока строка не станет нулевой.

Порт ответа C ++ будет 49 байтов:

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

05AB1E , 6 байтов

Tn°F1?

объяснение

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

Рубин, 20 байтов

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

Печать 1 с последующим переводом строки 1E100 раз.

1E100 не работает, так как вычисляет с плавающей точкой, а не с произвольным целым числом точности.

/// , 36 символов ASCII (4 разных)

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

Выводит .символ 3 * 10 ^ 125 раз, это означает, что он выводит строку, состоящую из 3 * 10 ^ 25 повторений .символа, 10 ^ 100 раз.

Объяснение:

1. /t./.ttttt/: Заменить t.на .tttttвсю оставшуюся программу, повторяя до тех пор, пока не t.останется ни одного экземпляра . Это заменяет t...с ...последующим 125 tс.
2. /.t/t\........../: Заменить .tна t..........всю оставшуюся программу, повторяя до тех пор, пока не .tостанется ни одного экземпляра . Это берет ...последующие 125 tс и превращает их в 125 tс, за которыми следуют 10 ^ 125 вхождений ....
3. /t//: Удалить все оставшиеся ts.
4. t...: Это заменяется на 3 * 10 ^ 125 .с. Выведите их.

Теперь, вывод 10 ^ 100 повторений 3 * 10 ^ 25 повторений чего-то вроде чувства обмана. Эта программа выводит .символ ровно 10 ^ 100 раз, используя 45 символов ASCII:

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

Объяснение этого:

1. /T/tttttttttt/: Заменить Tна ttttttttttвсю оставшуюся программу. Это заменяет TTTTTTTTTT100 повторений t.
2. /.t/t........../: Заменить .tна t..........всю оставшуюся программу. Это берет .100 tсекунд, и превращает его в 100 tсекунд, а затем 10 ^ 100 .секунд.
3. /t//: Удалить все оставшиеся ts.
4. .TTTTTTTTTT: Это заменяется на 10 ^ 100 .с. Выведите их.

Наконец, вот компромиссная программа, которая выводит .символ 2 * 10 ^ 100 раз, используя 40 символов:

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

Befunge 93, 33 байта

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

К сожалению, в Befunge нет функции power, поэтому почти весь этот код является моей реализацией функции power. Я все еще работаю над этим.

Объяснение:

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

1: Начните с 1левого верхнего угла, чтобы при умножении мы не получали 0каждый раз.

01g: получить символ в позиции (0, 1), то есть d, чей код ASCII равен 100.

0`: посмотреть, больше ли значение, хранящееся в (0, 1), больше 0; это значение изменится.

#@!# _Логически не !соответствует значению, которое мы получаем из последнего шага (0 или 1), так что если это было 1, теперь у нас есть 0, и мы отмечаем, что это #означает, что вы пропускаете следующий символ в коде.

01g 1- 01p: Возьмите значение, сохраненное в (0, 1) снова, вычтите 1 из него и сохраните это новое значение в (0, 1)

25**: умножить верхнее значение стека на 10

1.: печатать 1каждый раз, когда этот цикл

1 печатается (в теории) времена гугл, но это быстро уходит со страницы, на которой я это проверял.

Вы можете запустить код Befunge 93 здесь . По какой-то причине верхнее значение стека - 1.0000000000000006e+100это когда оно должно быть 1.0e+100. Я не знаю, откуда это 6взялось, но я не думаю, что это должно быть там, и что это может быть какая-то ошибка округления или что-то в этом роде.

ABCR , 56 байт

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

Тарпинги Тьюринга - это весело, особенно когда у них нет простого умножения или показателей. С другой стороны, мне нужно было использовать только две из трех очередей!

Объяснение:

++++++++++                                             Set register to 10
          AAAAAAAAAA                                   Queue 10 to queue A 10 times
                    7a*A!(x                            Sum up all of queue A by:
                    7     x                             While the register is truthy:
                     a*                                 Dequeue two elements of A, sum them...
                       A                                ...and queue the result back to A.
                        !(                              If there's only one element left,
                                                        i.e. !(A.len - 1),
                                                        break from the loop.  A now has 100, our exponent.

                             4                        While A's front is truthy:
                              bBBBBBBBBBB              Clone the front of B 10 (our base) times.  (The first iteration fills it up with ten 1s)
                                         7b+B@(x       Sum up all of queue B like we did with A
                                                a(A    Decrement a (so that the loop actually ends. Runs 101 times like it should) x   

                                                       B now contains 10^100 only.

                                                   5b(B x   10^100 times:
                                                       o     print the front of queue A (0)

Пакетный, 574 242 байта

@echo off
set t=for /l %%a in (2,1,33554432)do call:
set f=for /l %%a in (2,1,9765625)do call:
%t%a
:a
%t%b
:b
%t%c
:c
%t%d
:d
%f%e
:e
%f%f
:f
%f%g
:g
%f%h
:h
%f%i
:i
%f%j
:j
%f%k
:k
%f%l
:l
%f%m
:m
%f%n
:n
echo

Каждый цикл проваливается, поэтому выполняется дополнительная итерация. Циклы ограничены ~ 2³² из-за ограничения 32-битного целого числа. Первые четыре цикла каждый насчитывают 2 ⁵, в общей сложности 2 ¹⁰⁰, а остальные десять циклов каждый считают 5 ¹⁰ в общей сложности 5 ¹⁰⁰.

Редактировать: сэкономил невообразимые 58% благодаря @ ConorO'Brien.

TI-Basic, 20 байтов

Непосредственная. Только восемь строк отображаются одновременно, а предыдущие строки не остаются в памяти. Поскольку ᴇ100это не поддерживается, мы должны выполнить цикл от -ᴇ99до 9ᴇ99. Затем, если I!=0, отобразить строку (которая, кстати, 3). Таким образом, мы печатаем это точно ᴇ100раз.

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

Функция машинного кода x86-64, 30 байтов.

Использует ту же логику рекурсии как ответ С помощью @Level River St . (Макс. Глубина рекурсии = 100)

Использует puts(3)функцию из libc, с которой все равно связаны обычные исполняемые файлы. Он вызывается с помощью x86-64 System V ABI, то есть из C на Linux или OS X, и не сжимает никакие регистры, к которым он не должен.

objdump -drwC -Mintel вывод, прокомментированный с объяснением

0000000000400340 <g>:  ## wrapper function
  400340:       6a 64                   push   0x64
  400342:       5f                      pop    rdi       ; mov edi, 100  in 3 bytes instead of 5
  ; tailcall f by falling into it.

0000000000400343 <f>:  ## the recursive function
  400343:       ff cf                   dec    edi
  400345:       97                      xchg   edi,eax
  400346:       6a 0a                   push   0xa
  400348:       5f                      pop    rdi       ; mov edi, 10
  400349:       0f 8c d1 ff ff ff       jl     400320 <putchar>   # conditional tailcall
; if we don't tailcall, then eax=--n = arg for next recursion depth, and edi = 10 = '\n'

  40034f:       89 f9                   mov    ecx,edi   ; loop count = the ASCII code for newline; saves us one byte


0000000000400351 <f.loop>:
  400351:       50                      push   rax       ; save local state
  400352:       51                      push   rcx
  400353:       97                      xchg   edi,eax   ; arg goes in rdi
  400354:       e8 ea ff ff ff          call   400343 <f>
  400359:       59                      pop    rcx       ; and restore it after recursing
  40035a:       58                      pop    rax
  40035b:       e2 f4                   loop   400351 <f.loop>
  40035d:       c3                      ret    
# the function ends here

000000000040035e <_start>:

0x040035e - 0x0400340 = 30 bytes

# not counted: a caller that passes argc-1 to f() instead of calling g
000000000040035e <_start>:
  40035e:       8b 3c 24                mov    edi,DWORD PTR [rsp]
  400361:       ff cf                   dec    edi
  400363:       e8 db ff ff ff          call   400343 <f>
  400368:       e8 c3 ff ff ff          call   400330 <exit@plt>    # flush I/O buffers, which the _exit system call (eax=60) doesn't do.

Построен с yasm -felf64 -Worphan-labels -gdwarf2 golf-googol.asm && gcc -nostartfiles -o golf-googol golf-googol.o . Я могу опубликовать исходный исходный код NASM, но это выглядело как беспорядок, так как инструкции asm прямо в разборке.

putchar@pltна расстоянии менее 128 байт от jl, поэтому я мог бы использовать 2-байтовый короткий переход вместо 6-байтового ближнего перехода, но это верно только для крошечного исполняемого файла, а не как часть более крупной программы. Так что я не думаю, что смогу оправдать не считая размер реализации пут в libc, если я также воспользуюсь короткой jcc-кодировкой для ее достижения.

Каждый уровень рекурсии использует 24B стекового пространства (2 нажатия и адрес возврата, передаваемый CALL). Любая другая глубина будет вызывать putcharсо стеком, выровненным только на 8, а не на 16, так что это нарушает ABI. Реализация stdio, которая использовала выровненные хранилища для раздачи регистров xmm в стек, может привести к сбою. Но glibc putcharне делает этого: запись в канал с полной буферизацией или запись в терминал с линейной буферизацией. Проверено на Ubuntu 15.10. Это можно исправить с помощью фиктивного push / pop в .loop, чтобы сместить стек еще на 8 перед рекурсивным вызовом.

Доказательство того, что оно печатает правильное количество строк:

   # with a version that uses argc-1  (i.e. the shell's $i)  instead of a fixed 100
$ for i in {0..8}; do echo -n "$i: "; ./golf-googol $(seq $i) |wc -c; done
0: 1
1: 10
2: 100
3: 1000
4: 10000
5: 100000
6: 1000000
7: 10000000
8: 100000000
... output = 10^n newlines every time.

Моя первая версия этого была 43B и использовалась puts()в буфере из 9 символов новой строки (и завершающего 0 байт), поэтому путы добавляли бы 10-й. Этот базовый вариант рекурсии был еще ближе к вдохновению Си.

Факторизация 10 ^ 100 другим способом могла бы сократить буфер, возможно, до 4 новых строк, сэкономив 5 байтов, но использование putchar намного лучше. Для этого требуется только целочисленный аргумент arg, а не указатель и вообще никакого буфера. Стандарт C допускает реализации, для которых это макрос putc(val, stdout), но в glibc он существует как реальная функция, которую вы можете вызвать из asm.

Печать только одной новой строки за вызов вместо 10 означает, что нам нужно увеличить максимальную глубину рекурсии на 1, чтобы получить еще один коэффициент - 10 новых строк. Поскольку 99 и 100 могут быть представлены как расширенные знаком 8-битные значения, они push 100по-прежнему составляют только 2 байта.

Более того, наличие 10в регистре работает как символ новой строки и счетчик цикла, сохраняя байт.

Идеи для сохранения байтов

32-битная версия может сохранить байт для dec edi, но соглашение о вызове стековых аргументов (для библиотечных функций, таких как putchar) упрощает работу хвостового вызова и, вероятно, потребует больше байтов в большем количестве мест. Я мог бы использовать соглашение о регистрации-аргументе для частного f(), только вызываемого g(), но тогда я не мог выполнить хвостовой вызов putchar (потому что f () и putchar () принимали бы различное количество аргументов стека).

Было бы возможно, чтобы f () сохранял состояние вызывающего, вместо того, чтобы делать сохранение / восстановление в вызывающем. Это, вероятно, отстой, потому что, вероятно, нужно было бы получать по отдельности в каждой стороне ветви, и не совместим с вызовами хвоста. Я попробовал, но не нашел сбережений.

Хранение счетчика цикла в стеке (вместо push / popping rcx в цикле) также не помогло. Это было на 1B хуже с версией, которая использовала путы, и, вероятно, еще больше потерь с этой версией, которая устанавливает rcx дешевле.

PHP, 44 байта

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

Этот фрагмент будет выводить 1время googol. Это не исчерпает память, но это ужасно медленно. Я использую BCMath, чтобы иметь возможность обрабатывать длинные целые числа.

Немного лучше, но не так мало (74 байта):

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

Будет выводить письмо aраз Googol. Он будет занимать почти 4 ГБ памяти, выводя около 4e9 символов за раз.

Haskell, 45 43 байта

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

Пайк, 6 5 байт

TTX^V

Попробуй это здесь!

Не проверено, как он вылетает из моего браузера. Первые 4 символа генерируют 10 ^ 100 и Vвыводят столько строк перевода. Тест с 100V.

Ракетка 36 байтов

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

Выход:

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

JAISBaL , 4 байта

˖Q

Chrome не может прочитать все символы, и я не уверен насчет других браузеров, так что вот картинка:

Объяснение:

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

Довольно просто .... просто печатает гугл пробелы. Три инструкции, но константа googol составляет два байта.

(Написано в версии 3.0.5)

JavaScript ES6, 85 83 байта

Сохранено 2 байта благодаря ETHproductions!

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

Это печатает 1e100 новых строк.

Внутренняя часть генерирует эту программу, которая затем оценивается.

for($0=0;$0++<10;)for($1=0;$1++<10;)for($2=0;$2++<10;)for($3=0;$3++<10;)for($4=0;$4++<10;)for($5=0;$5++<10;)for($6=0;$6++<10;)for($7=0;$7++<10;)for($8=0;$8++<10;)for($9=0;$9++<10;)for($10=0;$10++<10;)for($11=0;$11++<10;)for($12=0;$12++<10;)for($13=0;$13++<10;)for($14=0;$14++<10;)for($15=0;$15++<10;)for($16=0;$16++<10;)for($17=0;$17++<10;)for($18=0;$18++<10;)for($19=0;$19++<10;)for($20=0;$20++<10;)for($21=0;$21++<10;)for($22=0;$22++<10;)for($23=0;$23++<10;)for($24=0;$24++<10;)for($25=0;$25++<10;)for($26=0;$26++<10;)for($27=0;$27++<10;)for($28=0;$28++<10;)for($29=0;$29++<10;)for($30=0;$30++<10;)for($31=0;$31++<10;)for($32=0;$32++<10;)for($33=0;$33++<10;)for($34=0;$34++<10;)for($35=0;$35++<10;)for($36=0;$36++<10;)for($37=0;$37++<10;)for($38=0;$38++<10;)for($39=0;$39++<10;)for($40=0;$40++<10;)for($41=0;$41++<10;)for($42=0;$42++<10;)for($43=0;$43++<10;)for($44=0;$44++<10;)for($45=0;$45++<10;)for($46=0;$46++<10;)for($47=0;$47++<10;)for($48=0;$48++<10;)for($49=0;$49++<10;)for($50=0;$50++<10;)for($51=0;$51++<10;)for($52=0;$52++<10;)for($53=0;$53++<10;)for($54=0;$54++<10;)for($55=0;$55++<10;)for($56=0;$56++<10;)for($57=0;$57++<10;)for($58=0;$58++<10;)for($59=0;$59++<10;)for($60=0;$60++<10;)for($61=0;$61++<10;)for($62=0;$62++<10;)for($63=0;$63++<10;)for($64=0;$64++<10;)for($65=0;$65++<10;)for($66=0;$66++<10;)for($67=0;$67++<10;)for($68=0;$68++<10;)for($69=0;$69++<10;)for($70=0;$70++<10;)for($71=0;$71++<10;)for($72=0;$72++<10;)for($73=0;$73++<10;)for($74=0;$74++<10;)for($75=0;$75++<10;)for($76=0;$76++<10;)for($77=0;$77++<10;)for($78=0;$78++<10;)for($79=0;$79++<10;)for($80=0;$80++<10;)for($81=0;$81++<10;)for($82=0;$82++<10;)for($83=0;$83++<10;)for($84=0;$84++<10;)for($85=0;$85++<10;)for($86=0;$86++<10;)for($87=0;$87++<10;)for($88=0;$88++<10;)for($89=0;$89++<10;)for($90=0;$90++<10;)for($91=0;$91++<10;)for($92=0;$92++<10;)for($93=0;$93++<10;)for($94=0;$94++<10;)for($95=0;$95++<10;)for($96=0;$96++<10;)for($97=0;$97++<10;)for($98=0;$98++<10;)for($99=0;$99++<10;)console.log()

Теперь, для доказательства правильности, мы будем использовать некоторую индукцию. Подставим начальные 100 для других значений, в общем N . Я утверждаю, что вставка N даст 10 ^N новых строк. Давайте передадим результат этому wc -l, который подсчитывает количество новых строк во входных данных. Мы будем использовать этот модифицированный, но эквивалентный скрипт, который принимает ввод N :

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

Теперь вот некоторые результаты:

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 1 | wc -l
10

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 2 | wc -l
100

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 3 | wc -l
1000

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 4 | wc -l
10000

Мы можем видеть, что это преобразует вход N для небольших значений в 10 ^N строк.

Вот пример вывода для N = 1:

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











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

Mathematica, 48 30 25 байтов

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

Выход:

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

Фортран 95, произвольной формы, рекурсивный, 117 байт

Program M
Call R(99)
END
Recursive Subroutine R(L)
IF(L)3,1,1
1 DO 2 I=1,10
2 Call R(L-1)
RETURN
3 PRINT*,0
END

Печатает гугол строк, содержащих

          0

Фортран 90, Рекурсивный, 149 байт

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

Рекурсивный вызов 100 вложенных циклов, каждые 10 итераций, дает ровно один гугол. N, L и счетчики циклов помещаются в целые байтовые числа.

Протестировано заменой 99 на 1, 2, 3, 4, 5 и отмечением, что в каждом случае результирующий счетчик строк из "wc" имеет n + 1 нулей.

Fortran II, IV, 66 или 77, 231 байт:

      N=2*10**9
      DO1I0=1,5**10
      DO1I=1,N
      DO1J=1,N
      DO1K=1,N
      DO1L=1,N
      DO1M=1,N
      DO1I1=1,N
      DO1J1=1,N
      DO1K1=1,N
      DO1L1=1,N
      DO1M1=1,N
1     PRINT2
2     FORMAT(X)
      END

Печатает гугол новых строк.

Все эти программы будут работать на 32-битных машинах; на самом деле, рекурсивные версии будут отлично работать на 16-битной машине. Можно использовать меньше циклов в версии с перебором, запустив старый Cray с его 60-битными целыми числами. Здесь десять вложенных циклов 2 * 10 ^ 9 внутри одного цикла 5 ^ 10 (9765625) равняется 10 ^ 100 полных итераций.

Ни одна из версий не использует какую-либо память, кроме самого объектного кода, счетчиков, одной копии выходной строки и, в рекурсивной версии, стек возврата на 100 уровней.

Проверьте факторы, сравнивая

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

Симулятор машины Тьюринга, 1082 байта

0 * 6 r 1
1 * E r 2
2 * C r 3
3 * 1 r 4
4 * B r 5
5 * C r 6
6 * F r 7
7 * 4 r 8
8 * 6 r 9
9 * 8 r A
A * 8 r B
B * 3 r C
C * 0 r D
D * 9 r E
E * G r F
F * H r G
G * 8 r H
H * 0 r I
I * 6 r J
J * H r K
K * 9 r L
L * 3 r M
M * 2 r N
N * A r O
O * D r P
P * C r Q
Q * C r R
R * 4 r S
S * 4 r T
T * E r U
U * E r V
V * G r W
W * 6 r X
X * D r Y
Y * E r Z
Z * 0 r a
a * F r b
b * E r c
c * 9 r d
d * F r e
e * A r f
f * H r g
g * D r h
h * E r i
i * 6 r j
j * 6 r k
k * D r l
l * G r m
m * H r n
n * 1 r o
o * 0 r p
p * 8 r q
q * C r r
r * 9 r s
s * G r t
t * 3 r u
u * 6 r v
v * 2 r w
w * 3 r x
x * E r y
y * 0 r z
z * 4 r +
+ * 5 r /
/ * A r =
= * 0 r -
- * H r \
\ * 7 r !
! * A r @
@ * 9 r #
# * 5 r $
$ * A r %
% * B r ^
^ * 5 r &
& * 9 r ?
? * 4 r (
( * C r )
) * E r `
` * 9 r ~
~ * 9 r _
_ * A * .
. 0 I l *
. 1 0 r <
. 2 1 r <
. 3 2 r <
. 4 3 r <
. 5 4 r <
. 6 5 r <
. 7 6 r <
. 8 7 r <
. 9 8 r <
. A 9 r <
. B A r <
. C B r <
. D C r <
. E D r <
. F E r <
. G F r <
. H G r <
. I H r <
. _ * r ]
< _ * r >
< * * r *
> _ = l [
> * * r *
[ _ * l .
[ * * l *
] _ * * halt
] * _ r *

Симулятор машины Тьюринга

Я не знаю, считается ли это правильным выводом, поскольку в нем 82 начальных пробела.

Я не знаю, учитывает ли это ограничение в 4 ГБ, поэтому, если это не так, то это неконкурентоспособно и просто для демонстрации. Выход составляет 1e100 байт, поэтому его следует вычесть из числа байтов памяти. Окончательный счетчик байтов составляет 82 байта.

Вот объяснение:

Первые 80 строк кода представляют собой 80 различных состояний, которые генерируют счетчик циклов base-19 ¹6EC1BCF4688309GH806H932ADCC44EEG6DE0FE9FAHDE66DGH108C9G3623E045A0H7A95AB594CE99A .

Следующие 19 строк кода представляют собой состояние счетчика, которое уменьшает счетчик каждый раз, когда печатается символ.

Следующие 6 строк - это состояние принтера, к которому добавляется =.

Наконец, последние 2 строки являются более чистым состоянием, которое необходимо, чтобы убедиться, что единственный выход =====...=====. Начальные / конечные пробелы не считаются выходными данными, поскольку они являются неизбежными побочными эффектами.

Затем программа останавливается.

^{1 Я сделал математику для этого.}

Pyth, 7 байт

Новый (Конкурирующий)

V^T*TTG

объяснение

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

Старый (неконкурентный) 7 байт

*G^T*TT

объяснение

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

Python 3, 32 байта

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

Альтернативный раствор, 33 байта:

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

Ява, 198 179 155 байт

import java.math.*;class a{void A(a[]x){for(BigInteger b=BigInteger.ZERO;!(b=b.add(BigInteger.ONE)).equals(BigInteger.TEN.pow(100));)System.out.print(x);}}

Печатает ( x== null?: nullСтроку, которая начинается с [La;@или что-то в этом роде) 10 ¹⁰⁰ раз за O (навсегда) время.

Java, 153 байта

import java.math.*;interface M{static void main(String[]a){for(BigInteger i=BigInteger.ZERO;!i.add(i.ONE).equals(i.TEN.pow(100));)System.out.print(1);}}

Выход: 1е100 1с

Я знаю, что есть другой ответ на Java, который также довольно близок. У меня есть основной и все еще короче, хотя.

Это моя первая запись в гольф. Советы приветствуются.

Pyth, 8 7 байтов

V^T100G

Ссылка

Решение протестировано с небольшим выходом, но оно должно печатать abcdefghijklmnopqrstuvwxyz1e100 раз.

По какой - то причине pбыл не нужен, а 31343 (Maltysen) сказал .