परिचय:

ज्या के xसूत्र द्वारा दिया जाता है:

sin(x) = x - x^3/3! + x^5/5! - x^7/7! + x^9/9! - x^11/11! // and more follows...

कोज्या के xसूत्र द्वारा दिया जाता है:

cos(x) = 1 - x^2/2! + x^4/4! - x^6/6! + x^8/8! - x^10/10! // and more follows...

कार्य:

के मान को देखते हुए xऔर nएक कार्यक्रम (कोई काम करता है, आदि) उत्पादन के मूल्य लिखना sin(x)और cos(x)सही तक nउपरोक्त सूत्र के मामले। मान लें कि xरेडियन में है।

इनपुट:

x n

एक दशमलव संख्या x(तक 3 दशमलव स्थानों के साथ) और एक पूर्णांक n। इनपुट स्टडिन या प्रांप्ट डायलॉग बॉक्स पर होना चाहिए (यदि आपकी भाषा स्टड का समर्थन नहीं करती है)

आउटपुट:

[sin(x)]
[cos(x)]

दोनों के मूल्य sin(x)और cos(x)6 दशमलव स्थानों के लिए गोल किया जाना चाहिए। अगर sin(x)है 0.5588558855(10 दशमलव अंक), यह पूर्ण होना चाहिए 0.558856(6 दशमलव अंक)। इस विकी लेख में तालिका के पांचवें स्तंभ "गोल से निकटतम" में वर्णित के रूप में गोलाई को निकटतम होना चाहिए ।

प्रतिबंध:

1 <= x <= 20
1 <= n <= 20

नमूने:

----
5 3

10.208333
14.541667
----
8.555 13

0.765431
-0.641092
----
9.26 10

-3.154677
-8.404354
----
6.54 12

0.253986
0.967147
----
5 1

5.000000
1.000000
----
20 20

-5364.411846
-10898.499385
----

स्टैंडर्ड खामियों की मनाही है।
त्रिकोणमिति (पाप, कॉस, टैन, इत्यादि), फैक्टरियल और एक्सप्रेशन के ऑपरेटर और अंतर्निहित गणित कार्यों का उपयोग नहीं किया जा सकता है। आप उपयोग कर सकते हैं एक अंतर्निहित की गणना के परिणाम के आकलन के लिए समारोह गोलाई sin(x)और cos(x)6 वें दशमलव अंकों के लिए।
गलत आदानों को संभालने के लिए कोई ज़रूरत नहीं।
केवल ASCII वर्ण कार्यक्रम, नहीं चीनी यूनिकोड जो कि कोड संपीड़न की अनुमति देने में इस्तेमाल किया जा सकता है।
आपके प्रोग्राम को इनपुट के 3 सेकंड के भीतर आउटपुट को समाप्त करना और प्रदर्शित करना होगा।
आपके उत्तर में कोड के स्पष्टीकरण के साथ-साथ (कोड अनिवार्य है यदि कोड प्रोग्रामर-नहीं-परिचित-आपकी-भाषा, विशेष रूप से गोल्फस्क्रिप्ट, जे, आदि के लिए स्पष्ट नहीं है) के साथ-साथ, आपका जवाब अनकॉल्ड कोड के साथ होना चाहिए।
कृपया एक ऑनलाइन कंपाइलर का लिंक शामिल करें जहाँ आपके प्रोग्राम का परीक्षण किया जा सकता है।

स्कोरिंग:

वर्णों में सबसे कम कोड लंबाई के साथ उत्तर, जिसमें सफेद स्थान, टैब आदि शामिल हैं, जीतता है! 21 मई 2014 को विजेता घोषित किया जाएगा।

संपादित करें : 21/05/14 विजेता है CJam भाषा का प्रयोग aditsu । रनर अप इस प्रकार जम्मू भाषा के साथ jpjacobs , और दूसरा धावक है पर्ल भाषा के साथ Primo । सभी को बधाई!

code-golf math

— गौरांग टंडन
स्रोत

;: (मॉड टिप्पणी दिखेगा अग्रिम में मेरी चेतावनी के बाद, सब कुछ है, हालांकि सवाल में अपनी तरह से की गई टिप्पणियों nuked कृपया मुझे किसी भी खो जानकारी है कि आप चाहते हो सकता है के लिए पिंग।।)

— दरवाज़े

पहले पैराग्राफ में, यह "साइन", नहीं "पाप" होना चाहिए

— ऐसा नहीं है कि चार्ल्स

है "निकटतम करने के लिए राउंड" अभी भी एक आवश्यकता है, या हम किसी भी निर्मित सुविधाओं गोलाई का उपयोग कर सकते हैं? जीरो की तरह गोल?

— डिजिटल ट्रामा

mod 2piआदानों को तेजी से अभिसरण करने के लिए एक ऑपरेशन के समतुल्य आवश्यक रूप से उपयोगी होगा - यह इन कार्यों से निपटने के दौरान वास्तविक दुनिया द्वारा उपयोग किए जाने वाले कई सुधारों में से एक है। (वास्तव में मॉड पी और हस्ताक्षर जागरूकता)।

— फ्लोरिस

1

@Floris मैं यह कभी नहीं जानता था। ठीक है, हम कुछ भी अब ऐसा नहीं कर सकते, नियम पहले से ही बहुत बदल गए हैं, और मैं उन्हें आगे परेशान करने के लिए बदल रहा है answerers रखने के लिए नहीं करना चाहती। फिर भी सुझाव के लिए धन्यवाद!

