Votre but est d'écrire un programme qui imprime un nombre. Plus le nombre est élevé, plus vous obtiendrez de points. Mais fais attention! La longueur du code est à la fois limitée et fortement pondérée dans la fonction de notation. Votre numéro imprimé sera divisé par le cube du nombre d'octets que vous avez utilisés pour votre solution .

Alors, disons que vous avez imprimé 10000000et que votre code est 100long en octets. Votre score final sera 10000000 / 100^3 = 10.

Il y a d'autres règles à suivre pour rendre ce défi un peu plus difficile.

• Vous ne pouvez pas utiliser de chiffres dans votre code (0123456789);
• Vous pouvez utiliser mathématique / physique / etc. constantes, mais seulement si elles sont inférieures à 10. (par exemple, vous pouvez utiliser Pi ~ = 3.14 mais vous ne pouvez pas utiliser la constante d'Avogadro = 6e23)
• La récursivité est autorisée, mais le nombre généré doit être fini (l' infini n'est donc pas accepté comme solution. Votre programme doit se terminer correctement, en supposant du temps et de la mémoire illimités, et générer le résultat demandé);
• Vous ne pouvez pas utiliser les opérations *(multiplier), /(diviser), ^(puissance) ni aucun autre moyen de les indiquer (par exemple, ce 2 div 2n'est pas autorisé);
• Votre programme peut générer plusieurs nombres, si vous en avez besoin . Seul le plus élevé comptera pour marquer;
• Cependant, vous pouvez concaténer des chaînes: cela signifie que toute séquence de chiffres adjacents sera considérée comme un nombre unique;
• Votre code sera exécuté tel quel. Cela signifie que l'utilisateur final ne peut éditer aucune ligne de code, ni saisir un nombre, ni rien d'autre.
• La longueur maximale du code est de 100 octets.

Classement

1. Steven H. , Pyth ≈ f _{φ (1,0,0) +7} (256 ²⁶ ) / 1000000 ^[1]
2. Simplement Beau Art , Ruby de f _{de φ 121 (ω)} (126) ^[1]
3. Peter Taylor , GolfScript ( f _{ε 0 + + 1} (17) / 1000 ^[1]
4. res , GolfScript ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126))))))))) ^[1]
5. Simply Beautiful Art , Ruby ≈ f _{w ^{© 2} + 1} (1983)
6. eaglgenes101 , Julia ≈ f _ω3 (127)
7. col6y , Python 3, (127 → 126 → ... → 2 → 1) / 99 ^{3 [1] [3]}
8. Toeofdoom , Haskell, ≈ un ₂₀ (1) / 99 ^{3 [1]}
9. Fraxtil , dc, 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 ^{3 [3]}
10. Magenta , Python, Ack (126,126) / 100 ³ ≈ 10 ↑ ¹²⁴ 129
11. Kendall Frey , ECMAScript 6, 10 ≈ ^{3 ↑ 4 3} /100 ^{3 [1]}
12. Ilmari Karonen , GolfScript, 10 ≈ ↑ ³ 10 ³⁷⁷ /18 ^{3 [1]}
13. BlackCap , Haskell, 10 ↑↑ 65503/100 ³
14. récursif , Python, 2 ↑↑ 11/95 ³ 10 ↑↑ 8.63297 ^{[1] [3]}
15. nm , Haskell, 2 ↑↑ 7/100 ³ 10 ↑↑ 4.63297 ^[1]
16. David Yaw , C, ≈ 10 ^{10 4 x 10 vingt-deux} / 83 ³ ≈ 10 ↑↑ 4,11821 ^[2]
17. Primo , Perl, 10 ≈ ^{(12750684161!) 5 x 2 27} /100 ³ ≈ 10 ↑↑ 4,11369
18. Art , C, ≈ 10 ^{10 2 x 10 6} /98 ³ ≈ 10 ↑↑ 3,80587
19. Robert Sørlie , x86, 10 ^{2 2 19 +32} / 100 ³ 10 ↑ ^ 3.71585
20. Tobia , APL, ≈ 10 ^{10 353} /100 ³ ≈ 10 ↑↑ 3,40616
21. Darren Stone , C, 10 10 ^{10 97,61735} / 98 ³ ≈ 10 ↑ ^ 3.29875
22. ecksemmess , C, 10 ≈ ^{2 320} /100 ³ ≈ 10 ↑↑ 3,29749
23. Adam Speight , vb.net, ≈ 10 ^{5000 × (2 64 ) quatre} / 100 ³ ≈ 10 ↑↑ 3,28039
24. Joshua , bash, ≈ 10 ^{10 15} /86 ³ ≈ 10 ↑↑ 3,07282

_{Notes de bas de page}

