La constante de Khinchin est une constante mathématique curieuse qui, selon Wolfram MathWold , est "notoirement difficile à calculer avec une grande précision" .

Le voici à 100 chiffres:

2,6845452001065306445309714835481795693820382293994462953051152345557218859537152002801141174931847697 ...

Écrivez un programme en 64 octets ou moins qui produit la constante de Khinchin au nombre maximum de décimales correctes.

• Vous ne pouvez pas utiliser de constantes ou de fonctions de bibliothèque intégrées directement liées à la constante de Khinchin. (Par exemple, Math.Khinchin (précision) n'est certainement pas autorisé.)
• Vous pouvez utiliser des bibliothèques mathématiques pour calculer des logarithmes, des sommations, etc.
• Vous pouvez coder en dur tout ou partie de votre réponse.
• Votre programme doit produire une sortie finie et s'exécuter en moins d'une heure sur un ordinateur raisonnablement moderne (comme ceux répertoriés ici ).
• Vous devez sortir vers stdout. Il n'y a aucune entrée.
• Vous pouvez utiliser les caractères de votre choix tant que http://mothereff.in/byte-counter enregistre 64 octets ou moins.

Notation

Votre score est le nombre de chiffres successifs dans la constante de Khinchin que votre programme sort correctement, en commençant par 2,68 ... Vous pouvez sortir des chiffres incorrects mais seul le dernier chiffre correct est pris en compte dans votre score.

Par exemple, une sortie de

2.68545200 2 06530644530971483548179569382038229399446295305115234555721

marquerait 9 points. Un pour chacun des chiffres 2 6 8 5 4 5 2 0 0mais rien après le 2 qui devrait être un 1.

Érable, 200+

La commande Maple suivante calcule la constante de Khinchin avec la précision demandée (ici, 200 chiffres):

evalf[200](exp(sum((-1)^k*(2-2^k)*ζ(1,k)/k,k=2..∞)/ln(2)));

Ce code devrait fonctionner si vous le copiez-collez dans l'interface graphique de Maple. Le ζprend deux octets en UTF-8, et les ∞trois, pour un total de 62 octets.

L'écriture des versions ASCII de ces symboles, même avec l'astuce d'utiliser min()au lieu de infinity, hélas, porte le nombre d'octets à 66:

evalf[200](exp(sum((-1)^k*(2-2^k)*Zeta(1,k)/k,k=2..min())/ln(2)));

Le nombre de chiffres calculés peut être facilement ajusté en changeant le nombre entre crochets après evalf. Sur mon ordinateur assez ancien, 200 chiffres semblent se terminer en une demi-heure environ; le vôtre pourrait être capable de plus. Notez que Maple arrondit le résultat à la précision demandée au lieu de le tronquer, de sorte que le nombre réel de chiffres correspondants peut être légèrement inférieur.

Cette méthode de calcul de la constante est basée sur la formule (9) de la page MathWorld citée dans Gosper (1996, comm. Pers.):

C'était la méthode la plus efficace que j'ai réussi à (à peine) presser en 64 octets ou moins.

CJam - 118

2'."*;TeT?_aN{.i9B*ZEay
G`9~eW}nE=Lr-`B}    )D>9m9"136b

Essayez-le sur http://cjam.aditsu.net/

Puisque stackexchange détruit certains des personnages, voici un programme qui génère le programme ci-dessus; exécutez-le d'abord, puis exécutez sa sortie:

"2'.\""685452001065306445309714835481795693820382293994462953051152345557218859537152002801141174931847697995153465905288090 136b:c"\"136b"

Explication:

2pousse 2
'.pousse le point
"…"est une chaîne contenant le reste des chiffres sous forme codée
128bconvertit la chaîne en un nombre, traitant les caractères comme des chiffres en base 128 (via leur code ASCII)

Kona 63

Réponse simple codée en dur:

2.68545200106530644530971483548179569382038229399446295305115234

Haskell, 5

Eh bien, puisque personne n'a posté de solution utilisant des mathématiques réelles, j'ai décidé que je le ferais, même si elle est loin d'être aussi proche que les autres réponses.

main=print$product[(1+1/r/(r+2))**2`logBase`r|r<-[1..99999999]]

Cela calcule 2.6854453689859192, qui est un énorme 5 caractères de la constante. Wolfram avait raison quand ils ont dit qu'il était "difficile de calculer avec une grande précision".

Mathematica, 6

