จำนวน Dottieเป็นจุดคงที่ของฟังก์ชั่นโคไซน์หรือวิธีการแก้สมการcos (x) = x ¹

งานของคุณคือการสร้างรหัสที่ใกล้เคียงกับค่าคงที่นี้ รหัสของคุณควรแสดงถึงฟังก์ชั่นที่ใช้จำนวนเต็มเป็นอินพุตและส่งออกจำนวนจริง ขีด จำกัด ของฟังก์ชันของคุณเมื่ออินพุตเพิ่มขึ้นควรเป็นหมายเลข Dottie

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

นี่เป็นคำถามเกี่ยวกับรหัสกอล์ฟดังนั้นคำตอบจะได้คะแนนเป็นไบต์โดยมีจำนวนไบต์น้อยกว่าดีกว่า

เคล็ดลับ

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

นี่คือการประมาณจำนวนที่ถูกต้องอย่างเป็นธรรม

0.739085133215161

^{1: ตรงนี้เราจะใช้โคไซน์เป็นเรเดียน}

MATL , 34 30 19 ไบต์

11 ไบต์ขอบคุณSanchises !

48i:"'cos('wh41hGY$

ตัวเลขทศนิยมสุดท้ายในผลลัพธ์อาจถูกปิด อย่างไรก็ตามจำนวนของตัวเลขที่ถูกต้องเริ่มต้นจากด้านซ้ายเพิ่มขึ้นด้วยการป้อนข้อมูลและผลลัพธ์ที่บรรจบกับค่าคงที่ที่เกิดขึ้นจริง

ลองออนไลน์!

คำอธิบาย

สำหรับอินพุตnและเริ่มต้นที่x = 1 จะใช้ฟังก์ชันนี้

              x ↦ cos ( x )

กับn -digit ตัวแปรความแม่นยำทางคณิตศาสตร์ nครั้ง

48         % Push 48, which is ASCII for '1': initial value for x as a string
i:"        % Do n times, where n is the input
  'cos('   %   Push this string
  w        %   Swap. Moves current string x onto the top of the stack
  h        %   Concatenate
  41       %   Push 41, which is ASCII for ')'
  h        %   Concatenate. This gives the string 'cos(x)', where x is the
           %   current number
  GY$      %   Evaluate with variable-prevision arithmetic using n digits
           %   The result is a string, which represents the new x
           % End (implicit). Display (implicit). The stack contains the last x

Python 3 , 58 ไบต์

lambda n:S('cos('*n+'0'+')'*n).evalf(n)
from sympy import*

ลองออนไลน์!

GNU bc -l, 30

คะแนนรวม +1 สำหรับธง-lbc

for(a=1;a/A-b/A;b=c(a))a=b
a

ขึ้นบรรทัดใหม่เป็นสิ่งสำคัญและจำเป็น

ลองมันออนไลน์

-l ทำ 2 สิ่ง:

• เปิดใช้งานห้องสมุด "คณิตศาสตร์" รวมถึงc()สำหรับ cos (x)
• ตั้งค่าความแม่นยำ (สเกล) เป็นทศนิยม 20 ตำแหน่ง ( bcมีการคำนวณความแม่นยำโดยพลการ)

ฉันไม่ชัดเจนเกี่ยวกับความต้องการความแม่นยำ โปรแกรมนี้จะคำนวณเป็นทศนิยม 20 ตำแหน่ง หากต้องการความแม่นยำที่แตกต่างกันจะต้องscale=n;มีการแทรกที่จุดเริ่มต้นของโปรแกรมโดยที่nเป็นจำนวนทศนิยม ฉันไม่รู้ว่าควรเพิ่มสิ่งนี้ลงในคะแนนของฉันหรือไม่

โปรดทราบว่าสำหรับบางตำแหน่งทศนิยม (เช่น 21 แต่ไม่ใช่ 20) การคำนวณจะแกว่งด้านใดด้านหนึ่งของการแก้ปัญหาในหลักสุดท้าย ดังนั้นในการเปรียบเทียบการทำซ้ำปัจจุบันและก่อนหน้านี้ฉันหารทั้งสองข้างด้วย 10 ( A) เพื่อลบตัวเลขสุดท้าย

