Saya tertarik melihat program yang tidak meminta input apa pun, mencetak salinan googol dari beberapa string kosong, tidak kurang, tidak lebih, dan kemudian berhenti. Sebuah googol didefinisikan sebagai 10 ^ 100, yaitu, 1 diikuti oleh seratus 0 di desimal.

Contoh output:

111111111111111111111111111111111111111111111111111111111111111111111111...

atau

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

Tali juga dapat seluruhnya terdiri dari ruang putih atau simbol khusus. Satu-satunya pengecualian untuk salinan identik dari string tetap adalah jika bahasa Anda menghiasi output dalam beberapa cara yang tidak dapat dicegah, tetapi bisa secara sepele dibatalkan dalam skrip pembungkus, seperti menambahkan nomor baris ke setiap baris. Skrip pembungkus dalam kasus seperti itu tidak perlu disediakan.

Anda dapat menganggap komputer Anda tidak akan pernah kehabisan waktu, tetapi selain itu, program Anda harus memiliki permintaan sumber daya yang masuk akal. Selain itu, Anda harus menghormati pembatasan apa pun yang dilakukan oleh bahasa pemrograman pilihan Anda, misalnya, Anda tidak dapat melebihi nilai maksimum yang diizinkan untuk jenis integernya, dan tidak boleh lebih dari 4 GB memori diperlukan.

Dengan kata lain, program pada prinsipnya harus dapat diuji dengan menjalankannya di komputer Anda. Tetapi karena besarnya jumlah ini, Anda akan diharapkan untuk membuktikan bahwa jumlah salinan dari string yang dihasilkannya persis 10 ^ 100 dan bahwa program berhenti setelahnya. Menghentikan bisa keluar atau berhenti atau bahkan berhenti karena kesalahan, tetapi jika demikian, kesalahan tidak harus menghasilkan output apa pun yang tidak dapat dengan mudah dipisahkan dari output program.

Ini adalah kode-golf , jadi solusi dengan byte paling sedikit menang.

Contoh solusi (C, ungolfed, 3768 bytes)

#include <stdio.h>

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

Jelly , 6 4 byte

³Ȯ*¡

Ini adalah tautan niladic (berfungsi tanpa argumen) yang mencetak 10 ²⁰⁰ salinan dari string 100 , artinya ia mencetak 10 ¹⁰⁰ salinan string yang terdiri dari 10 ¹⁰⁰ salinan dari string 100 .

Cobalah online!

Perhatikan bahwa juru bahasa online memotong output pada 100 KB untuk alasan praktis. Kode ini juga berfungsi sebagai program lengkap, tetapi karena keluaran implisit, program itu mencetak satu salinan terlalu banyak.

Bagaimana itu bekerja

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

9+ddpp![g] 

Penjelasan:

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. 

Sampel kambing yang dicetak:

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

Python, 28 byte

-1 byte terima kasih kepada Jonathan Allan!

Python 2:

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

Python 3 (30 byte):

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

Haskell, 28 byte

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

Menggabungkan 10 ^ 100 salinan string "1"dan mencetaknya.

Brainfuck, 480 188 114 106 98 byte

Hanya karena itu perlu dilakukan.

Diasumsikan sel 8-bit dengan pembungkus. Mencetak 250 ²⁵⁵ NUL byte, yaitu 10 ¹⁰⁰ kali 10 ¹⁵⁵ kali 25 ²⁵⁵ NUL byte.

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

Penjelasan:

>>>>>> diperlukan untuk meninggalkan sedikit ruang kerja.

- menghasilkan 255.

[[->>>+<<<]------>>>-] mengubahnya menjadi 255 salinan dari nilai 250, memberikan rekaman yang terlihat seperti:

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

<<<[<<<]+ memindahkan penunjuk data kembali dan menyelesaikan data awal:

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

Kemudian muncul loop: [+...-]awalnya menetapkan 1 ke 2, yang akan diatur kembali ke 1 pada akhir loop. Loop berakhir ketika badan loop sudah diatur 2 ke 1.

