คง Khinchin ของเป็นค่าคงที่ทางคณิตศาสตร์ที่อยากรู้อยากเห็นว่าตามวุลแฟรม MathWoldเป็น"ฉาวโฉ่ยากในการคำนวณเพื่อความแม่นยำสูง"

นี่คือตัวเลข 100 หลัก:

2,685452001065306445309714835481795693820382293994462953051152345557218859537152002801141174931847697 ...

เขียนโปรแกรมในขนาด64ไบต์หรือน้อยกว่าที่ส่งออกค่าคงที่ของ Khinchin ไปยังจำนวนทศนิยมที่ถูกต้องสูงสุด

• คุณไม่สามารถใช้ค่าคงที่ของไลบรารีหรือฟังก์ชันใด ๆ ที่เกี่ยวข้องโดยตรงกับค่าคงที่ของ Khinchin (เช่น Math.Khinchin (ความแม่นยำ) ไม่ได้รับอนุญาต)
• คุณอาจใช้ห้องสมุดคณิตศาสตร์เพื่อคำนวณลอการิทึมการสรุป ฯลฯ
• คุณอาจ hardcode ทั้งหมดหรือบางส่วนของคำตอบของคุณ
• โปรแกรมของคุณจะต้องสร้างเอาต์พุตที่แน่นอนและทำงานในเวลาน้อยกว่าหนึ่งชั่วโมงบนคอมพิวเตอร์ที่ทันสมัยพอสมควร (เช่นที่อยู่ในรายการที่นี่ )
• คุณต้องส่งออกไปยัง stdout ไม่มีอินพุต
• คุณสามารถใช้อักขระใดก็ได้ที่คุณต้องการตราบเท่าที่http://mothereff.in/byte-counterลงทะเบียน 64 ไบต์หรือน้อยกว่า

เกณฑ์การให้คะแนน

คะแนนของคุณคือจำนวนตัวเลขที่ต่อเนื่องในค่าคงที่ของ Khinchin ที่โปรแกรมของคุณส่งออกอย่างถูกต้องเริ่มต้นด้วย 2.68 ... คุณสามารถส่งออกตัวเลขที่ไม่ถูกต้อง แต่เฉพาะตัวเลขที่ถูกต้องสุดท้ายเท่านั้นที่จะถูกนับเข้ากับคะแนนของคุณ

ตัวอย่างเช่นผลลัพธ์ของ

2.68545200 2 065306445309714835481795693869382038229399446295305115234555721

จะให้คะแนน 9 คะแนน หนึ่งตัวสำหรับแต่ละหลัก2 6 8 5 4 5 2 0 0แต่ไม่มีอะไรหลังจาก2ที่ควรเป็น 1

ต้นเมเปิล 200+

คำสั่งMapleต่อไปนี้คำนวณค่าคงที่ของ Khinchin ตามความแม่นยำที่ร้องขอ (ที่นี่คือตัวเลข 200 หลัก):

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

รหัสนี้ควรใช้ถ้าคุณคัดลอกวางลงในส่วนต่อประสานกราฟิกแบบเมเปิ้ล ζจะใช้เวลาสองไบต์ UTF-8 และ∞สามรวมเป็น 62 ไบต์

การเขียนสัญลักษณ์เหล่านั้นในเวอร์ชัน ASCII ถึงแม้จะใช้กลอุบายmin()แทนinfinityก็ตามอนิจจาทำให้จำนวนไบต์สูงถึง 66:

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

evalfจำนวนของตัวเลขการคำนวณที่สามารถปรับเปลี่ยนได้อย่างง่ายดายโดยการเปลี่ยนตัวเลขในวงเล็บหลัง ในคอมพิวเตอร์เครื่องเก่าของฉันดูเหมือนว่าตัวเลข 200 หลักจะเสร็จในเวลาประมาณครึ่งชั่วโมง คุณอาจมีความสามารถมากขึ้น โปรดทราบว่าเมเปิลปัดผลลัพธ์เป็นความแม่นยำที่ร้องขอแทนที่จะตัดให้ต่ำดังนั้นจำนวนที่แท้จริงของตัวเลขที่ตรงกันอาจจะค่อนข้างน้อย