Mathematica ขนาด 22 ไบต์

Nest[Cos@#&,0,9#]~N~#&

อินพุต

[100]

เอาท์พุต

0.73908513321516064165531208767387340401341175890075746496568063577328 \ 46548835475945993761069317665318

PHP , 50 ไบต์

$a=$argv[1];$i=$j=0;while($i<$a){$j=cos($j);$i++;}

ลองออนไลน์!

K: 6 ไบต์

  _cos/1
0.7390851

f/ใช้fจนกว่าจะถึงจุดคงที่

R (+ Rmpfr), 55 ไบต์

function(n,b=Rmpfr::mpfr(1,n)){for(i in 1:n)b=cos(b);b}

Dennis ได้เพิ่ม Rmpfr ไปยัง TIO เพื่อให้สามารถใช้งานได้ เพิ่มกรณีทดสอบ

คำอธิบาย:

นำรหัสที่ผมเขียนจากความท้าทายนี้ในการประเมินcos nครั้งเริ่มต้นที่1แต่แรกที่ผมระบุความแม่นยำที่ฉันต้องการค่าที่จะอยู่ในโดยการสร้างวัตถุbของชั้นmpfrที่มีค่า1และความแม่นยำn, n>=2ดังนั้นเราจึงได้รับความแม่นยำมากขึ้นในขณะที่เราไปพร้อม

ลองออนไลน์!

อ็อกเทฟ 42 ไบต์

@(n)digits(n)*0+vpasolve(sym('cos(x)-x'));

ลองออนไลน์!

ค่อนข้างซ้ำกับคำตอบของฉันที่จะประมาณจำนวนพลาสติกแต่ค่อนข้างสั้นเนื่องจากความต้องการที่ผ่อนคลายมากขึ้น

dzaima / APL , 55 ไบต์

⎕←⊃{⍵,⍨-/P,((P÷⍨×)/¨(2×⍳N)⍴¨⊃⍵)÷!2L×⍳N}⍣{⍵≢∪⍵}P←10L*N←⎕

$10^N$1$N$$N$

ไม่มีลิงก์ TIO เนื่องจาก dzaima / APL ของ TIO ยังไม่ได้รับการอัปเดตเพื่อรองรับผู้ลงโฆษณารายใหญ่

ตัวอย่าง I / O:

1
9L

10
7390851332L

100
7390851332151606416553120876738734040134117589007574649656806357732846548835475945993761069317665318L

200
73908513321516064165531208767387340401341175890075746496568063577328465488354759459937610693176653184980124664398716302771490369130842031578044057462077868852490389153928943884509523480133563127677224L

Mathicsหรือ Mathematica ขนาด 46 ไบต์

{$MaxPrecision=#}~Block~Cos~FixedPoint~N[1,#]&

ลองออนไลน์!

Pyth , 57 54 ไบต์

u_.tG1lX$globals()$"neg"$__import__("decimal").Decimal

มันจะสั้นกว่านี้มากถ้าเราไม่ต้องการทศนิยมให้เป็นข้อมูลจำเพาะ แต่มันคืออะไร

แก้ไข 1: -3 ไบต์เนื่องจากเราต้องการตัวเลขจำนวนหนึ่งดังนั้นเราจึงสามารถใช้Xสำเนาที่มีglobals()ความยาวกลับมาเป็นค่าเริ่มต้นของเราย้ายมันไปยังจุดสิ้นสุดและลบ a $และช่องว่างบางส่วนออก

ลองออนไลน์!

APL (Dyalog Unicode)ขนาด 9 ไบต์

2○⍣=1

ลองออนไลน์!

( หมายเหตุ: TIO มีเพิ่มเติม⎕←; นี่เป็นสิ่งจำเป็นโดย TIO ล่าม APL "แบบสแตนด์อโลน" จะใช้การแสดงออกที่แน่นอนที่แสดงด้านบนจำนวนไบต์ที่กำหนดคือสิ่งที่ TIO คำนวณสำหรับการแสดงออกข้างต้นไม่ใช่สำหรับหนึ่งด้วย⎕←. )

สลายตัว / คำอธิบาย:

2○⍣=1
  ⍣          Apply repeatedly the function...
2○           ...cosine of x (in radians), such that...
    1        ...the initial value of x is 1, and...
   =         ...if cos x is NOT equal to x, then re-evaluate, substituting cos x for x...
             ...until they ARE equal.

ครั้งแรกที่มีการประเมินฟังก์ชัน cos x (2 ○ x) โดยที่ x = 1 ฟังก์ชันจะไม่เท่ากัน cos 1 คือ 0.5403 ... ดังนั้นประเมินอีกครั้งแทนที่ 1 ด้วย 0.5403 ... และทำซ้ำกระบวนการจนกระทั่ง (2 ○ x) = x ซึ่งเกิดขึ้นสำหรับ x = 0.73908 ...

ในการสร้างสิ่งนี้ฉันใช้ค่าเริ่มต้นสำหรับ "ความแม่นยำในการพิมพ์" ซึ่งสามารถตั้งค่าใน APL โดยใช้⎕PP←; ค่าสูงสุดสำหรับ⎕PPที่ Dyalog APL อนุญาตคือ 34 หลัก

นอกจากนี้ความแม่นยำเริ่มต้นสำหรับการใช้งานนี้เป็นแบบ 64 บิต หนึ่งสามารถใช้ลอย 128 บิตโดยการตั้งค่า⎕FR← 1287 การคำนวณ TIO เสร็จสิ้นด้วย 64 บิตลอย

การใช้ภาษาคอมพิวเตอร์อย่างแท้จริงไม่สามารถให้ความแม่นยำอย่างแท้จริง แต่รหัสสำหรับ APL ทฤษฎีที่ไม่ใช้ความแม่นยำโดยพลการจะตรงเดียวกัน

Python - 89 ไบต์

ใช้โมดูลทศนิยม

from decimal import*
import math
lambda n:reduce(lambda a,b:Decimal(math.cos(a)),[1]*n,1)

Perl 5, 41 Bytes

use bignum;sub f{$_[0]?cos(f($_[0]-1)):0}

จำเป็นต้องใช้ Bignum เพื่อความแม่นยำโดยพลการ กำหนดฟังก์ชั่น f ที่ใช้โคไซน์ซ้ำกับ 0 N ครั้ง

TIO ดูเหมือนว่าจะไม่มี bignum ดังนั้นจึงไม่มีลิงก์ :(

Mathematica 44 ไบต์

FindRoot[Cos@x-x,{x,0},WorkingPrecision->#]&

FindRoot ใช้วิธีการของนิวตันโดยค่าเริ่มต้น

Python 2, 86 ไบต์

import math as m,decimal as d
def f(x,n):return f(d.Decimal(m.cos(x)),n-1)if n else x

เวอร์ชันใหม่โดยใช้เคล็ดลับที่ให้ไว้

Python 2, 105 ไบต์

import math as m,decimal as d
def f(x,n):return d.Decimal(f(x+(m.cos(x)-x)/(m.sin(x)+1),n-1))if n else x

ใช้ วิธีการของนิวตันและฟังก์ชั่นวนซ้ำเพื่อคำนวณค่า xเป็นค่าเริ่มต้นและnเป็นขีด จำกัด การสอบถามซ้ำ

ความจริง 174 ไบต์

f(n:PI):Complex Float==(n>10^4=>%i;m:=digits(n+10);e:=10^(-n-7);a:=0;repeat(b:=a+(cos(a)-a)/(sin(a)+1.);if a~=0 and a-b<e then break;a:=b);a:=floor(b*10^n)/10.^n;digits(m);a)

ungolfed และแสดงความคิดเห็น

-- Input: n:PI numero di cifre
-- Output la soluzione x a cos(x)=x con n cifre significative dopo la virgola
-- Usa il metodo di Newton a_0:=a  a_(n+1)=a_n-f(a_n)/f'(a_n)
fo(n:PI):Complex Float==
  n>10^4=>%i
  m:=digits(n+10)
  e:=10^(-n-7)
  a:=0     -- Punto iniziale
  repeat
     b:=a+(cos(a)-a)/(sin(a)+1.)
     if a~=0 and a-b<e then break
     a:=b
  a:=floor(b*10^n)/10.^n
  digits(m)
  a

ผล:

(3) -> for i in 1..10 repeat output[i,f(i)]
   [1.0,0.7]
   [2.0,0.73]
   [3.0,0.739]
   [4.0,0.739]
   [5.0,0.73908]
   [6.0,0.739085]
   [7.0,0.7390851]
   [8.0,0.73908513]
   [9.0,0.739085133]
   [10.0,0.7390851332]
                                                               Type: Void
           Time: 0.12 (IN) + 0.10 (EV) + 0.12 (OT) + 0.02 (GC) = 0.35 sec
(4) -> f 300
   (4)
  0.7390851332 1516064165 5312087673 8734040134 1175890075 7464965680 635773284
  6 5488354759 4599376106 9317665318 4980124664 3987163027 7149036913 084203157
  8 0440574620 7786885249 0389153928 9438845095 2348013356 3127677223 158095635
  3 7765724512 0437341993 6433512538 4097800343 4064670047 9402143478 080271801
  8 8377113613 8204206631
                                                      Type: Complex Float
                                   Time: 0.03 (IN) + 0.07 (OT) = 0.10 sec

ฉันจะใช้วิธีนิวตันเพราะมันจะเร็วกว่า 'วิธี cos (x) ซ้ำ'

 800   92x
1000  153x
2000  379x

โดยที่ในคอลัมน์แรกมีจำนวนหลักและในคอลัมน์ที่สองนั่นคือวิธีการของนิวตันเร็วกว่าการใช้วิธี cos (x) ซ้ำที่นี่ อรุณสวัสดิ์

Stax , 5 ไบต์

╘ñ[EΩ

เรียกใช้และดีบักคำอธิบาย :

1       Push 1 to the stack, this will be our initial variable
 {      Begin block
  |7    Cosine
    }N  Repeat block a number of times specified by the input

JavaScript (Node.js) , 84 ไบต์

n=>"0."+(F=(J,Z=c=0n)=>J?F(J*-I*I/++c/++c/B/B,Z+J):I-Z>>2n?(I=Z,F(B)):I)(B=I=10n**n)

ลองออนไลน์!

มีความแม่นยำของn-1ตัวเลขคร่าวๆ BigInt ใช้และcos(x)คำนวณโดยใช้ส่วนขยายของ Taylor I-Z>>2nส่วนนี้ใช้เพื่อป้องกันการวนซ้ำตลอดไป (ด้วยราคา 4 ไบต์และความแม่นยำบางอย่าง) แม้ว่าทฤษฎีจะมีผลบังคับใช้สำหรับความแม่นยำโดยพลการ แต่ช่วงการใช้งานจริงนั้นเป็นn<63เพราะการล้นสแต็ก

สั้นกว่า (82 ไบต์) ไม่ต้องกังวลกับการล้นสแต็ก แต่มีความแม่นยำน้อย

n=>"0."+eval("for(I=B=10n**n;n--;I=Z)for(Z=J=B,c=0n;J;)Z+=(J=J*-I*I/++c/++c/B/B)")

สั้นกว่ามาก (80 ไบต์) ช่วงที่ใหญ่กว่าจนกระทั่งล้นสแต็ก ( n<172) แต่มีความแม่นยำเท่ากับ 82 ไบต์

n=>"0."+(F=(J,Z=c=0n)=>J?F(J*-I*I/++c/++c/B/B,Z+J):n--?(I=Z,F(B)):I)(B=I=10n**n)

หากความแม่นยำโดยพลการไม่ได้เป็นประเด็นหลักดังนั้น 25 ไบต์:

F=n=>n?Math.cos(F(n-1)):1