Sekarang, angka 2 250 250 250 ... 250 mewakili penghitung, dalam basis 250, dengan masing-masing angka satu lebih besar dari angka yang diwakilinya.

• [>>>]<<<bergerak sampai ke kanan. Karena setiap digit diwakili oleh angka bukan nol, ini sepele.

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-mengurangi penghitung dengan 1. Dimulai dengan digit terakhir: digit tersebut akan dikurangi. Jika tetap positif, kita sudah selesai. Jika berubah menjadi nol, atur ke 250, dan lanjutkan dengan digit sebelumnya.

• [<<<].>>>memindahkan penunjuk kembali sebelum digit paling kiri, dan ini adalah momen yang baik untuk mencetak byte NUL. Kemudian posisikan kembali ke digit paling kiri, untuk melihat apakah kita sudah selesai.

Untuk memverifikasi kebenaran, mengubah awal -untuk +mencetak 250 ¹ byte NUL, ++untuk 250 ² , dll

C, 51 byte

Fungsi g()memanggil fungsi rekursif f()ke kedalaman 99.

Tidak termasuk baris baru yang tidak perlu ditambahkan antara f()dan g()untuk kejelasan.

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

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

Mencetak 1E100 baris baru.

Deklarasi isebagai parameter kedua f()tidak dijamin bekerja di semua versi C. Diuji pada mesin saya sendiri (GCC di CygWin) dan di ideone.com (saya percaya mereka juga menjalankan GCC), tetapi tidak sampai f (99) untuk jelas alasan!

Commodore VIC 20 kode mesin (40 byte)

... di sini ditampilkan sebagai heksadesimal:

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

(Dimulai menggunakan: SYS 4160)

Arti byte dalam tanda kurung

• 0x64 (terjadi dua kali) adalah basis (100); (nilai dari 2 hingga 127 seharusnya berfungsi)
• 0x32 adalah eksponen (50) (nilai bukan nol (1-255) harus berfungsi)
• Perhatikan bahwa 100 ^ 50 = 10 ^ 100; menjalankan program 100 ^ 50 kali lebih efisien RAM daripada melakukannya 10 ^ 100 kali
• 0x31 adalah karakter ASCII yang akan dicetak

dan pada titik mana tidak lebih dari 4 GB memori harus dibutuhkan.

Apakah ini kesalahan pengetikan?

Kami memiliki tahun 1981.

Komputer rumahan pada umumnya memiliki RAM 1 hingga 16 K B! Dan Anda tidak akan menemukan model profesional yang memiliki 1 M B atau lebih.

(Ok. Hanya bercanda.)

Dengan kata lain, program pada prinsipnya harus dapat diuji dengan menjalankannya di komputer Anda. Tetapi karena besarnya jumlah ini, Anda akan diharapkan untuk membuktikan bahwa jumlah salinan dari string yang dihasilkannya persis 10 ^ 100 dan bahwa program berhenti setelahnya.

Program ini telah diuji dengan basis dan eksponen lain. Saya tidak ragu itu juga akan bekerja dengan 100 dan 50.

Setidaknya itu tidak crash dengan angka-angka ini (tetapi juga tidak berakhir dalam waktu yang terukur).

Ukuran memori cukup untuk eksponen 50 dan 100 kurang dari 127 sehingga basis 100 seharusnya tidak menjadi masalah.

Ide dasarnya

Ada penghitung 50 digit yang diperhitungkan dalam sistem 100. Bytes 0x01-0x64 mewakili angka 0-99. Byte pertama di penghitung adalah digit terendah. Byte terakhir di penghitung (digit tertinggi) diikuti oleh byte dengan nilai 0x00.

Penghitung memiliki nilai awal 100 ^ 50.

Loop luar menulis byte ke "saluran saat ini" ("output standar" pada sistem modern; biasanya layar) dan kemudian mengurangi penghitung.

Pengurangan dilakukan oleh lingkaran dalam: Mengurangi satu digit dan dalam kasus aliran bawah dari 1 hingga 99, ia maju ke digit berikutnya. Jika byte 0x00 di ujung penghitung dikurangi, program akan berhenti.