— गौरांग टंडन

6

CJam - 42

rd:X;1_ri2*,1>{_2%2*(*/X*_}/;]2/z{:+6mO}/p

पर ऑनलाइन का प्रयास करें http://cjam.aditsu.net

स्पष्टीकरण:

rपढ़ता इनपुट से एक टोकन
dडबल में धर्मान्तरित लोगों
:Xचर एक्स के लिए प्रदान करती है
;स्टैक से मूल्य पॉप
1ढेर पर डालता है 1 (पहले कार्यकाल)
_डुप्लिकेट 1
rपढ़ता अगले टोकन (एन)
iपूर्णांक में धर्मान्तरित लोगों
2*,1>{...}/पाश का एक प्रकार से है 1 2 * n करने के लिए - 1:
- 2*पलता 2 से
- ,(अंतिम मान) 0 से एक सरणी बनाता -1
- 1>सरणी के पहले आइटम को हटा (0)
- {...}/कार्यान्वित सरणी में प्रत्येक आइटम के लिए ब्लॉक
_डुप्लिकेट "लूप चर "(यह k कॉल)
2%2*(भी से / अजीब धर्मान्तरित -1/1 करने के लिए:
- 2%है सापेक्ष 2 (-> 0/1)
- 2*2 से गुणा करता है (-> 0/2)
-(decrements (-> -1/1)
*पलता है, इस प्रकार संकेत बदल रहा है हर दूसरी बार
/विभाजित कश्मीर या -k द्वारा स्टैक पर अवधि; यह "/ k" है!
X*एक्स द्वारा गुणा परिवर्तन के साथ एक साथ गणना का हिस्सा ; यह गणना का "X ^ k" भाग है; हम प्राप्त श्रृंखला में अगली अवधि
_डुप्लिकेट अवधि अगले चरण में निम्नलिखित अवधि की गणना के लिए प्रयोग की जाने वाली
;(पाश के बाद) पॉप पिछले डुप्लिकेट अवधि
]एक सरणी में स्टैक पर मामले एकत्र करता है
इस बिंदु पर हम एक सरणी है [ 1 एक्स-एक्स ^ 2/2! -X ^ 3/3! एक्स ^ 4/4! एक्स ^ 5/5! ...] वास्तव में सभी शर्तों हम cos (x) और पाप (एक्स), interleaved के लिए की जरूरत युक्त
2/विभाजन जोड़े में इस सरणी
z, मैट्रिक्स transposes क्योंकि (x) और पाप (एक्स) के लिए शर्तों से सरणी के लिए शर्तों से सरणी में जिसके परिणामस्वरूप, के रूप में "मैट्रिक्स पंक्तियाँ"
{...}/फिर से प्रत्येक सरणी मद (मैट्रिक्स पंक्ति) के लिए ब्लॉक निष्पादित करता है:
- :+तत्व कहते हैं एक साथ मैट्रिक्स पंक्ति के
- 6mO6 दशमलव के दौर
इस बिंदु पर हम ढेर पर वांछित क्योंकि (x) और sin (x) है
pप्रिंट पर ढेर अंतिम आइटम के प्रतिनिधित्व (sin (x)) एक नई पंक्ति के बाद
से कम कार्यक्रम के अंत में, स्टैक (कॉस (x)) की शेष सामग्री स्वचालित रूप से मुद्रित होती है।

— aditsu
स्रोत

1

+1 ने मुझे एक ऐसी भाषा से परिचित कराने के लिए कहा है जिसके बारे में मैंने कभी नहीं सुना है और शायद कभी उपयोग नहीं करेगा।

— एलेक्स ए

@ एलेक्स थैंक्स, सीजेएम कुछ हद तक स्टेरॉयड पर गोल्फस्क्रिप्ट की तरह है

— aditsu

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

— गौरांग टंडन

@ गौरांगटन मुझे बहुत पसंद नहीं है। आपको क्या लगा कि चीनी पात्रों को संभवतः इस समस्या के लिए इस्तेमाल किया जा सकता है? वैसे भी, संपादित।

— एडिट्स

18

पर्ल - 72 बाइट्स

$~=<>=~$"+$'*2;$_=1-$_*$`/$~--/$~*$`for($,,$;)x$';printf'%f
%f',$`*$,,$;

या, कमांड बाइट्स विकल्प को 1 बाइट के रूप में, 70 बाइट्स में गिना जाता है :

#!perl -n
$-=/ /+$'*2;$_=1-$_*$`/$---/$-*$`for($,,$;)x$';printf'%f
%f',$`*$,,$;

या, यदि आप मुझे 63 बाइट्स में पर्ल 5.8 की अनुमति देंगे, तो :

#!perl -p
$.+=$'<</ /;$_=1-$_*$`/$.--/$.*$`for($_=$#='%f
',$\)x$';$_*=$`

लेकिन आप क्यों करेंगे

संपादित करें : नए नियमों का अनुपालन। %fडिफ़ॉल्ट रूप से 6 स्थानों पर गोल, कितना सुविधाजनक है!

कलन विधि

पाप के लिए टेलर श्रृंखला की जांच (x) :

$\sin(x)=x-\frac{x^3}{3!}+\frac{x^5}{5!}-\frac{x^7}{7!}+\frac{x^9}{9!}-\frac{x^{11}}{11!}+\dots$

यह देखा जा सकता है कि प्रत्येक शब्द प्रत्येक क्रमिक शब्द को समान रूप से विभाजित करता है। इस वजह से, इसे सहज रूप से एक नेस्टेड अभिव्यक्ति में बदला जा सकता है:

$\sin(x)=x(1-\frac{x^2}{2\cdot 3}(1-\frac{x^2}{4\cdot 5}(1-\frac{x^2}{6\cdot 7}(1-\frac{x^2}{8\cdot 9}(1-\frac{x^2}{10\cdot 11}(1-\dots))))))$

cos (x) समान रूप से परिवर्तित होता है, अग्रणी x के बिना , और हर एक के लिए छोटा होता है।

इसके अतिरिक्त, इस नेस्टेड एक्सप्रेशन को एक रिवर्स रिकर्सिव एक्सप्रेशन के रूप में सुधार किया जा सकता है:

$s_n=1-\frac{s_{n+1}\cdot x^2}{(2n)\cdot(2n+1)}$

साथ रों _∞ = 0 और sin (x) = एक्स · एस ₁ , जो अंततः है क्या प्रयोग किया जाता है।

Ungolfed

<> =~ m/ /;          # read one line from stdin, match a space
                     # prematch ($`) is now x, postmatch ($') is now n
($x, $n) = ($`, $'); # reassign, for clarity
$i = 2*$n + 1;       # counting variable (denominators)

for (($s, $c)x$n) {  # iterate over $s and $c, n times each
  # compute the next term of the recursive expression
  # note: inside this loop $_ is not the _value_
  # of $s and $c alternately, it _is_ $s and $c

  $_ = 1 - $_ * $x**2 / $i-- / $i;
}

# formated output
printf("%f\n%f", $x*$s, $c);

नमूना उपयोग

$ echo 5 3 | perl sin-cos.pl
10.208333
14.541667

$ echo 8.555 13 | perl sin-cos.pl
0.765431
-0.641092

$ echo 9.26 10 | perl sin-cos.pl
-3.154677
-8.404354

$ echo 6.54 12 | perl sin-cos.pl
0.253986
0.967147

$ echo 5 1 | perl sin-cos.pl
5.000000
1.000000

$ echo 20 20 | perl sin-cos.pl
-5364.411846
-10898.499385

आप इस ऑनलाइन परीक्षण करना चाहते हैं, मैं उपयोग करने की अनुशंसा compileonline.com । कॉपी-पेस्ट में कोड main.pl, और में इनपुट STDINबॉक्स है, तो Execute Script।

— Primo
स्रोत

2

क्या इनपुट पार्स करने के लिए एक कुटिल रास्ते ... मैं उपयोग कर सकते हैं कि मेरे समाधान में? :)

— ताल

@ ताल मुक्त महसूस करो।

— प्रिमो

2

मुझे लगता है कि पर्ल (और विशेष रूप से आपके कोड) को "प्रोग्रामरों के लिए तुरंत स्पष्ट नहीं-परिचित-आपकी-अपनी भाषा के रूप में" के रूप में गिना जाता है

— एडिट्स

1

@aditsu सहमत। मैं कुछ क्लीनर कोड, और कलन विधि का एक विवरण जोड़ देंगे।

— Primo

2

यह उत्तर वास्तव में अत्यंत शैक्षिक था!

— ताल

10

पायथन 3 (102) / पायथन 2 (104)

पायथन 3 (102)

x,n=map(float,input().split())
k=2*n
t=1
while k>1:k-=1;t=1+t*1j*x/k
print('%.6f\n'*2%(t.imag,t.real))

पायथन 2.7 (104)

x,n=map(float,raw_input().split())
k=2*n
t=1
while k>1:k-=1;t=1+t*1j*x/k
print'%.6f\n'*2%(t.imag,t.real)

मूल रूप से समान कोड। हम के लिए कोष्ठक की जरूरत नहीं से दो पात्रों को बचाने printलेकिन खो चार ज़रूरत से raw_input।

नमूना चला

आप इन्हें यहां चला सकते हैं ।

>>>
20 20
-5364.411846
-10898.499385

कोड स्पष्टीकरण

मुख्य विचार गणना करने के लिए है 2*nके संदर्भ e^(ix), और फिर काल्पनिक और वास्तविक भाग लेने के प्राप्त करने के लिए sinऔर cosकरने के लिए अनुमानित मूल्यों nशर्तों। हम टेलर श्रृंखला का उपयोग करते हैं:

e^(ix)≈sum_{k=0}^{2n-1} (i*x)^k/k!

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

t_{2n} = 1
t_k = 1 + t_{k+1}*i*x/k,

जो देता है t_1वांछित मूल्य के बराबर।

6 दशमलव अंकों तक गोल प्रदर्शित करने के लिए मान प्राप्त करने के लिए पायथन स्ट्रिंग फ़ॉर्मेटिंग ऑपरेशन का उपयोग किया जाता है।

संपादित करें: नए नियमों के अनुसार 6 अंकों के दौर में परिवर्तित। कोई अन्य बदलाव की जरूरत थी।

— XNOR
स्रोत

एक ऑनलाइन py3 दुभाषिया :) के लिए आइडोन का प्रयास करें :)

— हैरी बीडल

@BritishColour धन्यवाद! मैं इसे पोस्ट करने के लिए जोड़ दिया है।

— XNOR

कृपया अपने उत्तर को अपडेट करें। सवाल में विवरण देखें। धन्यवाद।

— गौरांग टंडन

8

जम्मू 98 70 69 58

हालांकि यह शायद अधिक फैंसी कार्यों का उपयोग करके काफी कम हो सकता है ... टिप्पणियों का स्वागत है:

exit echo 0j6":,.-/(($%&(*/)1+i.@[)"0~i.@,&_2)/".}:stdin''

नोट 2: इनपुट समाप्त होता है EOF (linux में Ctrl-D) प्राप्त करते हैं। संपादित करें: एक अच्छे में घातांक और भाज्य में शामिल होने, और अधिक जम्मू-इश पूरे: ($ %&(*/) >:@i.@[ )। यह y के एक्स अनुकरण की एक सरणी और 1 से y के नंबरों की एक सरणी लेने के लिए निर्भर करता है। गुणा प्रत्येक और परिणाम विभाजित करते हैं। यह डुप्लिकेट से छुटकारा मिलता है */।

धन्यवाद algortihmshark करने के लिए, एक और 7 वर्ण बंद।

अनुगामी न्यू लाइन से छुटकारा पाने के लिए कटौती का सफाया कर दिया।

अधिक बड़ा संस्करण, जिसके लिए कांटे के बारे में जानते हुए भी बहुत जरूरी है।

NB. recursive Factorial
f=: */@>:@i.      NB. multiply all from 1 to n
NB. Exponential
e=: */@$          NB. replicate y x times, take the product.
NB. the x t y is the Nth (general) term without sign of the joint series
t=: (e % f@[)"0  NB. pretty straight forward: divide by (x!) on the exponential

NB. Piece the parts together, from right to left:
NB. read from stdin, cut the linefeed off , make the 2 n terms in 2 columns, which
NB. effectively splits out pair and odd terms, put in the minuses, put in rows
NB. instead of columns, echo, exit
exit echo 0j6&": ,. (-/) (i.@(,&_2)@{: t {.) , (". ;. _2) stdin''

कोई ऑनलाइन जम्मू दुभाषिया है, लेकिन यह एक कुछ वर्षों के बाद से खुला स्रोत है, स्थापना इन निर्देशों के साथ आसान है:

http://www.jsoftware.com/jwiki/System/Installation/J801

irc.freenode.org पर #jsoftware पर, एक जम्मू बॉट भी है।

stdin पर ही काम करता है भागा एक फ़ाइल से, कमांडलाइन से, किसी और की जगह stdin ''के साथ 'a b;', जहां एक और ख संख्या कि कमांडलाइन पर पारित किया गया है | कर रहे हैं।

— jpjacobs
स्रोत

5

मुझे लगता है कि यह प्यार करता हैexit

— डिजिटल ट्रामा

कृपया अपने उत्तर को अपडेट करें। सवाल में विवरण देखें। धन्यवाद।

— गौरांग टंडन

6 दशमलव स्थानों के लिए अद्यतन किया गया। अगर कुछ और है, तो कृपया बताएं। धन्यवाद

— jpjacobs

आप एक चार को बचाने के लिए &से हटा सकते हैं 0j6&":। इसके अलावा, एक और 6 के लिए (i.@(,&_2)@{:($%&(*/)>:@i.@[)"0{.)फिर से लिखा जा सकता है(($%&(*/)1+i.@[)"0~i.@,&_2)/

— एल्गोरिथमम्स्क

यह कार्य T.(n- टेलर टेलर श्रृंखला द्वारा अनुमानित कार्य) के लिए चिल्लाता है, लेकिन मुझे लगता है कि यह एक मानक खामियों के रूप में है।

— फ़ूजएक्सएक्सएल

6

पर्ल, 120 108 104 89 85

<>=~/ /;$c=$t=1;for(1..2*$'-1){$t*=$`/$_;$_%2?$s:$c+=$_&2?-$t:$t}printf"%f\n"x2,$s,$c

Ungolfed:

<> =~ / /;
$cosine = $t = 1;
for (1.. 2*$' - 1){
  $t *= $` / $_;
  ($_%2 ? $sine : $cosine) += $_&2?-$t:$t
}
printf "%.6f\n" x2, $sine, $cosine

पहली पंक्ति इनपुट पढ़ती है और एक स्थान खोजने के लिए रेगेक्स का उपयोग करती है; यह स्वचालित रूप से $ `में अंतरिक्ष से पहले मूल्य रखता है और इसके बाद $ में मूल्य '।

अब हम 1 से लूप करते हैं 2*n-1। $tहमारा शब्द है, जिसे लूप बार-बार गुणा xकरता है और लूप इंडेक्स ( $_) से विभाजित करता है । लूप 0 के बजाय 1 से शुरू होता है क्योंकि कोसाइन 1 से शुरू होता है, जिसने मुझे शून्य से विभाजित होने से निपटने के लिए बचाया।

अद्यतन करने के बाद $t, अनुक्रमणिका विषम है या यहां तक कि इस पर निर्भर करते हुए, $sineया तो त्रिकोणीय ऑपरेटर वापस आ $cosineजाता है, और $tइसके लिए मूल्य जोड़ता है। मैजिक फॉर्मूला $_&2?-$t:$tयह मान देता है कि क्या इस वैल्यू को जोड़ना या घटाना है (मूल रूप से बिटवाइड-और इंडेक्स और 2 पर "ऐड, ऐड, घटाना, घटाना" का दोहराव अनुक्रम उत्पन्न करने के लिए)।

आप इस कोड को compileonline.com पर टेस्ट-रन कर सकते हैं ।

— ताल
स्रोत

के लिए अपने उत्पादन को ठीक करें 20 20।

— गौरांग टंडन

1

मुझे लगता है कि आपके लूप के लिए 1..$n*2-1इसके बजाय से जाने की आवश्यकता हो सकती है 1..$n। जबकि मैं यहाँ हूँ ... एक संख्यात्मक संदर्भ में मूल्यांकन के अनुसार $s, बिल्कुल ठीक नहीं है। टर्नरी असाइनमेंट को कोष्ठक की आवश्यकता नहीं है :। एक अनुगामी न्यूलाइन जोड़ने के परिणाम पर छोटा किया जा सकता है । undef0$_&1?$s:$c+=$t"%.8f\n%.8f""%.8f\n"x2

— Primo

@Primo धन्यवाद, मैं उनमें से कुछ के बारे में नहीं जानता था। और अब यह सही परिणाम भी उत्पन्न करता है।

— ताल

@ मेरी खुशी। इसके अलावा, थोड़ा बेहतर जादू: $t*(1-($_&2))=> $_&2?-$t:$t।

— प्रिमो

कृपया अपने उत्तर को अपडेट करें। सवाल में विवरण देखें। धन्यवाद।

— गौरांग टंडन

5

फोरट्रान: 89 109 125 102 101 98 बाइट्स

complex*16::t=1;read*,x,n;do k=2*n-1,1,-1;t=1+t*(0,1)*x/k;enddo;print'(f0.6)',aimag(t),real(t);end

मैं अंतर्निहित टाइपिंग का दुरुपयोग करता हूं, लेकिन दुर्भाग्यवश ऐसा कोई निहित जटिल प्रकार मौजूद नहीं है, इसलिए मुझे उस और जटिल को निर्दिष्ट करना पड़ा i। Gfortran प्राकृतिक रूप से 8 दशमलव स्थानों पर उत्पादन में कटौती करता है, इसलिए हम उस युक्ति पर अच्छे हैं। दुर्भाग्य से, मेरे आउटपुट का मूल तरीका print*,t, चश्मा नहीं मिला, इसलिए मुझे काल्पनिक और वास्तविक घटकों के उत्पादन के लिए 16 अक्षर जोड़ने पड़े और आवश्यक 8 दशमलव स्थानों पर हिट करना पड़ा।

वेंटरो के लिए धन्यवाद, मैं आउटपुट और लूप के बीच 23 बाइट्स बचाने में कामयाब रहा। और सही उत्तर और स्वरूपित आउटपुट पाने के लिए एक और चरित्र। और readबयान पर 3 और ।

Ungolfed,

complex*16::t=1
read*,x,n
do k=2*n-1,1,-1
   t=1+t*(0,1)*x/k
enddo
print'(f0.6)',aimag(t),real(t)
end

— काइल कानोस
स्रोत

कृपया अपने उत्तर को अपडेट करें। सवाल में विवरण देखें। धन्यवाद!

— गौरांग टंडन

1

@ गौरांग टंडन: आपको शायद समस्या का विवरण बदलना बंद कर देना चाहिए।

— काइल कानोस

मुझे पता है, और मैं नहीं करना चाहता, लेकिन मैं इसकी मदद नहीं कर सकता। दरअसल, 5 जवाबों का परीक्षण करने के बाद, यह पता चला कि उनमें से लगभग सभी अलग-अलग परिणाम दे रहे थे (यह वास्तव में पूरी तरह से बिना पढ़े लिखे थे)। मैं कुछ अन्य दृष्टिकोण का पालन कर सकता था, लेकिन इससे वर्तमान उत्तरों के एल्गोरिदम के पूर्ण परिवर्तन को फिर से जागृत किया जा सकता था। यह सबसे अच्छा मैं समझ सकता है।

— गौरांग टंडन

2

वैसे मुझे पता है कि मेरा काम पूरी तरह से हो जाता है, इसलिए मुझे पूरी तरह से जांच कर लेनी चाहिए : डी;)

— काइल कानोस

4

सी, 120

double s,c,r,x;main(i,n){for(scanf("%lf %d",&x,&n),r=1;i<n*2;s+=r,r*=-x/i++)c+=r,r*=x/i++;printf("%.8lf\n%.8lf\n",s,c);}

एक बाइट, बयान है कि अद्यतन ज्या मूल्य के अंदर रखा जाता है को बचाने के लिए for()समापन कोष्ठक कि अद्यतन कोज्या मूल्य निम्नलिखित बयान, लेकिन वास्तव में क्रियान्वित कर रहे हैं बयान के बाद। (मुझे लगता है कि मैं प्रोग्राम के आउटपुट में अंतिम न्यूलाइन कैरेक्टर को हटाकर कुछ और बाइट्स बचा सकता हूं।)

वैश्विक चर s, c, rऔर xपरोक्ष शून्य करने के लिए प्रारंभ कर रहे हैं, और iवहाँ के रूप में कमांड लाइन पर उपलब्ध कराई गई कोई तर्क हैं लंबे समय के रूप में 1 का मान होगा। दुर्भाग्य printf()से दशमलव के 6 स्थानों पर चूक होती है, इसलिए आउटपुट प्रारूप थोड़ा वर्बोज़ है।

Ungolfed:

यहां कोड को फिर से व्यवस्थित करने के लिए कोड दिया गया है ताकि चीजें थोड़ी साफ हो जाएं:

double s,c,r,x;
main(i,n) {
    scanf("%lf %d",&x,&n);
    r=1;
    for(;i<n*2;) {
        c+=r;
        r*=x/i++;
        s+=r;
        r*=-x/i++;
    }
    printf("%.8lf\n%.8lf\n",s,c);
}

नमूना उत्पादन:

$ echo 1.23 4 | ./sincos
0.94247129
0.33410995

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

http://ideone.com/URZWwo

— बग़ल में ossifrage
स्रोत

3

पायथन> = 2.7.3, 186 184 211 200 182 170 अक्षर

नरक के समान सरल। साइन और कोसाइन के लिए पैरामीटर किए गए प्रश्न से सूत्र का उपयोग करता है।

ऑनलाइन दुभाषिया पाया जा सकता है ~~यहाँ~~ यहाँ

x,n=map(eval,raw_input().split())
f=lambda n:n<2and 1or n*f(n-1.)
for i in[1,0]:print"%.6f"%sum((1-j%2*2)*reduce(lambda o,p:o*p,[x]*(i+2*j),1)/f(i+2*j)for j in range(n))

संपादित करें: सभी प्रतिबंधों के साथ वैध संस्करण

Edit2:round Python 2.7.1 में अमान्य फ़ंक्शन आउटपुट के कारण ideone.com में ऑनलाइन दुभाषिया बदल दिया गया

Edit3: यह पता चला कि मैंने अनावश्यक इनलाइन लैम्ब्डा का उपयोग किया है + राउंडिंग को स्ट्रिंग प्रारूप में बदल दिया (xnor से चुराया गया :))

