Bir polinom fonksiyonu f (örn . Artan veya azalan sırada gerçek katsayıların p listesi olarak ), negatif olmayan bir tamsayı n ve gerçek bir x değeri döndürülür:

   f  ⁿ ( x )

yani değeri f ( f ( f (... f ( x için) ...))) n, uygulamalarında f ile x .

Makul hassasiyet ve yuvarlama kullanın.

Almak Çözümler f katsayılarının bir liste olarak belki de en ilginç, ama almak mümkün olup olmadığını olacak f gerçek bir fonksiyonu olarak (böylece önemsiz için bu zorluğu azaltan "bir işlev uygulamak n , times") dahil etmek çekinmeyin önemsiz olmayan çözümünüzden sonra.

Örnek vakalar

p  = [1,0,0]veya f  = x^2,  n  = 0,  x  = 3:  f  ⁰ (3) =3

p  = [1,0,0]veya f  = x^2,  n  = 1,  x  = 3:  f  ¹ (3) =9

p  = [0.1,-2.3,-4]veya f  = 0.1x^2-2.3x-4,  n  = 0,  x  = 2.3:  f  ⁰ (2,3) =2.3

p  = [0.1,-2.3,-4]veya f  = 0.1x^2-2.3x-4,  n  = 1,  x  = 2.3:  f  ¹ (2,3) =-8.761

p  = [0.1,-2.3,-4]veya f  = 0.1x^2-2.3x-4,  n  = 2,  x  = 2.3:  f  ² (2,3) =23.8258

p  = [0.1,-2.3,-4]veya f  = 0.1x^2-2.3x-4,  n  = 3,  x  = 2.3:  f  ³ (2,3) =-2.03244

p  = [0.1,-2.3,-4]veya f  = 0.1x^2-2.3x-4,  n  = 4,  x  = 2.3:  f  ⁴ (2,3) =1.08768

p  = [0.1,-2.3,-4]veya f  = 0.1x^2-2.3x-4,  n  = 5,  x  = 2.3:  f  ⁵ (2,3) =-6.38336

p  = [0.1,-2.3,-4]veya f  = 0.1x^2-2.3x-4,  n  = 6,  x  = 2.3:  f  ⁶ (2,3) =14.7565

p  = [0.1,-2.3,-4]veya f  = 0.1x^2-2.3x-4,  n  = 7,  x  = 2.3:  f  ⁷ (2,3) =-16.1645

p  = [0.1,-2.3,-4]veya f  = 0.1x^2-2.3x-4,  n  = 8,  x  = 2.3:  f  ⁸ (2,3) =59.3077

p  = [0.1,-2.3,-4]veya f  = 0.1x^2-2.3x-4,  n  = 9,  x  = 2.3:  f  ⁹ (2,3) =211.333

p  = [0.1,-2.3,-4]veya f  = 0.1x^2-2.3x-4,  n  = 10,  x  = 2.3:  f  ¹⁰ (2,3) =3976.08

p  = [0.1,-2.3,-4]veya f  = 0.1x^2-2.3x-4,  n  = 11,  x  = 2.3:  f  ¹¹ (2,3) =1571775

p  = [-0.1,2.3,4]veya f  = −0.1x^2+2.3x+4,  n  = 0,  x  = -1.1:  f  ⁰ (-1,1) =-1.1

p  = [-0.1,2.3,4]veya f  = −0.1x^2+2.3x+4,  n  = 1,  x  = -1.1:  f  ¹ (-1,1) =1.349

p  = [-0.1,2.3,4]veya f  = −0.1x^2+2.3x+4,  n  = 2,  x  = -1.1:  f  ² (-1,1) =6.92072

p  = [-0.1,2.3,4]veya f  = −0.1x^2+2.3x+4,  n  = 14,  x  = -1.1:  f  ¹⁴ (-1,1) =15.6131

p  = [0.02,0,0,0,-0.05]veya f  = 0.02x^4-0.05,  n  = 25,  x  = 0.1:  f  ²⁵ (0,1) =-0.0499999

p  = [0.02,0,-0.01,0,-0.05]veya f  = 0.02x^4-0.01x^2-0.05,  n  = 100,  x  = 0.1:  f  ¹⁰⁰ (0,1) =-0.0500249

Oktav , 49 bayt

