मेरे बॉस ने मुझे सिर्फ कॉशन फंक्शन लिखने के लिए कहा था। एक अच्छा गणित गीक होने के नाते, मेरे दिमाग ने तुरंत उचित टेलर सीरीज़ का निर्माण किया।

cos(x) = 1 / 0! - x^2 / 2! + x^4 / 4! - x^6 / 6! + ... + (-1)^k x^(2k) / (2k)! + ...

हालाँकि, मेरा बॉस बहुत अडियल है। वह यह बताने में सक्षम होना चाहिए कि टेलर श्रृंखला की गणना करने के लिए कितने शब्द हैं। क्या आप मुझे इस कार्य को लिखने में मदद कर सकते हैं?

आपका कार्य

एक चल बिन्दु मूल्य को देखते हुए xसे 0करने के लिए 2 piऔर उसे धन पूर्णांक nकी तुलना में कम 100है, पहले की राशि की गणना nके लिए ऊपर दिए गए टेलर श्रृंखला के मामले cos(x)।

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है। इनपुट और आउटपुट को किसी भी मानक तरीके से लिया जा सकता है। मानक खामियों को मना किया जाता है।

इनपुट, किसी भी उचित रूप में लिया जा सकता है जब तक कि वहाँ के बीच एक स्पष्ट जुदाई है xऔर n।
इनपुट और आउटपुट फ्लोटिंग-पॉइंट मान होना चाहिए, कम से कम उतना ही सटीक होना चाहिए कि कुछ मानक गोलाई नियम के साथ एकल-सटीक IEEE फ़्लोटिंग पॉइंट नंबरों का उपयोग करके सूत्र की गणना की जा सके।
यदि यह उपयोग की जा रही भाषा के लिए समझ में आता है, तो सटीक तर्कसंगत मात्रा का उपयोग करके गणना की जा सकती है, लेकिन इनपुट और आउटपुट अभी भी दशमलव रूप में होंगे।

उदाहरण

 x  |  n | Output
----+----+--------------
0.0 |  1 | 1.0
0.5 |  1 | 1.0
0.5 |  2 | 0.875
0.5 |  4 | 0.87758246...
0.5 |  9 | 0.87758256...
2.0 |  2 | -1.0
2.0 |  5 | -0.4158730...

— सिल्वियो मायोलो
स्रोत

1

मैं यह मान रहा हूँ कि nइससे भी बड़ा है 0?

— गेमक्रॉप्स

8

मैं कहता हूं कि वे तकनीकी रूप से ऐसा नहीं है जो पेडेंट का मतलब है, लेकिन यह भी मेटा होगा।

— PyRulez

8

यदि आपका बॉस चाहता है कि आप एक अच्छा या कम से कम पठनीय कार्य लिखें, तो आप गलत जगह पर हैं।

— रोमन ग्रैफ

2

एक सही मायने में picky बॉस टेलर सीरीज़ की तुलना में कुछ अधिक कुशल (और सटीक) कुछ का उपयोग करके

— कॉशन की

6

@ PM2Ring कि picky नहीं होगा, यह उचित होगा। टेलर श्रृंखला वास्तव में सबसे कठिन विकल्प है।

— user1997744

64

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 165 157 बाइट्स

F={x=_this select 0;n=_this select 1;i=0;r=0;while{i<n*2}do{r=r+x^i/(i call{c=_this;j=c-1;while{j>0}do{c=c*j;j=j-1};if(c<1)then{c=1};c})*(-1)^(i/2);i=i+2};r}

के साथ बुलाना:

hint format["%1\n%2\n%3\n%4\n%5\n%6\n%7",
    [0.0, 1] call f,
    [0.5, 1] call f,
    [0.5, 2] call f,
    [0.5, 4] call f,
    [0.5, 9] call f,
    [2.0, 2] call f,
    [2.0, 5] call f]

आउटपुट:

इनपुट और आउटपुट फ्लोटिंग-पॉइंट मान होना चाहिए, कम से कम उतना ही सटीक होना चाहिए कि कुछ मानक गोलाई नियम के साथ एकल-सटीक IEEE फ़्लोटिंग पॉइंट नंबरों का उपयोग करके सूत्र की गणना की जा सके।