Kode perakitan adalah

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

SUNTING

Program ini juga berjalan di Commodore C64!

Node, 89 byte

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

Output 10 ¹⁰⁰ baris baru. (Secara teoritis, yaitu; tes dengan mengganti 100dengan 1output 10 ¹ baris baru sebagai gantinya.)

Ini berfungsi dengan mengatur ike string

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

(100 nol dan 1; a googol terbalik), lalu berulang kali "kurangi 1" dengan regex ganti dan keluaran baris baru sampai string semua nol.

Port jawaban C ++ adalah 49 byte:

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

05AB1E , 6 byte

Tn°F1?

Penjelasan

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

Ruby, 20 byte

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

Mencetak 1 diikuti oleh baris baru 1E100 kali.

1E100 tidak bekerja karena mengevaluasi float, bukan integer presisi yang berubah-ubah.

/// , 36 karakter ASCII (4 berbeda)

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

Menghasilkan .karakter 3 * 10 ^ 125 kali, artinya mengeluarkan string yang terdiri dari 3 * 10 ^ 25 pengulangan .karakter, 10 ^ 100 kali.

Penjelasan:

1. /t./.ttttt/: Ganti t.dengan .tttttseluruh sisa program, ulangi sampai tidak ada contoh yang t.tersisa. Ini menggantikan t...dengan ...diikuti oleh 125 ts.
2. /.t/t\........../: Ganti .tdengan t..........seluruh sisa program, ulangi sampai tidak ada contoh yang .ttersisa. Ini mengambil ...diikuti oleh 125 ts, dan mengubahnya menjadi 125 ts diikuti oleh 10 ^ 125 kejadian ....
3. /t//: Hapus semua yang tersisa t.
4. t...: Ini akan diganti dengan 3 * 10 ^ 125 .dtk. Keluarkan mereka.

Sekarang, menghasilkan 10 ^ 100 pengulangan dari 3 * 10 ^ 25 pengulangan dari sesuatu yang terasa seperti curang. Program ini menghasilkan .karakter persis 10 ^ 100 kali, menggunakan 45 karakter ASCII:

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

Penjelasan yang ini:

1. /T/tttttttttt/: Ganti Tdengan ttttttttttseluruh sisa program. Ini menggantikan TTTTTTTTTTdengan 100 pengulangan dari t.
2. /.t/t........../: Ganti .tdengan t..........seluruh sisa program. Ini mengambil .diikuti oleh 100 ts, dan mengubahnya menjadi 100 ts diikuti oleh 10 ^ 100 .s.
3. /t//: Hapus semua yang tersisa t.
4. .TTTTTTTTTT: Ini diganti dengan 10 ^ 100 .dtk. Keluarkan mereka.

Akhirnya, inilah program kompromi, yang menampilkan .karakter 2 * 10 ^ 100 kali, menggunakan 40 karakter:

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

Menembus 93, 33 byte

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

Sayangnya, Befunge tidak memiliki fungsi daya, jadi hampir semua kode itu adalah implementasi fungsi daya saya. Saya masih mengerjakan ini.

Penjelasan:

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

1: Mulailah dengan 1di kiri atas sehingga ketika kita mengalikan, kita tidak mendapatkan 0setiap waktu.

01g: dapatkan karakter di posisi (0, 1), yaitu d, yang kode ASCII-nya adalah 100.