@(p,x,n)(f=@(r,m){@()p(r(r,m-1)),x}{~m+1}())(f,n)

Çevrimiçi deneyin!

Veya katsayıları alarak:

Oktav , 75 57 bayt

@(p,x,n)(f=@(f,n){@()polyval(p,f(f,n-1)),x}{~n+1}())(f,n)

Çevrimiçi deneyin!

StackOverflow'daki Suever over için özel bir teşekkür , bir süre önce bir soru üzerine bu cevap için , özyinelemeli anonim bir işlevin mümkün olduğunu kanıtlıyor.

Bu, özyinelemeli bir anonim işlev için bir sarıcı olan anonim bir işlevi tanımlar ; yerel Oktav konsepti olmayan ve bazı süslü hücre dizisi indekslemesi gerektiren bir şey.

Bonus olarak, ikinci versiyon Octave'de değişken kapsam belirleme konusunda güzel bir derstir. Tüm örnekleri ryasal olarak değiştirilebilir f, bu da daha sonra fen yerel kapsamda mevcut olanın üzerine yazar (benzer n)

açıklama

@(p,x,n)(f=@(r,m){@()p(r(r,m-1)),x}{~m+1}())(f,n)
@(p,x,n)         .                ..    .  ..   .   % Defines main anonymous function    
        (f=@(r,m).                ..    .  ).   .   % Defines recursive anonymous function
                 .                ..    .   .   .   %  r: Handle ('pointer') to recursive function
                 .                ..    .   .   .   %  m: Current recursion depth (counting from n to 0)
                 .                ..    .   (f,n)   % And call it, with
                 .                ..    .           %  r=f (handle to itself)
                 .                ..    .           %  m=n (initial recursion)
                 {                }{    }           % Create and index into cell array
                                    ~m+1            %  Index: for m>0: 1; for m==0: 2.
                                ,x                  %  Index 2: final recursion, just return x.
                  @()                               %  Index 1: define anonymous function, taking no inputs.
                     p(        )                    %   which evaluates the polynomial 
                       r(     )                     %    of the recursive function call
                         r,m-1                      %     which is called with r 
                                                    %     and recursion depth m-1 
                                                    %     (until m=0, see above)
                                         ()         % Evaluate the result of the cell array indexing operation.
                                                    %  which is either the anonymous function
                                                    %  or the constant `x`.

Bu işin anahtarı anonim fonksiyonları olmasıdır değil tanımlandıkları zaman değerlendirdi. Bu nedenle, doğrudan sonradan @()çağrılan anonim bir işlevi tanımladığı için biraz gereksiz gibi görünen (), aslında kesinlikle gereklidir. Bu çağrılmaz sürece o indeksleme deyimi ile seçilir.

Oktav , 39 bayt (sıkıcı yol)

function x=f(p,x,n)for i=1:n;o=p(o);end

Tamlık için, en kısa bayt sayısına sahip Octave çözümü. Esneyin. .

Mathematica, 56 47 28 bayt