1. ^{Si chaque électron de l’univers était un qubit et que chaque superposition de celui-ci pouvait être utilisée à bon escient pour stocker des informations (qui, tant que vous n’avez pas réellement besoin de savoir ce qui est stocké est théoriquement possible), ce programme nécessite plus de mémoire que de ressources existe peut-être, et ne peut donc pas être exécuté - maintenant, ou à tout moment imaginable dans le futur. Si l'auteur avait l'intention d'imprimer une valeur supérieure à 3 ↑↑ 3.28 en une fois, cette condition s'applique.}
2. ^{Ce programme nécessite plus de mémoire qu’il n’existe actuellement, mais pas tant qu’il ne pourrait théoriquement pas être stocké sur un nombre restreint de qubits; il peut donc exister un jour un ordinateur capable d’exécuter ce programme.}
3. ^{Tous les interprètes actuellement disponibles génèrent une erreur d'exécution ou le programme ne s'exécute pas autrement, comme le prévu l'auteur.}
4. ^{L'exécution de ce programme causera des dommages irréparables à votre système.}

Edit @primo : J'ai mis à jour une partie du tableau de bord en utilisant une notation plus facile à espérer, avec des décimales pour indiquer la distance logarithmique à la puissance immédiatement supérieure. Par exemple 10 ↑↑ 2.5 = 10 ^{10 √10} . J'ai également modifié certains scores si je croyais que l'analyse de l'utilisateur était erronée, n'hésitez pas à en discuter.

Explication de cette notation:

Si 0 ≤ b < 1, alors .a↑↑b = ab

Si b ≥ 1, alors .a↑↑b = aa↑↑(b-1)

Si b < 0, alors .a↑↑b = loga(a↑↑(b+1))

GolfScript; marquer au moins f _{ε_0 + ω + 1} (17) / 1000

Suite à la suggestion de res d’utiliser la réponse d’un ver à cette question, je présente deux programmes qui améliorent considérablement son utilisation de la solution de Howard.

Ils partagent un préfixe commun, modulo le nom de la fonction:

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g

calcule g(g(1)) = g(5)où g(x) = worm_lifetime(x, [x])croît approximativement comme f _{ε 0} (ce qui correspond à "la fonction dans la hiérarchie en croissance rapide qui croît à peu près au même rythme que la fonction de Goodstein").

Le peu plus facile (!) À analyser est

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*

.{foo}*cartes xà foo^x x.

,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*

donne ainsi g^(g(5)) ( g(5) ); les 8 autres niveaux d'itération sont similaires à l'enchaînement des flèches. Pour exprimer en termes simples: si h_0 = get h_{i+1} (x) = h_i^x (x)puis nous calculons h_10 (g(5)).

Je pense que ce deuxième programme a presque certainement des résultats bien meilleurs. Cette fois, le label assigné à function gest une nouvelle ligne (sic).

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^

Cette fois, je fais un meilleur usage en ^tant que fonction différente.

.['.{
}*'n/]*zip n*~

prend xla pile, et laisse xsuivi d'une chaîne contenant des xcopies de .{suivi de gsuivi de xcopies de }*; il évalue ensuite la chaîne. Comme j'avais un meilleur endroit pour graver des caractères de rechange, nous commençons par j_0 = g; si j_{i+1} (x) = j_i^x (x)ensuite la première évaluation des ^calculs j_{g(5)} (g(5))(dont je suis sûr qu'elle bat déjà le programme précédent). J'exécute ensuite ^16 autres fois; donc si k_0 = g(5)et k_{i+1} = j_{k_i} (k_i)puis il calcule k_17. Je suis reconnaissant (encore) d’avoir estimé que k_i>> f _{ε_0 + + 1} (i).

Windows 2000 - Windows 8 (3907172 / 23³ = 321)

NOTE: NE PAS F'ING COURIR CETTE!

Enregistrez les éléments suivants dans un fichier de commandes et exécutez-le en tant qu'administrateur.

CD|Format D:/FS:FAT/V/Q

Sortie lorsqu’il est exécuté sur un lecteur de 4 To avec le premier numéro imprimé en gras.

Insérez un nouveau disque pour le lecteur D:
et appuyez sur ENTREE lorsque vous êtes prêt ... Le type de système de fichiers est NTFS.
Le nouveau système de fichiers est FAT.
QuickFormatting 3907172M
Le volume est trop important pour FAT16 / 12.

GolfScript, score: façon trop

OK, quel nombre peut-on imprimer avec quelques caractères de GolfScript?

Commençons par le code suivant ( merci, Ben! ), Qui affiche 126:

'~'(

Ensuite, répétons-le 126 fois, nous donnant un nombre égal à environ 1,26126 × 10 ³⁷⁷ :

'~'(.`*

(C'est la répétition de chaîne, pas la multiplication, donc ça devrait aller selon les règles.)

Maintenant, répétons ce nombre à 378 chiffres un peu plus de 10 ³⁷⁷ fois:

'~'(.`*.~*

Vous ne verrez jamais ce programme se terminer car il essaie de calculer un nombre d'environ 10 ³⁸⁰ × 2 ¹¹⁴⁰ chiffres. Aucun ordinateur jamais construit ne pourrait stocker un nombre aussi grand, et un tel ordinateur ne pourrait jamais être construit en utilisant la physique connue; le nombre d'atomes dans l'univers observable est estimé à environ 10 ⁸⁰ , même si nous pouvions utiliser toute la matière dans l'univers pour stocker ce grand nombre, nous aurions toujours en quelque sorte à entasser environ 10 ³⁸⁰ /10 ⁸⁰ = 10 ³⁰⁰ chiffres dans chaque atome!

Mais supposons que nous ayons l'interprète GolfScript de Dieu, capable de faire un tel calcul, et que nous ne soyons toujours pas satisfaits. OK, refaisons ça!

'~'(.`*.~*.~*

La sortie de ce programme, si elle pouvait se terminer, aurait environ 10 ^{10 383} chiffres, ce qui équivaudrait à environ ^{10 10 383} .

Mais attendez! Ce programme devient un peu répétitif ... pourquoi ne le transformons-nous pas en boucle?

'~'(.`*.{.~*}*

Ici, le corps de la boucle est parcouru environ 10 ³⁷⁷ fois, ce qui nous donne une sortie théorique composée d'environ 10 ^{10⋰ 10 377} chiffres environ, où la tour de puissances itérées de 10 mesure environ 10 ³⁷⁷ pas. (En fait, c'est une sous-estimation flagrante, car je néglige le fait que le nombre de répétitions s'allonge également à chaque fois, mais relativement parlant, il s'agit d'un problème mineur.)

Mais nous n'avons pas encore fini. Ajoutons une autre boucle!

'~'(.`*.{.{.~*}*}*

Même écrire correctement une approximation de tels nombres nécessite une notation mathématique ésotérique. Par exemple, dans la notation avec flèche vers le haut Knuth , le nombre (théoriquement) généré par le programme ci-dessus devrait être d’environ 10 ↑ ³ 10 ³⁷⁷ , donnez ou prenez quelques (ou 10 ³⁷⁷ ) puissances de dix, en supposant que j’ai bien fait les calculs.

Des chiffres comme celui-ci vont bien au-delà du mot "incroyablement énorme" et dans le domaine de "l'inconcevable". Comme dans, non seulement il est impossible de compter ou d'écrire de tels nombres (nous avons déjà dépassé ce point au troisième exemple ci-dessus), mais ils n'ont littéralement aucun usage ou existence concevable en dehors des mathématiques abstraites. Nous pouvons prouver, à partir des axiomes des mathématiques , que de tels nombres existent, tout comme nous pouvons prouver de la spécification GolfScript que le programme ci - dessus les calculera, si les limites de la réalité et de l'espace de stockage disponible n'intervenaient pas), mais il n'y a littéralement rien dans l'univers physique que nous pourrions utiliser pour compter ou mesurer dans tous les sens.

Pourtant, les mathématiciens utilisent parfois des nombres encore plus grands . (Théoriquement) les numéros de calcul que grand prend un peu plus de travail - au lieu de l' imbrication des boucles un peu plus un par un, nous devons utiliser la récursivité pour télescoper la profondeur des boucles imbriquées. Néanmoins, en principe, il devrait être possible d'écrire un court programme GolfScript (bien inférieur à 100 octets, je suppose) pour calculer (théoriquement) tout nombre exprimable en, par exemple, la notation en flèche chaînée de Conway ; les détails sont laissés comme un exercice. ;-)

JavaScript 44 caractères

Cela peut sembler un peu trompeur:

alert((Math.PI+''+Math.E).replace(/\./g,""))

Score = 31415926535897932718281828459045/44 ^ 3 3.688007904758867e + 26 10 ↑↑ 2.1536134004

C, note = 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 2.29874984

unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}

J'apprécie l'aide pour marquer. Toutes les idées ou corrections sont appréciées. Voici ma méthode:

n = la concaténation de chaque nombre de 1 à 2 ⁶⁴ -1, répété (2 ⁶⁴ -1) ⁴ fois . Premièrement, voici comment j’estime (en bas) le nombre cumulé de chiffres compris entre 1 et 2 ⁶⁴ -1 (la "sous-séquence"): Le nombre final dans la séquence de sous-séquence est 2 ⁶⁴ -1 = 18446744073709551615avec 20 chiffres. Ainsi, plus de 90% des numéros de la sous-séquence (ceux commençant par 1.. 9) ont 19 chiffres. Supposons les 10% restants en moyenne, 10%. Ce sera beaucoup plus que cela, mais il s'agit d'une estimation basse pour un calcul facile et sans tricherie. Cette sous-séquence se répète (2 ⁶⁴ -1) ⁴ fois, donc la longueursur n sera au moins (0,9 × (2 ⁶⁴ -1) × 19 + 0,1 × (2 ⁶⁴ -1) × 10) × (2 ⁶⁴ -1) ⁴ = 3,86613 × 10 ⁹⁷ chiffres. Dans les commentaires ci - dessous, confirme @primo la longueur de n être 4.1433x10 ⁹⁷ . Donc, n sera lui-même 10 à ce pouvoir, ou 10 ^{10 97.61735} .

l = 98 caractères de code

note = n / l ³ = 10 ^{10 97.61735} / 98 ³

Condition préalable: doit être exécuté sur un ordinateur 64 bits où sizeof(long) == 8. Mac et Linux vont le faire.

Python 3 - 99 caractères - (le plus probable) nettement plus grand que le nombre de Graham

J'ai mis au point une fonction augmentant plus rapidement basée sur une extension de la fonction Ackermann.

A=lambda a,b,*c:A(~-a,A(a,~-b,*c)if b else a,*c)if a else(A(b,*c)if c else-~b);A(*range(ord('~')))

http://fora.xkcd.com/viewtopic.php?f=17&t=31598 m'a inspiré, mais vous n'avez pas besoin de chercher là-bas pour comprendre mon numéro.

Voici la version modifiée de la fonction ackermann que je vais utiliser dans mon analyse:

A(b)=b+1
A(0,b,...)=A(b,...)
A(a,0,...)=A(a-1,1,...)
A(a,b,...)=A(a-1,A(a,b-1,...),...)

Ma fonction Adans le code ci-dessus n'est techniquement pas la même, mais elle est en réalité plus forte, avec l'instruction suivante pour remplacer la troisième ligne de la définition ci-dessus:

A(a,0,...)=A(a-1,a,...)

(a doit être au moins 1, il doit donc être plus fort)

Mais pour mes besoins, je supposerai qu’il s’agit du même que le plus simple, car l’analyse est déjà partiellement effectuée pour la fonction d’Ackermann, et donc pour cette fonction quand elle a deux arguments.

Il est garanti que ma fonction finira par arrêter de récurer car elle supprime toujours un argument, décrémente le premier argument ou conserve le même premier argument et décrémente le deuxième argument.

Analyse de taille

Le numéro de Graham, autant que je sache, peut être représenté comme suit G(64):

G(n) = g^n(4)
g(n) = 3 ↑^(n) 3

Où ↑^(n)b est la notation de la flèche montante de knuth.

Ainsi que:

A(a,b) = 2 ↑^(a-2) (b+3) - 3
A(a,0) ≈ 2 ↑^(a-2) 3
g(n) ≈ A(n+2,0) // although it will be somewhat smaller due to using 2 instead of 3. Using a number larger than 0 should resolve this.
g(n) ≈ A(n+2,100) // this should be good enough for my purposes.

g(g(n)) ≈ A(A(n+2,100),100)

A(1,a+1,100) ≈ A(0,A(1,a,100),100) = A(A(1,a,100),100)

g^k(n) ≈ A(A(A(A(...(A(n+2,100)+2)...,100)+2,100)+2,100)+2,100) // where there are k instances of A(_,100)
A(1,a,100) ≈ A(A(A(A(...(A(100+2),100)...,100),100),100),100)

g^k(100) ≈ A(1,k,100)
g^k(4) < A(1,k,100) // in general
g^64(4) < A(1,64,100)

Le nombre exprimé dans le programme ci-dessus est A(0,1,2,3,4,...,123,124,125).

Puisque g^64(4)c'est le nombre de Graham, et en supposant que mes calculs soient corrects, il est inférieur à A(1,64,100), mon nombre est nettement supérieur à celui de Graham.

Signalez toutes les erreurs que j'ai commises dans mes calculs - bien que s’il n’y en ait pas, cela devrait être le plus grand nombre calculé à ce jour pour répondre à cette question.

Perl - score 10 ↑↑ 4.1

$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Une fois encore, abusant du moteur de regex de Perl pour passer à travers une quantité inimaginable de combinaisons, cette fois en utilisant une descente récursive.

Dans la plus grande partie de l'expression, nous avons le choix .d'éviter une récursion infinie, limitant ainsi les niveaux de récursion à la longueur de la chaîne.

Nous allons finir avec ceci:

/((((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*/
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                    .                                      \
                       .
                       .

... répété 671088640 fois, pour un total de 12750684161 nids - ce qui met complètement en échec ma précédente tentative de 23 nids. Remarquablement, perl n’étouffe même pas (une fois encore, l’utilisation de la mémoire reste stable à environ 1,3 Go), bien que la première instruction print prenne un certain temps à sortir.

De mon analyse précédente ci-dessous, il peut être conclu que le nombre de chiffres sortis sera de l'ordre de (! 12750684161) ^671088640 , où ! K est le facteur de gauche de k (voir A003422 ). Nous pouvons approximer cela comme (k-1)! , qui est strictement plus petit, mais du même ordre de grandeur.

Et si nous demandons à wolframalpha :

... qui change à peine mon score du tout. Je pensais que ce serait au moins 10 ↑↑ 5 . Je suppose que la différence entre 10 ↑↑ 4 et 10 ↑↑ 4.1 est beaucoup plus grande que vous ne le pensez.

Perl - score 10 ↑↑ 4

$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Abuser du moteur Perl regex pour faire de la combinatoire pour nous. Le codeblock intégré
(??{print})va insérer son résultat directement dans la regex. Puisque $_est entièrement composé de 2s (et le résultat de printest toujours 1), cela ne peut jamais correspondre, et envoie Perl tourner à travers toutes les combinaisons possibles, parmi lesquelles il en existe quelques-unes.

Constantes utilisées

• $^F- le descripteur de fichier système maximal, généralement 2.
• $]- le numéro de version perl, similaire à 5.016002.

$_est alors une chaîne contenant le chiffre 2répété 671088640 fois. L'utilisation de la mémoire est constante à environ 1,3 Go, la sortie commence immédiatement.

Une analyse

Définissons P _k (n) comme le nombre d'exécutions de l'instruction print, où k est le nombre d'imbrication et n la longueur de la chaîne plus un (simplement parce que je n'ai pas envie d'écrire n + 1 partout).

(.*.*)*
P ₂ (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

((.*.*)*)*
P ₃ (n) = [ 3, 18, 123, 900, 6693, 49926, 372615, 2781192, ... ]

(((.*.*)*)*)*
P ₄ (n) = [ 4, 56, 1044, 20272, 394940, 7696008, 149970676, 2922453344, ... ]

((((.*.*)*)*)*)*
P ₅ (n) = [ 5, 250, 16695, 1126580, 76039585, 5132387790, 346417023515, 23381856413800, ... ]

(((((.*.*)*)*)*)*)*
P ₆ (n) = [ 6, 1452, 445698, 137050584, 42142941390, 12958920156996, ... ]

((((((.*.*)*)*)*)*)*)*
P ₇ (n) = [ 7, 10094, 17634981, 30817120348, 53852913389555, ... ]

etc. En général, la formule peut être généralisée comme suit:

où

C’est-à- dire le facteur de gauche de k , c’est-à-dire la somme de toutes les factorielles inférieures à k (voir A003422 ).

Je suis incapable de déterminer les formulaires fermés pour D _k et E _k , mais cela n'a pas d'importance, si nous observons que

et

Avec 23 nids, cela nous donne un score approximatif de:

Cela devrait être presque exact, en fait.

Mais pour mettre cela dans une notation un peu plus facile à visualiser, nous pouvons approximer la base de l'exposant interne:

et ensuite l'exposant lui-même:

et ensuite demander à wolframalpha :

que vous pouvez aussi bien appeler 10 ↑↑ 4 et en finir .

Javascript, 10 ↑↑↑↑ 210

100 caractères:

z=~~Math.E+'';o={get f(){for(i=z;i--;)z+=i}};o.f;for(i=z;i--;)for(j=z;j--;)for(k=z;k--;)o.f;alert(z)

Sur la base de l'observation selon laquelle l'itération maximale fest la meilleure façon de procéder, j'ai remplacé les 13 appels à fpar 3 niveaux d'appels de boucles imbriquées f, zmultipliés par chacun (tout en fcontinuant d'augmenter).z ).

J'ai estimé la partition de manière analytique sur une feuille de papier. Je la dactylographierai si quelqu'un est intéressé à la voir.

Score amélioré: 10 ↑↑ 13

Javascript, encore exactement 100 caractères:

z=~~Math.E+'';__defineGetter__('f',function(){for(i=z;i--;)z+=i});f;f;f;f;f;f;f;f;f;f;f;f;f;alert(z)

Cela améliore ma réponse initiale de trois manières—

1. Définir zsur la portée globale nous évite d'avoir à taper à o.zchaque fois.

2. Il est possible de définir un getter sur la portée globale (fenêtre) et de taper à la fplace de o.f.

3. Avoir plus d'itérations de fvaut plus que de commencer par un nombre plus grand. Ainsi, au lieu de (Math.E+'').replace('.','')(= 2718281828459045, 27 caractères), il est préférable d'utiliser ~~Math.E+''(= 2, 11 caractères) et d'utiliser les caractères récupérés pour appeler fplusieurs fois.

Comme, comme on le verra plus loin, chaque itération produit, à partir d’un nombre de l’ordre de grandeur M , un nombre supérieur de l’ordre de 10 ^M , ce code produit après chaque itération

1. 210 O (10 ² )
2. O (10 ^{10 2} ) O (10 ↑↑ 2)
3. O (10 ^{10 ↑↑ 2} ) = O (10 ↑↑ 3)
4. O (10 ^{10 ↑↑ 3} ) = O (10 ↑↑ 4)
5. O (10 ^{10 ↑↑ 4} ) = O (10 ↑↑ 5)
6. O (10 ^{10 ↑↑ 5} ) = O (10 ↑↑ 6)
7. O (10 ^{10 ↑↑ 6} ) = O (10 ↑↑ 7)
8. O (10 ^{10 ↑↑ 7} ) = O (10 ↑↑ 8)
9. O (10 ^{10 ↑↑ 8} ) = O (10 ↑↑ 9)
10. O (10 ^{10 ↑↑ 9} ) = O (10 ↑↑ 10)
11. O (10 ^{10 ↑↑ 10} ) = O (10 ↑↑ 11)
12. O (10 ^{10 ↑↑ 11} ) = O (10 ↑↑ 12)
13. O (10 ^{10 ↑↑ 12} ) = O (10 ↑↑ 13)

Note: ^{10 10 10 10 10 16} 10 ↑↑ 6.080669764

Javascript, en exactement 100 caractères:

o={'z':(Math.E+'').replace('.',''),get f(){i=o.z;while(i--){o.z+=i}}};o.f;o.f;o.f;o.f;o.f;alert(o.z)

Chacune o.finvoque la boucle while, pour un total de 5 boucles. Après seulement la première itération, le score est déjà supérieur à 10 ^{42381398144233621} . À la deuxième itération, Mathematica était incapable de calculer même le nombre de chiffres du résultat.

Voici une procédure pas à pas du code:

Init

Commencez par 2718281828459045 en supprimant le point décimal de Math.E .

Itération 1

Concaténer la séquence décroissante des nombres,

• 2718281828459045
• 2718281828459044
• 2718281828459043
• ...
• 3
• 2
• 1
• 0

former un nouveau numéro (gigantesque),

• 271828182845904527182818284590442718281828459043 ... 9876543210.

Combien de chiffres sont dans ce nombre? Eh bien, c'est la concaténation de

• 1718281828459046 numéros à 16 chiffres
• 900000000000000 numéros à 15 chiffres
• 90000000000000 numéros à 14 chiffres,
• 9000000000000 numéros à 13 chiffres
• ...
• 900 numéros à 3 chiffres
• 90 numéros à 2 chiffres
• 10 numéros à 1 chiffre

Dans Mathematica,

In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626

En d'autres termes, il s'agit de 2.72⋅10 ^{42381398144233625} .

Faire ma partition, après seulement la première itération, 2.72⋅10 ^{42381398144233619} .

Itération 2

Mais ce n'est que le début. Maintenant, répétez les étapes, en commençant par le nombre gigantesque ! C'est-à-dire, concaténer la séquence décroissante de nombres,

• 271828182845904527182818284590442718281828459043 ... 9876543210
• 271828182845904527182818284590442718281828459043 ... 9876543209
• 271828182845904527182818284590442718281828459043 ... 9876543208
• ...
• 3
• 2
• 1
• 0

Alors, quelle est ma nouvelle partition, Mathematica?

In[2]:= 1.718281828459046*10^42381398144233624*42381398144233625 + Sum[9*10^i*(i + 1), {i, -1, 42381398144233623}] + 1

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

Out[2]= Overflow[]

Itération 3

Répéter.

Itération 4

Répéter.

Itération 5

Répéter.

Score analytique

Lors de la première itération, nous avons calculé le nombre de chiffres dans la concaténation de la séquence décroissante à partir de 2718281828459045, en comptant le nombre de chiffres dans

• 1718281828459046 numéros à 16 chiffres
• 900000000000000 numéros à 15 chiffres
• 90000000000000 numéros à 14 chiffres,
• 9000000000000 numéros à 13 chiffres
• ...
• 900 numéros à 3 chiffres
• 90 numéros à 2 chiffres
• 10 numéros à 1 chiffre

Cette somme peut être représentée par la formule,

où Z désigne le numéro de départ ( par exemple 2718281828459045) et O _Z désigne son ordre de grandeur ( par exemple 15, car Z 10 ¹⁵ ). En utilisant des équivalences pour des sommes finies , ce qui précède peut être exprimé explicitement par

qui, si nous prenons 9 ≈ 10, se réduit encore à

et, enfin, en élargissant les termes et en les classant par ordre de grandeur décroissant, nous obtenons

Maintenant, comme nous ne sommes intéressés que par l’ordre de grandeur du résultat, substituons à Z un "nombre de l’ordre de grandeur de O _Z ", c’est-à-dire 10 ^{O _Z} -

Enfin, les 2ème et 3ème termes sont annulés et les deux derniers termes peuvent être supprimés (leur taille est triviale), nous laissant

à partir duquel le premier terme l'emporte.

Retraité, fprend un nombre de l'ordre de M et produit un nombre approximativement de l'ordre de M (10 ^M ).

La première itération peut facilement être vérifiée à la main. 2718281828459045 est un nombre de l'ordre de 15 - fdoit par conséquent produire un nombre de l'ordre de 15 (10 ¹⁵ ) 10 ¹⁶ . En effet, le nombre produit est, à partir de l’avant, de 2,72 à 10 ^{42381398144233625} - soit 10 ^{42381398144233625} 10 ^{10 16} .

Notant que M n’est pas un facteur significatif dans M (10 ^M ), l’ordre de grandeur du résultat de chaque itération suit donc un schéma simple de pénétration:

1. dix ¹⁶
2. 10 ^{10 16}
3. 10 ^{10 10 16}
4. 10 ^{10 10 10 16}
5. 10 ^{10 10 10 10 16}

Sources LaTeX

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\sum_{k=0}^{\mathcal{O}_Z-1}{(9\cdot10^k(k+1))}+1

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\frac{10-\mathcal{O}_Z10^{\mathcal{O}_Z}+(\mathcal{O}_Z-1)10^{\mathcal{O}_Z+1}}{9}+10^{\mathcal{O}_Z}

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+1

Z\mathcal{O}_Z+Z-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}+10^{\mathcal{O}_Z}-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}

APL, 10 ↑↑ 3.4

Voici ma tentative révisée:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

Programme de 100 caractères / octet *, fonctionnant sur le matériel actuel (utilise une quantité de mémoire négligeable et des variables int standard de 32 bits) bien que son exécution prenne beaucoup de temps.

Vous pouvez réellement l'exécuter sur un interpréteur APL et il commencera à imprimer des chiffres. S'il est autorisé à terminer, il aura imprimé un nombre de 10 × 123456789 ⁴⁴ chiffres.

Par conséquent , le score est de 10 ^{10 x 123.456.789 44} /100 ³ ≈ 10 ^{10 353} ≈ 10 ↑↑ 3,406161

Explication

• ⎕D est une chaîne constante prédéfinie égale à '0123456789'
• n←⍎⎕Ddéfinit n comme étant le nombre représenté par cette chaîne: 123456789 (qui est <2 ³¹ et peut donc être utilisé comme variable de contrôle de boucle)
• {⍞←⎕D} imprimera les 10 chiffres sur la sortie standard, sans nouvelle ligne
• {⍞←⎕D}⍣nle fera n fois (⍣ est le "power operator": ce n'est ni *, /, ni ^, car ce n'est pas une opération mathématique, c'est une sorte de boucle)
• {⍞←n}⍣n⍣nrépétera l'opération précédente n fois, donc en imprimant les 10 chiffres n ² fois
• {⍞←n}⍣n⍣n⍣nva le faire n ³ fois
• Je pourrais tenir 44 ⍣ndedans, donc ça imprime n ⁴⁴ fois la corde '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL peut être écrit dans son propre jeu de caractères codé sur un octet (existant) qui mappe les symboles APL sur les valeurs supérieures à 128 octets. Par conséquent, aux fins de la notation, un programme de N caractères qui utilise uniquement des caractères ASCII et des symboles APL peut être considéré comme ayant une longueur de N octets.}

Haskell, score: (2 ^{2 2 65536} -3) / 1000000 2 ↑↑ 7 10 ↑↑ 4.6329710779

o=round$sin pi
i=succ o
q=i+i+i+i
m!n|m==o=n+i
 |n==o=(m-i)!i
 |True=(m-i)!(m!(n-i))
main=print$q!q

Ce programme contient exactement 100 octets de code Haskell pur. Il imprimera le quatrième nombre Ackermann, consommant ainsi toute l’énergie disponible, matière et heure de l’Univers et au-delà ( dépassant ainsi légèrement la limite souple de 5 secondes).

Python, 2 ↑↑ 11/830584 10 ↑↑ 8.632971 (notation avec la flèche vers le haut Knuth)

print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))

Probablement aucun ordinateur n'a assez de mémoire pour exécuter ceci correctement, mais ce n'est pas vraiment la faute du programme. Avec la configuration système minimale satisfaite, cela fonctionne.

Oui, cela change quelque peu les valeurs booléennes. Trueest contraint de 1dans ce contexte. Python a des entiers de longueur arbitraire.

GolfScript 3.673e + 374

'~'(.`*

Je pense que le * est autorisé car il indique la répétition de chaîne, pas la multiplication.

Explication: '~'(laissera 126 (la valeur ASCII de "~") sur la pile. Copiez ensuite le nombre, convertissez-le en chaîne et répétez-le 126 fois. Cela donne 126126126126...ce qui est approximativement 1.26 e+377. La solution est de 7 caractères, divisez donc par 7^3, pour un score d'environ3.673e+374

Ruby, probabilistiquement infini, 54 caractères

x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x

x est initialisé à 97. Nous procédons ensuite comme suit: Générez x nombres aléatoires entre 0 et 1. S'ils sont tous identiques, terminez et imprimez x. Sinon, doublez x et répétez. Comme les nombres aléatoires de Ruby ont une précision de 17 chiffres, les chances de terminer à chaque étape sont de 1 sur (10e17) ^ x. La probabilité de terminer par n étapes est donc la somme pour x = 1 à n de (1 / 10e17) ^ (2 ^ n), qui converge vers 1 / 10e34. Cela signifie que quel que soit le nombre, quelle que soit sa taille, il est extrêmement improbable que ce programme produise un nombre inférieur.

Maintenant, bien sûr, la question philosophique est de savoir si un programme qui a moins de 1 chance sur 10 ^ 34 de se terminer à l’étape n pour n’importe quel n se termine jamais. Si nous supposons non seulement un temps et une puissance infinis, mais également que le programme a la capacité de fonctionner à une vitesse croissante à un taux supérieur à celui auquel la probabilité de terminer diminue, nous pouvons, je crois, en fait rendre la probabilité de se terminant au temps t arbitrairement proche de 1.

GolfScript, ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0))} (f _{ε 0} (126)))))))))

