Encontre a taxa de alteração em um ponto em um polinômio

15

Dada a equação de um polinômio e uma coordenada x, encontre a taxa de mudança do ponto nessa coordenada x na curva.

Um polinômio está na forma: ax n + ax n-1 + ... + ax 1 + a, onde a ϵ Q e n ϵ W. Para esse desafio, n também pode ser 0 se você não quiser ter para lidar com casos especiais (constantes) onde não há x.

Para encontrar a taxa de mudança nessa coordenada x, podemos obter a derivada do polinômio e inserir a coordenada x.

Entrada

O polinômio pode ser obtido de qualquer forma razoável, mas você deve indicar qual é esse formato explicitamente. Por exemplo, uma matriz do formulário [..[coefficient, exponent]..]é aceitável.

Resultado

A taxa de mudança do ponto na coordenada x dada.

Isso é , então o código mais curto em bytes vence.

Exemplos

[[4, 3], [-2, 4], [5, 10]]   19    ->   16134384838410
                  [[0, 4]]  400    ->   0
           [[4, 0], [5,1]]  -13    ->   5
      [[4.14, 4], [48, 2]]   -3    ->   -735.12
         [[1, 3], [-5, 0]]    5.4  ->   87.48
Daniel
fonte
8
Algoritmo para quem não tem o fundo matemático apropriado: A derivada de A x ^ B + C x ^ D + ... é (A B) * x ^ (B-1) + (C D) * x ^ ( D-1) + ...
Sparr
Não estou familiarizado com o conjunto W. É essa a união dos números naturais 0?
Alex A.
@AlexA., Sim, é.
Daniel
1
Borderline dupe
Peter Taylor
2
@ PeterTaylor Eu acho que eles compartilham uma idéia semelhante, mas eu não acho que nenhuma resposta de lá possa ser postada aqui sem modificações muito, muito significativas.
Alex A.

Respostas:

23

Mathematica, 6 bytes

#'@#2&

(Bata ISSO , MATL e 05AB1E)

O primeiro argumento deve ser um polinômio, com #como sua variável e com &no final (ou seja, um polinômio de função pura; por exemplo 3 #^2 + # - 7 &). O segundo argumento é a coordenada x do ponto de interesse.

Explicação

#'

Tome a derivada do primeiro argumento ( 1está implícito).

... @#2&

Conecte o segundo argumento.

Uso

#'@#2&[4 #^3 - 2 #^4 + 5 #^10 &, 19] (* The first test case *)

16134384838410

JungHwan Min
fonte
3
Você ganha por 0 bytes agora :-P
Luis Mendo 11/11
@LuisMendo Quando um cara com a faca de um chef pode amarrar com uma bandolim em uma competição de fatias, vou explicar o cara que está usando a faca. ;)
J ...
8

MATL , 8 6 bytes

yq^**s

A entrada é: matriz de expoentes, número, matriz de coeficientes.

Experimente online! Ou verifique todos os casos de teste: 1 , 2 3 , 4 , 5 .

Explicação

Considere exemplo entradas [3 4 10], 19, [4 -2 5].

y    % Take first two inputs implicitly and duplicate the first
     %   STACK: [3 4 10], 19, [3 4 10]
q    % Subtract 1, element-wise
     %   STACK: [3 4 10], 19, [2 3 9]
^    % Power, element-wise
     %   STACK: [3 4 10], [361 6859 322687697779]
*    % Multiply, element-wise
     %   STACK: [1083 27436 3226876977790]
*    % Take third input implicitly and multiply element-wise
     %   STACK: [4332 -54872 16134384888950]
s    % Sum of array
     %   STACK: 16134384838410
Luis Mendo
fonte
7

Julia, 45 42 40 37 bytes

f(p,x)=sum(i->prod(i)x^abs(i[2]-1),p)

Esta é uma função que aceita um vetor de tuplas e um número e retorna um número. O valor absoluto é garantir que o expoente não seja negativo, o que é necessário porque Julia irritante lança a DomainErrorao elevar um número inteiro para um expoente negativo.

Experimente online! (inclui todos os casos de teste)

Agradecimentos a Glen O por algumas correções e bytes.

Alex A.
fonte
3
Eu temia que @AlexA. e Julia se separou, mas aqui estão eles novamente, juntos em harmonia <3
flawr
Você pode salvar três bytes extras se, em vez de usar i[2]>0&&para lidar com o caso constante, você usar abs(i[2]-1)o expoente de x. E um truque um pouco menos limpo para salvar outros três bytes é usar em p%xvez de f(p,x)- observe que você pode chamá-lo como %(p,x)se quisesse usá-lo em forma de função ... infelizmente, parece que não funciona no TIO (que aparentemente está executando o Julia 0.4.6), embora funcione no meu Julia 0.5.0.
Glen O
@GlenO Nice, obrigado pelas sugestões. Fui com a absparte, mas redefinindo operadores infixas me dói fisicamente ...
Alex A.
5

05AB1E ,12 11 bytes