Nest[x\[Function]x#+#2&~Fold~#,##2]&

\[Function] UTF-8'de 3 bayt alır.

Parametreleri sırayla alın p,x,n.

p (parametre 1) giderek artan bir sıradadır.

Açıkçası fbir işlev olarak alınabilirse, bu sadece azaltılabilir Nest.

Kabuk , 5 bayt

←↓¡`B

Çevrimiçi deneyin!

Burada anahtar fikir noktasında bir poinom değerlendiren olmasıdır x üssü gelen baz dönüşümünü gerçekleştirmek eşdeğerdir x .

Bbir taban ve basamak listesi verildiğinde temel dönüşüm gerçekleştirir. Burada, önce basamak listesini almak ve bu işlevi kısmen uygulamak için çevrilmiş sürümünü kullanıyoruz. Daha sonra verilen polinomun değerini bir noktada hesaplayan bir fonksiyon elde ederiz, bu çözümün ikinci kısmı bu fonksiyonu doğru miktarda tekrarlamakla ilgilenir:

Kabuk , 3 bayt

←↓¡

¡ "yineleme" işlevidir, bir işlev ve bir başlangıç ​​noktası alır ve işlevi yineleyen sonsuz değerlerin listesini döndürür.

↓ bir sayı alır (bu zorluğun üçüncü argümanı) ve listenin başlangıcından bu kadar çok eleman bırakır.

← sonuçtaki listenin ilk öğesini döndürür.

Pari / GP , 31 bayt

(p,n,x)->for(i=1,n,x=eval(p));x

Çevrimiçi deneyin!

Ruby , 42 bayt

->c,n,x{n.times{x=c.reduce{|s,r|s*x+r}};x}

C azalan sırada katsayıların listesidir

Önemsiz sürüm, burada f bir lambda işlevidir ( 26 bayt ):

->f,n,x{n.times{x=f[x]};x}

# For example:
# g=->f,n,x{n.times{x=f[x]};x}
# p g[->x{0.02*x**4-0.01*x**2-0.05},100,0.1]

Çevrimiçi deneyin!

JavaScript (ES6),  52 49 44  42 bayt

GB sayesinde 5 bayt ve Neil sayesinde 2 bayt daha kaydetti

Körleme sözdiziminde girdiyi alır (p)(n)(x), burada p azalan sırada katsayıların listesidir.

p=>n=>g=x=>n--?g(p.reduce((s,v)=>s*x+v)):x

Test senaryoları

let f =

p=>n=>g=x=>n--?g(p.reduce((s,v)=>s*x+v)):x

console.log(f([1,0,0])(0)(3))
console.log(f([1,0,0])(1)(3))
console.log(f([0.1,-2.3,-4])(0)(2.3))
console.log(f([0.1,-2.3,-4])(1)(2.3))
console.log(f([0.1,-2.3,-4])(2)(2.3))
console.log(f([0.1,-2.3,-4])(3)(2.3))
console.log(f([0.1,-2.3,-4])(4)(2.3))
console.log(f([0.1,-2.3,-4])(5)(2.3))
console.log(f([0.1,-2.3,-4])(6)(2.3))
console.log(f([0.1,-2.3,-4])(7)(2.3))
console.log(f([0.1,-2.3,-4])(8)(2.3))
console.log(f([0.1,-2.3,-4])(9)(2.3))
console.log(f([0.1,-2.3,-4])(10)(2.3))
console.log(f([0.1,-2.3,-4])(11)(2.3))
console.log(f([-0.1,2.3,4])(0)(-1.1))
console.log(f([-0.1,2.3,4])(1)(-1.1))
console.log(f([-0.1,2.3,4])(2)(-1.1))
console.log(f([-0.1,2.3,4])(14)(-1.1))
console.log(f([0.02,0,0,0,-0.05])(25)(0.1))
console.log(f([0.02,0,-0.01,0,-0.05])(100)(0.1))

J , 15 bayt

0{(p.{.)^:(]{:)

Çevrimiçi deneyin!

Polinomu artan güçlerin katsayılarının bir listesi olarak alır.

açıklama

0{(p.{.)^:(]{:)  Input: polynomial P (LHS), [x, n] (RHS)
            {:   Tail of [x, n], gets n
           ]     Right identity, passes n
  (    )^:       Repeat n times starting with g = [x, n]
     {.            Head of g
   p.              Evaluate P at that value
                   Return g = [P(head(g))]
0{               Return the value at index 0

05AB1E , 10 9 bayt

Outgolfer Erik sayesinde -1 bayt

sF³gݨm*O

Çevrimiçi deneyin!

X'i birinci argüman, n'yi ikinci, p'yi artan sırada üçüncü alır.

açıklama

sF³gݨm*O
s         # Forces the top two input arguments to get pushed and swaped on the stack
 F        # Do n times...
  ³        # Push the third input (the coefficients)
   g       # Get the length of that array...
    ݨ     # and create the range [0 ... length]
      m    # Take the result of the last iteration to these powers (it's just x for the first iteration)
       *   # Multiply the resuling array with the corresponding coefficients
         O # Sum the contents of the array
          # Implicit print

Haskell , 15 bayt

((!!).).iterate

Çevrimiçi deneyin!

Her iki çözümden de 11 baytlık tamamen insanlara teşekkürler

Bu, bir işlevi ilk argümanı ve nikinci argümanı olarak alan ve bu fonksiyonu kendi nzamanlarıyla birleştiren bir tacit fonksiyonunu tanımlar . Bu daha sonra xson değeri elde etmek için bir argümanla çağrılabilir . Körelme büyüsü sayesinde, bu üç argüman alan bir fonksiyona eşdeğerdir.

İşlev argümanı yerine katsayıların bir listesini alma:

Haskell , 53 bayt

((!!).).iterate.(\p x->sum$zipWith(*)p[x^i|i<-[0..]])

Çevrimiçi deneyin!

Bu yukarıdaki kodla aynıdır, ancak bir katsayı listesini polinom fonksiyonuna dönüştüren bir lambda fonksiyonuyla oluşturulur. Katsayılar örneklerden ters sırayla alınır - artan güçler x.

APL (Dyalog) , 20 9 bayt

{⊥∘⍵⍣⎕⊢⍺}

Çevrimiçi deneyin!

Bu xsol argüman olarak, fonksiyonun katsayıları doğru argüman olarak ve nSTDIN'den alır.

Uzun süre sonra buna baktığımda, baz dönüşümünü kullanarak hesaplamayı basitleştirebileceğimi fark ettim ⊥.

APL (Dyalog), 5 bayt

İşlevi bir Dyalog APL işlevi olarak alabilirsek, bu 5 bayt olabilir.

⎕⍣⎕⊢⎕

Alır x, ndaha sonra STDIN'den girdi olarak fonksiyon ve.

R , 96 58 55 52 bayt

f=function(n,p,x)`if`(n,f(n-1,p,x^(seq(p)-1)%*%p),x)

Çevrimiçi deneyin!

Açıklama:

seq(p)listesini üretmektedir , bu yüzden bir vektör dolayısıyla, polinom üsler olduğu eşdeğerdir (her zaman 1'e eşit) bir nokta ürünün işlem ile de polinom değerlendirir .1, 2, ..., length(p)pseq(p)-1x^(seq(p)-1)x^0, x^1, x^2, ...%*%px

Ayrıca, Pbir işlev olarak alınırsa, bu 38 bayt olur:

function(n,P,x)`if`(n,f(n-1,P,P(x)),x)

Ve biz elbette her zaman üretebilir PtarafındanP=function(a)function(x)sum(x^(seq(a)-1)*a)

Jöle , 10 bayt

*⁹LḶ¤×⁹Sµ¡

Çevrimiçi deneyin!

Bu sırayla x, artan sırada katsayıları alır.

4 bayt

⁹v$¡

Çevrimiçi deneyin!

Bu sırayla x, Jelly bağlantısı (alıntılanması / kaçması gerekebilir), n alır.

Python 3 , 70 69 bayt

f=lambda p,n,x:n and f(p,n-1,sum(c*x**i for i,c in enumerate(p)))or x

Alır peğer yani küçükten büyüğe polduğunu [0, 1, 2]daha sonra ilgili polinomlarıdır p(x) = 0 + 1*x + 2*x^2. Basit özyineleme çözümü.

Çevrimiçi deneyin!

C # (.NET Core) , 82 bayt

using System.Linq;f=(p,n,x)=>n<1?x:p.Select((c,i)=>c*Math.Pow(f(p,n-1,x),i)).Sum()

Çevrimiçi deneyin!

Test durumlarından (sırayla artan?) Karşı sıradaki katsayıların listesini alır, böylece dizideki dizinleri x değerine eşit olmalıdır.

Ve 30 baytlık önemsiz sürüm:

f=(p,n,x)=>n<1?x:f(p,n-1,p(x))

Çevrimiçi deneyin!

Bir delege alır ve tekrar tekrar uygular.

MATL , 11 bayt

ii:"ZQ6Mw]&

Çevrimiçi deneyin!

Oktav cevabımdan biraz daha az ilginç olsa da n=0, beklendiği gibi çalıştığından emin olmak için girdilerin zekice hokkabazlığı olduğunu düşünüyorum .

Julia 0.6.0 (78 bayt)

using Polynomials;g(a,n,x)=(p=Poly(a);(n>0&&(return g(a,n-1,p(x)))||return x))

explainations:

Polinomlar paketi oldukça açıklayıcıdır: polinomlar yaratır. Bundan sonra oldukça basit bir özyineleme.

Bir polinomunuz olması için: -4.0 - 2.3 * x + 0.1 * x ^ 2 girişi aaşağıdaki gibi olmalıdıra = [-4, -2.3, 0.1]

Aksiyom, 91 bayt

f(n,g,x)==(for i in 1..n repeat(v:=1;r:=0;for j in 1..#g repeat(r:=r+v*g.j;v:=v*x);x:=r);x)

senetli

fn(n,g,x)==
     for i in 1..n repeat
          v:=1; r:=0
          for j in 1..#g repeat(r:=r+v*g.j;v:=v*x)
          x:=r
     x

polinominin girdisi g, egzersiz örneğinin tersindeki sayıların bir listesidir. Örneğin

[1,2,3,4,5]  

polinomiyi temsil eder

1+2*x+3*x^2+4*x^3+5*x^4

Ölçek:

(3) -> f(0,[0,0,1],3)
   (3)  3
                                                    Type: PositiveInteger
(4) -> f(1,[0,0,1],3)
   (4)  9
                                                    Type: PositiveInteger
(5) -> f(0,[-4,-2.30,0.1],2.3)
   (5)  2.3
                                                              Type: Float
(6) -> f(1,[-4,-2.30,0.1],2.3)
   (6)  - 8.7610000000 000000001
                                                              Type: Float
(7) -> f(2,[-4,-2.30,0.1],2.3)
   (7)  23.8258121
                                                              Type: Float
(8) -> f(9,[-4,-2.30,0.1],2.3)
   (8)  211.3326335688 2052491
                                                              Type: Float
(9) -> f(9,[-4,-2.30,0.1,0,0,0,0,1],2.3)
   (9)  0.4224800431 1790652974 E 14531759
                                                              Type: Float
                                   Time: 0.03 (EV) + 0.12 (OT) = 0.15 sec
(10) -> f(2,[-4,-2.30,0.1,0,0,0,0,1],2.3)
   (10)  44199336 8495528344.36
                                                              Type: Float

Röda , 41 bayt

f p,n,x{([0]*n)|x=_+p()|reduce _*x+_;[x]}

Çevrimiçi deneyin!

Önemsiz bir versiyon:

f F,n{([_]..[0]*n)|reduce F(_)+_}

Çevrimiçi deneyin!

xAkış için değerini alır .

C ++ 14, 71 bayt

Genel isimsiz lambda olarak xParametre ile geri dönelim:

[](auto C,int n,auto&x){for(auto t=x;t=0,n--;x=t)for(auto a:C)t=a+x*t;}

Kurtulmamış ve testcase:

#include<iostream>
#include<vector>

using namespace std;

auto f=
[](auto C,int n,auto&x){
 for(
  auto t=x; //init temporary to same type as x
  t=0, n--; //=0 at loop start, also check n
  x=t       //apply the result
  )
  for(auto a:C)
   t=a+x*t; //Horner-Scheme
}
;


int main() {
 vector<double> C = {0.1,-2.3,-4};//{1,0,0};
 for (int i = 0; i < 10; ++i) {
  double x=2.3;
  f(C, i, x);
  cout << i << ": " << x << endl;
 }
}

QBIC , 19 bayt

[:|:=:*c^2+:*c+:}?c

Girdileri şu şekilde alır

• Yineleme sayısı
• başlangıç ​​değeri x
• Sonra polinomun 3 kısmı

Örnek çıktı:

Command line: 8 2.3 0.1 -2.3 -4
 59.30772

Clojure, 66 bayt

#(nth(iterate(fn[v](apply +(map *(iterate(partial * v)1)%3)))%2)%)

Tam örnek:

(def f #(nth(iterate(fn[v](apply +(map *(iterate(partial * v)1)%3)))%2)%))
(f 10 2.3 [-4 -2.3 0.1])
; 3976.0831439050253

Bir işlev oluşturmak 26 bayttır:

#(apply comp(repeat % %2))

(def f #(apply comp(repeat % %2)))
((f 10 #(apply + (map * [-4 -2.3 0.1] (iterate (partial * %) 1)))) 2.3)
; 3976.0831439050253

Japt , 18 bayt

Oldukça açık, teneke üzerinde meydan okuma ne diyor.

o r_VË*ZpVÊ-EÉÃx}W
o                  // Take `n` and turn it into a range [0,n).
  r_            }W // Reduce over the range with initial value of `x`.
    VË             // On each iteration, map over `p`, yielding the item
      *Z           // times the current reduced value
        pVÊ-EÉ     // to the correct power,
              Ãx   // returning the sum of the results.

Sırayla girişleri Alır n, p, x.

Çevrimiçi deneyin!