Einführung:

Der Sinus von xist gegeben durch die Formel:

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

Der Cosinus von xwird durch die Formel gegeben:

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

Aufgabe:

Wenn der Wert von xund gegeben ist n, schreiben Sie ein Programm (keine Funktionen usw.), um den Wert der obigen Formel auszugeben sin(x)und diese zu cos(x)korrigieren n. Angenommen, das xist im Bogenmaß.

Eingang:

x n

Eine Dezimalzahl x(mit bis zu 3 Dezimalstellen) und eine Ganzzahl n. Die Eingabe muss in stdin oder in einem Dialogfeld erfolgen (falls Ihre Sprache stdin nicht unterstützt).

Ausgabe:

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

Der Wert von beiden sin(x)und cos(x)sollte auf 6 Dezimalstellen gerundet werden. Wenn sin(x)ist 0.5588558855(10 Dezimalstellen), sollte es auf 0.558856(6 Dezimalstellen) gerundet werden . Die Rundung muss auf den nächsten Wert erfolgen, wie in der fünften Spalte "Auf den nächsten Wert runden" der Tabelle in diesem Wiki-Artikel beschrieben .

Einschränkungen:

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

Proben:

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

Anmerkungen:

1. Standardlücken sind verboten.
2. Eingebaute mathematische Funktionen und Operatoren für Trigonometrie (sin, cos, tan usw.), Fakultät und Exponentiation können nicht verwendet werden. Es steht Ihnen frei, eine integrierte Rundungsfunktion zur Schätzung des Rechenergebnisses sin(x)und cos(x)der 6. Dezimalstelle zu verwenden.
3. Keine Notwendigkeit, mit falschen Eingaben umzugehen.
4. Im Programm können nur ASCII-Zeichen verwendet werden, nicht die chinesischen Unicode-Zeichen, die die Codekomprimierung ermöglichen.
5. Ihr Programm muss innerhalb von 3 Sekunden nach der Eingabe beendet werden und die Ausgabe anzeigen.
6. Ihre Antwort muss zusammen mit der Erklärung des Codes dem Code ohne Golf beigefügt sein (obligatorisch, wenn der Code für Programmierer, die nicht mit Ihrer Sprache vertraut sind, insbesondere GolfScript, J usw., nicht sofort ersichtlich ist).
7. Bitte fügen Sie einen Link zu einem Online-Compiler hinzu, auf dem Ihr Programm getestet werden kann.

Wertung:

Die Antwort mit der niedrigsten Codelänge in Zeichen, einschließlich Leerzeichen, Tabulatoren usw., gewinnt! Der Gewinner wird am 21. Mai 2014 bekannt gegeben.

EDIT : 21/05/14 Gewinner ist Aditsu mit CJam-Sprache . Der zweite Platz folgt jpjacobs mit der Sprache J und der zweite Platz ist primo mit der Sprache Perl . Herzlichen Glückwunsch an alle!

CJam - 42

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

Versuchen Sie es online unter http://cjam.aditsu.net

Erläuterung:

rliest ein von dem Eingangstoken
dumwandelt , um Doppelabtretungsempfängern
:Xauf die Variable X
;den Wert von dem Stapel erscheint
1setzt 1 auf dem Stapel (die erste Term)
_dupliziert die 1
rliest das nächste Token (die n)
ikonvertiert zu integer
2*,1>{...}/ist eine Art von Schleife von 1 bis 2 * n - 1:
- 2*multipliziert mit 2
- erstellt ,ein Array von 0 bis (letzter Wert) -1
- 1>entfernt das erste Element des Arrays (0)
- {...}/führt den Block für jedes Element im Array aus und
_dupliziert die "Schleife" Variable "(nennen wir es k)
2%2*(konvertiert von gerade / ungerade zu -1/1:
- 2%ist Modulo 2 (-> 0/1)
- 2*multipliziert mit 2 (-> 0/2)
-(Dekremente (-> -1/1)
*multiplizieren sich, wodurch das Vorzeichen jedes zweite Mal geändert wird , wenn
/der Term auf dem Stapel durch k oder -k geteilt wird; das ist das "/ k!" ein Teil der Berechnung zusammen mit dem Vorzeichenwechsel
X*multipliziert mit X; dies ist der "X ^ k" -Teil der Berechnung; wir erhalten die nächste Laufzeit in der Serie
_dupliziert der Ausdruck für die Berechnung des folgenden Term in der nächsten Iteration verwendet werden soll
;(nach der Schleife) erscheint der letzte duplizierten Begriff
]die Bedingungen auf den Stapel in einem Array sammelt
An diesem Punkt haben wir eine Reihe haben [ 1 X-X ^ 2/2! -X ^ 3/3! X ^ 4/4! X ^ 5/5! ...] genau alle Terme enthält, die wir für cos (x) und sin (x) benötigen, und verschachtelt
2/dieses Array in Paare
ztransponiert die Matrix, woraus sich das Array mit den Begriffen für cos (x) und das Array mit den Begriffen für sin (x) ergibt, da "Matrixzeilen"
{...}/den Block für jedes Arrayelement (Matrixzeile) erneut ausführt:
- :+fügt die Elemente hinzu der Matrixreihe zusammen
- 6mOrundet auf 6 Dezimalstellen.
An diesem Punkt haben wir das gewünschte cos (x) und sin (x) auf dem Stapel,
pdruckt die Darstellung des letzten Elements auf dem Stapel (sin (x)), gefolgt von einer neuen Zeile
At am ende des programms wird der restliche inhalt des stapels (cos (x)) automatisch ausgedruckt.

Perl - 72 Bytes

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

Oder zählen Sie die Befehlszeilenoptionen als jeweils 1 Byte in 70 Byte :

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

Oder, wenn Sie mir Perl 5.8 erlauben, in 63 Bytes :

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

aber warum würdest du?

Bearbeiten : Einhaltung der neuen Regeln. %fRunden auf 6 Stellen standardmäßig, wie bequem!

Algorithmus

Untersuchen der Taylor-Reihe auf Sünde (x) :

Es ist ersichtlich, dass jeder Term jeden aufeinanderfolgenden Term gleichmäßig verteilt. Aus diesem Grund kann es mühelos in einen verschachtelten Ausdruck umgewandelt werden:

cos (x) transformiert ähnlich, ohne die führenden x- und Nenner-Terme eins kleiner.

Darüber hinaus kann dieser verschachtelte Ausdruck als umgekehrter rekursiver Ausdruck umformuliert werden:

mit s _∞ = 0 und sin (x) = x · s ₁ , was letztendlich verwendet wird.

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

Beispielnutzung

$ 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

Wenn Sie dies online testen möchten, empfehle ich die Verwendung von compileonline.com . Kopieren-Einfügen Sie den Code in main.plund die Eingabe in die STDINBox, dann Execute Script.

Python 3 (102) / Python 2 (104)

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

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

Grundsätzlich der gleiche Code. Wir sparen zwei Charaktere, weil sie keine Parens brauchen print, verlieren aber vier von ihnen raw_input.

Probelauf

Sie können diese hier ausführen .

>>>
20 20
-5364.411846
-10898.499385

Code Erklärung

Die Hauptidee ist es, 2*nTerme von zu berechnen e^(ix)und dann den imaginären und realen Teil zu nehmen, um die sinund cosWerte an nTerme anzunähern. Wir verwenden die Kürzung der Taylor-Reihe:

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

Dies ist ein Polynom in i * x, aber anstatt seinen Wert durch Summieren jedes Terms zu berechnen , verwenden wir eine modifizierte Horner-Methode , um die Sequenz zu berechnen (in umgekehrter Reihenfolge rekursiv definiert).

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

was t_1gleich den gewünschten Wert ergibt.

Formatierungsoperationen für Python-Strings werden verwendet, um die Werte auf 6 Dezimalstellen aufgerundet anzuzeigen.

Bearbeiten: Wurde geändert, um nach neuen Regeln auf 6 Stellen zu runden. Es waren keine weiteren Änderungen erforderlich.

J 98 70 69 58

Obwohl dies wahrscheinlich mit ausgefalleneren Funktionen einiges gekürzt werden kann ... Kommentare sind willkommen:

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

hinweis 2: die eingabe endet mit dem empfang von eof (strg-d unter linux). Edit: beitreten Potenzierung und Fakultäts in eine schönere, J-ish Ganzen: ($ %&(*/) >:@i.@[ ). Dies führt zu einer Reihe von x-Replikationen von y und einer Reihe von Zahlen von 1 bis y. Multiplizieren Sie jedes und teilen Sie das Ergebnis. Dadurch wird das Duplikat entfernt */.

Dank algortihmshark sind noch 7 Charaktere übrig.

Eliminierter Schnitt, um die nachlaufende Newline loszuwerden.

Längere Version, für die das Wissen über Gabeln ein Muss ist.

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

Es gibt keinen Online-J-Interpreter, aber es ist seit einigen Jahren Open Source. Die Installation ist mit diesen Anweisungen einfach:

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

Auf #jsoftware auf irc.freenode.org gibt es auch einen J-Bot.

stdin funktioniert nur, wenn es von einer Datei aus über die Befehlszeile ausgeführt wird, andernfalls ersetzen Sie es stdin ''durch, 'a b;'wobei a und b die Zahlen sind, die in der Befehlszeile übergeben worden wären.

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

Die erste Zeile liest die Eingabe und verwendet Regex, um ein Leerzeichen zu finden. Dadurch wird der Wert automatisch vor das Leerzeichen in "$" und der Wert danach in "$" gesetzt.

Jetzt schleifen wir von 1 bis 2*n-1. $tist unser Begriff, den die Schleife wiederholt mit xdem Index ( $_) der Schleife multipliziert und dividiert . Die Schleife beginnt bei 1 und nicht bei 0, da der Cosinus auf 1 initialisiert ist, wodurch ich mich nicht mit dem Teilen durch Null befassen musste.

Nach der Aktualisierung $tgibt der Trinary-Operator entweder $sineoder zurück $cosine, je nachdem, ob der Index ungerade oder gerade ist, und fügt $tden Wert hinzu . Die Zauberformel gibt an $_&2?-$t:$t, ob dieser Wert addiert oder subtrahiert werden soll (im Grunde genommen mit einem bitweisen und auf dem Index und 2, um die sich wiederholende Folge von "addieren, addieren, subtrahieren, subtrahieren" zu erzeugen).

Sie können diesen Code unter compileonline.com testen .

Fortran: 89 109 125 102 101 98 Byte

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

Ich missbrauche die implizite Typisierung, aber leider gibt es keinen solchen impliziten Komplextyp. Deshalb musste ich diesen & den Komplex angeben i. Gfortran schneidet die Ausgabe auf natürliche Weise mit 8 Dezimalstellen ab, daher halten wir diese Spezifikation gut ein. Leider entsprach meine ursprüngliche Ausgabemethode print*,tnicht den Spezifikationen, sodass ich 16 Zeichen hinzufügen musste, um die imaginären und realen Komponenten auszugeben und die erforderlichen 8 Dezimalstellen einzugeben.

Dank Ventero konnte ich 23 Bytes zwischen Ausgabe und Schleife einsparen. Und ein weiteres Zeichen, um korrekte Antworten und formatierte Ausgabe zu erhalten. Und 3 weitere zur readAussage.

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

C 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);}