C’est une adaptation sans vergogne de une autre réponse de @Howard et intègre les suggestions de @Peter Taylor.

[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f

Ma compréhension de GolfScript est limitée, mais je crois que le * et les ^opérateurs ci - dessus sont pas les opérateurs arithmétiques interdites par l'OP.

(Je supprimerai volontiers ceci si @Howard veut soumettre sa propre version, qui serait de toute façon supérieure à celle-ci.)

Ce programme calcule un nombre qui est d' environ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))) ))) - une itération neuf de f _{ε 0} - où f _{ε 0} est la fonction dans la hiérarchie en croissance rapide qui croît à peu près au même rythme que la fonction de Goodstein. (f _{ε 0}croît si vite que les taux de croissance de la fonction n (k) de Friedman et des flèches k-fold coniques de Conway sont pratiquement insignifiants, même par comparaison à un seul f _{ε 0} non itéré .)

dc, 100 caractères

[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp

Avec assez de temps et de mémoire, cela va calculer un nombre d'environ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15. J'avais initialement implémenté la fonction d' hyperopération , mais cela nécessitait trop de caractères pour relever ce défi. J'ai donc supprimé les conditions n = 2, b = 0et n >= 3, b = 0, transformant ainsi la n = 1, b = 0condition enn >= 1, b = 0 .

Les seuls opérateurs arithmétiques utilisés ici sont l'addition et la soustraction.

EDIT: comme promis dans les commentaires, voici le détail de ce que fait ce code:

[            # start "hyperoperation" macro
lnA A-=i     # if n == 0 call macro i
lbA A-=j     # if b == 0 call macro j
laSa         # push a onto a's stack
lbB A--Sb    # push b-1 onto b's stack
LndB A--SnSn # replace the top value on n with n-1, then push n onto n's stack
lhxlhx       # call macro h twice
]sh          # store this macro in h

[            # start "increment" macro (called when n=0, the operation beneath addition)
LaLnLb       # pop a, b, and n
F+sb         # replace the top value on b with b+15
q            # return
]si          # store this macro in i

[            # start "base case" macro (called when n>0 and b=0)
LbLnLa       # pop b, n, and a
sb           # replace the top value on b with a
q            # return
]sj          # store this macro in j

Fsa          # store F (15) in a
Fsb          # store F (15) in b
FFFFFFsn     # store FFFFFF "base 10" (150000+15000+1500+150+15=1666665) in n
lhx          # load and call macro h
lbp          # load and print b

Comme indiqué plus haut, ceci diffère de la fonction d'hyperopération en ce que les cas de base pour la multiplication et les niveaux supérieurs sont remplacés par le cas de base pour l'addition. Ce code se comporte comme si a*0 = a^0 = a↑0 = a↑↑0 ... = a, au lieu du mathématiquement correct a*0 = 0eta^0 = a↑0 = a↑↑0 ... = 1 . En conséquence, il calcule des valeurs un peu plus élevées qu’elles ne devraient être, mais ce n’est pas grave, car nous visons de plus grands nombres. :)

EDIT: Je viens de remarquer qu’un chiffre a glissé dans le code par accident, dans la macro qui effectue des incréments pour n=0. Je l'ai supprimé en le remplaçant par «F» (15), ce qui a pour effet secondaire de réduire chaque opération d'incrémentation de 15. Je ne sais pas dans quelle mesure cela affecte le résultat final, mais c'est probablement beaucoup plus grand maintenant.

Plus de limite d'exécution? Alors ok.

Le programme doit-il être exécutable sur des ordinateurs modernes?

Les deux solutions utilisant une compilation 64 bits, il longs’agit donc d’un entier 64 bits.

C: supérieur à 10 ^{(2 64 -1) 2 64} , ce qui est lui-même supérieur à 10 ^{10 355393490465494856447} 10 ↑↑ 4.11820744

long z;void f(long n){long i=z;while(--i){if(n)f(n+~z);printf("%lu",~z);}}main(){f(~z);}

88 caractères.

Pour faciliter ces formules, je vais utiliser t = 2^64-1 = 18446744073709551615.

mainappellera favec un paramètre de t, qui bouclera les ttemps, en imprimant chaque fois la valeur tet en appelant favec un paramètre de t-1.

Chiffres imprimés au total: 20 * t.

Chacun de ces appels favec un paramètre t-1it va itérer le ttemps, afficher la valeur tet appeler f avec un paramètre de t-2.

Nombre total de chiffres imprimés: 20 * (t + t*t)

J'ai essayé ce programme en utilisant l'équivalent de nombres entiers de 3 bits (je me suis mis i = 8et j'ai eu l'appel principal f(7)). Il a frappé la déclaration d'impression 6725600 fois. Cela 7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7revient à Par conséquent, je crois que ceci est le décompte final du programme complet:

Nombre total de chiffres imprimés: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

Je ne sais pas comment calculer (2 ⁶⁴ -1) ^{2 64} . Cette somme est inférieure à (2 ⁶⁴ ) ^{2 64} et il me faut une puissance de deux pour effectuer ce calcul. Par conséquent, je vais calculer (2 ⁶⁴ ) ^{2 64 -1} . C'est plus petit que le résultat réel, mais comme c'est une puissance de deux, je peux le convertir en une puissance de 10 pour la comparaison avec d'autres résultats.

Est-ce que quelqu'un sait comment effectuer cette sommation ou comment convertir (2 ⁶⁴ -1) ^{2 64} à 10 ⁿ ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
divisez cet exposant par la base de journal 2 sur 10 pour passer la base de l’exposant à des puissances de 10.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

Mais rappelez-vous, c'est le nombre de chiffres imprimés. La valeur de l'entier est 10 élevée à cette puissance, donc 10 ^ 10 ^ 355393490465494856447

Ce programme aura une profondeur de pile de 2 ^ 64. Cela fait 2 ^ 72 octets de mémoire juste pour stocker les compteurs de boucles. Cela représente 4 milliards de téraoctets de compteurs de boucles. Sans parler des autres choses qui iraient sur la pile pour 2 ^ 64 niveaux de récursivité.

Edit: Correction d'une paire de fautes de frappe et utilisation d'une valeur plus précise pour log2 (10).

Edit 2: Attendez une seconde, j'ai une boucle dont le printf est en dehors. Réglons ça. Ajout en cours d'initialisation i.

Edit 3: Dang it, j'ai foiré le calcul sur l'édition précédente. Fixé.

Celui-ci fonctionnera sur des ordinateurs modernes, bien qu'il ne finisse pas de si tôt.

C: 10 ^ 10 ^ 136 ≈ 10 ↑↑ 3.329100567

#define w(q) while(++q)
long a,b,c,d,e,f,g,x;main(){w(a)w(b)w(c)w(d)w(e)w(f)w(g)printf("%lu",~x);}

98 caractères.

Cela imprimera l'inverse-bit de zéro, 2 ^ 64-1, une fois pour chaque itération. 2 ^ 64-1 est un numéro à 20 chiffres.

Nombre de chiffres = 20 * (2^64-1)^7= 1453677448591213780547019529026486359825087615481303750744349513987271378796172778919719519719

Arrondissant la longueur du programme à 100 caractères, Score = numéro imprimé / 1 000 000

Score = 10 ^ 14536774485912137805419195902648635982508761548130375074434951398727137879678696286195485195195195195195195195195195197

R - 49 41 caractères de code, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348

set.seed(T)
cat(abs(.Random.seed),sep="")

imprimera [reproduisant ici juste le début]:

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6 - 10 ^ 3 ↑↑↑↑ 3/884736

(3 ↑↑↑↑ 3 est G (1) où G (64) est le nombre de Graham)

u=-~[v=+[]+[]]+[];v+=e=v+v+v;D=x=>x.substr(u);K=(n,b)=>b[u]?n?K(D(n),K(n,D(b))):b+b+b:e;u+K(v,e)

Sortie: 10 ^ 3 ↑↑↑↑ 3

Conseils:

Gest la fonction où G (64) est le numéro de Graham. L'entrée est un entier. La sortie est une chaîne unaire écrite avec 0. Supprimée pour des raisons de concision.

Kest la fonction de flèche vers le haut Knuth a ↑ ⁿ b où a est implicitement 3. L'entrée est n, une chaîne unaire et b, une chaîne unaire. La sortie est une chaîne unaire.

u est "1".

v est "0000" ou G (0)

e est "000".

C

(Avec des excuses à Darren Stone)

long n,o,p,q,r;main(){while(--n){while(--o){while(--p){while(--q){while(--r){putchar('z'-'A');}}}}}}

n = 2 ^ 64 chiffres (9 ...)

l = 100 caractères de code

score ≈ 1e + 213598703592091008239502170616955211460270452235665276994704160782221972578064055002296207097070 ≈ 10 ↑ ^ 3.2974890744

[Note = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 2135987035920910082395025025325625954252)

Notez que je mérite d'être fouetté sans pitié pour cette réponse, mais que je n'ai pas pu résister. Je ne recommande pas d'agir comme moi sur stackexchange, pour des raisons évidentes. :-P

EDIT: Il serait encore plus difficile de résister à la tentation de faire quelque chose comme

long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}

