डॉटी संख्या को अनुमानित करें

Question

Dottie संख्या कोसाइन फंक्शन के निश्चित बिंदु, या समीकरण का हल है क्योंकि (x) = एक्स । ¹

आपका कार्य कोड बनाना होगा जो इस स्थिरांक का अनुमान लगाएगा। आपके कोड को एक फ़ंक्शन का प्रतिनिधित्व करना चाहिए जो इनपुट के रूप में पूर्णांक लेता है और एक वास्तविक संख्या को आउटपुट करता है। इनपुट बढ़ने पर आपके फ़ंक्शन की सीमा डॉटी संख्या होनी चाहिए।

आप एक अंश, एक दशमलव, या एक संख्या के बीजगणितीय प्रतिनिधित्व के रूप में आउटपुट कर सकते हैं। आपका आउटपुट मनमाने ढंग से सटीक होना चाहिए, इस चुनौती के लिए फ्लोट्स और डबल्स पर्याप्त नहीं हैं। यदि आपकी भाषा मनमाने ढंग से सटीक संख्याओं में सक्षम नहीं है, तो आपको या तो उन्हें लागू करना होगा या एक नई भाषा चुननी होगी।

यह एक कोड-गोल्फ प्रश्न है, इसलिए उत्तर बाइट्स में दिए जाएंगे, कम बाइट बेहतर होने के साथ।

टिप्स

स्थिरांक की गणना करने का एक तरीका किसी भी संख्या को लेना है और बार-बार उस पर कोसाइन लगाना है। जैसा कि अनुप्रयोगों की संख्या अनंत की ओर जाती है, परिणाम कॉशन के निश्चित बिंदु की ओर जाता है।

यहां संख्या का काफी सटीक अनुमान लगाया गया है।

0.739085133215161

^{1: यहाँ हम रेडियन में कोसाइन लेंगे}

Comments

इसलिए, यदि हम पायथन का उपयोग कर रहे हैं, तो हमें अपने प्रकार या आयात को लागू करना चाहिए Decimal?

— श्री एक्सकोडर

हमारी प्रस्तुतियाँ कितनी सही होनी चाहिए?

— श्री एक्सकोडर

चोरी करने के लिए जेली ट्यूटोरियल को ÆẠȷ¡पता चलता है कि यह अमान्य है। ब्रेज़लॉग की कोशिश करता है; अरे नहीं ब्रेकीग्लॉट भी तैरता नहीं है।

— आउटगोल्फर

मुझे लगता है कि "मनमाने ढंग से सटीक" आवश्यकता थोड़ी बहुत कठोर है। क्यों नहीं एक बार एक उत्तर को मान्य माना जाए x=cos(x)?

— kamoroso94

मैं इसे हास्केल, एपीएल और कुछ लिस्प स्वाद में देखना चाहूंगा।

— मार्क सी

Answer 1

MATL , 34 30 19 बाइट्स

Sanchises के लिए धन्यवाद 11 बाइट्स !

48i:"'cos('wh41hGY$

आउटपुट में अंतिम दशमलव आंकड़े बंद हो सकते हैं। हालांकि, बाएं से शुरू होने वाले सही आंकड़ों की संख्या इनपुट के साथ बढ़ जाती है, और परिणाम वास्तविक स्थिरांक में परिवर्तित हो जाता है।

इसे ऑनलाइन आज़माएं!

व्याख्या

