Meu chefe acabou de me dizer para escrever uma função cosseno. Sendo um bom nerd de matemática, minha mente imediatamente conjurou a Série Taylor apropriada.
cos(x) = 1 / 0! - x^2 / 2! + x^4 / 4! - x^6 / 6! + ... + (-1)^k x^(2k) / (2k)! + ...
No entanto, meu chefe é muito exigente. Ele gostaria de poder especificar exatamente quantos termos da série Taylor computar. Você pode me ajudar a escrever esta função?
Sua tarefa
Dado um valor de ponto flutuante x
de 0
para 2 pi
e um número inteiro positivo n
menor que 100
, calcule a soma dos primeiros n
termos da série Taylor dados acima para cos(x)
.
Isso é código-golfe , então o código mais curto vence. A entrada e a saída podem ser obtidas de qualquer uma das maneiras padrão. As brechas padrão são proibidas.
Notas
- A entrada pode ser obtida de qualquer forma razoável, desde que haja uma separação clara entre
x
en
. - A entrada e a saída devem ser valores de ponto flutuante, pelo menos tão precisos quanto o cálculo da fórmula usando números de ponto flutuante IEEE de precisão única com alguma regra de arredondamento padrão.
- Se fizer sentido para o idioma que está sendo usado, os cálculos podem ser feitos usando quantidades racionais exatas, mas a entrada e a saída ainda devem estar na forma decimal.
Exemplos
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...
code-golf
math
trigonometry
calculus
Silvio Mayolo
fonte
fonte
n
também é maior que0
?Respostas:
Linguagem de script da operação Flashpoint ,
165157 bytesLigue para:
Saída:
Tenho certeza de que os números são números de ponto flutuante IEEE de precisão única, embora na saída impressa os decimais mais longos não sejam tão precisos. É a impressão que arredonda os números assim, na verdade os números são mais precisos.
Por exemplo,
a=1.00001;b=1.000011;hint format["%1\n%2\n%3", a, b, a==b]
produzirá isso:Tão claramente que a precisão real dos números é maior que a precisão impressa.
fonte
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}}}]
- Disparar em alguma direção incrementa o contador e, em seguida, disparar para outra direção chama a função cosseno com a direção anterior e o número de disparos nessa direção.05AB1E ,
1411 bytesExperimente online!
Explicação
fonte
²
, mas pode ser substituído porI
.MATL , 14 bytes
Experimente online! Ou verifique todos os casos de teste .
Explicação com exemplo
Todos os números têm precisão dupla (esse é o padrão).
Considere entradas
x = 2.0
,n = 5
.fonte
Mathematica,
49413931 bytesVersão antiga e mais "divertida": (39 bytes)
Economizou 10 bytes graças a @Pavel e 8 graças a @Greg Martin!
fonte
Series
capacidade do Mathematica seja realmente incrível e divertida, a implementação manualSum[(-#^2)^k/(2k)!,{k,0,#2-1}]&
é mais curta aqui.Geléia ,
1211 bytesExperimente online!
Quão?
fonte
Gelatina, 22 bytes
Este é um programa completo que toma n como o primeiro argumento ex como o segundo.
Explicação:
fonte
Python, 54 bytes
Se você estiver usando o Python 2, passe x como um float, não como um número inteiro, mas entendo que não importa se você está usando o Python 3.
fonte
TI-Basic,
4140 bytes1E-49
é adicionado ao ângulo porque o TI-Basic lança um erro para 0 ^ 0, é grande o suficiente para não causar o erro e não é grande o suficiente para alterar a resposta.fonte
C, 96 bytes
Recursivo ao vivo
Detalhado
Progressivo Recursivo, 133 bytes Ao Vivo
Detalhado
fonte
c(0.5, 80)
=> NaN, para estourof(80)=0
n<100
para que você pelo menos não vá tão longe no intervalo. Não estouro de pilhan<100
e você usarO(2^n)
solução que eu acho que está tudo bem, contanto que, eventualmente, Retuan o resultadoJavaScript (ES6), 46 bytes
Toma entradas com caril (x) (n).
fonte
C, 71 bytes
usando o esquema Horner
Versão não destruída:
fonte
R,
7064 byteseconomizou 6 bytes graças à resposta de pizzapants184 com o truque (-x ^ 2) ^ y
65 bytes:
praticamente a implementação ingênua disso, mas um pouco minuciosa; retorna uma função anônima que calcula a série Taylor para o n especificado
init
deve ser definido como 0gamma(n+1)
vez defactorial(n)
1:n-1
é equivalente a0:(n-1)
fonte
OK , 38 bytes
Isso também funciona em k , mas ocupa 39 bytes porque
'
é necessário escrever como um/:
(pelo menos no kmac 2016.06.28).Explicação:
Vamos começar com a parte do meio.
(*/y#x)
é exponenciação, é equivalente ax^y
.*/1+!y
seriay!
, ouy
fatorial.%
é divisão. Portanto, a função no meio émiddle(x,y) = (x^y)/(y!)
.Agora, o bit à direita, ao qual a função acima é aplicada.
2*!y
é{0, 2, 4, ..., 2*(y-1)}
.x,'
precedex
todos os itens dessa lista, transformando-os em{(x, 0), (x, 2), (x, 4), ..., (x, 2*(y-1))}
. O.'
então se aplicamiddle
a todos os pares de números (map
, essencialmente).Por fim,
(y#1 -1)*
multiplica o resultado por 1 ou -1 (alternando) e+/
recebe a soma.fonte
Haskell, 71 Bytes
Esta é uma resposta bastante chata que não é muito difícil de decifrar. As
fromIntegral
mordidas realmente, no entanto. (O/
operador requer operandos do mesmo tipo numérico em Haskell, e a coação entre tipos numéricos não é permitida sem uma função detalhada.)fonte
f x n=sum[(-1)^i*x^(2*i)/fromIntegral(product[1..2*i])|i<-[0..n-1]]
Gelatina , 12 bytes
Experimente online!
Como funciona
fonte
Pitão, 16 bytes
Aceita
n
primeiro, entãox
. Exemplo de execução.fonte
Haskell , 61 bytes
Isso parecia diferente o suficiente da outra solução Haskell para justificar uma resposta separada. A implementação deve ser bastante autoexplicativa - chame com
x#n
ondex
é o número cujo cosseno deve ser calculado en
a ordem da soma parcial a ser tomada.fonte
fromIntegral
e usando**
no lugar de^
, como estex#n=sum[(-x*x)**i/product[1..2*i]|i<-[0..n-1]]
economiza mais 3 bytes.Pyt ,
373433 bytesfonte
J,
2624 bytes-2 bytes graças a @cole
Inicialmente, planejei usar um gerúndio cíclico para alternar entre adicionar e subtrair, mas não consegui fazê-lo funcionar.
Explicação:
fonte
+/@:(!@]%~^*_1^2%~])2*i.
Vai investigar um gerúndio cíclico: provavelmente falhou, pois J avalia da/
direita para a esquerda, então você precisa usá-lo|.
(ou talvez você tenha explicado isso e ainda tenha dificuldades).Perl 6 , 53 bytes
Experimente online!
Na verdade, isso calcula o complexo exponencial e iθ para o dobro do número de termos solicitados e, em seguida, assume a parte real.
fonte
MATLAB com caixa de ferramentas matemática simbólica, 57 bytes
Isto define uma função anônima com que leva
double
entradasx
,n
e emite o resultado como umdouble
.Exemplo (testado no R2015b):
fonte
JavaScript ES7 60 bytes
Para usá-lo:
Pressione F12, digite a função e faça
fonte
C
144130 bytesVersão Ungolfed:
Obrigado Kevin por salvar alguns bytes!
fonte
F(m){...}f(x,n)float x;{...}
while(m)u*=m--
ouu=m;while(--m)u*=m
(mesmo comprimento)i<=n-1
é o mesmo que:i<n
Tcl , 126 bytes
Experimente online!
fonte
Stax , 12 bytes
Execute e depure
Descompactado, não jogado e comentado, parece com isso.
Execute este
fonte
JavaScript, 59 bytes
Experimente online!
fonte
PHP, 76 bytes
pega
X
eN
de argumentos de linha de comando; corra com-r
.laço
$i
de0
aN*2-1
, esperafac($i)
em$f
; se$i
for par, adicione termo à soma$s
. soma de impressão.Eu gostaria de ter números complexos (com uma
M_I
unidade imaginária);Eu simplesmente multiplicar
$f
comM_I*++$i
e salvar 7 bytes.Talvez o Mathematica possa fazer isso. Mas o Mathematica não precisa.
Eu poderia salvar dois bytes com em
cos(M_PI*$i/2)
vez de$i&1?:
e(-1)**$k++
;mas seria um pouco estranho usar um cosseno embutido para criar uma função de cosseno.
fonte
Axioma, 36 bytes
Crie a lista infinita (no sentido finito, mas pode-se pedir para criar a lista de 2 * n elementos se o PC tiver memória suficiente) de somas parciais para a série de Taylor para cos (x) calcular em 'a', em "eval ( taylor (cos (x)), a) "; obtém o elemento 2 * n dessa lista em ". (2 * n)". Casos de teste:
fonte
J , 17 bytes
Experimente online!
Usa um built-in , que eu assumo está OK.
Infelizmente, eu realmente não sei como trabalhar bem com funções que aceitam argumentos por meio de currying, então eu tive que fazer isso explicitamente. Tenho certeza de que existe uma maneira de fazê-lo tacitamente ou mais curto.
fonte
Limpo , 77 bytes
Experimente online!
fonte