... mais je suppose qu'une règle voulue mais non spécifiée était que toute la série de chiffres constituant le numéro devait être imprimée.

New Ruby: Note ~ f _{co ^co2 1} (126 ² 2 ¹²⁶ )

où f _α (n) est la hiérarchie en croissance rapide.

n=?~.ord;H=->a{b,*c=a;eval"b ?H[b==$.?c:[b==~$.?n:b-(b<=>$.)]*n+c]:p(n+=n);"*n};eval"H[~n];".*n*n<<n

Essayez-le en ligne!

Ce *nsont juste des multiplications de chaînes et de tableaux, elles devraient donc aller bien.

Code non golfé:

n = 126
H =-> a {
    b, *c = a
    n.times{
        case b
        when nil
            puts(n += n)
        when 0
            H[c]
        when -1
            H[[n]*n+c]
        else
            H[[b.-b<=>0]*n+c]
        end
    }
}
(n*n<<n).times{H[~n]}

où b.-b<=>0renvoie un entier 1plus proche de 0que b.

Explication:

Il imprime nau début de chaque appel de H.

H[[]]doubles n( nfois), à savoir n = n<<n.

H[[0,a,b,c,...,z]]appels H[[a,b,c,...,z]]( nfois).

H[[k+1,a,b,c,...,z]]appels H[[k]*n+[a,b,c,...,z]]( nfois), où [k]*n = [k,k,...,k].

