Plus grand nombre dans dix octets de code


77

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.


21
Qu'entendez-vous exactement par "calculer"? En outre, If it takes longer than an hour to run on any computer in the world, it's invalid.n'est pas objectif. Je pourrais (théoriquement) fabriquer un ordinateur qui prend une heure pour changer un état T
user80551

4
Le décalage de bit compte-t-il en tant qu'opérateur d'exponentiation puisqu'il est équivalent à * 2^x?
Claudiu

14
Le fait que la limite de temps dépende des performances de l'ordinateur le plus rapide du monde nous empêche de déterminer l'ensemble des réponses valables ... Je n'aime pas vraiment cela
David Z

6
Les fonctions d’exponentiation ne sont pas autorisées, mais la fonction ackermann est autorisée? Cela semble vraiment arbitraire. On ignore pourquoi une manipulation symbolique est considérée comme "calculant" le nombre.
WolframH

Réponses:


26

Wolfram Language

ack(9!,9!)

ack (9!, 9!) =enter image description here

La sortie est en notation de flèche.


3
@KyleKanos C'est différent parce que le code / programme n'appelle pas sur le Web. Autres exemples typescriptlang.org/Playground tryfsharp.org/Learn/getting-started
Adam Speight

35
Wolfram Language est disponible pour utiliser un Raspberry Pi et ne nécessite pas d'accès Web. Donc, n'est pas en violation de cette règle.
Adam Speight

6
Je pense que c'est une réponse très valable. Stupide raison d'être sur l'île et de ne pas avoir accès à Internet. La condition "pas de Web" est uniquement d'empêcher l'impression de sortie d'une ressource déjà disponible. Toutes les réponses sont valables tant qu'elles "exécutent" un morceau de code pour calculer la sortie. Le dernier Visual Studio arrive et exécute votre code sur le nuage Azure. Vous souhaitez donc restreindre l'utilisation de C #? Ou vous êtes inéligible si vous avez chromebook?
Microbian

26
ack(99!,9)est beaucoup, beaucoup plus grand.
Jimmy23013

11
Une des autres réponses dit que ack (4,2) est la plus grosse calculée en une heure, alors je serais surpris que cela arrive ...
Jerry Jeremiah

120

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!


Modifier:

Pour répondre à certains des commentaires, par «assez de millénaires», je veux dire en fait dans 100 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 100 ans), la valeur "finale" serait ~ 10 214 , 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!


23
J'ai voté parce que j'aime l'éventualité
Tim

5
Ne va pas se timeretourner et retourner un petit nombre à un moment donné? Cela dépend si c'est 32 ou 64 bits, je suppose
Claudiu

3
1000 ans ~ 3e10 secondes, vous resterez donc autour de 1e21 comme sortie. Peut-être que si vous attendiez pendant 150 ans, vous pourriez commencer à concurrencer les autres réponses?
Kyle Kanos

8
Prononcez-vous ce "temps, fois, temps"? :-) (salut Timwi!)
Pierre Arlaud le

1
Est-ce que l'heure de la chaleur de la mort de l'univers rend compte de l'heure avancée? Vous pourriez gagner quelques secondes d'existence.
Alpha

65

Wolfram ≅ 2,003529930 × 10 19728

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 19728

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.


85
Pas mal, mais ce n'est pas un match pour ma ack(4,2)+1solution.
user19057

13
ack (4,2) +2, JE GAGNE

1
Je pense que tu as gagné.
Anonymous Pi

20
@Kyle, Yimin Il y a beaucoup de déclarations trompeuses dans ce billet et les commentaires qu'il contient. Ce n'est pas le langage Wolfram, ni ce qui est utilisé comme backend de W | A. Il s'agit simplement d'une entrée de "langage naturel" dans Wolfram | Alpha. Dans la langue Wolfram, l' ack(4,2)entrée est invalide. La saisie en langage naturel de W | A ne devrait même pas être considérée comme un langage de programmation. Ce n'est pas complet, et vous ne pouvez même pas écrire de programmes basiques tels que l'algorithme d'Euclid. Pour cette raison, je ne pense pas que ce soit une réponse valable, pas plus qu'une requête de Google.
Szabolcs

4
Wolfram Language est le langage de programmation utilisé dans Mathematica, documenté ici . Wolfram | Alpha utilise le langage naturel en entrée, pas le langage Wolfram.
Szabolcs

30

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

2
Mince! Ceci est apparu pendant que j'écrivais la même réponse
James_pic

2
C'est vraiment juste 9 * 2**9999999, alors on pourrait argumenter qu'il utilise l'exponentiation.
Dennis

2
Attendez, ***built-in*** exponentiation functionsils ne sont pas autorisés, donc cela pourrait glisser sous les règles. +1
user80551

1
Manière mathématique de calculer la longueur:floor(log10(9 * 2**9999999))+1
Justin

8
9 << (9 << 99) est beaucoup plus gros s'il se termine.
Keith Randall

29

CJam, 2 × 10 268 435 457

A28{_*}*K*

Ceci calcule b , défini comme suit:

  • un 0 = 10

  • a n = a n - 1 2

  • b = 20 × a 28