मुझे पूरा यकीन है कि संख्या एकल-सटीक IEEE फ़्लोटिंग पॉइंट संख्याएँ हैं, भले ही मुद्रित आउटपुट में लंबे दशमलव अधिक सटीक नहीं हैं। यह मुद्रण है जो संख्याओं को उस तरह गोल करता है, वास्तव में संख्याएं अधिक सटीक होती हैं।

उदाहरण के लिए, a=1.00001;b=1.000011;hint format["%1\n%2\n%3", a, b, a==b]यह उत्पादन करेगा:

1.00001
1.00001
false

तो स्पष्ट रूप से संख्याओं की वास्तविक परिशुद्धता मुद्रित परिशुद्धता से अधिक है।

— Steadybox
स्रोत

10

पर क्यों?

— orlp

16

@orlp क्यों नहीं?

— स्टेडीबॉक्स

3

@orlp मुझे लगता है कि पूछने के लिए अधिक उपयुक्त प्रश्न यह है: ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा अर्नोल्ड का एक प्रकार क्यों नहीं है ?

— सीलिंगकैट

2

हममम ... क्या आप दिए गए कम्पास दिशा [x] के चक्कर [n] के दिए गए नंबर की शूटिंग करके इनपुट दर्ज करते हैं? 😍 ऑपरेशन फ्लैशपॉइंट!

— मॉरमगिल

14

@Mormegil वेल, आम तौर पर नहीं, लेकिन यह कोड के इस टुकड़े के साथ किया जा सकता है:

dir=-1;num=1;player addEventHandler ["fired", {_dir=getdir (nearestObject [_this select 0, _this select 4]);if (dir < 0) then {dir = _dir} else {if (abs(dir - _dir) < 5) then {num = num + 1} else {hint format["%1", [dir*(pi/180), num] call F];dir=-1;num=1}}}]

- कुछ दिशा में शूटिंग काउंटर को बढ़ाता है, और फिर दूसरी दिशा में शूटिंग को कोसाइन फ़ंक्शन को पूर्व दिशा और उस दिशा में शॉट्स की संख्या कहते हैं।

— स्टेडीबॉक्स

13

05AB1E , 14 11 बाइट्स