Edit4:join कार्यात्मक मुख्य forलूप के साथ प्रतिस्थापित

— avall
स्रोत

नमस्कार लाभ, मैंने हाल ही में उन नियमों को संपादित किया है जो अब बिल्ट-इन ऑपरेटरों को घातांक के लिए अनुमति नहीं देते हैं (जो कि **मुझे लगता है कि कर रहा है)। इसलिए, मुझे लगता है कि आपको अपना उत्तर संपादित करना होगा। असुविधा के लिए खेद है। यदि मैं गलत हूं तो मुझे बताएं।

— गौरांग टंडन

1

मुझे लगता है कि आगे के संशोधन xnor के जवाब के साथ बेकार हैं :)

— 14'14

@ ओवल ऑन 20 20, मुझे आउटपुट मिलता है -5364.4118142500001। 8 दशमलव तक इसे ठीक करना चाहते हैं।

— गौरांग टंडन

इसका कारण यह है 2.7.1। अजगर पायथन संस्करण । यदि आप इसे ideone.com पर चलाते हैं (पायथन 2.7.3) तो यह ठीक से काम करता है। ideone.com/JsYNNK

— avall

यह अब अच्छा काम करता है! +1

— गौरांग टंडन

3

जावास्क्रिप्ट - 114 वर्ण