$ 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 20 , défini comme suit:

  • un 0 = 20

  • a n = (n × a n - 1 ) 2

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.                               ";
}/

21
Haha, c'est Kirby? :)
Aditsu

Pouvez-vous décrire ce que cela fait?
Kyle Kanos

2
Pour votre information, j'ai effectué des tests pour vérifier les performances de BigInteger - j'ai calculé 100 000! et converti en chaîne. Résultats: java 6: calcul de 21 secondes, 44 secondes de chaîne; java 7: calcul de 14 secondes, 42 secondes jusqu'à la chaîne; java 8: 5 secondes, 1 seconde pour la chaîne!
Aditsu

1
@aditsu: La mise à niveau de Java a réduit le temps d'exécution de 5 minutes à 2 secondes!
Dennis

20

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.


Jusqu'à présent, cela semble être de loin la réponse la plus importante. C'est un numéro de 10 000 000 000 chiffres, après tout.
nneonneo

1
@nneonneo: Je crois que ma solution est plus grande :)
Zaid

Votre autre réponse nécessite juste moins de 1 MiYiB de mémoire et 100 bits de mémoire adressable (elle ne fonctionnera donc qu’au moins au moins 128 bits en Python). (Source: ma réponse similaire )
wizzwizz4

19

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


1
Ne pouvez-vous pas bronzer (PI / 2)?
user80551

1
@ user80551 C'est possible, mais je viens de remarquer que je pouvais utiliser ce dernier caractère restant dans la limite pour booster mon résultat 99 fois.
Niet the Dark Absol

Trop long dans Common Lisp: (/ 99(sin pi))(14 caractères). Erreur dans la TI-83: 99/sin(π(8 caractères) provoque la division par zéro. Travaux dans LibreOffice Calc : =99/SIN(PI((10 caractères, sans compter =) calcule 808423047055000000. auto-inserts LibreOffice les deux dernières ))dans =99/SIN(PI()).
kernigh

Cela dépend de la précision de la langue. En PHP 14 chiffres décimaux est une valeur commune.
Kenorb

@kernigh Cela n'a pas d'importance dans ce cas, mais serait de 99/sin(πcinq ou huit octets? Je sais que TI-BASIC stocke de nombreuses commandes sous forme d'octets simples. est l' sin(un d'entre eux?
wchargin

16

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

Troisième puce dit "Votre programme doit calculer ..."
user80551

8
floor(infinity)est un nombre fini? Que diable Haskell?
nneonneo

3
1/0! = Infini, c'est indéfini.
RubberDuck

1
Êtes-vous sûr de cela, @ ckuhn203? Dans GHC 7.6.3 et 7.8.2, je reçois isInfinite $ 1 / 0 -- True. Pour autant que je sache, IEEE 754 se définit 1 / 0 par l'infini.
Taylor Fausak

2
Oh, tu veux dire mathématiquement. Je suis complètement d'accord. Mais , en ce qui concerne la programmation avec Virgule flottante IEEE (et Haskell en particulier), 1 / 0 == Infinity.
Taylor Fausak

15

Powershell - 1.12947668480335E + 42

99PB*9E9PB

Multiplie 99 Pebibytes fois 9 000 000 000 Pebibytes.


7
98901 pétaoctets? Est-ce une méthode pour mesurer la densité de bits de surface des disques durs (future grande capacité)?
user80551

Oh sympa. Je ne savais pas que les pebibytes étaient possibles maintenant. J'ai toujours pensé que ça s'arrêtait à tebibytes.
Joey

@ Joey Maintenant, si MS se dépêchait d'ajouter des yobibytes, la réponse pourrait être encore meilleure.
Rynant

1
Je pourrais ajouter ça à Pash si ça peut aider ... ;-)
Joey

1+ "1" * 309 sorties 1.1111e308 bien que je suppose que cela casse l'esprit, sinon le mot de la règle sur l'impression des caractères. Il est transformé en double pour la sortie.
Tomkandy

14

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

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

!!!!!!!!9x

5
J'ai trouvé un compilateur , mais après 20 minutes, !!9xrien n'a été imprimé à l'écran. Je doute sincèrement que cela !!!!!!!!9xsera jamais calculé.
Kyle Kanos

16
"S'il faut plus d'une heure pour fonctionner sur l'ordinateur le plus rapide du monde, il n'est pas valide." Je ne suis pas sûr que cela soit valable car cela ne fonctionne pas dans l'heure
Claudiu

11
Cela a pris 70 minutes, mais !!9xfinalement imprimé à l'écran. Je suis impressionné par le fait qu'il ait réellement calculé la valeur, mais il échoue toujours complètement la
cinquième

6
@Quincunx: Probablement vrai, mais la condition pour une réponse valide est que le programme doit réussir en sortie; cette réponse manque complètement à ce critère. Malheureusement, les votants ont négligé tous les commentaires le soulignant et continuent de le relire par-dessus les réponses de CJam & Golfscript qui sont incroyablement énormes et calculent en un temps raisonnable.
Kyle Kanos

3
Moins voté parce qu’il n’affiche pas la réponse.
Isaacg

14

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


11

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.


Excellente idée mais malheureusement ça ne fait calculaterien.
user80551

3
Je crois que la *99partie appelle un calcul.
commando

Oh oui, je me sens stupide maintenant.
user80551

1
Si vous utilisez quelque chose de plus court - par exemple id(id)ou id(0j), vous pouvez multiplier par999
gnibbler

1
Parmi les noms plus petits nommés dans docs.python.org/2/library/functions.html , varsdonne systématiquement la valeur la plus élevée (mais 4 caractères) suivie de sum. Utilisez print(sorted([(id(x),x)for x in[id,len,max,min,str,int,ord,chr,sum,map,abs,all,any,bin,bool,eval,oct,vars,iter,list,set,repr,round,zip,type,pow,dict,dir,hex]])[::-1])pour vérifier.
user80551

10

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)

Quel est le problème avec les deux un devant le 2564 dans votre sortie?
Kyle Kanos

@KyleKanos: Ce n'est pas ma sortie, c'est la sortie de wc. Je vais éditer pour le rendre plus clair
Claudiu

vous pourriez utiliser wc -cpour rendre la sortie plus claire
daniero

Agréable! J'avais eu la même idée il y a quelques minutes, mais ça tourne beaucoup moins vite avec CJam (ce qui est étonnant, car c'est plus rapide que GolfScript en général).
Dennis

