Encontre o máximo local e mínimo

14

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 é então o código mais curto vence.

Manish Kundu
fonte
1
Se bem entendi: no exemplo, a etapa " Resolvendo equação " seria parcialmente esse desafio anterior de você ? Além disso, a etapa " Agora, colocando x = 3 e x = 5 na função " significa a função original em " Função " e não a função em " Derivada ", certo?
Kevin Cruijssen 31/01
1
Para a amostra de E / S 3, estou recebendo (-1, 0, 1), que acredito ser a resposta correta real ... embora não tenha certeza. Se você não concorda comigo, envie-me um bate-papo.
HyperNeutrino 31/01
1
The input will be valid so that the solutions of x are not saddle points, o caso [1,0,0,3]parece dar um ponto de sela.
JungHwan Min 31/01/19
1
@JungHwanMin ah, esse exemplo foi adicionado antes da regra ser feita. Removido agora.
Manish Kundu
1
x^3 - 12x^2 + 45x + 8 = 0 , embora pessoalmente prefira que você o escreva como f(x)=x^3-12x^2+45x+8sem o =0porque =0não faz sentido, pois estamos lidando com uma função, não resolvendo uma equação.
Weijun Zhou 31/01

Respostas:

4

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

HyperNeutrino
fonte
@JungHwanMin, vou apontar isso para OP. Isso é uma violação direta da afirmação de que não haverá pontos de sela porque a derivada do polinômio em 3é 0. editar oh você já fez nvm apenas upvoted o comentário então
HyperNeutrino
3

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

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)
Arnauld
fonte
1
falha para 0,0,1(x ^ 2 = 0)
betseg 31/01
@betseg Obrigado por relatar isso. Fixo.
Arnauld 31/01
3

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
Rɪᴋᴇʀ
fonte
3

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
Kevin Cruijssen
fonte
2
falha para 1,0,0(x ^ 2 = 0)
betseg 31/01
@betseg Thanks! Fixo e golfe.
Kevin Cruijssen 31/01
1
Você deve aceitar a entrada na ordem inversa (é explicitamente permitido) para reduzir a sua contagem assim: int... ,i, ...; for(;f>0;)A[--f]*=f;. A menos que eu esteja enganado, isso deve economizar pelo menos 4 bytes. Se você fizer isso, inverta todos os seus acessos à entrada.
Olivier Grégoire
@ OlivierGrégoire Obrigado, 8 bytes salvos!
Kevin Cruijssen
2

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.

totalmente humano
fonte
2
d<-tail$pode ser reduzido para _:d<-.
Laikoni
1

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

HyperNeutrino
fonte
1

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 .

Trauma Digital
fonte