Votre objectif est d’imprimer (sur la sortie standard) le plus grand nombre possible, en utilisant seulement dix caractères de code.

• Vous pouvez utiliser n’importe quelle fonctionnalité de votre langue, à l’exception des fonctions d’exponentiation intégrées.
  • De même, vous ne pouvez pas utiliser de notation scientifique pour entrer un nombre. (Ainsi, non 9e+99.)
• Le programme doit imprimer le numéro sans aucune entrée de l'utilisateur. De même, aucune lecture à partir d'autres fichiers, du Web, etc.
• Votre programme doit calculer un nombre unique et l’imprimer. Vous ne pouvez pas imprimer une chaîne, ni imprimer le même chiffre des milliers de fois.
• Vous pouvez exclure de la limite de 10 caractères tout code nécessaire pour imprimer quoi que ce soit. Par exemple, dans Python 2, qui utilise la print xsyntaxe, vous pouvez utiliser jusqu'à 16 caractères pour votre programme.
• Le programme doit réellement réussir dans la sortie. Si cela prend plus d'une heure pour fonctionner sur l'ordinateur le plus rapide du monde, il n'est pas valide.
• La sortie peut être dans un format quelconque (vous pouvez imprimer 999, 5e+100etc.)
• L'infini est un concept abstrait , pas un nombre. Donc, ce n'est pas une sortie valide.

Wolfram Language

ack(9!,9!)

ack (9!, 9!) =

La sortie est en notation de flèche.

Perl,> 1.96835797883262e + 18

time*time

Peut-être pas la plus grande réponse ... aujourd'hui! Mais attendez assez de millénaires et ce le sera!

Pour répondre à certains des commentaires, par «assez de millénaires», je veux dire en fait dans ¹⁰⁰ ans.

Pour être juste, si la grande mort de l'univers par la chaleur et le gel est la façon dont l'univers se terminera (estimé à se produire ~ 10 ¹⁰⁰ ans), la valeur "finale" serait ~ 10 ²¹⁴ , ce qui est certainement beaucoup moins que certains des autres réponses (cependant, "les fluctuations quantiques aléatoires ou le tunneling quantique peuvent produire un autre Big Bang dans 10 ^{10 56} ans"). Si nous adoptons une approche plus optimiste (par exemple, un modèle cyclique ou multivers), le temps s'écoulera infiniment et, par conséquent, un jour, dans un univers, une architecture haute résolution, la réponse dépasserait certaines des autres.

D'autre part, comme indiqué, timeest en effet limité par la taille de l'entier / long, de sorte qu'en réalité, quelque chose comme ~0produirait toujours un nombre plus grand que time(c'est-à-dire le maximum timepris en charge par l'architecture).

Ce n'était pas la réponse la plus sérieuse, mais j'espère que vous l'avez appréciée!

Wolfram ≅ 2,003529930 × 10 ¹⁹⁷²⁸

Oui, c'est une langue! Il pilote le back-end du site populaire Wolfram Alpha. C'est la seule langue que j'ai trouvée où la fonction Ackermann est intégrée et abrégée en moins de 6 caractères.

En huit personnages:

$ ack(4,2)

200352993...719156733

Ou 2,003529930 × 10 ¹⁹⁷²⁸

ack(4,3), ack(5,2)etc. sont beaucoup plus grandes, mais trop grandes. ack(4,2)est probablement le plus grand nombre Ackermann qui peut être complètement calculé en moins d’une heure.

Les plus grands nombres sont rendus sous forme symbolique, par exemple:

$ ack(4,3)

2↑²6 - 3 // using Knuth's up-arrow notation

Les règles disent que tout format de sortie est autorisé, donc cela pourrait être valide. Ce nombre est supérieur à 10 ^{10 19727} , ce qui est supérieur à toutes les autres entrées ici à l'exception de la factorielle répétée.

cependant,

$ ack(9,9)

2↑⁷12 - 3

est plus grande que la factorielle répétée. Le plus grand nombre que je puisse obtenir en dix caractères est:

$ ack(99,99)

2↑⁹⁷102 - 3

C’est incroyablement énorme, l’Univers n’est pas assez grand pour représenter une partie significative de ses chiffres, même si vous avez pris des journaux répétés du nombre.

Coquille Python2, 3 010 301 chiffres

9<<9999999