y=(z=prompt)().split(' ');for(x=l=s=+y[0],c=d=1;--y[1];c+=l*=-x/++d,s+=l*=x/++d);z(s.toFixed(6)+'\n'+c.toFixed(6))

जैम्स के शानदार जवाब के आधार पर। समान एल्गोरिथ्म, पहला चरण c = 1 और s = x के आरंभीकरण से बचा गया। आउटपुट के लिए एक सरणी के बजाय 2 var का उपयोग करने से लूप सरल हो जाता है।

Ungolfed

y = ( z = prompt)().split(' ');
for ( 
    x = l = s = +y[0], /* init to value x, note the plus sign to convert from string to number */
    c = d = 1;
    --y[1]; /* No loop variable, just decrement counter */
    c += (l *= -x / ++d), /* Change sign of multiplier on each loop */
    s += (l *= x / ++d) 
); /* for body is empty */
z(s.toFixed(6) + '\n' + c.toFixed(6))

— edc65
स्रोत

मामूली टाइपो: यह असंगठित कोड में होगा s += (l *= x / ++d)और नहीं भी होगा s += (l* = x / ++d)।

— गौरांग टंडन

1

@ गौरांगटंडन तय

— edc65

2

जावास्क्रिप्ट (ECMAScript 6 ड्राफ्ट) - 97 96 वर्ण

