介绍：

所述正弦的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个十进制数字）。舍入必须最接近此Wiki文章表的第五列“舍入到最接近”中所述。

限制条件：

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

笔记：

1. 禁止出现标准漏洞。
2. 不能使用内置的数学函数和三角函数（正弦，余弦，正切等），阶乘和幂运算。您可以自由使用内置的舍入函数来估计计算结果sin(x)并cos(x)精确到小数点后第六位。
3. 无需处理错误的输入。
4. 程序中只能使用ASCII字符，不能使用允许编码压缩的中文Unicode字符。
5. 您的程序必须在输入的3秒钟内终止并显示输出。
6. 您的答案必须与未分类的代码一起进行，并附有代码说明（如果该代码对程序员不熟悉，您不熟悉您的语言，尤其是GolfScript，J等，则强制使用该代码）。
7. 请提供一个在线编译器的链接，可以在其中测试您的程序。

得分：

字符长度（包括空格，制表符等）中的代码长度最低的答案将获胜！获奖者将于2014年5月21日宣布。

编辑：14/05/14 赢家是使用CJam语言的aittsu。亚军跟随J语言的jpjacobs，亚军跟随Perl语言的primo。恭喜大家！

果酱-42

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

在http://cjam.aditsu.net上在线尝试

说明：

r从输入中读取令牌，
d转换为
:X变量X的双
;精度值，将值从栈中弹出，
1将1放到栈中（第一项），
_重复1
r读取下一个令牌（n），
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）
-(减（-> -1/1/1）
*乘以，因此每第二次更改符号一次就将
/堆栈上的项除以k或-k；这是“ / k！” 计算的一部分连同符号变化
X*乘以X；这是计算的“ X ^ k”部分；我们获得了该系列中的下一个术语，该
_术语与用于在下一次迭代
;（循环之后）中计算下一个术语
]的术语重复。弹出最后一个重复的术语，将这些术语收集到数组中的堆栈中。
这时，我们有了一个数组[ 1 X -X ^ 2/2！-X ^ 3/3！X ^ 4/4！X ^ 5/5！...]完全包含我们需要cos（x）和sin（x）的所有术语，交错
2/将数组拆分成对
z转置矩阵，得到带有cos（x）项的数组和带有sin（x）项的数组，因为“矩阵行”
{...}/再次为每个数组项（矩阵行）执行块：
- :+添加元素矩阵行的总和
- 6mO四舍五入到小数点后六位
此时，我们在堆栈上具有所需的cos（x）和sin（x）
p打印堆栈上最后一项的表示形式（sin（x）），后跟换行符
At程序结束时，将自动打印堆栈的其余内容（cos（x））。

Perl-72个字节

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

或者，将命令行选项计为70个字节，每个1个字节：

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

或者，如果您允许我使用Perl 5.8（63字节）：

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

但是你为什么要

编辑：符合新规则。%f默认情况下四舍五入到四位，多么方便！

算法

检查sin（x）的泰勒级数：

可以看出，每个术语平均地划分了每个连续的术语。因此，可以轻松地将其转换为嵌套表达式：

cos（x）的转换类似，但前导x和分母项变小了。

此外，可以将此嵌套表达式重新构造为反向递归表达式：

与小号_∞ = 0和的sin（x）= X·S ₁，这是最终使用什么。

不打高尔夫球

<> =~ 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。

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)

基本上是相同的代码。我们节省了两个字符，而不必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等于所需的值。

Python字符串格式化操作用于获取要显示的值，并四舍五入至小数点后6位数字。

编辑：根据新规则更改为四舍五入。无需其他更改。

J 98 70 69 58

虽然可以使用更多高级功能将其缩短很多，但还是欢迎您提出以下评论：

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

注意2：输入在收到EOF时结束（在Linux中为ctrl-D）。编辑：将求幂和阶乘加入一个更好，更J的整体：($ %&(*/) >:@i.@[ )。这归结为一个y的x个复制数组和一个从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''

没有在线J解释器，但是几年来它是开源的。这些说明使安装变得容易：

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

在irc.freenode.org上的#jsoftware上，也有一个J机器人。

仅当从命令行中的文件中运行时，stdin才有效，否则请替换stdin ''为'a b;'其中a和b是将在命令行中传递的数字。

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

取消高尔夫：

<> =~ / /;
$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并除以循环的索引（$_）。循环从1开始而不是0，因为余弦被初始化为1，这使我不必处理除以零的问题。

更新后$t，三进制运算符将根据索引是奇数还是偶数返回$sine或$cosine，$t并向其添加值。魔术公式$_&2?-$t:$t计算出是增加还是减少这个值（基本上在索引和2上使用按位和，以生成“加，加，减，减”的重复序列）。

您可以在compileonline.com上测试运行此代码。

FORTRAN：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位小数位。

多亏了Ventero，我设法在输出和循环之间节省了23个字节。另一个字符可以获取正确答案和格式化输出。另有3条read声明。

不打高尔夫球，

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

为了节省字节，将更新正弦值的for()语句放置在该语句内，但实际上是在结束括号后的该余弦值更新后的语句之后执行。（我想我也可以通过删除程序输出中的最后换行符来节省几个字节。）

全局变量s，c，r和x隐式初始化为零，而i具有同样长的值为1，因为没有提供的命令行上的参数。不幸的是printf()默认默认为6位小数，因此输出格式有点冗长。

取消高尔夫：

这是经过一些重新排列的代码，可以使事情的执行顺序更加清晰：

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

Python> = 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：由于roundPython 2.7.1中的无效函数输出，已将在线解释器更改为ideone.com。

Edit3：原来我使用了不必要的内联lambda +将舍入更改为字符串格式（从xnor :)窃取了）

Edit4：替换join为不起作用的主for循环

JavaScript-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个vars而不是数组进行输出可简化循环。

不打高尔夫球

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草案）-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"]

C 114

信誉不足，无法发表评论，但对Soffamish Offisrage的C 答案而言，进一步提高了7个字节，这是通过使用float来加倍删除空格并结合声明和'r'的init来实现的

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

试试这里。

GNU bc，由bash驱动，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
.765431
-.641092
$ ./trig.sh 9.26 10
-3.154677
-8.404354
$ ./trig.sh 6.54 12
.253986
.967147
$ ./trig.sh 5 1
5000000
1.000000
$ ./trig.sh 20 20
-5364.411846
-10898.499385
$ 

Linux命令行工具，97个unicode字符

应OP的要求删除了Unicode hack答案。如果有兴趣，请查看编辑历史记录。

红宝石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)

JavaScript（ES6）-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]));

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

不打高尔夫球

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个字符

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

红宝石- 160 152 140个字符

使用递归和递归实现sin（x，2n +1）= 1 + cos（x，2n-1），即sin（x，n）和cos（x，n）的事实x和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]

编辑：由评论者贡献（阅读下面）。