Tanım

Belirli bir işlevin maksimum ve minimum değeri, belirli bir aralıkta veya işlevin tüm etki alanı içinde işlevin en büyük ve en küçük değerleridir.

Meydan okuma

Meydan etmektir yerel maksimum ve minimum noktalarının belirli bir polinom fonksiyonun sizin gibi herhangi bir yöntem kullanılarak . Endişelenme, meydan okumayı açıklamak ve mümkün olduğunca basit tutmak için elimden geleni yapacağım.

Giriş , tek değişkenli polinomun tüm katsayılarını, azalan veya artan güç düzeninde (size bağlı olarak) içerecektir . Örneğin,

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

Nasıl Çözülür (Türev Kullanarak)?

Şimdi diyelim ki girdimiz, [1,-12,45,8]fonksiyondan başka bir şey değil .x3 - 12x2 + 45x + 8

1. İlk görev, bu fonksiyonun türevini bulmaktır. Bu bir polinom işlevi olduğu için gerçekten basit bir görevdir.

   Türev IS . Mevcut sabit terimler basitçe çarpılır. Ayrıca, eklenen / çıkarılan terimler varsa, bunların türevleri de sırasıyla eklenir veya çıkarılır. Unutmayın, herhangi bir sabit sayısal değerin türevi sıfırdır. İşte birkaç örnek: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. Şimdi yeni polinomu sıfıra eşitleyerek denklemi çözün ve sadece x'in integral değerlerini alın.

3. Bu x değerlerini orijinal işleve koyun ve sonuçları döndürün. Çıktı bu olmalı .

Misal

Daha önce bahsettiğimiz örneği ele alalım, yani [1,-12,45,8].

• Giriş: [1,-12,45,8]
• İşlev: x3 - 12x2 + 45x + 8
• Türev -> 3x2 - 24x + 45 + 0 -> [3,-24,45]
• Denklemi çözerek , ya da alırız .3x2 - 24x + 45 = 0x = 3x = 5
• Şimdi x = 3ve x = 5fonksiyonda değerleri alıyoruz (62,58).
• Çıktı -> [62,58]

Varsayımlar

1. Tüm giriş katsayılarının tamsayı olduğunu varsayalım . Artan veya azalan güç düzeninde olabilirler.

2. Girişin en az 2 derecelik bir polinom olduğunu varsayın . Polinomun tamsayı çözümü yoksa, her şeyi iade edebilirsiniz.

3. Nihai sonucun yalnızca tamsayı olacağını varsayalım.

4. Sonuçları istediğiniz sırayla yazdırabilirsiniz. Giriş polinomunun derecesi 5'ten fazla olmayacaktır, böylece kodunuz onu işleyebilir.

5. Giriş, x'in çözümlerinin eyer noktası olmaması için geçerli olacaktır.

Ayrıca, türev yöntemle yapmak zorunda değilsiniz. İstediğiniz herhangi bir yöntemi kullanabilirsiniz.

Örnek Giriş ve Çıkış

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

puanlama

Bu kod golf yani kısa kod kazanır.

Jöle , 20 bayt

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

Çevrimiçi deneyin!

açıklama

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.

Bu programdaki yardımcı fonksiyon, Bay Xcoder'ın burada Luis'in cevabına dayanan cevabından alınmıştır .

JavaScript (ES7), 129 120 bayt

Artan güç düzenindeki katsayıları alır.

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

Test senaryoları

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) 

Yorumlananlar

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 ( Polynomialspaketli), 57 bayt

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

Çevrimiçi deneyin!

Katsayıları artan sırada alır, yani ilk girdi sabit terimdir.

Örnek çalışma:

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 bayt

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

Bu cevabımdan aynı işlevselliği kullanır.

@ OlivierGrégoire sayesinde diziyi tersine alarak -8 bayt .

Açıklama:

Çevrimiçi deneyin.

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 Dili (Mathematica) , 30 bayt

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

Saf fonksiyonlu bir polinom alır (yani #değişken olarak ve &sonunda a olan bir polinom ).

Çevrimiçi deneyin!

Haskell , 89 bayt

Laikoni sayesinde -3 bayt.

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

Çevrimiçi deneyin!

Katsayıları tersine çevirir.

Python 3 , 156 bayt

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]

Çevrimiçi deneyin!

Bay Xcoder sayesinde -2 bayt-ovs
sayesinde -22 bayt

Python + numpy, 91

• @KevinCruijssen sayesinde 1 byte tasarruf edildi

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

Çevrimiçi deneyin .

Pari / GP , 28 bayt

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

Polinomu türevinin köklerinden değerlendirin.

Çevrimiçi deneyin!