एक पुनरावर्ती समाधान:

f=(x,n,m=1,i=0,s=x,c=1)=>i<2*n?f(x,n,m*=-x*x/++i/++i,i,s+m*x/++i,c+m):[s,c].map(x=>x.toFixed(8))

आउटपुट:

f(0.3,1)
["0.29550000", "0.95500000"]

f(0.3,24)
["0.29552021", "0.95533649"]

— MT0
स्रोत

हालांकि यह गोलाई के संबंध में युक्ति से नहीं मिलता है।

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

@ m.buettner तय

— MT0

1

यह इनपुट प्रारूप और no functionsआवश्यकता को पूरा नहीं करता है ।

— avall

कृपया अपने उत्तर को अपडेट करें। सवाल में विवरण देखें। धन्यवाद।

— गौरांग टंडन

2

सी, 114

टिप्पणी करने के लिए अपर्याप्त प्रतिष्ठा, लेकिन आगे स्क्वीश ऑफ सीज का उत्तर , डबल और हटाने के लिए फ्लोट का उपयोग करके 7 बाइट में कमी, और घोषणा और संयोजन के संयोजन में 'आर' देता है।

float s,c,r=1,x;main(i,n){for(scanf("%f%d",&x,&n);i<n*2;s+=r,r*=-x/i++)c+=r,r*=x/i++;printf("%.8f\n%.8f\n",s,c);}