Um ein Byte zu speichern, werden die Anweisungen, die den Sinuswert aktualisieren, in die Anweisung eingefügt for(), aber tatsächlich nach den Anweisungen ausgeführt, die auf die schließende Klammer folgen, die den Cosinuswert aktualisieren. (Ich denke, ich könnte auch ein paar Bytes mehr sparen, indem ich das letzte Newline-Zeichen in der Programmausgabe entferne.)

Die globalen Variablen s, c, rundx werden auf Null implizit initialisiert, und ieinen Wert von 1 haben , solange es keine Argumente auf der Kommandozeile zur Verfügung gestellt. Unglücklicherweiseprintf() standardmäßig 6 Dezimalstellen verwendet, sodass das Ausgabeformat etwas ausführlich ist.

Ungolfed:

Hier ist der Code mit einigen Änderungen, um die Reihenfolge zu vereinfachen:

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);
}

Beispielausgabe:

$ echo 1.23 4 | ./sincos
0.94247129
0.33410995

Probieren Sie es online aus:

http://ideone.com/URZWwo

Python> = 2.7.3, 186 184 211 200 182 170 Zeichen

Ein bisschen einfach wie die Hölle. Verwendet die Formel aus der für Sinus und Cosinus parametrisierten Frage.

Online-Dolmetscher finden Sie hier Hier Hier

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