Calcul de la longueur: Python ajoutera un "L" à ces nombres longs, de sorte qu'il indique 1 caractère de plus que le résultat ne contient de chiffres.

>>> len(repr( 9<<9999999 ))
3010302

Premier et dernier 20 chiffres:

40724177878623601356... ...96980669011241992192

CJam, 2 × 10 ^{268 435 457}

A28{_*}*K*

Ceci calcule b , défini comme suit:

• un ₀ = 10

• a _n = a _{n - 1} ²

• b = 20 × a ₂₈

$ time cjam <(echo 'A28{_*}*K*') | wc -c
Real    2573.28
User    2638.07
Sys     9.46
268435458

Contexte

Cela correspond à la même idée que la réponse de Claudiu , mais elle n’est pas fondée. J'avais une idée similaire que j'ai publiée quelques minutes à peine après la sienne , mais je l'ai abandonnée car elle ne se rapprochait pas de la limite de temps.

Cependant, la suggestion de Aditsu de passer à Java 8 et mon idée d'utiliser des puissances de 10 permettaient à CJam de calculer des nombres qui échappaient à la portée de GolfScript, ce qui semble être dû à certains bugs / limitations de Ruby's Bignum.

Comment ça fonctionne

A    " Push 10.                                                          ";
28{  " Do the following 28 times:                                        ";
  _* " Duplicate the integer on the stack and multiply it with its copy. ";
}*   "                                                                   ";
K*   " Multiply the result by 20.                                        ";

CJam, ≈ 8,1 × 10 1 ^{826 751}

KK,{)*_*}/

Cela prend moins de cinq minutes sur ma machine, donc il reste encore des améliorations à apporter.

Ceci calcule un ₂₀ , défini comme suit:

• un ₀ = 20

• a _n = (n × a _{n - 1} ) ²

Comment ça fonctionne

KK,   " Push 20 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ]. ";
{     " For each integer in the array:                                 ";
  )*  " Increment it and compute the its product with the accumulator. ";
  _*  " Multiply the result with itself.                               ";
}/

Python 3, 9 * 2 ^ (7 * 2 ^ 33)> 10 ^ 18,100,795,813

9 * 2 ^ (2 ^ 35)> 10 ^ 10,343,311,894

Edit: Ma nouvelle réponse est:

9<<(7<<33)

Ancienne réponse, pour la postérité:

9<<(1<<35)

Dix personnages exactement.

J'imprime le nombre dans l'hex, et

Vous pouvez exclure de la limite de 10 caractères tout code nécessaire pour imprimer quoi que ce soit. Par exemple, dans Python 2, qui utilise la syntaxe print x, vous pouvez utiliser jusqu'à 16 caractères pour votre programme.

Par conséquent, mon code actuel est:

print(hex(9<<(7<<33)))

La preuve qu'il s'exécute à l'heure spécifiée et génère un nombre de la taille spécifiée:

time python bignum.py > bignumoutput.py

real    10m6.606s
user    1m19.183s
sys    0m59.171s
wc -c bignumoutput.py 
15032385541 bignumoutput.py

Mon numéro> 10 ^ (15032385538 * log (16))> 10 ^ 18100795813

3 chiffres hexadécimaux de moins que l'impression wc ci-dessus en raison de l'initiale 0x9.

Python 3 est nécessaire car, en python 2, 7<<33serait long et <<ne prend pas longtemps en entrée.

Je ne peux pas utiliser 9 << (1 << 36) à la place parce que:

Traceback (most recent call last):
  File "bignum.py", line 1, in <module>
    print(hex(9<<(1<<36)))
MemoryError

Donc, c’est le plus grand nombre possible de la forme a<<(b<<cd) imprimables sur mon ordinateur.

Selon toute vraisemblance, la machine la plus rapide au monde a plus de mémoire que moi, alors ma réponse alternative est:

9<<(9<<99)

9 * 2 ^ (9 * 2 ^ 99)> 10 ^ (1.7172038461 * 10 ^ 30)

Cependant, ma réponse actuelle est la plus importante jamais soumise, ce qui est probablement suffisant. En outre, tout cela est supposé que le transfert de bits est autorisé. Il semble être, à partir des autres réponses utilisant.

Toute langue avec des noms suffisamment courts et constants, environ 18 chiffres.

99/sin(PI)