यहाँ प्रयास करें ।

— tpb261
स्रोत

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है। अच्छी तरह से यह स्वीकार करने के लिए किया जाता है कि आपका उत्तर @ squeamishossifrage's पर एक मामूली सुधार है (मैं अभी भी इसे अपने संपादन में गलत तरीके से लिखने में कामयाब रहा।) उत्तर "ऊपर" का संदर्भ नहीं देने के लिए सबसे अच्छा है क्योंकि आदेश हर बार एक बदलाव होता है। BTW, मैंने rघोषणा में इनिशियलाइज़ेशन पर ध्यान दिया । मैंने यह देखने के लिए परीक्षण नहीं किया है कि क्या floatआवश्यक सटीकता देता है।

— लेवल रिवर सेंट

@steveverrill न तो मैंने सोचा था कि floatआवश्यक परिशुद्धता देगा, लेकिन यह काम करता है :) और PPCG में आपका स्वागत है, user2702245!

— गौरांग टंडन

यह सिर्फ मुझे floatचर के साथ गलत जवाब मिल रहा है ? के लिए x=5और n=3, मैं sin(x)=10.20833206और cos(x)=14.54166412:-( (इंटेल कोर की जोड़ी, मामले में आप सोच रहे थे)

— उतरी ossifrage

क्या आप मुझे उक्त उत्तर पर टिप्पणी में बदलना चाहेंगे?

— दरवाज़े

@Doorknob मई भी अब इसे छोड़ दें :-)