(Times@@Rest@ContinuedFraction[Pi,977])^(1.`9/976)

donne

2.68545843

et n'utilise que 50 octets, donc il y a de la place pour trouver quelque chose de mieux que Piet utiliser une fraction continue plus grande, mais je ne suis pas sûr que cela ira beaucoup mieux avec un temps d'exécution d'une heure. (Surtout que trouver une meilleure combinaison prendrait probablement plusieurs jours si j'utilise simplement la force brute.)

(Bien sûr, vous étiez assez intelligent pour refuser Khinchin~N~2000, où 2000pourrait être remplacé par n'importe quel nombre qui vous donne un résultat dans l'heure;).)

wxMaxima 3

Une méthode réellement calculée!

bfloat(product((1+1/(n*(n+2)))^(log(n)/log(2)),n,1,10000));

Après environ 25 minutes, il est revenu

2.681499686663101b0

Je comprends maintenant pourquoi la page Mathematica le dit. J'ai 6 personnages avec lesquels jouer, mais je ne peux pas imaginer que l'ajout de 6 0 (a) fonctionnerait en moins de 60 minutes et (b) me donnerait une solution plus précise.

GNU BC , 5 chiffres (programme de 54 octets)

Une tentative de calculer réellement. GNU BC est horriblement lent. Cela a fonctionné pendant 53 minutes sur une machine virtuelle Ubuntu 14.04 fonctionnant sur un MacBook Pro Retina mi-2012. Étrangement, il fonctionne plus rapidement dans la machine virtuelle que le métal nu OSX - sans doute la version GNU est mieux optimisée pour cette tâche que la version BSD.

for(k=r=1;r++<10^7;)k*=e(l(1/(r*(r+2))+1)*l(r)/l(2))
k

Sortie:

2.68544536902156538295

Remarque:

bc -ldoit être utilisé pour e()et l()fonctions (et réglage de l'échelle = 20).

Calcul de virgule flottante CJam - 6

1e8{I{1.II2+*/)I2mL#*}1.?}fI

Il tient dans les 32 octets d'origine :)

Fonctionnant avec l'interpréteur java à l'aide de java 8, il affiche cela après environ une minute sur mon ordinateur portable:

2.6854513126595827

L'interprète en ligne prendrait probablement trop de temps.

Python, 64 66

print"2.%i"%int('anljsgqif7gwwwsrntcz7zv2obv6gv5us7fzfwjcaj',36)

Les sorties:

2.68545200106530644530971483548179569382038229399446295305115234555

Rubis - 73

Malheureusement, vous ne pouvez convertir que jusqu'à la base 36 en utilisant to_iRuby:

"2.#{"hmegxpkvliy1vaw4lb054ep8wsqwkz2yx9cm9jvc9yfd48j".to_i 36}"

qui revient

"2.6854520010653064453097148354817956938203822939944629530511523455572188595"

RPL / 2, 7 chiffres calculés, 61 octets

'LN(FLOOR(1/X))/(X+1)/LN(2)' { 'X' 1e-9 1 } 1e-7 INT DROP EXP

renvoie 2.68545210493822 en une minute sur mon ancien ordinateur portable (Intel Core2).

Pas de fonction Zeta dans RPL / 2 pour autant que je sache, c'est pourquoi j'ai utilisé l'intégration (formule 15 de la page Mathworld). En principe, la précision pourrait être améliorée en remplaçant 1e-9 et 1e-7 par un plus petit nombre, mais je manquais apparemment de mémoire pour cela.

Bien sûr, le recours au produit infini résout ce point, il semble

1 1 1e9 FOR I 1 1 I dup 2 + * / + I LN 2 LN / ^ * NEXT

et fonctionnera tel quel sur un calcul HP RPL, mais il s'avère être deux ordres de grandeur plus lent (sur l'ordinateur portable, n'a pas essayé sur mon HP!), et ne donne que 6 chiffres.

Donc, l'algorithme d'intégration dans RPL / 2 fait vraiment du bon travail.

Plusieurs langues de repl, 61

désolé, je n'ai pas trouvé de meilleure solution.

"2.685452001065306445309714835481795693820382293994462953051152"

Les règles ne disent pas que la séquence de nombres correcte ne peut pas être précédée de guillemets, donc j'utilise ceci. En exécutant cela dans une console JS par exemple, vous obtiendrez la même chaîne, y compris les guillemets.

Python (5)

x=3**.1
p=1
for _ in[1]*10**6:p*=(x//1)**1e-6;x=1/(x%1)
print(p)

Output: 2.6854396408091694

(La sortie dure environ 2 secondes.)

En solidarité avec les autres solutions mathématiques, je donnerai une solution encore plus convergente qui calcule la moyenne géométrique du premier million de coefficients de fraction continue d'un seul nombre irrationnel arbitraire qui n'est pas d'un type connu pour ne pas fonctionner. En fait, j'ai truqué ce nombre en essayant quelques-uns jusqu'à ce que j'en obtienne un qui coïncide avec un chiffre supplémentaire.

Chose drôle: j'ai gelé mon ordinateur et j'ai dû faire un arrêt dur après avoir essayé de raccourcir ce code avec l'astuce de golf Python de remplacer for _ in[1]*10**6:codepar exec("code"*10**6).

ES7, 56

alert`2.6854520010653064453097148354817956938203822939944629531`