Definição

Os máximos e mínimos de uma determinada função são os maiores e menores valores da função, dentro de um determinado intervalo ou de outra forma, dentro de todo o domínio da função.

Desafio

O desafio é encontrar os máximos e mínimos locais de uma determinada função polinomial usando qualquer método que você desejar . Não se preocupe, vou tentar o meu melhor para explicar o desafio e mantê-lo o mais simples possível.

A entrada conterá todos os coeficientes do polinômio de variável única na ordem de potência decrescente ou crescente (até você). Por exemplo,

• [3,-7,1] representará 3x2 - 7x + 1 = 0
• [4,0,0,-3] representará 4x3-3=0.

Como resolver (usando derivativos)?

Agora, digamos que nossa entrada seja [1,-12,45,8], que nada mais é que a função .x3 - 12x2 + 45x + 8

1. A primeira tarefa é encontrar a derivada dessa função. Como é uma função polinomial, é de fato uma tarefa simples de executar.

   A derivada de é . Quaisquer termos constantes presentes com são simplesmente multiplicados. Além disso, se houver termos adicionados / subtraídos, seus derivados também serão adicionados ou subtraídos, respectivamente. Lembre-se, a derivada de qualquer valor numérico constante é zero. Aqui estão alguns exemplos:xnn*xn-1xn

   • x3 -> 3x2
   • 9x4 -> 9*4*x3 = 36x3
   • -5x2 -> -5*2*x = - 10x
   • 2x3 - 3x2 + 7x -> 6x2 - 6x + 7
   • 4x2 - 3 -> 8x - 0 = 8x

2. Agora resolva a equação equiparando o novo polinômio a zero e obtenha apenas os valores integrais de x.

3. Coloque esses valores de x na função original e retorne os resultados. Essa deve ser a saída .

Exemplo

Vamos pegar o exemplo que mencionamos anteriormente, ou seja [1,-12,45,8],.

• Entrada: [1,-12,45,8]
• Função: x3 - 12x2 + 45x + 8
• Derivada -> 3x2 - 24x + 45 + 0 -> [3,-24,45]
• Resolvendo a equação , obtemos ou .3x2 - 24x + 45 = 0x = 3x = 5
• Agora, colocando x = 3e x = 5na função, obtemos os valores (62,58).
• Saída -> [62,58]

Premissas

1. Suponha que todos os coeficientes de entrada sejam inteiros . Eles podem estar em ordem crescente ou decrescente de poder.

2. Suponha que a entrada seja pelo menos um polinômio de 2 graus . Se o polinômio não tiver soluções inteiras, você poderá retornar qualquer coisa.

3. Suponha que o resultado final será apenas números inteiros.

4. Você pode imprimir os resultados em qualquer ordem. O grau do polinômio de entrada não seria superior a 5, para que seu código possa lidar com isso.

5. A entrada será válida para que as soluções de x não sejam pontos de sela.

Além disso, você não é forçado a fazê-lo pelo método derivativo. Você pode usar qualquer método que desejar.

Entrada e saída de amostra

[2,-8,0] -> (-8)
[2,3,-36,10] -> (91,-34)
[1,-8,22,-24,8] -> (-1,0,-1) 
[1,0,0] -> (0)

Pontuação

Isso é código-golfe, então o código mais curto vence.

Gelatina , 20 bytes

ASŒRḅ@Ðḟ
J’U×µṖÇḅ@€³

Experimente online!

Explicação

ASŒRḅ@Ðḟ     Helper Function; find all integer solutions to a polynomial
             All integer roots are within the symmetric range of the sum of the absolute values of the coefficients
A            Absolute Value (Of Each)
 S           Sum
  ŒR         Symmetric Range; `n -> [-n, n]`
      Ðḟ     Filter; keep elements where the result is falsy for:
    ḅ@       Base conversion, which acts like the application of the polynomial
J’U×µṖÇḅ@€³  Main Link
J                             Range of length
 ’                    Lowered
  U          Reversed
   ×         Multiplied with the original list (last value is 0)
    µ        Begin new monadic chain
     Ṗ       Pop; all but the last element
      Ç      Apply last link (get all integer solutions of the derivative)
       ḅ@€³  Base conversion of the polynomial into each of the solutions; apply polynomial to each solution of the derivative.

A função auxiliar deste programa foi retirada da resposta do Sr. Xcoder aqui, que foi baseada na resposta de Luis aqui

JavaScript (ES7), 129 120 bytes

Toma os coeficientes em ordem crescente de poder.

a=>(g=x=>x+k?(A=g(x-1),h=e=>a.reduce((s,n,i)=>s+n*(e||i&&i--)*x**i,0))()?A:[h(1),...A]:[])(k=Math.max(...a.map(n=>n*n)))

Casos de teste

let f =

a=>(g=x=>x+k?(A=g(x-1),h=e=>a.reduce((s,n,i)=>s+n*(e||i&&i--)*x**i,0))()?A:[h(1),...A]:[])(k=Math.max(...a.map(n=>n*n)))

console.log(JSON.stringify(f([0,-8,2])))        // (-8)
console.log(JSON.stringify(f([10,-36,3,2])))    // (91,-34)
console.log(JSON.stringify(f([8,-24,22,-8,1]))) // (-1,0,-1) 

