Je suis intéressé à voir des programmes qui ne demandent aucune entrée, impriment une copie googol d'une chaîne non vide, ni moins, ni plus, et puis s'arrêtent. Un googol est défini comme 10 ^ 100, soit 1 suivi de cent 0 en décimal.

Exemple de sortie:

111111111111111111111111111111111111111111111111111111111111111111111111...

ou

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

La chaîne peut également être entièrement composée d'espaces ou de symboles spéciaux. La seule exception aux copies identiques d'une chaîne fixe est si votre langue décore la sortie d'une manière qui ne peut pas être empêchée, mais peut être annulée de manière triviale dans un script wrapper, comme par exemple l'ajout d'un numéro de ligne à chaque ligne. Dans ce cas, le script d'emballage ne doit pas être fourni.

Vous pouvez supposer que votre ordinateur ne manquera jamais de temps, mais à part cela, votre programme doit avoir une demande raisonnable en ressources. En outre, vous devez respecter les restrictions éventuelles imposées par le langage de programmation de votre choix. Par exemple, vous ne pouvez pas dépasser la valeur maximale autorisée pour ses types d'entiers. Vous ne devez en aucun cas utiliser plus de 4 Go de mémoire.

En d'autres termes, le programme devrait en principe pouvoir être testé en l'exécutant sur votre ordinateur. Mais à cause de l’ampleur de ce nombre, il vous sera demandé de prouver que le nombre de copies de la chaîne qu’il génère est exactement égal à 10 ^ 100 et que le programme s’arrête ensuite. L'arrêt peut être une sortie, une fin ou même une fin due à une erreur, mais si c'est le cas, l'erreur ne doit générer aucune sortie difficile à séparer de la sortie du programme.

C'est du code-golf , donc la solution avec le moins d'octets gagne.

Exemple de solution (C, non golfé, 3768 octets)

#include <stdio.h>

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

Gelée , 6 4 octets

³Ȯ*¡

Il s'agit d'un lien niladique (fonction sans arguments) qui imprime 10 ²⁰⁰ copies de la chaîne 100 , ce qui signifie qu'il imprime 10 ¹⁰⁰ copies de la chaîne composée de 10 ¹⁰⁰ copies de la chaîne 100 .

Essayez-le en ligne!

Notez que l'interprète en ligne coupe la sortie à 100 Ko pour des raisons pratiques. Le code fonctionne également comme un programme complet, mais en raison d'une sortie implicite, ce programme en imprime une copie de trop.

Comment ça fonctionne

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

9+ddpp![g] 

Explication:

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. 

Echantillon de la chèvre imprimé:

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

Python, 28 octets

-1 octet grâce à Jonathan Allan!

Python 2:

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

Python 3 (30 octets):

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

Haskell, 28 octets

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

Concatène 10 ^ 100 copies de la chaîne "1"et l’imprime.

Brainfuck, 480 188 114 106 98 octets

Juste parce que cela doit être fait.

Suppose des cellules 8 bits avec habillage. Imprime 250 ²⁵⁵ octets NUL, soit 10 ¹⁰⁰ fois 10 ¹⁵⁵ fois 25 ²⁵⁵ octets NUL.

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

Explication:

>>>>>> est nécessaire pour laisser un peu d’espace de travail.

- produit 255.

[[->>>+<<<]------>>>-] transforme ceci en 255 copies de la valeur 250, donnant une bande qui ressemble à:

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

<<<[<<<]+ déplace le pointeur de données vers l'arrière et termine les données initiales:

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

Vient ensuite la boucle: [+...-]initialise le 1 à 2, ce qui revient à 1 à la fin de la boucle. La boucle se termine lorsque le corps de la boucle a déjà défini 2 sur 1.

Maintenant, les nombres 2 250 250 250 ... 250 représentent un compteur, en base 250, avec chaque nombre un supérieur au chiffre qu'il représente.

• [>>>]<<<se déplace tout à fait à droite. Puisque chaque chiffre est représenté par un nombre différent de zéro, ceci est trivial.

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-diminue le compteur de 1. À partir du dernier chiffre: le chiffre est décrémenté. Si cela reste positif, nous avons fini. S'il atteint zéro, définissez-le sur 250 et continuez avec le chiffre précédent.

• [<<<].>>>déplace le pointeur vers le chiffre le plus à gauche, ce qui est un bon moment pour imprimer un octet NUL. Puis repositionnez exactement le chiffre le plus à gauche pour voir si nous avons terminé.

Pour vérifier l'exactitude, modifiez l'initiale -en +pour imprimer 250 ¹ NUL octets, ++pour 250 ² , etc.

