Die Dottie-Zahl ist der Fixpunkt der Kosinusfunktion oder die Lösung der Gleichung cos (x) = x . ¹

Ihre Aufgabe wird es sein, Code zu erstellen, der sich dieser Konstante annähert. Ihr Code sollte eine Funktion darstellen, die eine ganze Zahl als Eingabe annimmt und eine reelle Zahl ausgibt. Die Grenze Ihrer Funktion, wenn die Eingabe zunimmt, sollte die Dottie-Zahl sein.

Sie können einen Bruch, eine Dezimalzahl oder eine algebraische Darstellung einer Zahl ausgeben. Ihre Ausgabe sollte willkürlich genau sein können, Floats und Doubles reichen für diese Herausforderung nicht aus. Wenn Ihre Sprache keine Zahlen mit willkürlicher Genauigkeit unterstützt, müssen Sie sie entweder implementieren oder eine neue Sprache auswählen.

Dies ist eine Code-Golf- Frage, daher werden die Antworten in Bytes bewertet, wobei weniger Bytes besser sind.

Tipps

Eine Möglichkeit, die Konstante zu berechnen, besteht darin, eine beliebige Zahl zu nehmen und den Cosinus wiederholt darauf anzuwenden. Da die Anzahl der Anwendungen gegen unendlich tendiert, tendiert das Ergebnis gegen den festen Kosinuspunkt.

Hier ist eine ziemlich genaue Annäherung an die Anzahl.

0.739085133215161

^{1: Hier nehmen wir den Kosinus im Bogenmaß}

MATL , 34 30 19 Bytes

Dank Sanchises 11 Bytes weniger !

48i:"'cos('wh41hGY$

Die letzten Dezimalstellen in der Ausgabe sind möglicherweise deaktiviert. Die Anzahl der korrekten Ziffern von links steigt jedoch mit der Eingabe und das Ergebnis konvergiert gegen die tatsächliche Konstante.

Probieren Sie es online!

Erläuterung

Für den Eingang n gilt ab x = 1 die Funktion

              x ↦ cos ( x )

mit n- stelliger Arithmetik mit variabler Genauigkeit n- mal.

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 Bytes

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

Probieren Sie es online!

PHP , 50 Bytes

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

Probieren Sie es online!

GNU bc-1, 30

Punktzahl enthält +1 für -lFlagge an bc.

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

Die letzte Zeile ist wichtig und notwendig.

Probieren Sie es online aus .

-l macht 2 Dinge:

• aktiviere die "math" Bibliothek, auch c()für cos (x)
• Setzt die Genauigkeit (Skala) auf 20 Dezimalstellen ( bchat eine willkürliche Genauigkeitsberechnung)

Ich bin mir nicht ganz sicher, welche Präzision erforderlich ist. Wie es ist, berechnet dieses Programm auf 20 Dezimalstellen. Wenn eine andere Genauigkeit erforderlich ist, scale=n;muss zu Beginn des Programms ndie Anzahl der Nachkommastellen eingegeben werden. Ich weiß nicht, ob ich das zu meiner Punktzahl hinzufügen soll oder nicht.

Beachten Sie auch, dass bei einigen Dezimalstellen (z. B. 21, aber nicht 20) die Berechnung auf beiden Seiten der Lösung in der letzten Ziffer oszilliert. Beim Vergleich der aktuellen und vorherigen Iterationen dividiere ich beide Seiten durch 10 ( A), um die letzte Ziffer zu löschen.

Mathematica, 22 Bytes

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

Eingang

[100]

Ausgabe

0,73908513321516064165531208767387340401341175890075746496568063577328 \ 46548835475945993761069317665318

R (+ Rmpfr), 55 Bytes

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

Dennis hat jetzt Rmpfr zu TIO hinzugefügt, damit dies funktioniert. einige Testfälle hinzugefügt.

Erläuterung:

Ist der Code , den ich aus schrieb diese Herausforderung zu bewerten cos nmal ab 1, aber zuerst angeben ich die Präzision ich die Werte wollen in sein , indem er ein Objekt erstellt bder Klasse mpfrmit dem Wert 1und Präzision n, n>=2, so dass wir mehr Präzision erhalten , wie wir entlang gehen.

Probieren Sie es online!

Oktave , 42 Bytes

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

Probieren Sie es online!

So ziemlich ein Duplikat meiner Antwort auf "Approximate the Plastic Number" , aber etwas kürzer aufgrund entspannterer Anforderungen.

Mathematik oder Mathematica, 46 Bytes

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

Probieren Sie es online!

K: 6 Bytes

  _cos/1
0.7390851

f/gilt fbis zum Erreichen eines festen Punktes.

Python - 89 Bytes

Verwendet das Dezimalmodul.

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 wird für die beliebige Genauigkeit benötigt. Definiert eine Funktion f, die den Cosinus rekursiv auf 0 N-mal anwendet.

TIO scheint kein Bignum zu haben, also kein Link :(

Mathematica 44 Bytes

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

FindRoot verwendet standardmäßig die Newton-Methode.

Python 2, 86 Bytes

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

Neue Version mit dem mitgelieferten Tipp.

Python 2, 105 Bytes

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

Verwendet die Newton-Methode und die rekursive Funktion, um den Wert zu berechnen. xist der Anfangswert und ndie Rekursionsgrenze.

Axiom, 174 Bytes

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 und kommentiert

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

Ergebnisse:

(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

Ich würde die Newton-Methode verwenden, weil sie schneller ist als die wiederholte cos (x) -Methode.

 800   92x
1000  153x
2000  379x

In der ersten Spalte steht die Anzahl der Ziffern und in der zweiten Spalte, wie viel Newton-Methode schneller ist als die wiederholte cos (x) -Methode. Guten Morgen