1
Amélioration mineure: 10{.*}25délivre 33 554 434 chiffres et termine en 90 secondes sur ma machine. Je ne sais pas pourquoi, mais 10{.*}26*n'imprime rien.
Dennis

7

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 .


6

Haskell, 4950

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

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

Pourquoi pas juste print? En outre, 9/0.000001est supérieur à sum[1..99].
Taylor Fausak

5
À ce rythme, nous pourrions considérer que 9 999 999 999 est une limite inférieure des résultats.
Keen

@TaylorFausak Cette réponse n'est évidemment pas à prendre au sérieux!
Flonk

6

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

Dix personnages exactement.


7
Est-il techniquement en train de calculer quelque chose, et affiche-t-il tous les chiffres et pas seulement la notation scientifique?

@Yimin: La sortie peut être dans n'importe quel format (vous pouvez donc imprimer 999, 5e + 100, etc.)
edc65

La valeur n'est pas définie au moment de la compilation, mais dépend de la machine sur laquelle la commande est exécutée. Je pense que ça compte.
Michael Stern

5

Coquille Python, 649539 999890001

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

99999*9999

6
9999999999 est plus grande, n'est-ce pas?
MadTux

5
@MadTux Il existe une restriction ambiguë à calculatela réponse.
user80551

1
Si cette réponse est correcte, la mienne l' 9**9**9**9est également, car il s'agit d'un opérateur arithmétique (non intégré dans func).
Kenorb

3
@kenorb C'est une exponentiation intégrée qui n'est pas autorisée.
user80551

5

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.


Je suis presque sûr que c’est le chiffre le plus important du sujet depuis mon article, mais Wolfram étouffe en le comparant à d’autres numéros et ((99!)!)! > 4ne revient jamais.
gggg

Cela va à l’encontre de la règle selon laquelle il est impossible de l’obtenir sur le Web.
Kyle Kanos

1
Trop de W | A!
Anonyme Pi

5
Je ne suis pas d'accord pour dire que cela enfreint les règles. Il ne le "lit pas sur le Web", ce qui est contraire aux règles, il "calcule en fait un seul nombre et l’imprime", comme il est censé le faire. Le fait que la seule interface disponible est un site Web ne signifie pas qu'il ne peut pas être considéré comme un langage de programmation.
gggg

1
C'est une réponse tout à fait valide.
Microbian

4

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.



4

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


3

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

Depuis que l'OP a demandé de retourner une valeur calculée , vous devriez mettre realmax+1. Je l’ai essayée pour le plaisir et surprise, elle retourne exactement le même nombre que vous (puis j’ai ri quand j’ai réalisé… eps(realmax)=1.99584030953472e+292).
Hoki

3

Python, ca. 1.26e1388

9<<(9<<9L)

Donne:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562671606191396751475718572657335136386433456031845303125303125303183modification des produits chimiques3763403631303885997729562671606191396751475718572657335136386433456031845303125303125303183modification des produits chimiques


3

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.


"Seulement 0,2% de l'espace de stockage mondial"
Benjamin Urquhart

1
@BenjaminUrquhart Si vous pensez que c'est bon, pourquoi ne pas voter à la majorité?
wizzwizz4

Il y a votre double vote positif;)
Benjamin Urquhart

3

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.


2

Scala, 2 63 -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)

2

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


Cette deuxième réponse sera imprimée -1sur les interprètes qui utilisent des valeurs signées pour la bande
Benjamin Urquhart

2

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


2

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

entrez la description de l'image ici


2

Perl 6 , 456,574 chiffres

[*] 1..ↈ

Pas de TIO car il faut 2 minutes pour courir.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.