Je publierais ceci en tant que réponse PHP, mais malheureusement M_PIcela rend un peu trop long! Mais PHP rapporte 8.0839634798317E + 17 pour cela. Fondamentalement, il abuse du manque de précision absolue dans PI: p

Haskell

Sans astuces:

main = print -- Necessary to print anything
    $9999*9999 -- 999890001

On peut dire sans rien calculer:

main = print
    $floor$1/0 -- 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216

Adapter la réponse de Niet :

main = print
    $99/sin pi -- 8.083963479831708e17

Powershell - 1.12947668480335E + 42

99PB*9E9PB

Multiplie 99 Pebibytes fois 9 000 000 000 Pebibytes.

J ( ((((((((9)!)!)!)!)!)!)!)!)

Oui, c'est beaucoup. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))être pas très précis.

!!!!!!!!9x

K / Kona : 8.977649e261 1.774896e308

*/1.6+!170

• !170 crée un vecteur de nombres de 0 à 169
• 1.6+ ajoute un à chaque élément du vecteur et les convertit en réels (plage de 1,6 à 170,6)
• */ multiplie chaque élément du tableau ensemble

Si Kona prenait en charge la précision quad, je pourrais le faire */9.+!999et éviter 1e2584. Malheureusement, ce n'est pas le cas et je suis limité à la double précision.

ancienne méthode

*/9.*9+!99

• !99 crée un vecteur de nombres de 0 à 98
• 9+ ajoute 9 à chaque élément du vecteur (plage de 9 à 107)
• 9.* multiplie chaque élément par 9.0 (conversion implicite en reals, donc 81.0 à 963.0)
• */ multiplie chaque élément du vecteur ensemble

HTML, 9999999999

9999999999

.. j'y suis arrivé.

Python - Varie, jusqu'à 13916486568675240 (jusqu'à présent)

Pas tout à fait sérieux mais je pensais que ce serait amusant.

print id(len)*99

Parmi toutes les choses que j’ai essayées, lenc’est de manière constante que l’on me donne de gros identifiants

Cédé 13916486568675240 (17 chiffres) sur mon ordinateur et 13842722750490216 (également 17 chiffres) sur ce site . Je suppose qu’il est possible que cela vous donne une valeur aussi basse que 0, mais cela pourrait aussi aller plus haut.

Golfscript, 1e + 33 554 432

10{.*}25*

Les calculs 10 ^ (2 ^ 25) , sans utiliser d'exposants, s'exécute en 96 secondes:

$ time echo "10{.*}25*" | ruby golfscript.rb  > BIG10

real    1m36.733s
user    1m28.101s
sys     0m6.632s
$ wc -c BIG10
 33554434 BIG10
$ head -c 80 BIG10
10000000000000000000000000000000000000000000000000000000000000000000000000000000
$ tail -c 80 BIG10
0000000000000000000000000000000000000000000000000000000000000000000000000000000

Il peut calculer jusqu'à 9 ^ (2 ^ 9999) , si on lui donne suffisamment de temps, mais incrémenter l'exposant interne d'un unité le fait multiplier par trois le temps; la limite d'une heure sera donc bientôt atteinte.

Explication :

Utiliser une version précédente avec la même idée:

8{.*}25*

Le décomposer:

8         # push 8 to the stack
{...}25*  # run the given block 25 times

La pile au début de chaque bloc se compose d'un numéro, le numéro actuel. Cela commence comme 8. Ensuite:

.         # duplicate the top of the stack, stack is now | 8 | 8 |
*         # multiply top two numbers, stack is now       | 64 |

Donc, la pile, pas à pas, ressemble à ceci:

8
8 8
64
64 64
4096
4096 4096
16777216
16777216 16777216

... etc. Ecrit en notation mathématique, la progression est la suivante:

n=0, 8                     = 8^1  = 8^(2^0)
n=1, 8*8                   = 8^2  = 8^(2^1)
n=2, (8^2)*(8^2) = (8^2)^2 = 8^4  = 8^(2^2)
n=3,               (8^4)^2 = 8^8  = 8^(2^3)
n=4,               (8^8)^2 = 8^16 = 8^(2^4)

wxMaxima ~ 3x10 ^49,948 (ou 10 ^{8.565.705.514} )

999*13511!

La sortie est

269146071053904674084357808139[49888 digits]000000000000000000000000000000