C, 51 octets

La fonction g()appelle la fonction récursive f()à la profondeur 99.

Sont exclus les sauts de ligne inutiles ajoutés entre f()et g()pour plus de clarté.

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

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

Imprime les nouvelles lignes 1E100.

Déclaration de ideuxième paramètre de f()non garantie de fonctionner dans toutes les versions de C. Testé sur ma propre machine (GCC sur CygWin) et sur ideone.com (je crois qu'ils exécutent également GCC), mais pas jusqu'à f (99) pour des raisons évidentes les raisons!

Code machine du Commodore VIC 20 (40 octets)

... affiché en hexadécimal:

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

( En route en utilisant: SYS 4160)

Signification des octets entre parenthèses

• 0x64 (se produit deux fois) est la base (100); (les valeurs de 2 à 127 devraient fonctionner)
• 0x32 est l'exposant (50) (toute valeur autre que zéro (1-255) devrait fonctionner)
• Notez que 100 ^ 50 = 10 ^ 100; Exécuter le programme 100 ^ 50 fois est plus efficace en RAM que le faire 10 ^ 100 fois
• 0x31 est le caractère ASCII à imprimer

et à aucun moment pas plus de 4 Go de mémoire ne doivent être nécessaires.

Est-ce une faute de frappe?

Nous avons l'année 1981.

Un ordinateur à la maison typique a 1 à 16 K B de RAM! Et vous trouverez difficilement des modèles professionnels ayant 1 M ou plus.

(Ok. Juste une blague.)

En d'autres termes, le programme devrait en principe pouvoir être testé en l'exécutant sur votre ordinateur. Mais à cause de l’ampleur de ce nombre, il vous sera demandé de prouver que le nombre de copies de la chaîne qu’il génère est exactement égal à 10 ^ 100 et que le programme s’arrête ensuite.

Le programme a été testé avec d’autres bases et exposants. Je ne doute pas que cela fonctionnera également avec 100 et 50.

Au moins, il ne tombe pas en panne avec ces chiffres (mais ne se termine pas non plus dans un temps mesurable).

La taille de la mémoire est suffisante pour un exposant de 50 et 100 est inférieur à 127, une base de 100 ne devrait donc pas poser de problème.

L'idée de base

Il existe un compteur à 50 chiffres qui compte dans le système 100. Les octets 0x01-0x64 représentent les chiffres 0 à 99. Le premier octet dans le compteur est le chiffre le plus bas. Le dernier octet du compteur (chiffre le plus élevé) est suivi d'un octet avec la valeur 0x00.

Le compteur a la valeur initiale 100 ^ 50.

Une boucle externe écrit un octet sur le "canal actuel" ("sortie standard" sur les systèmes modernes; généralement l'écran), puis décrémente le compteur.

La décrémentation se fait par une boucle interne: elle décrémente un chiffre et, dans le cas d’un dépassement insuffisant, de 1 à 99, elle passe au chiffre suivant. Si l'octet 0x00 à la fin du compteur est décrémenté, le programme s'arrête.

Le code d'assemblage est

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

MODIFIER

Le programme fonctionne également sur le Commodore C64!

Noeud, 89 octets

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

Sorties 10 ¹⁰⁰ nouvelles lignes. (Théoriquement, c’est-à-dire tester en remplaçant 100par 110 ¹ nouvelles lignes à la place.)

Cela fonctionne en mettant ià la chaîne

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

(100 zéros et un 1; un googol inversé), puis à plusieurs reprises "soustraire 1" avec un remplacement de regex et générer une nouvelle ligne jusqu'à ce que la chaîne soit entièrement à zéro.

Un port de la réponse C ++ aurait 49 octets:

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

05AB1E , 6 octets

Tn°F1?

Explication

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

Ruby, 20 octets

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

Imprime 1 suivi d'une nouvelle ligne 1E100 fois.

1E100 ne fonctionne pas car il s’agit d’un nombre flottant et non d’un nombre entier de précision arbitraire.

/// , 36 caractères ASCII (4 distincts)

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

Sort le .caractère 3 * 10 ^ 125 fois, ce qui signifie qu'il sort la chaîne composée de 3 * 10 ^ 25 répétitions du .caractère, 10 ^ 100 fois.

Explication:

1. /t./.ttttt/: Remplacer t.par .ttttttout au long du programme, en répétant jusqu'à ce qu'il ne t.reste plus aucune instance . Ceci remplace t...par ...suivi de 125 ts.
2. /.t/t\........../: Remplacer .tpar t..........tout au long du programme, en répétant jusqu'à ce qu'il ne .treste plus aucune instance . Cela prend le ...suivi de 125 ts et le transforme en 125 ts suivi de 10 ^ 125 occurrences de ....
3. /t//: Supprimer tous les ts restants .
4. t...: Ceci est remplacé par 3 * 10 ^ 125 .s. Les sortir.

Maintenant, produire 10 ^ 100 répétitions de 3 * 10 ^ 25 répétitions de quelque chose ressemble à de la triche. Ce programme génère le .caractère exactement 10 à 100 fois, en utilisant 45 caractères ASCII:

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

Explication de celui-ci:

1. /T/tttttttttt/: Remplacer Tpar tttttttttttout au long du programme. Cela remplace TTTTTTTTTTpar 100 répétitions de t.
2. /.t/t........../: Remplacer .tpar t..........tout au long du programme. Cela prend le .suivi de 100 ts et le transforme en 100 ts suivi de 10 ^ 100 .s.
3. /t//: Supprimer tous les ts restants .
4. .TTTTTTTTTT: Ceci est remplacé par 10 ^ 100 .s. Les sortir.

Enfin, voici un programme de compromis, qui génère le .caractère 2 * 10 ^ 100 fois, en utilisant 40 caractères:

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

Befunge 93, 33 octets

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

Malheureusement, Befunge n'a pas de fonction d'alimentation, donc la quasi-totalité de ce code est ma mise en œuvre d'une fonction d'alimentation. Je travaille toujours sur ça.

Explication:

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

1: Commencez par 1en haut à gauche afin que lorsque nous nous multiplions, nous n'obtenions pas à 0chaque fois.

01g: récupère le caractère à la position (0, 1), c’est-à- ddire dont le code ASCII est 100.

0`: voir si la valeur stockée dans (0, 1) est supérieure à 0; cette valeur va changer.

#@!# _: Logique pas !à la valeur que nous obtenons de la dernière étape (0 ou 1), donc si c'est 1, maintenant nous avons 0, et nous notons que cela #signifie que vous sautez le caractère suivant dans le code.

01g 1- 01p: Reprendre la valeur stockée dans (0, 1), en soustraire 1 et stocker cette nouvelle valeur à (0, 1)

25**: multipliez la valeur supérieure de la pile par 10

1.: imprimer 1chaque fois que cela boucle

1 est imprimé (en théorie) fois googol, mais cela court rapidement de la page que j'ai testé cela.

Vous pouvez exécuter le code Befunge 93 ici . Pour une raison quelconque, la valeur la plus élevée de la pile est 1.0000000000000006e+100celle qui devrait l'être 1.0e+100. Je ne sais pas d'où cela 6vient, mais je ne pense pas que cela devrait être là et que cela pourrait être une erreur d'arrondi ou quelque chose du genre.

ABCR , 56 octets

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

Les tarpits de Turing sont amusants, surtout quand ils n'ont pas de multiplication ou d'exposants faciles. D'autre part, je n'avais besoin que de deux des trois files d'attente!

Explication:

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

Lot, 574 242 octets

@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

Chaque boucle passe alors en exécutant une itération supplémentaire. Les boucles sont limitées à ~ 2³² en raison de la limite de nombre entier 32 bits. Les quatre premières boucles comptent chacune 2²⁵ pour un total de 2¹⁰⁰, tandis que les dix boucles restantes comptent chacune 5¹⁰ pour un total de 5¹⁰⁰.

Edit: Enregistré un impensable de 58% grâce à @ ConorO'Brien.

TI-Basic, 20 octets

Simple. Seules huit lignes sont affichées en même temps et les lignes précédentes ne restent pas en mémoire. Parce que ᴇ100n'est pas supporté, nous devons boucler de -ᴇ99à 9ᴇ99. Ensuite, si I!=0, affichez la chaîne (qui est d'ailleurs égale à 3). De cette façon, nous l’imprimons exactement au bon ᴇ100moment.

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

Fonction du code machine x86-64, 30 octets.

Utilise la même logique récursive que la réponse C par @level rivière St . (Profondeur maximale de récursivité = 100)

Utilise la puts(3)fonction de libc, à laquelle les exécutables normaux sont liés de toute façon. Il est appelable à l'aide de l'ABI System V x86-64, c'est-à-dire à partir de C sous Linux ou OS X, et n'empiète pas sur les registres non prévus.

objdump -drwC -Mintel sortie, commentée avec explication

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.

Construit avec yasm -felf64 -Worphan-labels -gdwarf2 golf-googol.asm && gcc -nostartfiles -o golf-googol golf-googol.o . Je peux publier la source NASM d'origine, mais cela semblait être une image de fond, car les instructions asm sont exactement là dans le désassemblage.

putchar@pltest à moins de 128 octets de la jl, alors j'aurais pu utiliser un saut court de 2 octets au lieu d'un saut de près de 6 octets, mais ce n'est vrai que dans un exécutable minuscule, pas dans le cadre d'un programme plus important. Donc, je ne pense pas pouvoir justifier de ne pas prendre en compte la taille de la mise en œuvre de libc si je profite également d'un codage jcc court pour l'atteindre.

Chaque niveau de récursivité utilise 24B d’espace de pile (2 envois et l’adresse de retour transmise par CALL). Toutes les autres profondeurs appellent putcharavec la pile alignée uniquement par 8 et non 16, ce qui constitue une violation de l’ABI. Une implémentation stdio qui utilisait des magasins alignés pour renverser des registres xmm sur la pile serait défaillante. Mais glibc's putcharne fait pas cela, écrire dans un tube avec mise en mémoire tampon complète ou écrire sur un terminal avec mise en mémoire tampon de ligne. Testé sur Ubuntu 15.10. Cela pourrait être corrigé avec un push / pop factice dans le .loop, pour décaler la pile de 8 autres avant l'appel récursif.

La preuve qu'il imprime le bon nombre de nouvelles lignes:

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

Ma première version était 43B, et utilisée puts()sur un tampon de 9 nouvelles lignes (et un octet final 0), donc put ajouter le 10ème. Ce cas de base de la récursivité était encore plus proche de l'inspiration en C.

Factoriser 10 ^ 100 d'une manière différente aurait peut-être pu raccourcir la mémoire tampon, peut-être même réduire à 4 lignes, économiser 5 octets, mais utiliser putchar est de loin meilleur. Il n'a besoin que d'un argument entier, pas d'un pointeur, et pas de tampon du tout. Le standard C autorise les implémentations pour lesquelles c'est une macro putc(val, stdout), mais dans glibc, il existe une fonction réelle que vous pouvez appeler depuis asm.

Imprimer seulement un saut de ligne par appel au lieu de 10 signifie simplement que nous devons augmenter la profondeur maximale de récursivité de 1, pour obtenir un facteur supplémentaire de 10 sauts de ligne. Étant donné que 99 et 100 peuvent tous deux être représentés par un signe immédiat étendu sur 8 bits, push 100n’a encore que 2 octets.

Mieux encore, la présence 10dans un registre fonctionne à la fois comme une nouvelle ligne et un compteur de boucles, ce qui enregistre un octet.

Idées pour économiser des octets

Une version 32 bits pourrait économiser un octet pour le dec edi, mais la convention d'appel stack-args (pour les fonctions de bibliothèque telles que putchar) facilite le travail de suivi d'appels et nécessiterait probablement davantage d'octets à plusieurs endroits. Je pouvais utiliser une convention register-arg pour le privé f(), uniquement appelé par g(), mais je ne pouvais pas ensuite appeler putchar (car f () et putchar () prendraient un nombre différent d'arguments stack).

Il serait possible que f () conserve l'état de l'appelant au lieu d'effectuer la sauvegarde / restauration dans l'appelant. Cela ne sert probablement à rien, cependant, car il faudrait probablement qu'il se place séparément de chaque côté de la branche et que cela ne soit pas compatible avec le suivi des appels. J'ai essayé mais je n'ai trouvé aucune économie.

Garder un compteur de boucle sur la pile (au lieu de pousser / décompresser rcx dans la boucle) n'a pas aidé non plus. C'était 1B pire avec la version qui utilisait des options de vente, et probablement encore plus d'une perte avec cette version qui met en place rcx à moindre coût.

PHP, 44 octets

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

Cet extrait affichera les 1temps googol. Il ne manquera pas de mémoire, mais il est terriblement lent. J'utilise BCMath pour pouvoir gérer des entiers longs.

Un peu plus performant, mais pas aussi petit (74 octets):

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

Va afficher la lettre afois googol. Il consomme près de 4 Go de mémoire et génère environ 4e9 caractères à la fois.

Haskell, 45 43 octets

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

Pyke, 6 5 octets

TTX^V

Essayez-le ici!

Non testé car il bloque mon navigateur. Les 4 premiers caractères génèrent 10 ^ 100 et Vimpriment beaucoup de nouvelles lignes. Testez avec 100V.

Raquette 36 octets

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

Sortie:

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

JAISBaL , 4 octets

˖Q

Chrome ne peut pas lire tous les symboles et je ne suis pas sûr des autres navigateurs. Voici donc une image:

Explication:

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

Assez simple .... imprime juste un espace googol. Trois instructions, mais la constante de googol est deux octets.

(Écrit dans la version 3.0.5)

JavaScript ES6, 85 83 octets

2 octets sauvés grâce à ETHproductions!

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

Ceci imprime 1e100 nouvelles lignes.

La partie interne génère ce programme, qui est ensuite évalué.

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

Maintenant, pour une preuve d'exactitude, nous allons utiliser une induction. Nous allons substituer les 100 initial pour d' autres valeurs, génériquement N . Je prétends que l'insertion de N donnera 10 ^N nouvelles lignes. Envoyons le résultat à wc -l, qui compte le nombre de nouvelles lignes dans l’entrée. Nous allons utiliser ce script modifié mais équivalent qui prend l’entrée N :

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

Maintenant, voici quelques résultats:

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

Nous pouvons voir que cela transforme l'entrée N pour les petites valeurs en 10 ^N lignes nouvelles.

Voici un exemple de sortie pour N = 1:

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











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

Mathematica, 48 30 25 octets

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

Sortie:

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

Fortran 95, forme libre, récursive, 117 octets

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

Imprime un googol de lignes contenant

          0

Fortran 90, récursif, 149 octets

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

L'appel récursif de 100 boucles imbriquées, toutes les 10 itérations, donne exactement un googol. Les compteurs N, L et de boucle tiennent tous dans des entiers de la taille en octets.

Testé en remplaçant 99 par 1, 2, 3, 4, 5 et en notant que dans chaque cas, le nombre de lignes résultant de "wc" a n + 1 zéros.

Fortran II, IV, 66 ou 77, 231 octets:

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

Imprime un googol de nouvelles lignes.

Tous ces programmes fonctionneront sur des machines 32 bits; En fait, les versions récursives fonctionneraient parfaitement sur une machine 16 bits. On pourrait utiliser moins de boucles dans la version brute-force en exécutant sur un ancien Cray avec ses entiers 60 bits. Ici, dix boucles imbriquées de 2 * 10 ^ 9 dans une boucle de 5 ^ 10 (9765625) sont égales à 10 ^ 100 itérations totales.

Aucune des versions n'utilise de mémoire pour parler d'autre que du code d'objet lui-même, des compteurs, d'une copie de la chaîne de sortie et, dans la version récursive, d'une pile de retour de niveau 100.

Vérifiez les facteurs en comparant

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

Simulateur de machine de Turing, 1082 octets

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 *

Simulateur de turing machine

Je ne sais pas si cela compte comme la sortie correcte, car il y a 82 espaces de début.

Je ne sais pas si cela respecte la limite de 4 Go. Par conséquent, si ce n'est pas le cas, il est non compétitif et juste pour la vitrine. La sortie est 1e100 octets, donc cela devrait être déduit du nombre d'octets mémoire. Le nombre final d'octets est de 82 octets.

Voici une explication:

Les 80 premières lignes de code sont 80 états différents qui génèrent le nombre de boucles en base 19 ¹6EC1BCF4688309GH806H932ADCC44EEG6DE0FE9FAHDE66DGH108C9G3623E045A0H7A95AB594CE99A .

Les 19 lignes de code suivantes constituent l'état du compteur, qui décrémente le compte chaque fois qu'un caractère est imprimé.

Les 6 lignes suivantes correspondent à l’état de l’imprimante, qui ajoute un =.

Enfin, les deux dernières lignes indiquent l'état de nettoyage, ce qui est nécessaire pour s'assurer que la seule sortie est =====...=====. Les espaces de début / fin ne comptent pas comme une sortie, car ils constituent des effets secondaires inévitables.

Le programme s'arrête alors.

^{1 J'ai fait le calcul pour ça.}

Pyth, 7 octets

Nouveau (en compétition)

V^T*TTG

Explication

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

Ancien (non concurrent) 7 octets

*G^T*TT

Explication

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

Python 3, 32 octets

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

Solution alternative, 33 octets:

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

Java, 198 179 155 octets

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?: nullUne chaîne qui commence par [La;@ou quelque chose comme ça) 10 à ¹⁰⁰ fois en temps O (éternel).

Java, 153 octets

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

Sortie: 1e100 1s

Je sais qu'il existe une autre réponse Java qui est également assez proche. Le mien a une main et est toujours plus court cependant.

Ceci est ma première entrée code-golf. Conseils appréciés.

Pyth, 8 7 octets

V^T100G

Lien

La solution est testée avec une petite sortie, mais elle devrait imprimer abcdefghijklmnopqrstuvwxyz1e100 fois.

Pour une raison quelconque, l' pétait inutile, comme 31343 (Maltysen) dit .