Interesuje mnie widok programów, które nie proszą o żadne dane wejściowe, wypisują kopie googolów jakiegoś niepustego łańcucha, nie mniej, nie więcej, a potem się zatrzymują. Googol definiuje się jako 10 ^ 100, to znaczy 1, a następnie przez sto 0 jest w systemie dziesiętnym.

Przykładowe dane wyjściowe:

111111111111111111111111111111111111111111111111111111111111111111111111...

lub

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

Sznurek może również w całości składać się z białych znaków lub specjalnych symboli. Jedynym wyjątkiem od identycznych kopii stałego ciągu jest to, że Twój język zdobi dane wyjściowe w taki sposób, że nie można temu zapobiec, ale można je w trywialny sposób cofnąć w skrypcie opakowania, na przykład przygotowując numer linii do każdej linii. Skrypt opakowania w takich przypadkach nie musi być dostarczony.

Możesz założyć, że na twoim komputerze nigdy nie zabraknie czasu, ale poza tym twój program musi mieć rozsądne zapotrzebowanie na zasoby. Ponadto należy przestrzegać wszelkich ograniczeń, jakie stawia wybrany przez siebie język programowania, na przykład nie można przekroczyć maksymalnej dopuszczalnej wartości dla jego typów liczb całkowitych, aw żadnym momencie nie potrzeba więcej niż 4 GB pamięci.

Innymi słowy, program powinien w zasadzie być testowalny, uruchamiając go na komputerze. Ale ze względu na zasięg tej liczby będziesz musiał udowodnić, że liczba kopii łańcucha, który wysyła, wynosi dokładnie 10 ^ 100, a program zatrzymuje się później. Zatrzymanie może być zakończeniem lub zatrzymaniem, a nawet zakończeniem z powodu błędu, ale jeśli tak, błąd nie może generować żadnych danych wyjściowych, których nie można łatwo oddzielić od danych wyjściowych programu.

To jest golf golfowy , więc wygrywa rozwiązanie z najmniejszą liczbą bajtów.

Przykładowe rozwiązanie (C, bez golfa, 3768 bajtów)

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

Galaretka , 6 4 bajtów

³Ȯ*¡

Jest to łącze niladyczne (funkcja bez argumentów), które drukuje 10 ²⁰⁰ kopii ciągu 100 , co oznacza, że ​​drukuje 10 ¹⁰⁰ kopii ciągu, który składa się z 10 ¹⁰⁰ kopii ciągu 100 .

Wypróbuj online!

Należy pamiętać, że ze względów praktycznych interpreter online ogranicza dane wyjściowe do 100 KB. Kod działa również jako pełny program, ale z powodu niejawnego wyniku program ten drukuje jedną kopię za dużo.

Jak to działa

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

Rozmyte Octo Guacamole, 13 12 11 10 bajtów

9+ddpp![g] 

Wyjaśnienie:

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. 

Wydrukowano próbkę kozy:

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

Python, 28 bajtów

-1 bajt dzięki Jonathan Allan!

Python 2:

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

Python 3 (30 bajtów):

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

Haskell, 28 bajtów

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

Łączy 10 ^ 100 kopii ciągu "1"i drukuje go.

Brainfuck, 480 188 114 106 98 bajtów

Tylko dlatego, że trzeba to zrobić.

Zakłada 8-bitowe komórki z zawijaniem. Drukuje 250 ²⁵⁵ bajtów NUL, czyli 10 ¹⁰⁰ razy 10 ¹⁵⁵ razy 25 ²⁵⁵ bajtów NUL.

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

Wyjaśnienie:

>>>>>> jest potrzebne, aby zostawić trochę miejsca do pracy.

- produkuje 255.

[[->>>+<<<]------>>>-] zamienia to w 255 kopii o wartości 250, dając taśmę, która wygląda następująco:

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

<<<[<<<]+ przesuwa wskaźnik danych z powrotem i kończy początkowe dane:

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

Potem pojawia się pętla: [+...-]początkowo ustawia 1 na 2, która zostaje ustawiona z powrotem na 1 na końcu pętli. Pętla kończy się, gdy korpus pętli jest już ustawiony na 2 na 1.