Je ne sais pas si cela correspond tout à fait aux spécifications (en particulier au format de sortie), mais je peux frapper encore plus gros:

bfloat(99999999!)

La sortie est

9.9046265792229937372808210723818b8565705513

C'est à peu près 10 ^{8.565.705.514,} ce qui est nettement plus grand que la plupart des réponses principales et a été calculé en environ 2 secondes. La bfloatfonction donne une précision arbitraire .

Haskell, 4950

Aww man, ce n'est pas beaucoup! 10 caractères commencent après le signe dollar.

main=putStr.show$sum[1..99]

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

Dix personnages exactement.

Coquille Python, 649539 999890001

Beats Haskell, pas vraiment une réponse sérieuse.

99999*9999

Wolfram Alpha (un site Web compte-t-il comme une langue)?

9! ! ! ! !

les sorties

10^(10^(10^(10^(10^(6.27...))))

Merci à Cory pour le conseil que les espaces fonctionnent aussi bien que les parens.

Befunge-93 (1,853,020,188,851,841)

Heureux que personne n'ait encore fait Befunge (c'est mon créneau), mais bon sang je ne peux trouver aucun truc pour en augmenter le nombre.

9:*:*:*:*.

Donc, il est 9 ^ 16.

:*

Multiplie fondamentalement la valeur en haut de la pile avec elle-même. Donc, la valeur au sommet de la pile va:

9
81
6561
43046721
1853020188851841

et

.

Affiche la valeur finale. Je serais intéressé de voir si quelqu'un a de meilleures idées.

Je préfère poster ceci comme un commentaire ci-dessus, mais apparemment je ne peux pas puisque je suis un noob.

Python:

9<<(2<<29)

J'adopterais un décalage plus important, mais Python semble vouloir que l'opérande correct d'un décalage soit un entier non long. Je pense que cela se rapproche du max théorique:

9<<(7<<27)

Le seul problème avec ceux-ci est qu'ils pourraient ne pas satisfaire la règle 5

Matlab (1.7977e + 308)

Matlab stocke la valeur du plus grand nombre (à double précision) en virgule flottante dans une variable appelée realmax. L'appeler dans la fenêtre de commande (ou sur la ligne de commande) affiche sa valeur:

>> realmax

ans =

  1.7977e+308

Python, ca. 1.26e1388

9<<(9<<9L)

Donne:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562671606191396751475718572657335136386433456031845303125303125303183modification des produits chimiques3763403631303885997729562671606191396751475718572657335136386433456031845303125303125303183modification des produits chimiques

Au moins Python 3.5.0 (64 bits), plus de 10 ^ 242944768872896860

print("{:x}".format( 9<<(7<<60) ))

Dans un monde idéal, ce serait 9<<(1<<63)-1 , mais il n'y a pas assez d'octets pour cela. Ce nombre est si grand qu'il faut presque 1 EiB de mémoire pour le contenir, ce qui est un peu plus que ce que j'ai sur mon ordinateur. Heureusement, il vous suffit d'utiliser environ 0,2% de l'espace de stockage mondial pour le stocker. La valeur en binaire est1001 suivie de 8070450532247928832 zéros.

Si Python sortait pour les machines 128 bits, le maximum serait 9<<(9<<99), ce qui nécessite moins de 1 MiYiB de mémoire. C'est bien, car il vous resterait assez d'espace adressable pour stocker l'interpréteur Python et le système d'exploitation.

Cubix , 9.670457478596419e + 147 (non compétitif)

****"///**

Non compétitif car Cubix est plus récent que ce défi. Vous pouvez le tester en ligne ici , mais notez qu'il n'imprime pas le numéro; vous devrez mettre le programme en pause après les deux dernières* s pour voir la valeur sur la pile.

Comment ça fonctionne

Cubix est un esolang à 2 dimensions dans lequel le code est enroulé autour d'un cube. Ce code est exactement équivalent au cube suivant, avec .no-op:

    * *
    * *
" / / / * * . .
. . . . . . . .
    . .
    . .

Ensuite, le code est exécuté, le pointeur d'instruction (IP) commençant dans le coin supérieur gauche de la face la plus à gauche, en regard de droite. "active le mode chaîne, où tous les caractères rencontrés jusqu'à la prochaine "poussent leurs codes dans la pile. L’IP tourne tout autour du code en poussant trois /s (47), deux *s (42) et deux. s (46) sur la pile, avant de quitter à nouveau le mode chaîne.