— स्क्वीश ossifrage

2

GNU बीसी, बैश द्वारा संचालित, 128 बाइट्स

बहुत अधिक बाइट्स दशमलव स्थानों और निकटतम गोलाई को सेट करने में बिताए। ओह ठीक है, यहाँ यह वैसे भी है:

bc -l<<<"m=1000000
w=s=$1
c=1
for(p=2;p/2<$2;s+=w){w*=-1*$1/p++
c+=w
w*=$1/p++}
s+=((s>0)-.5)/m
c+=((c>0)-.5)/m
scale=6
s/1
c/1"

आउटपुट:

$ ./trig.sh 5 3
10.208333
14.541667
$ ./trig.sh 8.555 13
.७,६५,४३१
-.641092
$ ./trig.sh 9.26 10
-३.१,५४,६७७
-८.४,०४,३५४
$ ./trig.sh 6.54 12
.२,५३,९८६
.९,६७,१४७
$ ./trig.sh 5 1
5.000000
1.000000
$ ./trig.sh 20 20
-५,३६४.४,११,८४६
-१०,८९८.४,९९,३८५
$

लिनक्स कमांड-लाइन टूल, 97 यूनिकोड वर्ण

ओपी के अनुरोध पर यूनिकोड हैक जवाब हटा दिया गया। यदि आप रुचि रखते हैं तो संपादन इतिहास को देखें।

— डिजिटल आघात
स्रोत

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

— गौरांग टंडन

@GaurangTandon इसका वास्तव में संपीड़न नहीं है - यूनिकोड संस्करण वास्तव में अधिक बाइट्स (लेकिन कम वर्ण) लेता है। लेकिन मैं आपकी भावना से सहमत हूं - मैं वास्तव में बाइट काउंट का उपयोग करके स्कोरिंग करना पसंद करता हूं, लेकिन आपके ओपी में चीनी अक्षरों के बारे में थोड़ा भी विरोध नहीं कर सकता।

— डिजिटल ट्रामा

आप अवैध घातीय ऑपरेटर का उपयोग

— avall

@avall ऊप्स। मेरी कीमत 4 बाइट्स है।

— डिजिटल ट्रॉमा

1

रूबी, 336