H[[-1,a,b,c,...,z]]appels H[[n]*n+[a,b,c,...,z]]( nfois).

H[[-(k+1),a,b,c,...,z]]appels H[[-k]*n+[a,b,c,...,z]]( nfois).

H[k] = H[[k]].

Mon programme s’initialise n = 126puis appelle H[-n-1]126 ² 2 ¹²⁶ fois.

Exemples:

H[[0]]appellera H[[]]qui s’applique n = n<<n(n fois).

H[[0,0]]va appeler H[[0]]( nfois).

H[[1]]va appeler H[[0]*n]( nfois).

H[[-1]]va appeler H[[n]*n]( nfois).

H[[-1,-1]]va appeler H[[n]*n+[-1]]( nfois).

H[[-3]]va appeler H[[-2]*n]( nfois).

Essayez-le en ligne!

Voir les révisions pour d'autres choses intéressantes.

Haskell - Fonction Ackermann appliquée à son résultat 20 fois - 99 caractères

C’est la meilleure solution haskell que je puisse trouver sur la base de la fonction ackermann - vous remarquerez peut-être quelques similitudes avec la solution de nm, le i = round $ log pi a été inspiré à partir de là et le reste n’est qu’une coïncidence: D

i=round$log pi
n?m|m<i=n+i|n<i=i?(m-i)|True=(n-i)?m?(m-i)
a n=n?n
b=a.a.a.a
main=print$b$b$b$b$b$i