Guardou um byte graças a Adnan.

vy¤<²smsP*O

v          For each [coefficient, power] in the input array
 y         Push [coefficient, power]
  ¤<       Compute (power-1)
   ²       Push x value (second input entry)
    sms    Push pow(x, power-1)
       P   Push coefficient * power ( = coefficient of derivative)
        *  Push coefficient * power * pow(x, power-1)
         O Sum everything and implicitly display the result

Experimente online!

A precisão do ponto flutuante é do Python. Atualmente, troco os valores da pilha duas vezes, talvez haja uma maneira de evitá-lo e salvar alguns bytes.

Osable
fonte
1
Eu acredito que você pode deixar de fora o }:).
Adnan
DIs<m**Oé de 8 bytes, seguindo a resposta MATL que o @Luis Mendo forneceu.
Magic Octopus Urn
Melhor ainda, s¹<m**Osão 7 bytes. ( 05ab1e.tryitonline.net/… )
Magic Octopus Urn
Ele altera substancialmente o formato de entrada enquanto eu mantive o original. Mas concordo que manipular o formato de entrada permite respostas mais curtas.
Osable
@Osable true, mas outros usaram essa brecha;)
Magic Octopus Urn
4

Python 3, 41 bytes

6 bytes removidos graças a @AndrasDeak ! Na verdade, essa resposta agora é mais dele que minha ...

Agradecemos também a @ 1Darco1 por duas correções!

lambda A,x:sum(a*b*x**(b-1) for a,b in A)

Função anônima que aceita uma lista de listas com coeficientes e expoentes (mesmo formato descrito no desafio) e um número.

Experimente aqui .

Luis Mendo
fonte
Por que você pode somar em a*x**(b-1)vez de a*b*x**(b-1)? E ainda mais, e se $ x = 0 $?
1Darco1
@ 1Darco1 Você está certo em ambos. Vou mudar daqui a pouco
Luis Mendo
3

R, 31 bytes

function(a,n,x)sum(a*n*x^(n-1))

Função anônima que recebe um vetor de coeficientes a , um vetor de expoentes ne um xvalor.

rturnbull
fonte
1
Agradável! Eu adicionei outra resposta com a mesma contagem de bytes. Ele usa uma abordagem completamente diferente. R não é incrível?
Billywob #
1
Edit: Não é mais a mesma contagem de bytes :)
Billywob
2

Matlab, 27 bytes

Esta é uma função anônima que aceita um valor xe um polônio pna forma de uma lista de coeficientes, por exemplo, x^2 + 2pode ser representada como [1,0,2].

@(x,p)polyval(polyder(p),x)
flawr
fonte
2

JavaScript (ES7), 40 bytes

(a,n)=>a.reduce((t,c,i)=>t+i*c*n**--i,0)

aé uma matriz dos coeficientes em ordem crescente de expoente com zeros incluídos, por exemplo, x ³-5 seria representado por [-5, 0, 0, 1].

Neil
fonte
2

MATLAB com caixa de ferramentas matemática simbólica, 26 bytes

@(p,x)subs(diff(sym(p)),x)

Isso define uma função anônima. As entradas são:

  • uma linha p define o polinômio, no formato'4*x^3-2*x^4+5*x^10'
  • um número x

Exemplo de uso:

>> f = @(p,x)subs(diff(sym(p)),x)
f = 
    @(p,x)subs(diff(sym(p)),x)

>> f('4*x^3-2*x^4+5*x^10', 19)
ans =
16134384838410
Luis Mendo
fonte
Você pode usar @(x,p)polyval(polyder(p),x)para obter um byte.
flawr
@ flawr Bem, ele não deveria agora, porque você acabou de postar isso como resposta; P #
Alex A.
@ Flawr Obrigado, mas isso é muito diferente, você deve publicá-lo!
Luis Mendo 10/11
1
Bem, eu acho que você não teria feito isso de qualquer maneira, porque ganharia um byte = D
flawr 10/11/16
@flawr Aww. I completamente mal interpretado, haha
Luis Mendo
2

R, 31 27 bytes

Função sem nome, tendo duas entradas pe x. pé considerado uma expressão R do polinômio (veja o exemplo abaixo) e xé simplesmente o ponto de avaliação.

function(p,x)eval(D(p,"x"))

Ele funciona chamando o Dque calcula a derivada simbólica wrt xe avalia a expressão em x.

Saída de exemplo

Supondo que a função agora seja nomeada, fela pode ser chamada da seguinte maneira:

f(expression(4*x^3-2*x^4+5*x^10),19)
f(expression(0*x^4),400)
f(expression(4*x^0+5*x^1),-13)
f(expression(4.14*x^4+48*x^2),-3)
f(expression(1*x^3-5*x^0),5.4)

que produz respectivamente:

[1] 1.613438e+13
[1] 0
[1] 5
[1] -735.12
[1] 87.48
Billywob
fonte
Obrigado por me mostrar isso! Eu não tinha considerado a possibilidade de ter a entrada como uma expressão - essa é uma solução realmente elegante.
rturnbull
2