Teraz liczby 2 250 250 250 ... 250 reprezentują licznik w bazie 250, przy czym każda liczba jest większa od cyfry, którą reprezentuje.

• [>>>]<<<przesuwa się maksymalnie w prawo. Ponieważ każda cyfra jest reprezentowana przez liczbę niezerową, jest to trywialne.

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-zmniejsza licznik o 1. Począwszy od ostatniej cyfry: cyfra ulega zmniejszeniu. Jeśli pozostanie pozytywny, skończymy. Jeśli zmieni się na zero, ustaw go na 250 i kontynuuj od poprzedniej cyfry.

• [<<<].>>>przesuwa wskaźnik z powrotem przed najbardziej lewą cyfrą, i jest to dobry moment na wydrukowanie bajtu NUL. Następnie zmień położenie dokładnie na lewą cyfrę, aby zobaczyć, czy skończyliśmy.

Aby zweryfikować poprawność, zmień wartość początkową -na +drukującą 250 ¹ NUL bajtów, ++dla 250 ² itd.

C, 51 bajtów

Funkcja g()wywołuje funkcję rekurencyjną f()na głębokość 99.

Nie obejmuje niepotrzebnego nowego wiersza dodanego pomiędzy f()i g()dla jasności.

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

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

Drukuje nowe linie 1E100.

Deklaracja ijako drugiego parametru f()nie gwarantowanego działania we wszystkich wersjach C. Testowana na mojej własnej maszynie (GCC na CygWin) i na ideone.com (myślę, że one również działają GCC), ale oczywiście nie do f (99) powody!

Kod maszynowy Commodore VIC 20 (40 bajtów)

... tutaj pokazany jako szesnastkowy:

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

(Kroki z: SYS 4160)

Znaczenie bajtów w nawiasach

• 0x64 (występuje dwukrotnie) jest podstawą (100); (wartości od 2 do 127 powinny działać)
• 0x32 jest wykładnikiem wykładni (50) (każda niezerowa wartość (1-255) powinna działać)
• Zauważ, że 100 ^ 50 = 10 ^ 100; uruchomienie programu 100 ^ 50 razy jest bardziej wydajne RAM niż robienie tego 10 ^ 100 razy
• 0x31 to znak ASCII do wydrukowania

i w żadnym punkcie nie więcej niż 4 G muszą być wymagane B pamięci.

Czy to błąd w pisaniu na klawiaturze?

Mamy rok 1981.

Typowy komputer domowy ma od 1 do 16 KB pamięci RAM! I prawie nie znajdziesz profesjonalnych modeli, które mają 1 M B lub więcej.

(Ok. Tylko żart.)

Innymi słowy, program powinien w zasadzie być testowalny, uruchamiając go na komputerze. Ale ze względu na zasięg tej liczby będziesz musiał udowodnić, że liczba kopii łańcucha, który wysyła, wynosi dokładnie 10 ^ 100, a program zatrzymuje się później.

Program został przetestowany z innymi bazami i wykładnikami. Nie mam wątpliwości, że będzie działać również ze 100 i 50.

Przynajmniej nie ulega awarii z tymi liczbami (ale nie kończy się również w mierzalnym czasie).

Rozmiar pamięci jest wystarczający dla wykładnika 50, a 100 jest mniejszy niż 127, więc podstawa 100 nie powinna stanowić problemu.

Podstawowy pomysł

Istnieje 50-cyfrowy licznik, który liczy się w systemie 100. Bajty 0x01-0x64 reprezentują cyfry 0–99. Pierwszy bajt w liczniku jest najniższą cyfrą. Po ostatnim bajcie w liczniku (najwyższa cyfra) następuje bajt o wartości 0x00.

Licznik ma wartość początkową 100 ^ 50.

Zewnętrzna pętla zapisuje bajt do „kanału bieżącego” („standardowe wyjście” w nowoczesnych systemach; zazwyczaj ekran), a następnie zmniejsza licznik.

Zmniejszanie odbywa się za pomocą wewnętrznej pętli: Zmniejsza cyfrę, aw przypadku niedomiaru od 1 do 99 przesuwa się do następnej cyfry. Jeżeli bajt 0x00 na końcu licznika jest zmniejszany, program zatrzymuje się.