0`: lihat apakah nilai yang disimpan dalam (0, 1) lebih besar dari 0; nilai ini akan berubah.

#@!# _: Logikanya bukan !dengan nilai yang kita dapatkan dari langkah terakhir (0 atau 1), sehingga jika itu adalah 1, sekarang kita memiliki 0, dan kita catat itu #berarti bahwa Anda melewatkan karakter berikutnya dalam kode.

01g 1- 01p: Ambil nilai yang disimpan dalam (0, 1) lagi, kurangi 1 dari itu, dan simpan nilai baru ini di (0, 1)

25**: kalikan nilai teratas tumpukan dengan 10

1.: cetak 1setiap kali loop ini

1 dicetak (secara teori) kali googol, tapi itu dengan cepat lari dari halaman yang saya uji ini.

Anda dapat menjalankan kode Befunge 93 di sini . Untuk beberapa alasan, nilai teratas tumpukan adalah 1.0000000000000006e+100kapan seharusnya 1.0e+100. Saya tidak tahu dari mana 6asalnya, tetapi saya tidak berpikir itu harus ada di sana dan mungkin ada kesalahan pembulatan atau sesuatu seperti itu.

ABCR , 56 byte

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

Turing tarpit menyenangkan, terutama ketika mereka tidak memiliki perkalian atau eksponen yang mudah. Di sisi lain, saya hanya perlu menggunakan dua dari tiga antrian!

Penjelasan:

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

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

                                                       B now contains 10^100 only.

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

Batch, 574 242 byte

@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

Setiap loop jatuh karena itu melaksanakan iterasi tambahan. Loop dibatasi hingga ~ 2³² karena batas integer 32-bit. Empat loop pertama masing-masing menghitung 2²⁵ dengan total 2¹⁰⁰ sedangkan sepuluh loop sisanya masing-masing menghitung 5¹⁰ dengan total 5¹⁰⁰.

Sunting: Menyimpan 58% yang tak terbayangkan berkat @ ConorO'Brien.

TI-Basic, 20 byte

Mudah. Hanya delapan baris yang ditampilkan sekaligus, dan baris sebelumnya tidak tersimpan di memori. Karena ᴇ100tidak didukung, kita harus beralih dari -ᴇ99ke 9ᴇ99. Kemudian, jika I!=0, tampilkan string (yang, omong-omong, adalah 3). Dengan cara ini, kami mencetaknya tepat ᴇ100waktu.

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

fungsi kode mesin x86-64, 30 byte.

Menggunakan logika rekursi sama dengan jawaban C dengan @Level Sungai St . (Kedalaman rekursi maksimum = 100)

Menggunakan puts(3)fungsi dari libc, yang biasanya dijalankan oleh executable normal. Itu bisa dipanggil menggunakan Sistem V86 ABI x86-64, yaitu dari C di Linux atau OS X, dan tidak mengalahkan register yang tidak seharusnya.

objdump -drwC -Mintel output, berkomentar dengan penjelasan

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.

Dibangun dengan yasm -felf64 -Worphan-labels -gdwarf2 golf-googol.asm && gcc -nostartfiles -o golf-googol golf-googol.o . Saya dapat memposting sumber NASM asli, tetapi sepertinya berantakan karena instruksi asm ada di sana di pembongkaran.

putchar@pltkurang dari 128 byte dari jl, jadi saya bisa menggunakan lompatan pendek 2-byte alih-alih 6-byte dekat, tapi itu hanya berlaku dalam eksekusi kecil, bukan sebagai bagian dari program yang lebih besar. Jadi saya tidak berpikir saya bisa membenarkan tidak menghitung ukuran implementasi libc jika saya juga mengambil keuntungan dari pengkodean jcc pendek untuk mencapainya.

Setiap level rekursi menggunakan ruang stack 24B (2 push dan alamat balik didorong oleh CALL). Setiap kedalaman lainnya akan memanggil putchardengan tumpukan hanya selaras dengan 8, bukan 16, jadi ini melanggar ABI. Implementasi stdio yang menggunakan toko yang disejajarkan untuk menumpahkan register xmm ke stack akan bermasalah. Tetapi glibc putchartidak melakukan itu, menulis ke pipa dengan buffering penuh atau menulis ke terminal dengan buffering baris. Diuji pada Ubuntu 15.10. Ini bisa diperbaiki dengan dummy push / pop di .loop, untuk mengimbangi tumpukan dengan 8 lain sebelum panggilan rekursif.

Bukti bahwa ia mencetak jumlah baris baru yang benar:

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

Versi pertama saya adalah 43B, dan digunakan puts()pada buffer 9 baris baru (dan terminasi 0 byte), jadi put akan menambahkan tanggal 10. Basis rekursi itu bahkan lebih dekat dengan inspirasi C.

Anjak 10 ^ 100 dengan cara yang berbeda mungkin bisa memperpendek buffer, mungkin turun ke 4 baris baru, menghemat 5 byte, tetapi menggunakan putchar jauh lebih baik. Ini hanya membutuhkan integer arg, bukan pointer, dan tidak ada buffer sama sekali. Standar C memungkinkan implementasi untuk makro putc(val, stdout), tetapi dalam glibc ia ada sebagai fungsi nyata yang dapat Anda panggil dari asm.

Mencetak hanya satu baris baru per panggilan, bukan 10 hanya berarti kita perlu meningkatkan kedalaman maks rekursi sebesar 1, untuk mendapatkan faktor lain dari 10 baris baru. Karena 99 dan 100 keduanya dapat diwakili oleh tanda yang langsung diperpanjang 8-bit, push 100masih hanya 2 byte.

Lebih baik lagi, memiliki 10dalam register berfungsi sebagai baris baru dan penghitung lingkaran, menghemat satu byte.

Gagasan untuk menyimpan byte

Versi 32-bit dapat menyimpan byte untuk dec edi, tetapi konvensi pemanggilan stack-args (untuk fungsi pustaka seperti putchar) membuat tail-call berfungsi lebih mudah, dan mungkin akan membutuhkan lebih banyak byte di lebih banyak tempat. Saya dapat menggunakan konvensi register-arg untuk privat f(), hanya dipanggil oleh g(), tetapi kemudian saya tidak dapat memanggil-putchar (karena f () dan putchar () akan mengambil jumlah stack-arg yang berbeda).

Mungkin saja f () mempertahankan status pemanggil, alih-alih melakukan save / restore di pemanggil. Namun, itu mungkin menyebalkan, karena mungkin perlu terpisah di setiap sisi cabang, dan tidak kompatibel dengan panggilan ekor. Saya mencobanya tetapi tidak menemukan penghematan.

Menjaga loop counter pada stack (bukannya push / popping rcx di loop) tidak membantu. Itu 1B lebih buruk dengan versi yang menggunakan put, dan mungkin bahkan lebih dari kerugian dengan versi ini yang membuat rcx lebih murah.

PHP, 44 byte

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

Cuplikan ini akan menampilkan 1kali googol. Ini tidak akan kehabisan memori, tetapi sangat lambat. Saya menggunakan BCMath untuk dapat menangani bilangan bulat panjang.

Performa yang sedikit lebih baik, tetapi tidak sekecil (74 byte):

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

Akan menampilkan huruf akali googol. Ini akan menghabiskan hampir 4GB memori, menghasilkan sekitar 4e9 karakter sekaligus.

Haskell, 45 43 byte

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

Pyke, 6 5 byte

TTX^V

Coba di sini!

Tidak diuji karena browser saya mogok. 4 karakter pertama menghasilkan 10 ^ 100 dan Vmencetak banyak baris baru. Tes dengan 100V.

Racket 36 byte

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

Keluaran:

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

JAISBaL , 4 byte

˖Q

Chrome tidak dapat membaca semua simbol, dan saya tidak yakin tentang browser lain, jadi inilah gambarnya:

Penjelasan:

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

Cukup sederhana .... hanya mencetak spasi googol. Tiga instruksi, tetapi konstanta googol adalah dua byte.

(Ditulis dalam versi 3.0.5)

JavaScript ES6, 85 83 byte

Disimpan 2 byte berkat produk ETH!

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

Ini mencetak 1e100 baris baru.

Bagian dalam menghasilkan program ini, yang kemudian dievaluasi.

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

Sekarang, sebagai bukti kebenaran, kami akan menggunakan beberapa induksi. Mari pengganti awal 100 untuk nilai-nilai lain, umum N . Saya mengklaim bahwa memasukkan N akan menghasilkan 10 ^N baris baru. Mari pipa hasil ini ke wc -l, yang menghitung jumlah baris baru di input. Kami akan menggunakan skrip yang dimodifikasi tetapi setara ini yang mengambil input N :

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

Sekarang, inilah beberapa keluaran:

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

Kita dapat melihat bahwa ini mengubah input N untuk nilai kecil menjadi 10 ^N baris baru.

Berikut ini contoh output untuk N = 1:

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











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

Mathematica, 48 30 25 byte

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

Keluaran:

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

Fortran 95, bentuk-bebas, Rekursif, 117 byte

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

Mencetak googol dari garis yang mengandung

          0

Fortran 90, Rekursif, 149 byte

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

Secara rekursif memanggil 100 loop bersarang, masing-masing 10 iterasi, membuat persis satu googol. N, L, dan loop counters semuanya cocok dengan bilangan bulat berukuran byte.

Diuji dengan mengganti 99 dengan 1, 2, 3, 4, 5 dan mencatat bahwa dalam setiap kasus, jumlah garis yang dihasilkan dari "wc" memiliki n + 1 nol.

Fortran II, IV, 66, atau 77, 231 byte:

      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

Mencetak googol dari baris baru.

Semua program ini akan berjalan di mesin 32-bit; sebenarnya, versi rekursif akan bekerja dengan baik pada mesin 16-bit. Seseorang dapat menggunakan loop yang lebih sedikit dalam versi brute-force dengan menjalankan Cray lama dengan bilangan bulat 60-bit. Di sini, sepuluh loop bersarang dari 2 * 10 ^ 9 di dalam satu loop dari 5 ^ 10 (9765625) sama dengan 10 ^ 100 total iterasi.

Tidak ada versi yang menggunakan memori apa pun untuk berbicara selain dari kode objek itu sendiri, penghitung, satu salinan string keluaran, dan, dalam versi rekursif, tumpukan pengembalian 100-tingkat.

Periksa faktor-faktor dengan membandingkan

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

Simulator mesin Turing, 1082 byte

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 *

Simulator mesin Turing

Saya tidak tahu apakah ini dianggap sebagai output yang benar, karena memiliki 82 ruang terdepan.

Saya tidak tahu apakah ini menghormati batas 4 GB, jadi, jika tidak, maka itu tidak kompetitif dan hanya untuk showcase. Outputnya adalah 1e100 byte, sehingga harus dikurangkan dari jumlah byte memori. Jumlah byte terakhir adalah 82 byte.

Berikut ini penjelasannya:

80 baris kode pertama adalah 80 negara bagian yang menghasilkan jumlah loop base-19 ¹6EC1BCF4688309GH806H932ADCC44EEG6DE0FE9FAHDE66DGH108C9G3623E045A0H7A95AB594CE99A .

19 baris kode berikutnya adalah status penghitung, yang menurunkan jumlah setiap kali karakter dicetak.

6 baris berikutnya adalah status printer, yang menambahkan =.

Akhirnya, 2 baris terakhir adalah status pembersih, yang diperlukan untuk memastikan satu-satunya output =====...=====. Leading / trailing space tidak dihitung sebagai output, karena mereka adalah efek samping yang tidak dapat dihindari.

Program kemudian terhenti.

^{1 Saya melakukan matematika untuk itu.}

Pyth, 7 Bytes

Baru (Bersaing)

V^T*TTG

Penjelasan

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

Lama (Tidak Bersaing) 7 Bytes

*G^T*TT

Penjelasan

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

Python 3, 32 byte

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

Solusi alternatif, 33 byte:

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

Java, 198 179 155 byte

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

Prints ( x== null? null: String yang dimulai dengan [La;@atau sesuatu seperti itu) 10 ¹⁰⁰ kali dalam O (selamanya) waktu.

Java, 153 byte

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

Output: 1e100 1s

Saya tahu ada jawaban Java lain yang juga cukup dekat. Milik saya punya utama dan masih lebih pendek.

Ini adalah entri kode-golf pertama saya. Tips dihargai.

Pyth, 8 7 byte

V^T100G

Tautan

Solusi diuji dengan output kecil, tetapi harus mencetak abcdefghijklmnopqrstuvwxyz1e100 kali.

Untuk beberapa alasan, pitu tidak dibutuhkan, seperti 31343 (Maltysen) katakan .