FIn(NmN·!/O

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

व्याख्या

F                # for N in [0 ... n] do
 In              # push (x^2)
   (             # negate
    Nm           # raise to the Nth power
      N·!        # push (2*N)!
         /       # divide
          O      # sum

— Emigna
स्रोत

@JamesHolderness: हाँ, तब से भाषा एक बहुत बड़े बदलाव से गुज़री है। एक अजीब बग पीड़ित को लगता है ², लेकिन इसके बजाय इसे बदला जा सकता है I।

— 19

10

MATL , 14 बाइट्स

U_iqE:2ep/YpsQ

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

उदाहरण सहित व्याख्या

सभी नंबरों में दोहरी सटीकता है (यह डिफ़ॉल्ट है)।

आदानों पर विचार करें x = 2.0, n = 5।

U_     % Implicitly input x. Square and negate
       % STACK: -4
iqE    % Input n. Subtract 1, multiply by 2
       % STACK: -4, 8
:      % Range
       % STACK: -4, [1 2 3 4 5 6 7 8]
2e     % Reshape into a 2-row matrix
       % STACK: -4, [1 3 5 7;
       %             2 4 6 8]
p      % Product of each column
       % STACK: -4, [2 12 30 56]
/      % Divide, element-wise
       % STACK: [-2 -0.333333333333333 -0.133333333333333 -0.0714285714285714]
Yp     % Cumulative product of array
       % STACK: [-2 0.666666666666667 -0.0888888888888889 0.00634920634920635]
s      % Sum of array
       % STACK: -1.41587301587302
Q      % Add 1. Implicitly display
       % STACK: -0.41587301587302

— लुइस मेंडो
स्रोत

10

गणितज्ञ, ४ ९ ४१ ३ ९ ३१ बाइट्स

Sum[(-#^2)^k/(2k)!,{k,0,#2-1}]&

पुराना, अधिक "मज़ेदार" संस्करण: (39 बाइट्स)

Normal@Series[Cos@k,{k,0,2#2-2}]/.k->#&

सहेजे गए 10 बाइट्स @Pavel और 8 धन्यवाद @Greg मार्टिन के लिए!

— GamrCorps
स्रोत

9

जबकि मैथेमेटिका की Seriesक्षमता वास्तव में भयानक और मज़ेदार है, यह पता चलता है कि यहाँ उप-क्रियान्वयन Sum[(-#^2)^k/(2k)!,{k,0,#2-1}]&कम है।

— ग्रेग मार्टिन

9

जेली , 12 11 बाइट्स

ḶḤµ⁹*÷!_2/S

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

कैसे?

ḶḤµ⁹*÷!_2/S - Main link: n, x           e.g. 5, 2.0
Ḷ           - lowered range(n)              [0,1,2,3,4]
 Ḥ          - double (vectorises)           [0,2,4,6,8]
  µ         - monadic chain separation (call that i)
   ⁹        - link's right argument         2.0
    *       - exponentiate(i) (vectorises)  [1.0,4.0,16.0,64.0,256.0]
      !     - factorial(i) (vectorises)     [1,  2,  24,  720, 40320]
     ÷      - divide (vectorises)           [1.0,2.0,0.6666666666666666,0.08888888888888889,0.006349206349206349]
        2/  - pairwise reduce by:
       _    -     subtraction               [-1.0,0.5777777777777777,0.006349206349206349]
         S  - sum                           -0.41587301587301617

— जोनाथन एलन
स्रोत

8

जेली, 22 बाइट्स

-*ð×ø⁹*⁸²ð÷ø⁸Ḥ!
⁸R’Ç€S

यह एक पूर्ण कार्यक्रम है जो पहले तर्क के रूप में और दूसरे के रूप में x लेता है।

स्पष्टीकरण:

              Creates a function to compute each term in the series. 
Its argument we will call k, eg k=3 computes 3rd term. Take x=2 for example.
-*           Computes (-1)^k. Eg -1
ð×ø        Multiplies by the quantity of
⁹             x.  
*             to the power of
⁸             k
²             ...squared. Eg -1 × (2³)² 
ð÷ø        divides by the quantity of
⁸              k
Ḥ             doubled
!               ...factorial. Eg -1 × (2³)²/(6!).


                Main link, first argument n and second argument n. Eg n=4, x=2.
⁸R            Creates range(n). Eg [1,2,3,4]
’                Decrements each element. Eg [0,1,2,3]
Ç€            Maps the above function over each element. Eg [1,-2,0.666,-0.0889]
S               Sum all all of the elements.  Eg -0.422.

— fireflame241
स्रोत

7

PPCG में आपका स्वागत है!

— मार्टिन एंडर

6

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

f=lambda x,n,t=1,p=1:n and t+f(x,n-1,-t*x*x/p/-~p,p+2)

यदि पायथन 2 का उपयोग किया जाता है, तो x को एक फ्लोट के रूप में पास करना सुनिश्चित करें, पूर्णांक नहीं, लेकिन मुझे मेरी समझ यह है कि यदि आप पायथन 3 का उपयोग कर रहे हैं तो इससे कोई फर्क नहीं पड़ता।

— नील
स्रोत

5

टीआई-बेसिक, 41 40 बाइट्स

Prompt X,N
sum(seq((-(X+1_E-49)²)^Q/((2Q)!),Q,0,N-1

1E-49 को कोण में जोड़ा जाता है क्योंकि TI-Basic 0 ^ 0 के लिए एक त्रुटि फेंकता है, यह त्रुटि का कारण नहीं बनने के लिए बस काफी बड़ा है, और यह उत्तर को बदलने के लिए पर्याप्त बड़ा नहीं है।

— pizzapants184
स्रोत

4

सी, 96 बाइट्स

पुनरावर्ती लाइव

f(n){return n?n*f(n-1):1;}float c(n,x)float x;{return n?c(n-1,x)+pow(-1,n)*pow(x,2*n)/f(2*n):1;}

विस्तृत

f(n) // factorial(n)
{
    return n ?   // n != 0 ?
        n*f(n-1) // n! = n * (n-1)!
    : 1;         // 0! = 1
}

float c(n,x)float x; // cos(x) with n+1 terms
{
    return n ?        // n != 0 ?
        c(n-1, x)     // cos(x) (n-1)th term
        + pow(-1, n)  // + (-1)^n
        * pow(x, 2*n) // * x^(2n)
        / f(2 * n)    // / (2n)!
    : 1;              // cos(x) at n=0
}

प्रगतिशील पुनरावर्ती, 133 बाइट्स लाइव

#define F float
#define c(x,n) 1+g(1,n,x,1,1,1)
F g(F i,F n,F x,F s,F p,F f){s=-s;p*=x*x;f*=i;return i<n?g(i+1,n,x,s,p,f)+s/2*p/f:0;}

विस्तृत

#define F float // shorthand float

#define c(x,n) 1+g(1,n,x,1,1,1) // macro function

F g(F i,F n,F x,F s,F p,F f)
{
    s = -s;   // (-1)^n = (-1) * (-1)^(n-1)
    p *= x*x; // x^(2n) =  x^2 * x^(2(n-1))
    f *= i;   //    2n! =    2 * (1*2*..*n)

    return i < n ?       // i = 0 .. n-1
        g(i+1,n,x,s,p,f) // next term
        + s / 2 * p / f  // s*p/2f = s/2*p/f
        : 0;             // don't compute nth term
}

— Khaled.K
स्रोत

96b संस्करण c(0.5, 80)=> NaN, अतिप्रवाह के लिएf(80)=0

— l4m2

@ l4m2 पुनरावर्ती कार्य यहां गोल्फिंग के उद्देश्य से हैं, लेकिन वे अव्यवहारिक हैं क्योंकि वे आसानी से अतिप्रवाह कर सकते हैं क्योंकि कॉल की संख्या कॉल-स्टैक सीमा से अधिक है, और यहां तक कि उच्च सीमा के साथ यह संसाधन की बर्बादी है, ऊपर दिए गए समाधान के लिए। छोटी संख्या।

— खालिद.के

1

समस्या सीधे कहती है n<100ताकि आप कम से कम उस सीमा तक न जाएं। स्टैक ओवरफ्लो नहीं

— l4m2

यदि समस्या कहती है n<100और आप O(2^n)समाधान का उपयोग करते हैं, तो मुझे लगता है कि यह ठीक है, जब तक कि यह अंततः परिणाम

— सामने न आ जाए

1

FYI करें, NaN परिणाम को पुनरावृत्ति से कोई लेना-देना नहीं है - यह फैक्टरियल गणना का एक अतिप्रवाह है जो पूर्णांकों का उपयोग कर रहा है जब इसे फ्लोट्स (198 का उपयोग करना चाहिए! यह कभी भी एक इंट में फिट नहीं होने वाला है)।

— जेम्स होल्डरनेस

4

जावास्क्रिप्ट (ईएस 6), 46 बाइट्स

f=
x=>g=(n,t=1,p=0)=>n&&t+g(--n,-t*x*x/++p/++p,p)

<div oninput=o.textContent=f(x.value)(n.value)><input id=x><input type=number min=1 value=1 id=n><pre id=o>1

स्निपेट का विस्तार करें

करी इनपुट (x) (n) लेता है।

— नील
स्रोत

इसे स्निपेट क्यों नहीं बनाया गया?

— अर्जुन

4

सी, 71 बाइट्स

हॉर्नर योजना का उपयोग करना

float f(n,x)float x;{float y;for(n+=n;n;)y=1-(y*x*x/n--)/n--;return y;}

Ungolfed संस्करण:

float f(n,x) float x;
{
  float y = 0.0;
  for(n = 2*n; n>0; n -= 2)
  {
    y = 1-y*x*x/n/(n-1);
  }
  return y;
}

— हेगेन वॉन एटिजन
स्रोत

यह किस प्लेटफार्म पर काम करता है?

— एनाटोलिग

4

आर, 70 64 बाइट्स

function(x,n)sum(sapply(1:n-1,function(y)(-x^2)^y/gamma(2*y+1)))

pizzapants184 के जवाब के लिए 6 बाइट्स को बचाया (-x ^ 2) ^ y ट्रिक के साथ

65 बाइट्स:

function(x,n)Reduce(function(a,b)a+(-x^2)^b/gamma(2*b+1),1:n-1,0)

बहुत ज्यादा अनुभवहीन इसका क्रियान्वयन लेकिन एक छोटा सा गोल्फ; एक अनाम फ़ंक्शन लौटाता है जो टेलर श्रृंखला को निर्दिष्ट n पर गणना करता है

Reduce का उपयोग एक और बाइट लेता है जैसा initकि 0 पर सेट किया जाना है
के gamma(n+1)बजाय का उपयोग करता हैfactorial(n)
1:n-1 के बराबर है 0:(n-1)

— ग्यूसेप
स्रोत

3

ओके , 38 बाइट्स

यह k में भी काम करता है , लेकिन 39 बाइट्स लेता है क्योंकि एक 'को /:इसके बजाय लिखा जाना चाहिए (कम से कम, kmac 2016.06.28 में ऐसा नहीं है)।

{+/(y#1 -1)*{(*/y#x)%*/1+!y}.'x,'2*!y}

स्पष्टीकरण:

मध्य बिट के साथ शुरू करते हैं। (*/y#x)प्रतिपादक है, यह इसके बराबर है x^y। */1+!yहोगा y!, या yभाज्य। %विभाजन है। इसलिए मध्य में कार्य है middle(x,y) = (x^y)/(y!)।

अब दाईं ओर थोड़ा, जिस पर ऊपर का फ़ंक्शन लागू होता है। 2*!yहै {0, 2, 4, ..., 2*(y-1)}। x,'पहले जोड़ता xहै कि सूची में हर आइटम के लिए, यह में बदल {(x, 0), (x, 2), (x, 4), ..., (x, 2*(y-1))}। .'तब लागू होता है middle(संख्या की प्रत्येक जोड़ी के लिए mapअनिवार्य रूप से)।

अंत में, (y#1 -1)*परिणाम को 1 या -1 (प्रत्यावर्ती) से गुणा करता है, और +/योग लेता है।

— zgrep
स्रोत

3

हास्केल, 71 बाइट्स

f x n=sum$map(\i->(-1)^i*x^(2*i)/fromIntegral(product[1..2*i]))[0..n-1]

यह एक बहुत ही उबाऊ उत्तर है जिसे समझना बहुत कठिन नहीं है। fromIntegralवास्तव में काटता है, हालांकि। ( /ऑपरेटर को हास्केल में समान संख्यात्मक प्रकार के ऑपरेंड की आवश्यकता होती है, और संख्यात्मक प्रकारों के बीच किसी वर्कट कार्य के बिना अनुमति नहीं दी जाती है।)

— Enderperson1010
स्रोत

1

एक सूची समझ आपको कुछ काटने से बचा सकती है:f x n=sum[(-1)^i*x^(2*i)/fromIntegral(product[1..2*i])|i<-[0..n-1]]

— जूलियन वुल्फ

1

विशेष रूप से PPCG और हास्केल गोल्फ में आपका स्वागत है!

— लकोनी

3

जेली , 12 बाइट्स

²N*Ḷ}©÷®Ḥ!¤S

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

यह काम किस प्रकार करता है

²N*Ḷ}©÷®Ḥ!¤S  Main link. Left argument: x. Right argument: n

²             Square; yield x².
 N            Negate; yield -x².
     ©         Call the link to the left and copy the result to the register.
   Ḷ}          Call unlength on the right argument, yielding [0, 1, ..., n-1].
  *           Yield [1, -x², ..., (-x²)**(n-1)].
          ¤   Combine the three links to the left into a niladic chain.
       ®        Yield the value in the register, [0, 1, ..., n-1].
        Ḥ       Unhalve; yield [0, 2, ..., 2n-2].
         !      Factorial; yield [0!, 2!, ..., (2n-2)!].
      ÷         Division; yield [1/0!, -x²/2!, ..., (-x²)**(n-1)/(2n-2)!].
           S  Take the sum.

— डेनिस
स्रोत

3

पायथ, 16 बाइट्स

sm_Fc^vzyd.!yddU

nपहले स्वीकार करता है , फिर x। उदाहरण चलाते हैं।

— स्टीवन एच।
स्रोत

3

हास्केल , 61 बाइट्स

x#n=sum[(-1*x^2)^i/fromIntegral(product[1..2*i])|i<-[0..n-1]]

यह एक अलग उत्तर को वारंट करने के लिए अन्य हास्केल समाधान से काफी अलग लग रहा था। कार्यान्वयन बहुत ही आत्म-व्याख्यात्मक होना चाहिए - कॉल उस संख्या के साथ होनी चाहिए x#nजहां xकी कोज्या की गणना की जानी है और nआंशिक राशि का आदेश लिया जाना है।

— जूलियन वुल्फ
स्रोत

आप को हटाने के द्वारा काफी कुछ बाइट्स बचा सकता है fromIntegralऔर का उपयोग कर **के स्थान पर ^इस तरह के रूप में, इस

— बी मेहता

x#n=sum[(-x*x)**i/product[1..2*i]|i<-[0..n-1]]3 और बाइट्स बचाता है।

— लिन

3

पाइट , 37 34 33 बाइट्स

←←ĐĐ↔3Ș1~⇹ř⁻^04Ș⇹ř⁻^²*0↔ř⁻2*!+/+Ʃ

— mudkip201
स्रोत

3

जे, 26 24 बाइट्स

+/@:(!@]%~^*_1^2%~])2*i.

-2 बाइट्स @cole का धन्यवाद

मैंने मूल रूप से जोड़ने और घटाने के बीच वैकल्पिक करने के लिए एक चक्रीय गेरुंड का उपयोग करने की योजना बनाई, लेकिन इसे काम करने के लिए नहीं मिला।

स्पष्टीकरण:

                    2*i.     | Integers from 0 to 2(n-1)
    (              )         | Dyadic train:
            _1^-:@]          | -1 to the power of the left argument
          ^*                 | Times left arg to the power of right arg
     !@]%~                   | Divided by the factorial of the right arg
+/@:                         | Sum

— बोलस बूसियर
स्रोत

1

24 बाइट्स: +/@:(!@]%~^*_1^2%~])2*i.गोना एक चक्रीय गेरुंड की जांच करते हैं: यह संभवतः विफल हो गया क्योंकि जे /दाएं-बाएं का मूल्यांकन करता है इसलिए आपको उपयोग करने की आवश्यकता है |.(या हो सकता है कि आपने इसके लिए जिम्मेदार हो और अभी भी कठिनाई हो)।

— कोल

3

पर्ल 6 , 53 बाइट्स

{(sum (1,*i*$^x...*)[^2*$^n] »/»(1,|[\*] 1..*)).re}

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

यह वास्तव में जटिल घातांक ई ^{i comp की} गणना अनुरोधित पदों की संख्या से दोगुनी है और फिर वास्तविक भाग लेता है।

— शॉन
स्रोत

2

MATLAB प्रतीकात्मक गणित टूलबॉक्स के साथ, 57 बाइट्स

@(x,n)eval(subs(taylor(sym('cos(x)'),'Order',2*n),'x',x))

यह एक अनाम फ़ंक्शन को परिभाषित करता है जो doubleइनपुट लेता है x, nऔर परिणाम को एक के रूप में आउटपुट करता है double।

उदाहरण (R2015b पर परीक्षण किया गया):

>> @(x,n)eval(subs(taylor(sym('cos(x)'),'Order',2*n),'x',x))
ans = 
    @(x,n)eval(subs(taylor(sym('cos(x)'),'Order',2*n),'x',x))
>> f = ans; format long; f(0,1), f(0.5,1), f(0.5,2), f(0.5,4), f(0.5,9), f(2,2), f(2,5)
ans =
     1
ans =
     1
ans =
   0.875000000000000
ans =
   0.877582465277778
ans =
   0.877582561890373
ans =
    -1
ans =
  -0.415873015873016

— लुइस मेंडो
स्रोत

2

जावास्क्रिप्ट ईएस 7 60 बाइट्स

x=>a=n=>--n?(-1)**n*x**(2*n)/(f=m=>m?m*f(m-1):1)(2*n)+a(n):1


x=>a=n=>                                                         // Curry-d function, it basically returns another function
        --n?                                              :1  // subtract one from n. If n - 1 is 0, return 1
            (-1)**n*                                             // This generates the sign of the number
                    x**(2*n)/                                    // This creates the part before the division, basicaly x^2n
                             (f=m=>m?m*f(m-1):1)(2*n)            // This creates a recursive factorial function and calls it with 2n
                                                     +a(n)    // Recursively call the function. This adds the elements of the taylor series together

इसके प्रयेाग के लिए:

F12 दबाएँ, फ़ंक्शन में टाइप करें और फिर करें

c(x)(n)

— Bálint
स्रोत

2

C 144 130 बाइट्स

F(m){int u=1;while(m)u*=m--;return u;}float f(float x,n){float s;for(int i=1;i<n;i++)s+=pow(-1,i)*pow(x,2*i)/(F(2*i));return 1+s;}

Ungolfed संस्करण:

//Function to calculate factorial
int F(int m)
{
  int u=1;

  while(m>1)
   u*=m--; 

  return u;
}

//actual function called in main function   
float f(float x, int n)
{

  float s=0.0;

  for(int i=1;i<=n-1;i++)
     s+=pow(-1,i)*pow(x,2*i)/(F(2*i)); 

  return 1+s;
 }

कुछ बाइट्स बचाने के लिए केविन धन्यवाद!

— हाबिल टॉम
स्रोत

आप फ़ंक्शन परिभाषाओं की मालिश करके कुछ बाइट्स बचा सकते हैं:F(m){...}f(x,n)float x;{...}

— केविन

यू * 1 == यू के बाद से, आप पहले फ़ंक्शन में लूप बना सकते हैं while(m)u*=m--या u=m;while(--m)u*=m(एक ही लंबाई)

— केविन

i<=n-1वही हैi<n

— केविन

@ केविन धन्यवाद, आप बिल्कुल सही कह रहे हैं, अब थोड़ी देर में गोल्फ नहीं खेलेंगे। :)

— हाबिल टॉम

2

101 बाइट्स

— सीलिंगकैट

2

Tcl , 126 बाइट्स

proc c {x n k\ 0 r\ 0} {proc F n {expr $n?($n)*\[F $n-1]:1}
time {set r [expr $r+-1**$k*$x**(2*$k)/[F 2*$k]]
incr k} $n
set r}

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

— sergiol
स्रोत

असफल प्रकोप: 129

— सर्जियोल

2

स्टैक्स , 12 बाइट्स

ü┘·.ⁿYeò≥Vîû

इसे चलाएं और डीबग करें

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह ऐसा दिखता है।

            Input is `x n`
Z           Push a zero underneath the top.  The stack is now `x 0 n` 
D           Run the rest of the program n times.
  xJNi|*    (-x*x)^i where i is the iteration index
  iH|F/     divide that by factorial(2i)
  +         add to the running total so far
            final result is implicitly printed

इसको चलाओ

— पुनरावर्ती
स्रोत

1

जावास्क्रिप्ट, 59 बाइट्स

x=>k=n=>--n?k(n)+(-1)**n*x**(n*=2)/f(n):1
f=p=>p?p*f(p-1):1

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

— fənɛtɪk
स्रोत

यह 65 बाइट्स है

— बैलिंट

@ बैलिंट ने बदलावों की नकल करने में गलती की थी। (n) माना जाता था कि बस n

— f )nɪt Aprk

1

PHP, 76 बाइट्स

for($f=1;$i<$argv[2]*2;$f*=++$i)$i&1?:$s+=(-1)**$k++*$argv[1]**$i/$f;echo$s;

कमांड लाइन तर्क से Xऔर लेता Nहै; साथ चलाना -r।

पाश $iसे 0करने के लिए N*2-1, पकड़ fac($i)में $f; यदि $iहै, तो भी योग जोड़ सकते हैं $s। प्रिंट राशि।

काश मेरे पास जटिल संख्याएं M_Iहोतीं ( काल्पनिक इकाई के रूप में);
मैं बस 7 बाइट्स के $fसाथ गुणा M_I*++$iऔर बचत करूंगा ।

शायद गणितज्ञ ऐसा कर सकते हैं। लेकिन गणितज्ञ को नहीं करना है।

मैं कर सकता है के साथ दो बाइट्स को बचाने cos(M_PI*$i/2)के बजाय $i&1?:और (-1)**$k++;
लेकिन यह एक cosine फ़ंक्शन का उपयोग करने के लिए एक cosine फ़ंक्शन का उपयोग करने के लिए थोड़ा अजीब लगेगा।

— टाइटस
स्रोत

1

Axiom, 36 बाइट्स

g(a,n)==eval(taylor(cos(x)),a).(2*n)

अनंत का निर्माण करें (अर्थ परिमित में लेकिन कोई 2 * n तत्वों की सूची बनाने के लिए कह सकता है यदि पीसी में पर्याप्त मेमोरी है) कॉस के लिए टेलर श्रृंखला के लिए आंशिक रकम की सूची (x) 'ए' में गणना करें, "eval ( टेलर (cos (x)), क) "; "(2 * n)" में उस सूची के 2 * n तत्व प्राप्त करता है। परीक्षण के मामलों:

(47) -> g(0,1)
   (47)  1
                                                 Type: Expression Integer
(48) -> g(0.5,1)
   (48)  1.0
                                                   Type: Expression Float
(49) -> g(0.5,2)
   (49)  0.875
                                                   Type: Expression Float
(50) -> g(0.5,4)
   (50)  0.8775824652 7777777778
                                                   Type: Expression Float
(51) -> g(0.5,9)
   (51)  0.8775825618 9037271611
                                                   Type: Expression Float
(52) -> g(2.0,5)
   (52)  - 0.4158730158 7301587302
                                                   Type: Expression Float
(53) -> g(2.0,800)
   (53)  - 0.4161468365 471423870

— RosLuP
स्रोत

1

जे , 17 बाइट्स

4 :'2&o.T.(+:y)x'

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

एक अंतर्निहित का उपयोग करता है , जो मुझे लगता है कि ठीक है।

दुर्भाग्य से, मैं वास्तव में यह नहीं जानता कि इस तरह के करी के माध्यम से तर्क लेने वाले कार्यों के साथ अच्छी तरह से कैसे काम किया जाए, इसलिए मुझे यह स्पष्ट रूप से करना पड़ा। मुझे यकीन है कि वहाँ एक तरीका है यह tacitly या कम है।

— गोभी
स्रोत

1

क्लीन , 77 बाइट्स

import StdEnv
?x n=sum[(-1.0)^(p/2.0)*x^p/prod[1.0..p]\\p<-take n[0.0,2.0..]]

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

— Οurous
स्रोत

पेडेंट का कोसाइन

आपका कार्य

टिप्पणियाँ

उदाहरण

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 165 157 बाइट्स

05AB1E , 14 11 बाइट्स

MATL , 14 बाइट्स

उदाहरण सहित व्याख्या

गणितज्ञ, ४ ९ ४१ ३ ९ ३१ बाइट्स

जेली , 12 11 बाइट्स

कैसे?

जेली, 22 बाइट्स

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

टीआई-बेसिक, 41 40 बाइट्स

सी, 96 बाइट्स

जावास्क्रिप्ट (ईएस 6), 46 बाइट्स

सी, 71 बाइट्स

आर, 70 64 बाइट्स

ओके , 38 बाइट्स

हास्केल, 71 बाइट्स

जेली , 12 बाइट्स

यह काम किस प्रकार करता है

पायथ, 16 बाइट्स

हास्केल , 61 बाइट्स

पाइट , 37 34 33 बाइट्स

जे, 26 24 बाइट्स

स्पष्टीकरण:

पर्ल 6 , 53 बाइट्स

MATLAB प्रतीकात्मक गणित टूलबॉक्स के साथ, 57 बाइट्स

जावास्क्रिप्ट ईएस 7 60 बाइट्स

C 144 130 बाइट्स

Tcl , 126 बाइट्स

स्टैक्स , 12 बाइट्स

जावास्क्रिप्ट, 59 बाइट्स

PHP, 76 बाइट्स

Axiom, 36 बाइट्स

जे , 17 बाइट्स

क्लीन , 77 बाइट्स