A constante de Khinchin com o máximo de casas decimais possível em 64 bytes ou menos

22

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.

Passatempos de Calvin
fonte
2
Por que você está permitindo codificar toda a resposta?
William Barbosa
5
@WilliamBarbosa por que não? idealmente, deve haver uma solução com pontuação melhor que 31. se não, bem, isso é lamentável.
Martin Ender
1
O unicode é permitido? Como contar?
Aditsu
3
Você deve permitir 64b em vez de 32 e contar todos os caracteres como UTF-8 bytes ( mothereff.in/byte-counter ) (= 1 a 4 bytes por caractere, dependendo do plano Unicode). Além disso, as soluções existentes podem ser facilmente adaptadas para 64b
xem
3
@PeterTaylor I codificados uma solução de ponto flutuante CJam, e deixe-me dizer-lhe, precisão limitada não é o principal problema: p
aditsu

Respostas:

11

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):

            Equação

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

Ilmari Karonen
fonte
Muito arrumado. Se eu tivesse Maple: /
Calvin's Hobbies
12

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)

aditsu
fonte
2
Muito agradável. Você pode explicar um pouco?
Kyle Kanos
@KyleKanos adicionou explicação
aditsu
Fantástico. Eu deveria aprender CJam um dia ... Além disso, não consigo que seu intérprete online funcione no navegador Opera, embora funcione no meu Firefox. Provavelmente uma questão do Opera, mas pensei em mencionar.
Kyle Kanos
1
@ Calvin'sHobbies Em 1997, Xavier Gourdon calculou os primeiros 110.000 dígitos em 22 horas usando no máximo um processador de 250 MHz. Assim, você poderá calcular 1000 vezes mais dígitos que esta solução em uma hora. web.archive.org/web/20120218093629/http://pi.lacim.uqam.ca/…
Alex L
1
@ Calvin'sHobbies veja este link para um programa completo que calcula 2000 dígitos em 7 segundos.
Aditsu
5

Kona 63

Resposta simples codificada:

2.68545200106530644530971483548179569382038229399446295305115234
Kyle Kanos
fonte
mmm não é 63?
Xem
@ xem: pequeno erro tipográfico. Fixo. : D
Kyle Kanos
1
Também funciona no GNU BC
Digital Trauma
@DigitalTrauma: Provavelmente funciona em vários outros idiomas também, eu só fiquei com Kona porque já respondi antes.
Kyle Kanos
5

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

Zaq
fonte
Programa de 63 bytes - 1 byte de sobra! Agradável!
Digital Trauma
O byte extra pode ser outro 9, mas meu computador não suportava isso e, mesmo que pudesse, não tenho certeza se resultaria em outro dígito preciso.
Zaq
Usando Ruby, eu basicamente atingi o máximo que poderia fazer usando essa fórmula, executando em 60 segundos. Eu tenho 2.685451312659854: tio.run/##KypNqvz/P9vWkEvDUE/…
Simply Beautiful Art
3

Mathematica, 6

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

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;).)

Martin Ender
fonte
1
+1 para usar o significado da constante, não apenas uma fórmula.
Vi.
2

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.

Kyle Kanos
fonte
Suspeita: Cada zero adicional adiciona menos de um dígito correto: '(
Simply Beautiful Art
1

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

Trauma Digital
fonte
1

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.

aditsu
fonte
1

Python, 64 66

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

Saídas:

2.68545200106530644530971483548179569382038229399446295305115234555
Dan Getz
fonte
Você pode cortar o espaço após o printapertar em outro personagem.
Xnor
1

Ruby - 73

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

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

que retorna

"2.6854520010653064453097148354817956938203822939944629530511523455572188595"
OI
fonte
1

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.

Nácar
fonte
0

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.

xem
fonte
1
Sim, isso é válido mesmo com uma citação na frente. Só importa que o 2.685 ... seja ininterrupto.
9789 Calvin's Hobbies
0

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

xnor
fonte
0

ES7, 56

alert`2.6854520010653064453097148354817956938203822939944629531`
elipszilon
fonte