Kod zestawu to

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

EDYTOWAĆ

Program działa również na Commodore C64!

Węzeł, 89 bajtów

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

Wyprowadza 10 ¹⁰⁰ nowych linii. (Teoretycznie, to znaczy, test zastępując 100z 1wyjściowe 10 ¹ nowe linie zamiast).

Działa to poprzez ustawienie ina ciąg

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

(100 zer i 1; googol odwrócony), a następnie kilkakrotnie „odejmowanie 1” z wyrażeniem regularnym zamienia i wypisuje znak nowej linii, aż wszystkie zera będą ciągiem zerowym.

Port odpowiedzi C ++ miałby 49 bajtów:

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

05AB1E , 6 bajtów

Tn°F1?

Wyjaśnienie

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

Ruby, 20 bajtów

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

Drukuje 1, a następnie nowy wiersz 1E100 razy.

1E100 nie działa, ponieważ jest liczbą zmiennoprzecinkową, a nie liczbą całkowitą o dowolnej precyzji.

/// , 36 znaków ASCII (4 różne)

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

Wysyła .znak 3 * 10 ^ 125 razy, co oznacza, że ​​wysyła ciąg składający się z 3 * 10 ^ 25 powtórzeń .znaku, 10 ^ 100 razy.

Wyjaśnienie:

1. /t./.ttttt/Wymienić t.z .tttttcałej pozostałej części programu, powtarzając aż żadne przypadki t.pozostają. Zastępuje t...się ...następnie przez 125 ts.
2. /.t/t\........../Wymienić .tz t..........całej pozostałej części programu, powtarzając aż żadne przypadki .tpozostają. Zajmuje to ...następujące po nich 125 ts, i zamienia je w 125 ts, po których następuje 10 ^ 125 wystąpień ....
3. /t//: Usuń wszystkie pozostałe ts.
4. t...: Zostaje zastąpione przez 3 * 10 ^ 125 .s. Wyjmij je.

Teraz generowanie 10 ^ 100 powtórzeń 3 * 10 ^ 25 powtórzeń czegoś w rodzaju czucia się jak oszustwo. Ten program wypisuje .znak dokładnie 10 ^ 100 razy, używając 45 znaków ASCII:

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

Wyjaśnienie tego:

1. /T/tttttttttt/Wymienić Tz ttttttttttcałej pozostałej części programu. Zastępuje to TTTTTTTTTT100 powtórzeniami t.
2. /.t/t........../Wymienić .tz t..........całej pozostałej części programu. To zajmuje .następne 100 tsekund i zamienia je w 100 tsekund, a następnie 10 ^ 100 .sekund.
3. /t//: Usuń wszystkie pozostałe ts.
4. .TTTTTTTTTT: Zostaje zastąpione przez 10 ^ 100 .s. Wyjmij je.

Wreszcie, oto program kompromisowy, który wypisuje .znak 2 * 10 ^ 100 razy, używając 40 znaków:

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

Befunge 93, 33 bajty

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

Niestety Befunge nie ma funkcji power, więc prawie cały ten kod jest moją implementacją funkcji power. Nadal nad tym pracuję.

Wyjaśnienie:

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

1: Zacznij od 1w lewym górnym rogu, aby po pomnożeniu nie za 0każdym razem.

01g: pobierz znak na pozycji (0, 1), czyli do kodzie ASCII 100.