Voici où ça devient intéressant. Le premier miroir /reflète l'adresse IP, elle est donc tournée vers le haut. il tourne ensuite autour du cube, en tapant ces caractères:

           
    * *
  /     *      
  .     .      
    . .

Les trois *s multiplient les deux premiers éléments de la pile. Désormais, contrairement à la plupart des langages basés sur des piles où les opérateurs arithmétiques affichent leurs arguments, Cubix laisse les valeurs précédentes sur la pile. Cela signifie donc que cela calcule46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976 .

Lorsque l'IP atteint le /nouveau, il est tourné à droite. Il frappe ensuite le miroir suivant et suit ce chemin:

    *  
    *  
    /         .
    .         .
    .  
    .  

Les deux astérisques multiplient les deux premiers éléments. Ensuite, le miroir dirige à nouveau correctement l’adresse IP et le troisième miroir répète le processus:

      *
      *
      /     .  
      .     .  
      .
      .

Enfin, l’IP quitte la section miroir orientée vers l’est. Les deux astérisques finissent par se multiplier deux fois, laissant un résultat de 9.670457478596419e + 147 sur la pile. Cela pourrait être imprimé avec O, mais il n'y a pas de moyen facile de le faire car pratiquement tous les points du cube sont déjà utilisés.

Scala, 2 ⁶³ -1

Pauvre, pauvre Scala. Prend au moins 8 caractères pour obtenir unBigInt valeur, ce qui ne laisse pas assez de place pour en faire une grande.

Mais avec seulement 7 caractères de code (compté), nous pouvons imprimer le plus grand positif possible Long:

print(-1L>>>1)

Brainf ** k 256 - 2147483647

>+[<+>+]<.

_{Si vous ignorez le fait que la plupart des compilateurs et interprètes génèrent des données telles qu'elles sont équivalentes à l'ASCII (soyez leanient, c'est ce qu'elle est;))} , la valeur maximale du type de données de l'interpréteur / compilateur sera renvoyée.

Sur certains systèmes, il ne s'agit que de 256, mais sur certains (le mien par exemple), il s'agit de la valeur maximale d'un entier de 32 bits, soit 2 147 483 647.

Modifier:

-.

Imprimera la même chose dans beaucoup moins de caractères

Perl, non en compétition

J'utilise ceci pour mettre en évidence un petit coin connu de Perl.

Perl ne peut pas vraiment rivaliser sur ce marché car il n’a pas de bignums intégrés (vous pouvez bien sûr charger une bibliothèque de bignum).

Mais ce que tout le monde sait n'est pas complètement vrai. Une fonction principale peut en réalité gérer de grands nombres.

Le packformat wpeut en fait convertir un nombre naturel de n'importe quelle taille entre base 10et base 128. Le nombre entier en base 128 est toutefois représenté sous forme d'octets de chaîne. La chaîne de bits xxxxxxxyyyyyyyzzzzzzzdevient les octets: 1xxxxxxx 1yyyyyyy 0zzzzzzz(chaque octet commence par 1 sauf le dernier). Et vous pouvez convertir une telle chaîne en base 10 avec unpack. Donc, vous pouvez écrire du code comme:

unpack w,~A x 4**4 .A

qui donne:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

Vous pouvez remplacer les 4**4valeurs par des valeurs plus grandes jusqu'à ce que vous sentiez que cela prend trop de temps ou utilise trop de mémoire.

Malheureusement, c'est beaucoup trop long pour la limite de ce défi et vous pouvez affirmer que le résultat en base 10 est converti en chaîne avant de devenir le résultat, de sorte que l'expression ne produit pas vraiment de nombre. Mais en interne, perl fait vraiment l’arithmétique nécessaire pour convertir l’entrée en base 10, ce que j’ai toujours considéré plutôt soigné.

TI-36 (pas 84, 36), 10 octets, environ. 9.999985426E99

Les calculatrices plus anciennes peuvent également être programmées dans une certaine mesure;)

69!58.4376

Ceci est très proche de la plage maximale qu'une calculatrice TI peut afficher:-1E100<x<1E100

Perl 6 , 456,574 chiffres

[*] 1..ↈ

Pas de TIO car il faut 2 minutes pour courir.