इनपुट n के लिए , और x = 1 से शुरू होकर , यह फ़ंक्शन को लागू करता है

              x ↦ कॉस ( 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

Comments

क्यों न इसे n अंको की सटीकता पर लागू किया जाए? यह अत्यधिक जटिल लगता है।

— Sanchises

यह अविश्वसनीय है। मैं इसे एपीएल में देखना चाहता हूं।

— मार्क सी

Answer 2

पायथन 3 , 58 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

पायथन 2 में एक संस्करण जो स्मृति त्रुटि को उतनी जल्दी नहीं करता है।

— नॉटजगन

नो evalfइन एम : ओ

— जोनाथन एलन

Answer 3

जीएनयू बीसी-एल, ३०

-lफ्लैग टू के लिए स्कोर में +1 शामिल है bc।

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

अंतिम न्यूलाइन महत्वपूर्ण और आवश्यक है।

इसे ऑनलाइन आज़माएं ।

-l 2 चीजें करता है:

• c()कॉस (x) सहित "गणित" लाइब्रेरी को सक्षम करें
• 20 दशमलव स्थानों पर सटीक (स्केल) सेट करता है ( bcसटीक परिशुद्धता गणना है)

मैं वास्तव में सटीक आवश्यकता पर स्पष्ट नहीं हूं। जैसा कि यह है, यह कार्यक्रम 20 दशमलव स्थानों की गणना करता है। यदि एक अलग परिशुद्धता की आवश्यकता होती है, तो scale=n;कार्यक्रम की शुरुआत में सम्मिलित करने की आवश्यकता होती है, जहां nदशमलव स्थानों की संख्या है। मुझे नहीं पता कि मुझे इसे अपने स्कोर में जोड़ना चाहिए या नहीं।

यह भी ध्यान दें कि दशमलव स्थानों की कुछ संख्याओं के लिए (जैसे 21, लेकिन 20 नहीं), गणना अंतिम अंक में समाधान के दोनों ओर स्थित है। इस प्रकार वर्तमान और पिछले पुनरावृत्तियों की तुलना में, मैं Aअंतिम अंक को मिटाने के लिए दोनों पक्षों को 10 ( ) से विभाजित करता हूं ।

Answer 4

वोल्फ्राम भाषा (गणितज्ञ) , 22 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 5

डीज़िमा / एपीएल , 55 बाइट्स

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

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

टीआईओ की डीज़िमा / एपीएल के रूप में कोई भी टीआईओ लिंक बिगिनटेगर का समर्थन करने के लिए अपडेट नहीं किया गया है।

उदाहरण I / O:

1
9L

10
7390851332L

100
7390851332151606416553120876738734040134117589007574649656806357732846548835475945993761069317665318L

200
73908513321516064165531208767387340401341175890075746496568063577328465488354759459937610693176653184980124664398716302771490369130842031578044057462077868852490389153928943884509523480133563127677224L

Answer 6

आर (+ Rmpfr), 55 बाइट्स

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

डेनिस ने अब Rmpfr को TIO में जोड़ दिया है इसलिए यह काम करेगा; कुछ परीक्षण मामलों को जोड़ा।

स्पष्टीकरण:

कोड मैं से लिखा जाता है इस चुनौती का मूल्यांकन करने cos nपर शुरू बार 1, लेकिन पहले मैं परिशुद्धता मैं मान एक वस्तु बनाने के द्वारा में रहना चाहता हूँ निर्दिष्ट bवर्ग के mpfrमूल्य के साथ 1और सटीक n, n>=2ताकि हम और अधिक सटीक मिल के रूप में हम साथ जाने।

इसे ऑनलाइन आज़माएं!

Comments

पुनः प्रयास करें। :) भविष्य में, अगर कुछ भी TIO से गायब है, तो talk.tryitonline.net में एक संदेश छोड़ने में संकोच न करें ।

— डेनिस

@ डेनिस धन्यवाद! मैं भविष्य में इसे ध्यान में रखूंगा!

— Giuseppe

Answer 7

ऑक्टेव , 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

प्लास्टिक नंबर के लगभग मेरे उत्तर की बहुत नकल , लेकिन अधिक आराम की आवश्यकताओं के कारण कुछ हद तक कम।

Answer 8

K: 6 बाइट्स

  _cos/1
0.7390851

f/fयह तब तक लागू होता है जब तक यह एक निश्चित बिंदु तक नहीं पहुंचता।

Comments

k का यह कौन सा संस्करण है? _मैं जानता हूँ कि ज्यादातर संस्करणों में फर्श है। K4 और ठीक में आप के साथ 5 बाइट्स प्राप्त कर सकते हैंcos/1

— घसीट

K3। बिल्ट-इन वहाँ एक अंडरस्कोर के साथ शुरू करते हैं।

— स्पर्शरेखा

दिलचस्प! मैं जंगली में k3 नहीं देखा है। हो सकता है कि इसे लेबल करने लायक हो जैसे कि इस मंच पर उपयोग किए जाने वाले एक से अधिक दो संस्करण हैं :)

— scrawl

यदि Dyalog APL समाधान को अमान्य माना जाता है, तो इसे अमान्य माना जाना चाहिए और साथ ही साथ यह बिल्कुल वैसा ही एल्गोरिथम होगा।

— जेफ ज़िटलिन

Answer 9

Mathics या Mathematica, 46 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 10

PHP , 50 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

साइट पर आपका स्वागत है! :)

— जेम्स

मेरा मानना ​​है कि for($a=$argv[1];$a--;)$j=cos($j);echo$j;(40 बाइट्स) काफी है।

— इस्माईल मिगुएल

Answer 11

पायथ , 57 54 बाइट्स

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

यह बहुत कम होगा यदि हमें कल्पना करने के लिए दशमलव की आवश्यकता नहीं है, लेकिन यह वही है जो यह है।

1: -3 बाइट्स को संपादित करें क्योंकि हमें एक नंबर की आवश्यकता है, इसलिए हम अपने शुरुआती मूल्य के रूप Xमें globals()लंबाई की लौटी हुई प्रतिलिपि का उपयोग कर सकते हैं , इसे अंत तक स्थानांतरित कर सकते हैं और एक $और कुछ व्हाट्सएप को हटा सकते हैं ।

इसे ऑनलाइन आज़माएं!

Answer 12

एपीएल (डायलॉग यूनिकोड) , 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 time x) का मूल्यांकन किया जाता है, x = 1 के साथ, वे समान नहीं होंगे। cos 1 0.5403 है ..., इसलिए पुन: मूल्यांकन करें, 1 की जगह 0.5403 ... और प्रक्रिया को तब तक दोहराएं जब तक (2 ... x) = x, जो x = 0.73908 के लिए होता है ...