Bearbeiten: Gültige Version mit allen Einschränkungen

Edit2: Der Online-Interpreter wurde wegen ungültiger roundFunktionsausgaben in Python 2.7.1 zu ideone.com geändert

Edit3: Es stellte sich heraus, dass ich unnötiges Inline-Lambda + Rundung auf String-Format geändert habe (von xnor gestohlen :))

Edit4: Ersetzt joinmit nicht funktionellen forHauptschleife

JavaScript - 114 Zeichen

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

Basierend auf der großartigen Antwort von James. Gleicher Algorithmus, erster Schritt vermieden mit Initialisierung von c = 1 und s = x. Die Verwendung von 2 Variablen anstelle eines Arrays für die Ausgabe vereinfacht die Schleife.

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

JavaScript (ECMAScript 6 Draft) - 97 96 Zeichen

Eine rekursive Lösung:

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

Ausgabe:

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

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

C 114

Unzureichende Reputation zum Kommentieren, aber zusätzlich zu der C- Antwort von Squeamish Offisrage , 7-Byte-Reduktion durch Verwendung von float zum Verdoppeln und Entfernen von Leerzeichen und Kombinieren von Deklaration und Init von 'r' ergibt

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);}

versuche es hier .

GNU bc, driven by bash, 128 bytes

Far too many bytes spent setting decimal places and to-nearest rounding. Oh well, here it is anyway:

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"

Output:

$ ./trig.sh 5 3
10.208333
14.541667
$ ./trig.sh 8.555 13
.765431
-.641092
$ ./trig.sh 9.26 10
-3.154677
-8.404354
$ ./trig.sh 6.54 12
.253986
.967147
$ ./trig.sh 5 1
5.000000
1.000000
$ ./trig.sh 20 20
-5364.411846
-10898.499385
$ 

Linux command-line tools, 97 unicode characters

Unicode hack answer removed at OP's request. Look at the edit history if you interested.

Ruby, 336

Probably the longest one here, but I'm sure it could be made shorter :(

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)

JavaScript (ES6) - 185 chars

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

Uses a function q for factorial, i for exponentiation, and p for performing both sin and cos. Run at jsbin.com. Uses exactly the formula without any modification.

EDIT: Changed 8 decimal places to 6 decimal places. 15/May/14

Ungolfed Code:

/*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]));

JavaScript - 133 chars

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

Mathematica, 96 chars

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

Ruby - 160 152 140 Chars

Using recursion and the fact that for this recursive implementation sin(x, 2n + 1) = 1 + cos(x, 2n - 1), being sin(x, n) and cos(x, n) the series defined above for cos x and sin 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]

Edit: Contributed by commenters (read below).