Il exécute la fonction ackermann sur elle-même 20 fois, en commençant à un, la séquence étant

• 1,
• 3
• 61,
• a (61,61),
• a (a (61,61), a (61,61)) --- nous appellerons cela un ₂ (61) ou un ₄ (1) ---
• un ₃ (61)
• ...
• un ₁₈ (61) ou un ₂₀ (1). Je pense que c'est environ ₁₈ g (voir ci-dessous).

En ce qui concerne l'estimation, Wikipédia dit:

a (m, n) = 2 ↑ ^m-2 (n + 3) - 3

De là, on peut voir a3 (1) = a (61,61) = 2 ↑ ⁵⁹ 64 + 3, ce qui est nettement supérieur à g1 = 3 ↑ ⁴ 3, à moins que le 3 au départ soit beaucoup plus important que je ne le pense. Ensuite, chaque niveau effectue les opérations suivantes (en éliminant les constantes non significatives dans un _n ):

• g _n = 3 ↑ ^{g _n-1} 3
• a _n ~ = 2 ↑ ^{a _n-1} (a _n-1 )

Si ceux-ci sont approximativement équivalents, alors un ₂₀ (1) ~ = g ₁₈ . Le terme final dans un _n , (un _n-1 ) est beaucoup plus grand que 3, donc potentiellement plus grand que g ₁₈ . Je verrai si je peux comprendre si cela le stimulerait même une seule itération et ferait rapport.

