Định nghĩa

Cực đại và cực tiểu của một hàm đã cho là các giá trị lớn nhất và nhỏ nhất của hàm trong phạm vi đã cho hoặc theo cách khác trong toàn bộ miền của hàm.

Thử thách

Thách thức là tìm cực đại và cực tiểu cục bộ của hàm đa thức đã cho bằng bất kỳ phương pháp nào bạn muốn . Đừng lo lắng, tôi sẽ cố gắng hết sức để giải thích thử thách và giữ nó đơn giản nhất có thể.

Đầu vào sẽ chứa tất cả các hệ số của đa thức biến đơn theo thứ tự công suất giảm hoặc tăng (tùy thuộc vào bạn). Ví dụ,

• [3,-7,1] sẽ đại diện 3x2 - 7x + 1 = 0
• [4,0,0,-3] sẽ đại diện 4x3-3=0.

Làm thế nào để giải quyết (sử dụng các công cụ phái sinh)?

Bây giờ, giả sử đầu vào của chúng ta [1,-12,45,8], không có gì ngoài chức năng .x3 - 12x2 + 45x + 8

1. Nhiệm vụ đầu tiên là tìm đạo hàm của hàm đó. Vì nó là một hàm đa thức, nên nó thực sự là một nhiệm vụ đơn giản để làm.

   Đạo hàm của là . Bất kỳ điều khoản không đổi hiện tại với chỉ đơn giản là nhân. Ngoài ra, nếu có các thuật ngữ được thêm / bớt, thì các dẫn xuất của chúng cũng được thêm hoặc trừ tương ứng. Hãy nhớ rằng, đạo hàm của bất kỳ giá trị số không đổi nào đều bằng không. Đây là vài ví dụ: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. Bây giờ giải phương trình bằng cách tính đa thức mới bằng 0 và chỉ nhận các giá trị tích phân của x.

3. Đặt các giá trị đó của x vào hàm ban đầu và trả về kết quả. Đó phải là đầu ra .

Thí dụ

Chúng ta hãy lấy ví dụ mà chúng ta đã đề cập trước đó, nghĩa là , [1,-12,45,8].

• Đầu vào: [1,-12,45,8]
• Chức năng: x3 - 12x2 + 45x + 8
• Đạo hàm -> 3x2 - 24x + 45 + 0 -> [3,-24,45]
• Giải phương trình , ta được hoặc .3x2 - 24x + 45 = 0x = 3x = 5
• Bây giờ đặt x = 3và x = 5trong hàm, chúng ta nhận được các giá trị (62,58).
• Đầu ra -> [62,58]

Giả định

1. Giả sử rằng tất cả các hệ số đầu vào là số nguyên . Họ có thể theo thứ tự tăng hoặc giảm quyền lực.

2. Giả sử đầu vào ít nhất là đa thức 2 độ . Nếu đa thức không có nghiệm nguyên, bạn có thể trả về bất cứ thứ gì.

3. Giả sử rằng kết quả cuối cùng sẽ chỉ là số nguyên.

4. Bạn có thể in kết quả theo thứ tự bất kỳ. Mức độ của đa thức đầu vào sẽ không quá 5, để mã của bạn có thể xử lý nó.

5. Đầu vào sẽ hợp lệ để các giải pháp của x không phải là điểm yên ngựa.

Ngoài ra, bạn không bị buộc phải làm điều đó bằng phương pháp phái sinh. Bạn có thể sử dụng bất kỳ phương pháp nào bạn cảm thấy thích.

Đầu vào và đầu ra mẫu

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

Chấm điểm

Đây là môn đánh gôn nên mã ngắn nhất sẽ thắng.

Thạch , 20 byte

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

Hãy thử trực tuyến!

Giải trình

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.

Hàm trợ giúp trong chương trình này được lấy từ câu trả lời của ông Xcoder ở đây dựa trên câu trả lời của Luis tại đây

JavaScript (ES7), 129 120 byte

Đưa các hệ số theo thứ tự tăng dần sức mạnh.

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

Các trường hợp thử nghiệm

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) 

Đã bình luận

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 (có Polynomialsgói), 57 byte

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

Hãy thử trực tuyến!

Lấy các hệ số theo thứ tự tăng dần, tức là đầu vào đầu tiên là số hạng không đổi.

Chạy ví dụ:

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 byte

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

Sử dụng chức năng tương tự từ câu trả lời này của tôi.

-8 byte nhờ @ OlivierGrégoire bằng cách lấy mảng theo thứ tự đảo ngược.

Giải trình:

Hãy thử trực tuyến.

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

Ngôn ngữ Wolfram (Mathicala) , 30 byte

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

Lấy một đa thức hàm thuần túy (tức là một đa thức với #một biến và có một &ở cuối).

Hãy thử trực tuyến!

Haskell , 89 byte

-3 byte nhờ Laikoni.

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

Hãy thử trực tuyến!

Có hệ số đảo ngược.

Python 3 , 156 byte

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]

Hãy thử trực tuyến!

-2 byte nhờ ông Xcoder
-22 byte nhờ vào các lò nướng

Python + numpy, 91

• Lưu 1 byte nhờ @KevinCruijssen

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

Hãy thử trực tuyến .

Pari / GP , 28 byte

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

Đánh giá đa thức tại gốc của đạo hàm của nó.

Hãy thử trực tuyến!