0`: sprawdź, czy wartość zapisana w (0, 1) jest większa niż 0; ta wartość się zmieni.

#@!# _: Logiczne nie !do wartości, którą otrzymujemy z ostatniego kroku (0 lub 1), więc jeśli był to 1, teraz mamy 0, i zauważamy, że #oznacza to pominięcie następnego znaku w kodzie.

01g 1- 01p: Weź ponownie wartość zapisaną w (0, 1), odejmij 1 od niej i zapisz nową wartość w (0, 1)

25**: pomnóż najwyższą wartość stosu przez 10

1.: drukuj za 1każdym razem, gdy ta pętla

1 jest drukowany (teoretycznie) razy googol, ale to szybko ucieka ze strony, na której testowałem to.

Możesz uruchomić kod Befunge 93 tutaj . Z jakiegoś powodu najwyższą wartością stosu jest to, 1.0000000000000006e+100kiedy powinno być 1.0e+100. Nie wiem, skąd to się 6wzięło, ale nie sądzę, że powinno tam być i że może to być jakiś błąd zaokrąglenia lub coś takiego.

ABCR , 56 bajtów

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

Turingi są zabawne, zwłaszcza gdy nie mają łatwego mnożenia lub wykładników. Z drugiej strony musiałem użyć tylko dwóch z trzech kolejek!

Wyjaśnienie:

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

Partia, 574 242 bajtów

@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

Każda pętla przechodzi przez to, wykonując dodatkową iterację. Pętle są ograniczone do ~ 2³² ze względu na 32-bitowy limit liczb całkowitych. Pierwsze cztery pętle liczą 2²⁵, co daje w sumie 2¹⁰⁰, podczas gdy pozostałe dziesięć pętli liczy 5¹⁰, co daje w sumie 5¹⁰⁰.

Edycja: Zaoszczędź niewyobrażalne 58% dzięki @ ConorO'Brien.

TI-Basic, 20 bajtów

Bezpośredni. Wyświetlanych jest tylko osiem wierszy jednocześnie, a poprzednie wiersze nie pozostają w pamięci. Ponieważ ᴇ100nie jest obsługiwany, musimy wykonywać pętle od -ᴇ99do 9ᴇ99. Następnie, jeśli I!=0, wyświetl ciąg (który, nawiasem mówiąc, wynosi 3). W ten sposób drukujemy go dokładnie ᴇ100razy.

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

funkcja kodu maszynowego x86-64, 30 bajtów.

Wykorzystuje tę samą logikę rekurencji jako C Odpowiedź @Level rzeki św . (Maksymalna głębokość rekurencji = 100)

Korzysta z puts(3)funkcji libc, z którą normalne pliki wykonywalne są powiązane. Można go wywoływać za pomocą ABI x86-64 System V, tj. Z C w systemie Linux lub OS X, i nie blokuje żadnych rejestrów, których nie powinien.

objdump -drwC -Mintel wyjście, skomentowane z wyjaśnieniem

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.

Zbudowany z yasm -felf64 -Worphan-labels -gdwarf2 golf-googol.asm && gcc -nostartfiles -o golf-googol golf-googol.o . Mogę opublikować oryginalne źródło NASM, ale wydawało się, że to bałagan, ponieważ instrukcje asm są tam w trakcie demontażu.

putchar@pltznajduje się w odległości mniejszej niż 128 bajtów jl, więc mógłbym użyć 2-bajtowego krótkiego skoku zamiast 6-bajtowego skoku w pobliżu, ale jest to prawdą tylko w małym pliku wykonywalnym, a nie jako część większego programu. Więc nie sądzę, żebym mógł usprawiedliwić nie liczenie wielkości implementacji put libc, jeśli skorzystam z krótkiego kodowania jcc, aby to osiągnąć.

Każdy poziom rekurencji wykorzystuje 24B przestrzeni stosu (2 wypychania i adres zwrotny wypychany przez CALL). Każda inna głębokość będzie putcharsprawdzać ze stosem wyrównanym tylko o 8, a nie o 16, więc to narusza ABI. Implementacja stdio, która używa wyrównanych sklepów do rozlewania rejestrów xmm na stos, byłaby błędna. Ale glibc's putchartego nie robi, pisząc do potoku z pełnym buforowaniem lub pisząc do terminala z buforowaniem linii. Testowane na Ubuntu 15.10. Można to naprawić za pomocą manekina push / pop w .loopcelu wyrównania stosu o kolejne 8 przed wywołaniem rekurencyjnym.

Dowód, że drukuje odpowiednią liczbę nowych linii:

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

Moja pierwsza wersja to 43B i była używana puts() w buforze 9 nowych linii (i kończącym 0 bajtów), więc put wstawiałby 10. Ten podstawowy przypadek rekurencji był jeszcze bliższy inspiracji C.

Faktoring 10 ^ 100 w inny sposób mógł skrócić bufor, może nawet do 4 nowych linii, oszczędzając 5 bajtów, ale zdecydowanie lepiej jest użyć putchar. Potrzebuje tylko liczby całkowitej, a nie wskaźnika i bufora. Standard C pozwala na implementacje, dla których jest to makro putc(val, stdout), ale w glibc istnieje jako prawdziwa funkcja, którą można wywołać z asm.

Drukowanie tylko jednej nowej linii na połączenie zamiast 10 oznacza po prostu, że musimy zwiększyć maksymalną głębokość rekurencji o 1, aby uzyskać kolejny współczynnik 10 nowych linii. Ponieważ zarówno 99, jak i 100 mogą być reprezentowane przez 8-bitowy znak bezpośredni z rozszerzonym znakiem,push 100 nadal jest to tylko 2 bajty.

Co więcej, posiadanie 10w rejestrze działa zarówno jako licznik nowej linii, jak i licznik pętli, oszczędzając bajt.

Pomysły na oszczędzanie bajtów

Wersja 32-bitowa może zaoszczędzić bajt dla dec edi, ale konwencja wywoływania argumentów stosu (dla funkcji bibliotecznych takich jak putchar) sprawia, że ​​wywołanie ogonowe jest trudniejsze i prawdopodobnie wymagałoby więcej bajtów w większej liczbie miejsc. Mógłbym użyć konwencji register-arg dla prywatnego f(), wywoływanego tylko przez g(), ale wtedy nie mogłem wywołać putchar tail-call (ponieważ f () i putchar () przyjmowałyby inną liczbę argumentów stosu).

Byłoby możliwe, aby f () zachowywał stan dzwoniącego, zamiast zapisywania / przywracania w dzwoniącym. Prawdopodobnie jest to do bani, ponieważ prawdopodobnie musiałoby się dostać osobno z każdej strony gałęzi i nie jest kompatybilne z ogłaszaniem. Próbowałem, ale nie znalazłem żadnych oszczędności.

Utrzymywanie licznika pętli na stosie (zamiast push / pop rcx w pętli) również nie pomogło. Było gorzej o 1B z wersją, która używa putów, i prawdopodobnie jeszcze większą stratę z tą wersją, która taniej konfiguruje rcx.

PHP, 44 bajty

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

Ten fragment wyświetli 1czasy googola. Nie zabraknie pamięci, ale jest strasznie powolny. Korzystam z BCMath, aby móc obsługiwać długie liczby całkowite.

Nieco lepsza wydajność, ale nie tak mała (74 bajty):

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

Wyświetli literę arazy googol. Zużyje prawie 4 GB pamięci, generując jednocześnie około 4e9 znaków.

Haskell, 45 43 bajtów

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

Pyke, 6 5 bajtów

TTX^V

Wypróbuj tutaj!

Niesprawdzony, ponieważ powoduje awarię przeglądarki. Pierwsze 4 znaki generują 10 ^ 100 i Vwypisują tyle nowych linii. Przetestuj za pomocą 100V.

Rakieta 36 bajtów

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

Wynik:

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

JAISBaL , 4 bajty

˖Q

Chrome nie może odczytać wszystkich symboli i nie jestem pewien co do innych przeglądarek, więc oto zdjęcie:

Wyjaśnienie:

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

Całkiem proste .... po prostu drukuje przestrzenie googol. Trzy instrukcje, ale stała googol ma dwa bajty.

(Napisane w wersji 3.0.5)

JavaScript ES6, 85 83 bajtów

Zaoszczędzono 2 bajty dzięki produktom ETH!

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

Drukuje 1e100 nowych linii.

Wewnętrzna część generuje ten program, który jest następnie oceniany.

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

Teraz, jako dowód poprawności, użyjemy indukcji. Załóżmy zastąpić początkowej 100 dla innych wartości, ogólnie N . Twierdzę, że wstawienie N da 10 ^N nowych linii. Piszmy wynik tego do wc -l, który zlicza liczbę nowych linii na wejściu. Użyjemy tego zmodyfikowanego, ale równoważnego skryptu, który pobiera dane wejściowe N :

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

Oto kilka wyników:

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

Widzimy, że przekształca to wejściowe N dla małych wartości na 10 ^N nowych linii.

Oto przykładowy wynik dla N = 1:

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











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

Mathematica, 48 30 25 bajtów

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

Wynik:

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

Fortran 95, Free-form, Recursive, 117 bajtów

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

Drukuje googol linii zawierających

          0

Fortran 90, rekurencyjny, 149 bajtów

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

Rekurencyjne wywoływanie 100 zagnieżdżonych pętli, każda 10 iteracji, tworzy dokładnie jeden googol. N, L i liczniki pętli pasują do bajtów liczb całkowitych.

Testowany przez zastąpienie 99 przez 1, 2, 3, 4, 5 i zauważenie, że w każdym przypadku wynikowa liczba wierszy z „wc” ma n + 1 zer.

Fortran II, IV, 66 lub 77, 231 bajtów:

      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

Drukuje googol nowych linii.

Wszystkie te programy będą działać na komputerach 32-bitowych; w rzeczywistości wersje rekurencyjne działałyby dobrze na komputerze 16-bitowym. Można użyć mniejszej liczby pętli w wersji brute-force, uruchamiając na starym Cray z 60-bitowymi liczbami całkowitymi. Tutaj dziesięć zagnieżdżonych pętli 2 * 10 ^ 9 w jednej pętli 5 ^ 10 (9765625) odpowiada 10 ^ 100 całkowitej iteracji.

Żadna z wersji nie używa pamięci, by mówić o innym kodzie niż sam kod obiektu, liczniki, jedna kopia ciągu wyjściowego, a w wersji rekurencyjnej 100-poziomowy stos zwrotny.

Sprawdź czynniki, porównując

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

Symulator maszyny Turinga, 1082 bajty

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 *

Symulator maszyny Turinga

Nie wiem, czy jest to poprawne wyjście, ponieważ ma 82 spacje wiodące.

Nie wiem, czy przestrzega to limitu 4 GB, więc jeśli nie, to jest niekonkurencyjny i służy tylko prezentacji. Dane wyjściowe to 1e100 bajtów, więc należy je odjąć od liczby bajtów pamięci. Końcowa liczba bajtów wynosi 82 ​​bajty.

Oto wyjaśnienie:

Pierwsze 80 wierszy kodu to 80 różnych stanów, które generują licznik pętli base-19 ¹6EC1BCF4688309GH806H932ADCC44EEG6DE0FE9FAHDE66DGH108C9G3623E045A0H7A95AB594CE99A .

Następne 19 wierszy kodu to stan licznika, który zmniejsza liczbę za każdym razem, gdy znak jest drukowany.

Następne 6 wierszy to stan drukarki, do którego dołączony jest znak = .

Wreszcie, ostatnie 2 wiersze to stan czyszczenia, który jest potrzebny, aby upewnić się, że jedynym wyjściem jest =====...===== . Wiodące / końcowe spacje nie są liczone jako wynik, ponieważ są nieuniknionymi efektami ubocznymi.

Program zatrzymuje się.

^{1 Zrobiłem z tego matematykę.}

Pyth, 7 bajtów

Nowy (konkurencyjny)

V^T*TTG

Wyjaśnienie

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

Stare (niekonkurujące) 7 bajtów

*G^T*TT

Wyjaśnienie

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

Python 3, 32 bajty

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

Alternatywne rozwiązanie, 33 bajty:

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

Java, 198 179 155 bajtów

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

Drukuje ( x== null?: nullCiąg, który zaczyna się [La;@lub coś takiego) 10 ¹⁰⁰ razy w czasie O (na zawsze).

Java, 153 bajty

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

Wyjście: 1e100 1s

Wiem, że jest jeszcze jedna odpowiedź Java, która jest również bardzo bliska. Mój ma główną i wciąż jest krótszy.

To mój pierwszy wpis do golfa. Docenione wskazówki.

Pyth, 8 7 bajtów

V^T100G

Połączyć

Rozwiązanie jest testowane z małą wydajnością, ale powinno wydrukować abcdefghijklmnopqrstuvwxyz1e100 razy.

Z jakiegoś powodu, pbyło niepotrzebne, a 31343 (Maltysen) powiedział .