Konstanta Khinchin adalah konstanta matematika yang aneh yang, menurut Wolfram MathWold , "sangat sulit untuk dihitung dengan presisi tinggi" .

Ini dia untuk 100 digit:

2.685452001065306445309714835481795693820382293994462953051152345557218859537152002801141174931847697 ...

Tulis sebuah program dalam 64 byte atau kurang yang menghasilkan konstanta Khinchin ke jumlah maksimum tempat desimal yang benar.

• Anda tidak boleh menggunakan konstanta atau fungsi perpustakaan bawaan yang berkaitan langsung dengan konstanta Khinchin. (mis. Math.Khinchin (presisi) jelas tidak diizinkan.)
• Anda dapat menggunakan perpustakaan matematika untuk menghitung logaritma, penjumlahan, dll.
• Anda dapat menyalin semua atau sebagian jawaban Anda.
• Program Anda harus menghasilkan output yang terbatas dan berjalan dalam waktu kurang dari satu jam di komputer yang cukup modern (seperti yang tercantum di sini ).
• Anda harus keluar ke stdout. Tidak ada input.
• Anda dapat menggunakan karakter apa pun yang Anda inginkan selama http://mothereff.in/byte-counter mendaftar 64 byte atau kurang.

Mencetak gol

Skor Anda adalah jumlah digit berturut-turut dalam konstanta Khinchin yang dihasilkan program Anda dengan benar, dimulai dengan 2.68 ... Anda dapat menampilkan digit yang salah, tetapi hanya digit yang benar terakhir yang dihitung terhadap skor Anda.

Misalnya, output dari

2.68545200 2 06530644530971483548179569382038229399446295305115234555721

akan mencetak 9 poin. Satu untuk masing-masing digit 2 6 8 5 4 5 2 0 0tetapi tidak ada setelah 2 yang seharusnya menjadi 1.

Maple, 200+

Perintah Maple berikut menghitung konstanta Khinchin dengan presisi yang diminta (di sini, 200 digit):

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

Kode ini akan berfungsi jika Anda menyalin-menempelnya ke antarmuka grafis Maple. The ζmengambil dua byte di UTF-8, dan ∞tiga, untuk total 62 byte.

Menuliskan versi ASCII dari simbol-simbol itu, bahkan dengan trik menggunakan min()alih-alih infinity, sayangnya, membawa jumlah byte hingga 66:

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

Jumlah digit yang dihitung dapat dengan mudah disesuaikan dengan mengubah angka dalam tanda kurung setelahnya evalf. Di komputer saya yang agak lama, 200 digit tampaknya selesai dalam waktu sekitar setengah jam; milikmu mungkin lebih mampu. Perhatikan bahwa Maple membulatkan hasil ke presisi yang diminta alih-alih memotongnya, sehingga jumlah digit pencocokan yang sebenarnya mungkin agak kurang.

Metode penghitungan konstanta ini didasarkan pada rumus (9) dari halaman MathWorld , dikutip di sana untuk Gosper (1996, komunikasi pers):

Ini adalah metode paling efisien yang saya berhasil (hampir) memeras menjadi 64 byte atau kurang.

CJam - 118

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

Cobalah di http://cjam.aditsu.net/

Karena stackexchange menghancurkan beberapa karakter, inilah program yang menghasilkan program di atas; jalankan dulu, lalu jalankan outputnya:

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

Penjelasan:

2push 2
'.pushes dot
"…"adalah string yang berisi sisa digit dalam bentuk yang dikodekan
128bmengubah string menjadi angka, memperlakukan karakter sebagai digit pada basis 128 (melalui kode ASCII mereka)

Kona 63

Jawaban kode sederhana:

2.68545200106530644530971483548179569382038229399446295305115234

Haskell, 5

Yah, karena tidak ada yang memposting solusi menggunakan matematika yang sebenarnya, saya memutuskan untuk melakukannya, meskipun itu tidak sedekat jawaban yang lain.

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

Ini menghitung 2.6854453689859192, yang merupakan kekalahan 5 karakter dari konstanta. Wolfram benar ketika mereka mengatakan "sulit untuk menghitung dengan presisi tinggi".

Mathematica, 6

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

memberi

2.68545843