इसे बनाने में, मैंने "मुद्रण परिशुद्धता" के लिए डिफ़ॉल्ट मान का उपयोग किया, जिसे एपीएल में ⎕PP ⎕ का उपयोग करके सेट किया जा सकता है; ogPP के लिए अधिकतम मूल्य जो Dyalog APL 34 अंकों की अनुमति देता है।

इसके अलावा, इस कार्यान्वयन के लिए डिफ़ॉल्ट परिशुद्धता 64-बिट फ़्लोट्स है; ⎕FR। 1287 को सेट करके 128-बिट फ्लोट का उपयोग कर सकते हैं। टीआईओ गणना 64-बिट फ्लोट्स के साथ की जाती है।

कंप्यूटर भाषा का कोई वास्तविक कार्यान्वयन वास्तव में मनमानी परिशुद्धता नहीं दे सकता है; हालाँकि, एक सैद्धांतिक एपीएल के लिए कोड जिसने मनमाना परिशुद्धता लागू किया था, बिल्कुल वैसा ही होगा ।

Comments

यह 5 बाइट्स है।

— आदम

जैसा कि आपने चैट में उल्लेख किया है, यह एक NARS2000 समाधान होना चाहिए, यह Dyalog में अमान्य है। फिर, इसे एक उचित प्रविष्टि बनाने के लिए, आपको सेट करना चाहिए ⎕CT←0, और संभवतः इनपुट को असाइन करना चाहिए ⎕FPC।

— द्विजिमा

यह मनमानी परिशुद्धता का समर्थन नहीं करता है, जो कि कल्पना द्वारा आवश्यक है:Your output should be capable of being arbitrarily precise, floats and doubles are not sufficient for this challenge.

— ग्रैमी

@ Adám यह उत्तर अमान्य है; ऊपर ग्रिम की टिप्पणी देखें। dzaima का समाधान काम करेगा लेकिन यह पहला नहीं है।

— एसएस ऐनी

@JeffZeitlin आपका उत्तर अभी भी अमान्य है। मनमानी परिशुद्धता कैसे संभव है, इस बारे में (स्पष्ट रूप से गलत) टिप्पणी जोड़ना मदद नहीं करता है। तुलना के लिए कुछ मान्य उत्तरों को देखने का प्रयास करें ।

— ग्रैमी

Answer 13

जावास्क्रिप्ट (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)इसकी टेलर विस्तार से गणना की जाती है। 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

Answer 14

पायथन - 89 बाइट्स

दशमलव मॉड्यूल का उपयोग करता है।

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

Comments

आयातों को मिलाकर 84 बाइट्स ।

— अर्नोल्ड पामर

72 बाइट्स

— मारिया मिलर

Answer 15

पर्ल 5, 41 बाइट्स

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

Bignum को मनमानी परिशुद्धता के लिए आवश्यक है। एक फंक्शन को परिभाषित करता है जो पुनरावर्ती को 0 एन बार को कोसाइन करता है।

TIO नहीं लग रहा है तो कोई लिंक bignum है :(

Answer 16

गणितज्ञ 44 बाइट्स

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

FindRoot डिफ़ॉल्ट रूप से न्यूटन की विधि का उपयोग करता है।

Answer 17

पायथन 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

प्रदान की गई टिप का उपयोग कर नया संस्करण।

पायथन 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पुनरावृत्ति सीमा है।

Comments

पायथन के बिलिन फ्लोट प्रकार में अनिश्चित परिशुद्धता होती है, इस प्रकार आपका कार्य वास्तव में स्पर्शोन्मुख नहीं होता है।

— तदर्थ गार्फ हंटर

धन्यवाद, जानकर अच्छा लगा। फिक्स्ड मुझे लगता है, अब बहुत कम नहीं थो :) :)

— सिडबी 22

प्रश्न में प्रदान की गई टिप शायद न्यूटन की विधि से छोटी होगी।

— तदर्थ गार्फ हंटर

धन्यवाद फिर से, लगता है जैसे मैं भी फैंसी गणित के साथ दूर किया गया था।

— सिडबी

आपके फ़ंक्शन को nआवश्यकता के अनुसार केवल 1 तर्क लेना चाहिए , इसलिए आपको डिफ़ॉल्ट करने की आवश्यकता है x=0। इसके अलावा, यह कार्य मनमाना-सटीक नहीं है, क्योंकि math.cosनिश्चित परिशुद्धता है।

— सर्कुलस स्पुतम

Answer 18

Axiom, 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)

असहमति और टिप्पणी की

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

मैं न्यूटन विधि का उपयोग करूंगा क्योंकि यह 'बार-बार कॉस (एक्स) विधि' से तेज होगा

 800   92x
1000  153x
2000  379x

जहां पहले कॉलम में अंकों की संख्या होती है और दूसरे कॉलम में न्यूटन विधि कितनी बार उपयोग की जाती है, यह यहां दोहराए गए कॉस (x) विधि से तेज है। शुभ प्रभात

Answer 19

स्टैक्स , 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

Comments

यह मनमानी परिशुद्धता का समर्थन नहीं करता है, जो कल्पना द्वारा आवश्यक है:Your output should be capable of being arbitrarily precise, floats and doubles are not sufficient for this challenge.

— ग्रैमी