Code machine x86 - 100 octets (assemblé en tant que fichier MSDOS .com)

Note: peut plier les règles un peu

Ce programme produira 2 ^{(65536 * 8 + 32)} neuf résultats qui donneraient le score à (10 ^{2 524320} -1) / 1000000

En guise de compteur, ce programme utilise l’ensemble de la pile (64kiB) plus deux registres 16 bits.

Code assemblé:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Assemblée:

ORG 0x100

SECTION .TEXT
            mov bh, [b_ss]
            mov dx, ss
            mov [b_ss], dx
            mov [b_sp], sp
            mov ss, bx
            xor sp, sp
            mov bx, inthackdst
            inc bx
            mov ah, [inthacksrc]
            mov [bx], ah
            mov al, [nine]
            xor ah, ah
            inc ah
            inc ah
            inc ah
inthacksrc: adc ah, ah
            inc ah
            add ah, ah
            xor cx, cx
fillstack:  push cx
nine:       cmp sp, cx
            jnz fillstack
regloop:    xor dx, dx
dxloop:     xor cx, cx
cxloop:     xor bx, bx
inthackdst: int '?'
            inc cx
            jnz cxloop
            inc dx
            jnz dxloop
            pop cx
            inc cx
            jnz restack
popmore:    cmp sp, dx
            jz end
            pop cx
            inc cx
            jz popmore
restack:    push cx
            xor cx, cx
            cmp sp, dx
            jnz restack
            jmp regloop
end:        mov sp, [b_sp]
            mov ax, [b_ss]
            mov ss, ax
            ret

b_ss:       dw 'SX'
b_sp:       db 'X'

C

La taille du fichier est de 45 octets.

Le programme est:

main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}

Et le nombre produit est supérieur à 10 ^ (10 ^ (10 ^ 1.305451600608433)).

Le fichier que j'ai redirigé vers std out est actuellement supérieur à 16 Go et continue de croître.

Le programme se terminerait dans un délai raisonnable si j'avais un meilleur ordinateur.

Mon score n'est pas calculable avec une virgule flottante en double précision.

GNU Bash, 10 ^ 40964096² / 80 ^ 3 10 ↑↑ 2.072820169

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C count=$C$C|tr \\$((C-C)) $SHLVL'

C = 4096 sur tout système raisonnable. SHLVL est un petit entier positif (généralement 1 ou 2 selon que / bin / sh est bash ou non).

UNIX 64 bits uniquement:

Score: ~ 10 ^ (40964096409640964096 * 40964096409640964096) / 88 ^ 3

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C$C$C$C count=$C$C$C$C$C|tr \\$((C-C)) $SHLVL'