dan hanya menggunakan 50 byte, jadi ada beberapa ruang untuk menemukan sesuatu yang lebih baik daripada Pidan menggunakan fraksi lanjutan yang lebih besar, tapi saya tidak yakin itu akan menjadi jauh lebih baik dengan runtime satu jam. (Terutama karena menemukan kombinasi yang lebih baik mungkin akan memakan waktu beberapa hari jika aku hanya menggunakan kekuatan kasar.)

(Tentu saja, Anda cukup pintar untuk melarang Khinchin~N~2000, di mana 2000dapat diganti dengan nomor apa pun yang memberi Anda hasil dalam satu jam;).)

wxMaxima 3

Metode yang benar-benar dihitung!

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

Setelah sekitar 25 menit, ia kembali

2.681499686663101b0

Sekarang saya mengerti mengapa halaman Mathematica menyatakan itu. Saya memiliki 6 karakter untuk dimainkan, tetapi saya tidak bisa membayangkan menambahkan 6 0 akan (a) berjalan dalam <60 mnt dan (b) memberi saya solusi yang lebih akurat.

GNU BC , 5 digit (program 54 byte)

Upaya untuk benar-benar menghitung. GNU BC sangat lambat. Ini berjalan selama 53 menit pada Ubuntu 14,04 VM berjalan pada pertengahan 2012 MacBook Pro Retina. Anehnya itu berjalan lebih cepat di VM daripada logam telanjang OSX - mungkin versi GNU lebih baik dioptimalkan untuk tugas ini daripada versi BSD.

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

Keluaran:

2.68544536902156538295

catatan:

bc -lperlu digunakan untuk e()dan l()fungsi (dan skala pengaturan = 20).

Perhitungan floating point CJam - 6

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

Cocok dengan 32 byte asli :)

Berjalan dengan interpreter java menggunakan java 8, output ini setelah sekitar satu menit di laptop saya:

2.6854513126595827

Penerjemah online mungkin akan terlalu lama.

Python, 64 66

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

Output:

2.68545200106530644530971483548179569382038229399446295305115234555

Ruby - 73

Sayangnya, Anda hanya dapat mengonversi hingga basis 36 menggunakan to_idi Ruby:

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

yang kembali

"2.6854520010653064453097148354817956938203822939944629530511523455572188595"

RPL / 2, 7 digit terhitung, 61 byte

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

mengembalikan 2.68545210493822 dalam satu menit di laptop lama (intel Core2) saya.

Tidak ada fungsi Zeta di RPL / 2 sejauh yang saya tahu, inilah mengapa saya menggunakan integrasi (formula 15 dari halaman Mathworld). Pada prinsipnya keakuratan dapat ditingkatkan dengan mengganti 1e-9 dan 1e-7 dengan jumlah yang lebih kecil, tetapi saya tampaknya kurang memori untuk itu.

Tentu saja menggunakan produk tanpa batas untuk menyelesaikan masalah ini, sepertinya

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

dan akan bekerja seperti pada HP RPL calc, tetapi ternyata dua urutan besarnya lebih lambat (pada laptop, tidak mencoba HP saya!), dan hanya memberikan 6 digit.

Jadi algoritma integrasi dalam RPL / 2 melakukan pekerjaan yang cukup baik sebenarnya.

Banyak bahasa pengganti, 61

maaf, tidak menemukan solusi yang lebih baik.

"2.685452001065306445309714835481795693820382293994462953051152"

Aturan tidak mengatakan bahwa urutan nomor yang benar tidak dapat didahului dengan tanda kutip, jadi saya menggunakan ini. Dengan menjalankan itu di konsol JS misalnya, Anda akan mendapatkan string yang sama, termasuk tanda kutip.

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

(Output membutuhkan ~ 2 detik.)

Dalam solidaritas dengan solusi matematika lainnya, saya akan memberikan yang lebih buruk konvergen yang menghitung rata-rata geometris dari jutaan pertama koefisien fraksi lanjutan dari nomor irasional tunggal arbitrer-ish yang bukan tipe yang diketahui tidak bekerja. Sebenarnya, saya mencurangi nomor itu dengan mencoba beberapa sampai saya mendapatkan nomor yang bertepatan dengan angka tambahan.

Lucunya: Aku membeku komputer saya dan harus melakukan shutdown keras setelah mencoba untuk mempersingkat kode ini dengan Python golf trik mengganti for _ in[1]*10**6:codedengan exec("code"*10**6).

ES7, 56

alert`2.6854520010653064453097148354817956938203822939944629531`