A constante de Khinchin é uma constante matemática curiosa que, de acordo com Wolfram MathWold , é "notoriamente difícil de calcular com alta precisão" .

Aqui está 100 dígitos:

2.685452001065306445309714835481795693820382293994462953051152345557218859537152002801141174931847697 ...

Escreva um programa em 64 bytes ou menos que produza a constante de Khinchin para o número máximo de casas decimais corretas.

• Você não pode usar constantes ou funções da biblioteca integradas diretamente relacionadas à constante de Khinchin. (por exemplo, Math.Khinchin (precisão) definitivamente não é permitido.)
• Você pode usar bibliotecas de matemática para calcular logaritmos, somatórios etc.
• Você pode codificar toda ou parte da sua resposta.
• Seu programa deve produzir uma saída finita e executar em menos de uma hora em um computador razoavelmente moderno (como os listados aqui ).
• Você deve enviar para stdout. Não há entrada.
• Você pode usar qualquer caractere que quiser, desde que http://mothereff.in/byte-counter registre 64 bytes ou menos.

Pontuação

Sua pontuação é o número de dígitos sucessivos na constante de Khinchin que seu programa gera corretamente, começando com 2,68 ... Você pode gerar dígitos incorretos, mas apenas o último dígito correto é contado para sua pontuação.

Por exemplo, uma saída de

2.68545200 2 06530644530971483548179569382038229399446295305115234555721

marcaria 9 pontos. Um para cada um dos dígitos, 2 6 8 5 4 5 2 0 0mas nada após o 2 que deve ser um 1.

Maple, 200+

O seguinte comando Maple calcula a constante de Khinchin com a precisão solicitada (aqui, 200 dígitos):

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

Esse código deve funcionar se você o copiar e colar na interface gráfica do Maple. oζ toma dois bytes de UTF-8, e a ∞três, para um total de 62 bytes.

Escrever as versões ASCII desses símbolos, mesmo com o truque de usar em min()vez de infinity, infelizmente, leva a contagem de bytes até 66:

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

O número de dígitos calculados pode ser facilmente ajustado alterando o número entre colchetes depois evalf. No meu computador bastante antigo, 200 dígitos parecem terminar em cerca de meia hora; o seu pode ser capaz de mais. Note que Maple arredonda o resultado para a precisão solicitada em vez de truncá-lo, portanto, o número real de dígitos correspondentes pode ser um pouco menor.

Este método de calcular a constante é baseado na fórmula (9) da página MathWorld , citada ali por Gosper (1996, comunicação pessoal):

Este foi o método mais eficiente que eu consegui (quase) espremer em 64 bytes ou menos.

CJam - 118

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

Experimente em http://cjam.aditsu.net/

Como stackexchange destrói alguns dos caracteres, aqui está um programa que gera o programa acima; execute-o primeiro e depois execute sua saída:

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

Explicação:

2empurra 2
'.empurra o ponto
"…"é uma sequência que contém o restante dos dígitos na forma codificada
128bconverte a sequência em um número, tratando os caracteres como dígitos na base 128 (através do código ASCII)

Kona 63

Resposta simples codificada:

2.68545200106530644530971483548179569382038229399446295305115234

Haskell, 5

Bem, como ninguém postou uma solução usando matemática real, decidi que o faria, mesmo que não seja tão próximo quanto as outras respostas.

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

Isso calcula 2.6854453689859192, que são uns impressionantes 5 caracteres da constante. Wolfram estava certo quando disseram que é "difícil calcular com alta precisão".

Mathematica, 6

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

dá

2.68545843

e usa apenas 50 bytes; portanto, há espaço para encontrar algo melhor Pie usar uma fração contínua maior, mas não tenho certeza de que isso melhore muito com o tempo de execução de uma hora. (Especialmente porque encontrar uma combinação melhor provavelmente levaria vários dias se eu estivesse usando força bruta.)

(Obviamente, você foi esperto o suficiente para proibir Khinchin~N~2000, onde 2000poderia ser substituído por qualquer número que lhe desse um resultado em uma hora;).)

wxMaxima 3

Um método realmente calculado!

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

Após cerca de 25 minutos, ele retornou

2.681499686663101b0

Agora entendo por que a página do Mathematica afirmou isso. Eu tenho 6 personagens para brincar, mas não consigo imaginar adicionar 6 0s (a) seja executado em <60 min e (b) me dê uma solução mais precisa.

GNU BC , 5 dígitos (programa de 54 bytes)

Uma tentativa de realmente calcular. O GNU BC é terrivelmente lento. Isso foi executado por 53 minutos em uma VM Ubuntu 14.04 em execução em um MacBook Pro Retina de meados de 2012. Estranhamente, ele roda mais rápido na VM do que o OSX bare metal - presumivelmente a versão GNU é melhor otimizada para esta tarefa do que a versão BSD.

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

Saída:

2.68544536902156538295

Nota:

bc -lprecisa ser usado para e()e l()funções (e definir escala = 20).

CJam cálculo de ponto flutuante - 6

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

Cabe nos 32 bytes originais :)

Correndo com o interpretador java usando o java 8, ele gera isso após cerca de um minuto no meu laptop:

2.6854513126595827

O intérprete online provavelmente levaria muito tempo.

Python, 64 66

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

Saídas:

2.68545200106530644530971483548179569382038229399446295305115234555

Ruby - 73

Infelizmente, você só pode converter até a base 36 usando o to_iRuby:

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

que retorna

"2.6854520010653064453097148354817956938203822939944629530511523455572188595"

RPL / 2, 7 dígitos calculados, 61 bytes

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

retorna 2.68545210493822 em um minuto no meu laptop antigo (intel Core2).

Nenhuma função Zeta no RPL / 2, tanto quanto eu sei, é por isso que usei a integração (fórmula 15 da página Mathworld). Em princípio, a precisão poderia ser melhorada substituindo 1e-9 e 1e-7 por um número menor, mas aparentemente estava faltando memória para isso.

É claro que recorrer ao produto infinito resolve esse ponto, parece que

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

e funcionará como está no HP RPL calc, mas acaba sendo duas ordens de magnitude mais lento (no laptop, não experimentou no meu HP!), e fornece apenas 6 dígitos.

Portanto, o algoritmo de integração no RPL / 2 faz um bom trabalho, na verdade.

Muitos idiomas de reposição, 61

desculpe, não encontrou uma solução melhor.

"2.685452001065306445309714835481795693820382293994462953051152"

As regras não dizem que a sequência numérica correta não pode ser precedida por aspas, então estou usando isso. Ao executar isso em um console JS, por exemplo, você obterá a mesma sequência, incluindo as aspas.

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

(A saída leva ~ 2 segundos.)

Em solidariedade às outras soluções matemáticas, darei uma ainda pior convergente que calcula a média geométrica do primeiro milhão de coeficientes de fração contínua de um único número irracional arbitrário que não é de um tipo conhecido por não funcionar. Na verdade, eu manipulei esse número tentando alguns até conseguir um que coincidisse com um dígito extra.

O engraçado: congelei meu computador e tive que fazer um desligamento rígido depois de tentar diminuir esse código com o truque de golfe do Python para substituí for _ in[1]*10**6:code-lo exec("code"*10**6).

ES7, 56

alert`2.6854520010653064453097148354817956938203822939944629531`