PARI / GP , 20 bytes

a(f,n)=subst(f',x,n)

Por exemplo, a(4*x^3-2*x^4+5*x^10,19)produz 16134384838410.

Charles
fonte
Como diabos isso funciona?
cat
@cat Calcula o derivado f'de f, e, em seguida, substitui npara x.
Paŭlo Ebermann 12/11
2

C ++ 14, 165 138 133 112 110 bytes

O Lambda Variadic Genérico economiza muito. -2 bytes para #importe excluindo o espaço antes<

#import<cmath>
#define A auto
A f(A x){return 0;}A f(A x,A a,A b,A...p){return a*b*std::pow(x,b-1)+f(x,p...);}

Ungolfed:

#include <cmath>

auto f(auto x){return 0;}

auto f(auto x,auto a,auto b,auto...p){
    return a*b*std::pow(x,b-1)+f(x,p...);
}

Uso:

int main() {
 std::cout << f(19,4,3,-2,4,5,10) << std::endl;
 std::cout << f(400,0,4) << std::endl;
 std::cout << f(-13,4,0,5,1) << std::endl;
 std::cout << f(-3,4.14,4,48,2) << std::endl;
 std::cout << f(5.4,1,3,-5,0) << std::endl;
}
Karl Napf
fonte
Você parece ter riscado todas as suas contagens de bytes. Qual é a contagem real de bytes, então?
Numbermaniac #
1
@numbermaniac obrigado, feito.
Karl Napf
1

Haskell, 33 bytes

f x=sum.map(\[c,e]->c*e*x**(e-1))

Uso:

> f 5.4 [[1, 3], [-5, 0]]
87.48000000000002
Angs
fonte
1

dc, 31 bytes

??sx0[snd1-lxr^**ln+z2<r]srlrxp

Uso:

$ dc -e "??sx0[snd1-lxr^**ln+z2<r]srlrxp"
4.14 4 48 2
_3
-735.12
poi830
fonte
0

DASH , 33 bytes

@@sum(->@* ^#1- :1#0 1(sS *)#0)#1

Uso:

(
  (
    @@sum(->@* ^#1- :1#0 1(sS *)#0)#1
  ) [[4;3];[_2;4];[5;10]]
) 19

Explicação

@@                             #. Curried 2-arg lambda
                               #. 1st arg -> X, 2nd arg -> Y
  sum                          #. Sum the following list:
    (map @                     #. Map over X
                               #. item list -> [A;B]
      * ^ #1 - :1#0 1(sS *)#0  #. This mess is just A*B*Y^(B-1)
    )#1                        #. X
Mama Fun Roll
fonte
0

Scala, 46 bytes

s=>i=>s map{case(c,e)=>c*e*math.pow(i,e-1)}sum

Uso:

val f:(Seq[(Double,Double)]=>Double=>Double)=
  s=>i=>s map{case(c,e)=>c*e*math.pow(i,e-1)}sum
print(f(Seq(4.0 → 3, -2.0 → 4, 5.0 → 10))(19))

Explicação:

s=>                        //define an anonymous function with a parameter s returning
  i=>                        //an anonymous function taking a paramater i and returning
    s map{                   //map each element of s:
      case(c,e)=>              //unpack the tuple and call the values c and e
        c*e*math.pow(i,e-1)    //calculate the value of the first derivate
    }sum                      //take the sum
corvus_192
fonte
0

Axioma 31 bytes

h(q,y)==eval(D(q,x),x,y)::Float

resultados

 -> h(4*x^3-2*x^4+5*x^10, 19)
     161343 84838410.0

 -> h(4.14*x^4+48*x^2, -3)
     - 735.12
RosLuP
fonte
0

Python 2, 39 bytes

lambda p,x:sum(c*e*x**~-e for c,e in p)

lambdaA função requer duas entradas pe x. pé o polinômio, fornecido no formato de exemplo fornecido na pergunta. xé o valor x no qual encontrar a taxa de alteração.

nog642
fonte
0

C, 78 bytes

f(int*Q,int*W,int S,int x){return Q[--S]*W[S]*pow(x,W[S]-1)+(S?f(Q,W,S,x):0);}
Khaled.K
fonte
0

Clojure, 53 bytes

#(apply +(for[[c e]%](apply * c e(repeat(dec e)%2))))

O polinômio é expresso como um mapa de hash, chaves sendo coeficientes e valores são expoentes.

NikoNyrh
fonte
0

Casio Basic, 16 bytes

diff(a,x)|x=b

A entrada deve ser o polinômio em termos de x. 13 bytes para o código, +3 bytes para inserir a,bcomo parâmetros.

Simplesmente deriva a expressão aem relação a xe depois se inscreve x=b.

numbermaniac
fonte
0

Dyalog APL, 26 25 23 bytes

{a←⍺⋄+/{×/⍵×a*2⌷⍵-1}¨⍵}

Toma polinômio como argumento da direita e valor como argumento da esquerda.

Zacharý
fonte