संभवतः यहां सबसे लंबा है, लेकिन मुझे यकीन है कि इसे छोटा किया जा सकता है :(

def f(n)
n==0 ? 1: 1.upto(n).inject(:*)
end
def p(x,y)
i=1
return 1 if y==0 
y.times {i *= x}
i
end
def s(x,n)
a = 0.0
for k in 0...n
a += p(-1,k) * p(x.to_f, 1+2*k)/f(1+2*k)
end
a.round(8)
end
def c(x,n)
a= 0.0
for k in 0...n
a +=p(-1,k) * p(x.to_f, 2*k)/f(2*k)
end
a.round(8)
end
x = gets.chomp
n = gets.chomp.to_i
puts s(x,n), c(x,n)

— mhmd
स्रोत

1

जावास्क्रिप्ट (ईएस 6) - 185 वर्ण

i=(h,n)=>n?h*i(h,n-1):1;q=x=>x?x*q(x-1):1;p=(a,j,n)=>{for(c=b=0,e=1;c++<n;j+=2,e=-e)b+=e*i(a,j)/q(j);return b.toFixed(6)}
_=(y=prompt)().split(" ");y(p(_[0],1,_[1])+"\n"+p(_[0],0,_[1]))

qफैक्टरियल के लिए एक फ़ंक्शन का उपयोग करता है , एक्सप्रेशन के iलिए, और pदोनों के प्रदर्शन के लिए sinऔर cos। Jsbin.com पर चलें। बिना किसी संशोधन के बिल्कुल सूत्र का उपयोग करता है।

संपादित करें : 8दशमलव स्थानों को 6दशमलव स्थानों में बदल दिया । 15 / मई / 14

असिंचित कोड :

/*Note that `name=args=>function_body` is the same as `function name(args){function_body} */

// factorial
function fact(x) {
    return x > 1 ? x * fact(x - 1) : 1
}

// Exponentiation
function expo(number, power){
    return power > 0 ? number * expo(number, power - 1) : 1;
}

function sin_and_cos(number, starter, terms) {
    for (count = sum = 0, negater = 1;
            count++ < terms;
            starter += 2, negater = -negater) 

        sum += (negater * expo(number, starter)) / fact(starter);

    // to 6-decimal places
    return sum.toFixed(6);
}

input = (out = prompt)().split(" ");

out(sin_and_cos(input[0], 1,input[1]) 
        + "\n" +                
        sin_and_cos(input[0], 0, input[1]));

— गौरांग टंडन
स्रोत

1

जावास्क्रिप्ट - 133 वर्ण

y=(z=prompt)().split(" "),s=[0,0],l=1;for(i=0;i<y[1]*2;i++){s[i%2]+=i%4>1?-1*l:l;l*=y[0]/(i+1)}z(s[1].toFixed(6));z(s[0].toFixed(6));

Ungolfed

var y = prompt().split(" ");

var out = [0,0]; // out[1] is sin(x), out[0] is cos(x)
var l = 1; // keep track of last term in series
for (var i=0; i < y[1] * 2; i++) {
    out[i % 2] += (i % 4 > 1) ? -1 * l : l;
    l *= y[0] / (i + 1);
}

prompt(out[1].toFixed(6));
prompt(out[0].toFixed(6));

— जेम्स
स्रोत

इनपुट में दो अलग-अलग पूर्णांक होते हैं, दो अलग-अलग संवाद बॉक्स में नहीं। कृपया इसे ठीक करें।

— गौरांग टंडन

@GaurangTandon तय - इसे इंगित करने के लिए धन्यवाद

— जेम्स

1

गणितज्ञ, 96 वर्ण

{{x,n}}=ImportString[InputString[],"Table"];Column@{Im@#,Re@#}&@Fold[1+I#x/#2&,1,2n-Range[2n-1]]

— alephalpha
स्रोत

इनपुट प्रारूप कैसा है, x,nमुझे लगता है?

— गौरांग टंडन

@ गौरांगटांड यह है x n।

— एलेफाल्फा

ठीक है, स्पष्ट करने के लिए धन्यवाद।

— गौरांग टंडन

1

माणिक - 160 152 140 शुल्क

पुनरावर्तन और इस पुनरावर्ती कार्यान्वयन पाप (x, 2n + 1) = 1 + cos (x, 2n - 1) के लिए, पाप (x, n) और cos (x, n) होने के कारण उपरोक्त श्रृंखला को cos के लिए परिभाषित किया गया है। x और पाप x।

p=->x,n{n<1?1:x*p[x,n-1]}
f=->n{n<2?1:n*f[n-1]}
c=->x,n{n<1?1:p[x,n]/f[n]-c[x,n-2]}
x,n=gets.split.map &:to_f
n*=2
puts c[x,n-1]+1,c[x,n-2]

संपादित करें: टिप्पणीकारों द्वारा योगदान दिया गया है (नीचे पढ़ें)।

— Boriel
स्रोत

1

आप lambdas का उपयोग करके पात्रों में से एक बहुत कुछ बचा सकते हैं: p=->x,n{...}, f=->n{...}और इतने पर, और फिर कोष्ठकों के बजाय वर्ग कोष्ठक का उपयोग की तरह, उन्हें कॉल करने के लिए p[x,n-1]। इसके अलावा, मुझे लगता collectहै कि इसके लिए सिर्फ एक उपनाम है map, जो बहुत कम है, और चूंकि आप केवल एक सदस्य कॉल की मैपिंग कर रहे हैं, आप इसे छोटा कर सकते हैं gets.split.map &:to_f।

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

@ मार्टिनबटनर धन्यवाद! यह जोड़ देगा! (आशा है कि आपकी टिप्पणी यहाँ कहा गया है कि यह समाधान केवल मेरा नहीं है, बल्कि कोलाब है) ईमानदार होने के लिए: मैं माणिक के लिए भी नया हूं (केवल 2 महीने :)))

— बोरियल

त्रिकोणमिति शुरू करते हैं!

परिचय:

कार्य:

इनपुट:

आउटपुट:

प्रतिबंध:

नमूने:

टिप्पणियाँ:

स्कोरिंग:

CJam - 42

पर्ल - 72 बाइट्स

पायथन 3 (102) / पायथन 2 (104)

जम्मू 98 70 69 58

पर्ल, 120 108 104 89 85

फोरट्रान: 89 109 125 102 101 98 बाइट्स

सी, 120

Ungolfed:

नमूना उत्पादन:

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

पायथन> = 2.7.3, 186 184 211 200 182 170 अक्षर

जावास्क्रिप्ट (ECMAScript 6 ड्राफ्ट) - 97 96 वर्ण

सी, 114

GNU बीसी, बैश द्वारा संचालित, 128 बाइट्स

लिनक्स कमांड-लाइन टूल, 97 यूनिकोड वर्ण

रूबी, 336

जावास्क्रिप्ट (ईएस 6) - 185 वर्ण

गणितज्ञ, 96 वर्ण

माणिक - 160 152 140 शुल्क