C, 10 ^ 10 ^ 2485766 ≈ 10 ↑↑ 3.805871804

unsigned a['~'<<'\v'],l='~'<<'\v',i,z;main(){while(*a<~z)for(i=l;printf("%u",~z),i--&&!++a[i];);}

Nous créons un tableau de 258048 entiers non signés. Il ne pouvait pas être longtemps non signé car cela rendait le programme trop long. Ils ne sont pas signés parce que je ne veux pas utiliser un comportement indéfini, ce code est propre C (autre que l'absence de retour de main ()) et sera compilé et exécuté sur n'importe quel ordinateur normal, il continuera à fonctionner pendant longtemps . Cette taille est la plus grande que nous puissions légalement exprimer sans utiliser de caractères non ASCII.

Nous parcourons le tableau à partir du dernier élément. Nous imprimons les chiffres de 2^32-1, incrémentons l’élément et lâchons la boucle si l’élément n’a pas été encapsulé à 0. De cette façon, nous bouclerons les (2^32 - 1)^254048 = 2^8257536temps en imprimant 10 chiffres à chaque fois.

Voici un exemple de code montrant le principe dans une plage de données plus limitée:

#include <stdio.h>
unsigned int a[3],l=3,i,f;

int
main(int argc, char *argc){
        while (*a<4) {
        for (i = l; i-- && (a[i] = (a[i] + 1) % 5) == 0;);
            for (f = 0; f < l; f++)
                printf("%lu ", a[f]);
            printf("\n");
        }
}

Le résultat est environ 10 ^ 10 ^ 2485766 divisé par un million, ce qui correspond encore à peu près à 10 ^ 10 ^ 2485766.

Powershell (2.53e107976 / 72³ = 6.78e107970 10 ↑↑ 1.701853371)

Cela prend plus de 5 secondes pour s'exécuter.

-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"

Il récupère et concatène la longueur en octets de chaque fichier de votre lecteur actuel. Regex supprime tous les caractères non numériques.

Python 3, score = ack (126,126) / 100 ^ 3

g=len('"');i=ord('~');f=lambda m,n:(f(m-g,f(m,n-g))if n else f(m-g,g))if m else n+g
print(f(i,i))

La fonction f est la fonction ackermann, que j’ai juste assez d’espace pour être invoquée.

Edit: précédemment "else n + 1", ce qui contrevenait aux règles du challenge - bravo à Simply Beautiful Art.

JavaScript 98 caractères

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(m.E<<k<<k<<k<<m.E);i+=j)a+=k;alert(a)

génère 2.718e + 239622337 10 ↑↑ 2.9232195202

Pour un score légèrement supérieur à 2,718e + 239622331 ≈ 10 ↑↑ 2.9232195197

qui est la plus grande que je puisse faire sans que le navigateur ne se bloque.

(console.log (a) vous montrera la sortie complète)

Ne lancez pas ceci:

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(k<<k<<k<<k<<k<<k<<k);i+=j)a+=k;alert(a)

serait sortie 2.718 + e121333054704 10 ↑↑ 3.0189898069 (aka 2.718 * 10 ^ (1.213 * 10 ^ 12) à comparer à la réponse plus longue:

version plus extrême, si cela n'a pas bloqué votre navigateur: (80 char)

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<k;i+=j)a+=k;alert(a)

ce qui créerait un nombre autour de la même taille que e * 10 ^ (10 ^ 19) 10 ↑↑ 3.106786869689

Edit: la solution originale mise à jour du code n'a généré que 2.718e + 464

Python 3: 98 caractères, 10 ↑↑ 256

Utiliser une fonction à argument variable:

E=lambda n,*C:E(*([~-n][:n]+[int("%d%d"%(k,k))for k in C]))if C else n;print(E(*range(ord('~'))))

Effectivement, E décrémente le premier argument en augmentant le reste des arguments, sauf qu'au lieu de mettre -1 dans les arguments, il supprime l'argument. Étant donné que chaque cycle décrémente le premier argument ou diminue le nombre d'arguments, il est garanti que cela se termine. La fonction croissante utilisée est int ("% d% d"% (k, k)), ce qui donne un résultat compris entre k ** 2 + 2 * k et 10 * k ** 2 + k. Mon code utilise le symbole *, mais pas comme une multiplication. Il est habitué à travailler avec un nombre variable d'arguments, ce qui, à mon avis, devrait suivre les règles, car l'objectif clair de ces règles était de restreindre des opérations spécifiques, pas les symboles eux-mêmes.

Quelques exemples de la taille rapide de E:

E(1,1) = 1111
E(0,1,1) = E(11,11) = (approx) 10^8191
E(1,1,1) = E(1111,1111) = (approx) 10^(10^335)
E(2,1,1) = E(11111111,11111111) = (approx) 10^(10^3344779)

Seuls les deux premiers sont exécutables sur mon ordinateur dans un délai raisonnable.

Ensuite, E est invoqué par E(*range(ord('~')))- ce qui signifie:

E(0,1,2,3,4,5, ... ,121,122,123,124,125)

Je ne suis pas tout à fait sûr de sa taille (j'ai essayé de l'approcher en vain) - mais il est évident que c'est ~ vraiment ~ grand.

Par exemple, environ douze cycles, le résultat est environ: (techniquement un peu plus que)

E(2**27211,2**27211,2**27212,2**27212,2**27212,2**27212,2**27213,2**27213,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636)

Estimation du résultat:

Si on se rapproche de l’augmentation progressive lambda k: 10 * k**2, la fonction peut être décrite comme

E(n, C₁, C₂, ... Cᵥ) ≈ E(10^(n²/2) ⋅ C₁²ⁿ, 10^(n²/2) ⋅ C₂²ⁿ, ... 10^(n²/2) ⋅ Cᵥ²ⁿ)
                     ≈ E(10^((10^(n²/2) ⋅ C₁²ⁿ)²/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )
                     ≈ E(10^((10^n² ⋅ C₁⁴ⁿ)/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )

La chose pertinente que nous faisons ici est de construire une tour avec des puissances de dix, de sorte que le score final puisse être estimé à 10 ↑↑ 256.

Meilleure estimation des résultats (bien que partielle):

Ceci utilise la même chose 10 * k**2que l'autre estimation.

E(0, b) = 10 * b**2
E(1, b) = 10 * (10 * b**2)**2 = 10 * 100 * b**4 = 10**3 * b**4
E(2, b) = 10 * (10**3 * b**4)**2 = 10 * (10**6 * b**8) = 10**7 * b**8
E(a, b) = 10**(2**(a+1)-1) * b**(2**(a+1))

Selon l'estimation précédente, ce serait:

E(a, b) = 10**(a**2/a) * b**(2*a)

Ce qui est nettement inférieur à la valeur réelle car il utilise a**2au lieu de 2**apour le 10 et utilise a*2au lieu de 2**apour le b.

C (score ≈ 10 ^ 20 000 000 000 ≈ 10 ↑↑ 3.005558275)

• ~ 20 Go de sortie
• 41 caractères (41 ^ 3 ne signifie rien)

main(){for(;rand();printf("%d",rand()));}

Malgré rand()le résultat, il est déterministe car il n’ya pas de fonction graine.