Comentado

a => (                        // given the input array a[]
  g = x =>                    // g = recursive function checking whether x is a solution
    x + k ? (                 //   if x != -k:
      A = g(x - 1),           //     A[] = result of a recursive call with x - 1
      h = e =>                //     h = function evaluating the polynomial:
        a.reduce((s, n, i) => //       for each coefficient n at position i:
          s +                 //         add to s
          n                   //         the coefficient multiplied by
          * (e || i && i--)   //         either 1 (if e = 1) or i (if e is undefined)
          * x**i,             //         multiplied by x**i or x**(i-1)
          0                   //         initial value of s
        )                     //       end of reduce()
      )() ?                   //     if h() is non-zero:
        A                     //       just return A[]
      :                       //     else:
        [h(1), ...A]          //       prepend h(1) to A[]
    :                         //   else:
      []                      //     stop recursion
  )(k = Math.max(             // initial call to g() with x = k = maximum of
    ...a.map(n => n * n)      // the squared coefficients of the polynomial
  ))                          // (Math.abs would be more efficient, but longer)

Julia 0.6 (com Polynomialspacote), 57 bytes

using Polynomials
x->map(Poly(x),roots(polyder(Poly(x))))

Experimente online!

Toma coeficientes em ordem crescente, ou seja, a primeira entrada é o termo constante.

Exemplo de execução:

julia> using Polynomials

julia> g = x -> map(Poly(x), roots(polyder(Poly(x))))
(::#1) (generic function with 1 method)

julia> g([8,45,-12,1])
2-element Array{Float64,1}:
 58.0
 62.0

Java 8, 364 239 227 226 218 bytes

a->{int l=a.length,A[]=a.clone(),s=0,i,r,f=l,p;for(;f>0;A[--f]*=f);for(int n:A)s+=n<0?-n:n;for(r=~s;r++<s;){for(p=0,i=f=1;i<l;f*=r)p+=A[i++]*f;if(p==0){for(f=i=0;i<l;f+=a[i++]*Math.pow(r,p++));System.out.println(f);}}}

Usa a mesma funcionalidade desta resposta minha.

-8 bytes graças a @ OlivierGrégoire , tomando a matriz em ordem inversa.

Explicação:

Experimente online.

a->{                  // Method with integer-varargs parameter and integer return-type
  int l=a.length,     //  The length of the input-array
      A[]=a.clone(),  //  Copy of the input-array
      s=0,            //  Sum-integer, starting at 0
      i,              //  Index-integer
      r,              //  Range-integer
      f=l,            //  Factor-integer, starting at `l`
      p;              //  Polynomial-integer
  for(;f>0;           //  Loop over the copy-array
    A[--f]*=f);       //   And multiply each value with it's index
                      //   (i.e. [8,45,-12,1] becomes [0,45,-24,3])
  for(int n:A)        //  Loop over this copy-array:
    s+=n<0?-n:n;      //   And sum their absolute values
  for(r=~s;r++<s;){   //  Loop `r` from `-s` up to `s` (inclusive) (where `s` is the sum)
    for(p=0,          //   Reset `p` to 0
        i=f=1;        //   and `f` to 1
                      //   (`i` is 1 to skip the first item in the copy-array)
        i<l;          //   Inner loop over the input again, this time with index (`i`)
        f*=r)         //     After every iteration: multiply `f` with the current `r`
      p+=             //    Sum the Polynomial-integer `p` with:
         A[i++]       //     The value of the input at index `i`,
               *f;}   //     multiplied with the current factor `f`
    if(p==0){         //   If `p` is now 0:
      for(f=i=0;      //    Use `f` as sum, and reset it to 0
          i<l;        //    Loop over the input-array
        f+=a[i++]*Math.pow(r,p++));
                      //     Fill in `r` in the parts of the input-function
      System.out.println(f);}}}
                      //    And print the sum

Wolfram Language (Mathematica) , 30 bytes

a@x/.#&/@Solve[a=#;#'@x==0,x]&

Toma um polinômio de função pura (ou seja, um polinômio com #uma variável e com um &no final).

Experimente online!

Haskell , 89 bytes

-3 bytes graças a Laikoni.

r#l=foldr1((.(r*)).(+))l
r l|_:d<-zipWith(*)[0..]l,t<-sum$abs<$>d=[i#l|i<-[-t..t],i#d==0]

Experimente online!

Toma coeficientes invertidos.

Python 3 , 156 bytes

def f(p,E=enumerate):a=lambda p,v:sum(e*v**i for i,e in E(p));d=[e*i for i,e in E(p)][1:];r=sum(map(abs,d));return[a(p,x)for x in range(-r,r+1)if a(d,x)==0]

Experimente online!

-2 bytes graças ao Sr. Xcoder
-22 bytes graças ao ovs

Python + numpy, 91

• 1 byte salvo graças a @KevinCruijssen

from numpy import*
p=poly1d(input())
print map(lambda x:int(polyval(p,x)),roots(p.deriv()))

Experimente online .

Pari / GP , 28 bytes

p->[eval(p)|x<-polroots(p')]

Avalie o polinômio nas raízes de sua derivada.

Experimente online!