วิธีการคำนวณค่าคงที่นี้จะขึ้นอยู่กับสูตร (9) จากหน้า MathWorld ที่อ้างถึง Gosper (1996, pers. comm.):

นี่เป็นวิธีที่มีประสิทธิภาพที่สุดที่ฉันสามารถบีบ (เป็น) ได้ถึง 64 ไบต์หรือน้อยกว่า

CJam - 118

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

ลองที่http://cjam.aditsu.net/

เนื่องจาก stackexchange ทำลายอักขระบางตัวนี่คือโปรแกรมที่สร้างโปรแกรมด้านบน เรียกใช้ก่อนจากนั้นเรียกใช้เอาต์พุต:

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

คำอธิบาย:

2pushes 2
'.pushes dot
"…"เป็นสตริงที่มีตัวเลขที่เหลืออยู่ในรูปแบบที่เข้ารหัส
128bแปลงสตริงเป็นตัวเลขโดยใช้อักขระเป็นตัวเลขในฐาน 128 (ผ่านรหัส ASCII)

โคนา 63

คำตอบที่เข้ารหัสง่าย ๆ :

2.68545200106530644530971483548179569382038229399446295305115234

Haskell, 5

เนื่องจากไม่มีใครโพสต์วิธีแก้ปัญหาโดยใช้คณิตศาสตร์จริงฉันจึงตัดสินใจว่าฉันจะทำได้แม้ว่ามันจะใกล้เคียงกับคำตอบอื่น ๆ

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

การคำนวณนี้2.6854453689859192ซึ่งเป็นค่าคงที่ 5 อักขระของค่าคงที่ Wolfram พูดถูกเมื่อพวกเขาพูดว่า "ยากที่จะคำนวณความแม่นยำสูง"

Mathematica, 6

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

จะช่วยให้

2.68545843

และใช้เพียง 50 ไบต์ดังนั้นจึงมีห้องสำหรับการค้นหาสิ่งที่ดีกว่าPiและใช้เศษส่วนต่อเนื่องที่ใหญ่กว่า แต่ฉันไม่แน่ใจว่ามันจะดีขึ้นมากเมื่อใช้เวลาหนึ่งชั่วโมง (โดยเฉพาะอย่างยิ่งเมื่อค้นหาชุดค่าผสมที่ดีกว่าอาจใช้เวลาหลายวันถ้าฉันใช้กำลังดุร้าย)

(แน่นอนว่าคุณฉลาดพอที่จะไม่อนุญาตKhinchin~N~2000ซึ่ง2000สามารถแทนที่ด้วยหมายเลขใด ๆ ที่ให้ผลลัพธ์ภายในหนึ่งชั่วโมง))

wxMaxima 3

วิธีการคำนวณจริง!

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

หลังจากนั้นประมาณ 25 นาทีมันก็กลับมา

2.681499686663101b0

ตอนนี้ฉันเข้าใจแล้วว่าทำไมหน้า Mathematica ระบุไว้ว่า ฉันมีตัวละคร 6 ตัวที่จะเล่นด้วย แต่ฉันไม่สามารถจินตนาการได้ว่าการเพิ่ม 6 0 จะ (a) วิ่งใน <60 นาทีและ (b) ให้ทางออกที่แม่นยำยิ่งขึ้นแก่ฉัน

GNU BC , 5 หลัก (โปรแกรม 54 byte)

ความพยายามในการคำนวณจริง GNU BC ช้าอย่างน่ากลัว นี่ใช้เวลา 53 นาทีบน Ubuntu 14.04 VM ที่ทำงานบน MacBook Pro Retina กลางปี ​​2012 น่าแปลกที่มันทำงานได้เร็วกว่าใน VM กว่าโลหะเปลือย OSX - สันนิษฐานว่าเป็นรุ่น GNU ที่เหมาะสำหรับงานนี้มากกว่ารุ่น BSD

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

เอาท์พุท:

2.68544536902156538295

บันทึก:

bc -lจำเป็นต้องใช้สำหรับe()และl()ฟังก์ชั่น (และการตั้งค่าขนาด = 20)

การคำนวณจุดลอยตัว CJam - 6

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

มันพอดีกับ 32 ไบต์ดั้งเดิม :)

ทำงานกับล่าม java โดยใช้ java 8 มันจะออกผลลัพธ์หลังจากผ่านไปประมาณหนึ่งนาทีบนแล็ปท็อปของฉัน:

2.6854513126595827

ล่ามออนไลน์อาจใช้เวลานานเกินไป

งูหลาม64 66

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

ขาออก:

2.68545200106530644530971483548179569382038229399446295305115234555

ทับทิม - 73

น่าเสียดายที่คุณสามารถแปลงได้สูงสุด 36 ฐานที่ใช้to_iใน Ruby:

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

ซึ่งผลตอบแทน

"2.6854520010653064453097148354817956938203822939944629530511523455572188595"

RPL / 2, 7 ตัวเลขที่คำนวณได้, 61 ไบต์

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

ส่งคืน 2.68545210493822 ในหนึ่งนาทีบนแล็ปท็อปเก่า (intel Core2) ของฉัน

ไม่มีฟังก์ชัน Zeta ใน RPL / 2 เท่าที่ฉันรู้นี่คือสาเหตุที่ฉันใช้การรวม (สูตร 15 จากหน้า Mathworld) โดยหลักการแล้วความถูกต้องสามารถปรับปรุงได้โดยการแทนที่ 1e-9 และ 1e-7 ด้วยจำนวนที่น้อยกว่า แต่ดูเหมือนว่าฉันขาดความทรงจำไปแล้ว

แน่นอนว่าการใช้ผลิตภัณฑ์ที่ไม่มีที่สิ้นสุดแก้จุดนี้ได้ดูเหมือน

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

และจะทำงานได้เหมือนใน HP RPL calc แต่มันกลับกลายเป็นว่าลำดับสองขนาดช้ากว่า (บนแล็ปท็อปไม่ได้ลองกับ HP ของฉัน!) และให้ตัวเลขเพียง 6 หลักเท่านั้น

ดังนั้นอัลกอริธึมการรวมใน RPL / 2 จึงทำได้ค่อนข้างดี

ภาษาจำลองจำนวนมาก 61

ขออภัยไม่พบวิธีแก้ไขที่ดีกว่า

"2.685452001065306445309714835481795693820382293994462953051152"

กฎไม่ได้บอกว่าลำดับหมายเลขที่ถูกต้องไม่สามารถนำหน้าด้วยเครื่องหมายคำพูดได้ดังนั้นฉันจึงใช้มัน โดยการดำเนินการนั้นในคอนโซล JS ตัวอย่างเช่นคุณจะได้รับสตริงเดียวกันรวมถึงคำพูด

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

(เอาต์พุตใช้เวลา ~ 2 วินาที)

ในความสมัครสมานกับโซลูชันทางคณิตศาสตร์อื่น ๆ ฉันจะให้ค่าที่มาบรรจบกันที่แย่ยิ่งกว่านั้นซึ่งคำนวณค่าเฉลี่ยทางเรขาคณิตของค่าสัมประสิทธิ์เศษส่วนต่อเนื่องล้านตัวแรกของหมายเลขอาร์บิทอิก - อาร์เหตุผลเดียวที่ไม่ได้รู้จัก ที่จริงแล้วฉันขึงหมายเลขนั้นโดยพยายามไม่กี่จนกว่าฉันจะได้ตัวเลขที่ใกล้เคียงกับตัวเลขพิเศษ

สิ่งที่ตลก: ผมแช่แข็งคอมพิวเตอร์ของฉันและมีการทำปิดอย่างหนักหลังจากที่พยายามที่จะลดลงรหัสนี้มีเคล็ดลับกอล์ฟงูหลามของการแทนที่ด้วยfor _ in[1]*10**6:codeexec("code"*10**6)

ES7, 56

alert`2.6854520010653064453097148354817956938203822939944629531`