Cho hàm đa thức f (ví dụ như danh sách p các hệ số thực theo thứ tự tăng dần hoặc giảm dần), một số nguyên n không âm và giá trị thực x , trả về:

   f  ⁿ ( x )

tức là giá trị của f ( f ( f ( f f ( x ) '))) cho n ứng dụng của f trên x .

Sử dụng độ chính xác hợp lý và làm tròn.

Các giải pháp lấy f làm danh sách các hệ số có thể sẽ thú vị nhất, nhưng nếu bạn có thể coi f là một hàm thực tế (do đó giảm thách thức này thành "áp dụng một hàm n lần"), hãy thoải mái đưa nó vào sau giải pháp không tầm thường của bạn.

Ví dụ trường hợp

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

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

p  = [0.1,-2.3,-4]hoặc f  = 0.1x^2-2.3x-4,  n  = 0,  x  = 2.3:  f  ⁰ (2.3) =2.3

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

p  = [0.1,-2.3,-4]hoặc f  = 0.1x^2-2.3x-4,  n  = 2,  x  = 2.3:  f  ² (2.3) =23.8258

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

p  = [0.1,-2.3,-4]hoặc f  = 0.1x^2-2.3x-4,  n  = 4,  x  = 2.3:  f  ⁴ (2.3) =1.08768

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

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

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

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

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

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

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

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

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

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

p  = [-0.1,2.3,4]hoặc 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]hoặc 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]hoặc f  = 0.02x^4-0.01x^2-0.05,  n  = 100,  x  = 0.1:  f  ¹⁰⁰ (0,1) =-0.0500249

Octave , 49 byte

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

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

Hoặc, lấy hệ số:

Octave , 75 57 byte

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

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

Một lời cảm ơn đặc biệt cho Suever tại StackOverflow, cho câu trả lời này một thời gian trước cho một câu hỏi của tôi, chứng minh rằng một hàm ẩn danh đệ quy là có thể.

Điều này xác định một hàm ẩn danh, là một trình bao bọc cho một hàm ẩn danh đệ quy ; một cái gì đó không phải là một khái niệm Octave bản địa và đòi hỏi một số chỉ mục mảng ô ưa thích.

Như một phần thưởng, phiên bản thứ hai là một bài học hay về phạm vi biến trong Octave. Tất cả các trường hợp rcó thể được thay thế một cách hợp pháp f, sau đó đơn giản ghi đè lên hiện tại ftrong phạm vi cục bộ nhất (tương tự chon )

Giải trình

@(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`.

Chìa khóa cho điều này là các hàm ẩn danh không được đánh giá khi chúng được xác định. Vì vậy, @()cái có vẻ hơi thừa vì nó định nghĩa một hàm ẩn danh được gọi ()trực tiếp sau đó, thực sự rất cần thiết. Nó không được gọi trừ khi nó được chọn bởi câu lệnh lập chỉ mục.

Octave , 39 byte (cách nhàm chán)

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

Chỉ cần cho đầy đủ, giải pháp Octave với bytecount ngắn nhất. Ngáp .

Toán học, 56 47 28 byte

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

\[Function] mất 3 byte trong UTF-8.

Lấy tham số theo thứ tự p,x,n.

p (tham số 1) là theo thứ tự tăng dần của mức độ.

Rõ ràng nếu fcó thể được coi là một chức năng thì điều này có thể được giảm xuống chỉ còn Nest.

Husk , 5 byte

←↓¡`B

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

Ý tưởng chính ở đây là việc đánh giá một đa thức tại một điểm x tương đương với việc thực hiện chuyển đổi cơ sở từ cơ sở x .

Bkhi được cung cấp một cơ sở và một danh sách các chữ số thực hiện chuyển đổi cơ sở. Ở đây chúng tôi sử dụng phiên bản lật của nó, để lấy danh sách các chữ số đầu tiên và áp dụng một phần chức năng này cho nó. Chúng ta có được một hàm tính giá trị của đa thức đã cho tại một điểm, phần thứ hai của giải pháp này liên quan đến việc lặp lại hàm này với số lần chính xác:

Husk , 3 byte

←↓¡

¡ là hàm "lặp", nó lấy một hàm và một điểm bắt đầu và trả về danh sách vô hạn các giá trị thu được khi lặp lại hàm.

↓ lấy một số (đối số thứ ba của thử thách này) và loại bỏ nhiều yếu tố từ đầu danh sách.

← trả về phần tử đầu tiên của danh sách kết quả.

Pari / GP , 31 byte

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

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

Ruby , 42 byte

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

C là danh sách các hệ số theo thứ tự giảm dần

Phiên bản tầm thường, trong đó f là hàm lambda ( 26 byte ):

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

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

JavaScript (ES6),  52 49 44  42 byte

Đã lưu 5 byte nhờ GB và 2 byte nữa nhờ Neil

Đưa đầu vào theo cú pháp currying như (p)(n)(x), trong đó p là danh sách các hệ số theo thứ tự giảm dần.

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

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

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 byte

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

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

Lấy đa thức là một danh sách các hệ số của các lũy thừa tăng dần.

Giải trình

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 byte

-1 byte nhờ Erik the Outgolfer

sF³gݨm*O

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

Lấy x làm đối số thứ nhất, n là thứ hai và p theo thứ tự tăng dần là thứ ba.

Giải trình

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 byte

((!!).).iterate

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

Cảm ơn hoàn toàn vì đã loại bỏ 11 byte cho cả hai giải pháp

Điều này định nghĩa một hàm ngầm định lấy một hàm làm đối số thứ nhất và nlà đối số thứ hai của nó và kết hợp hàm đó với nthời gian của chính nó . Điều này sau đó có thể được gọi với một đối số xđể có được giá trị cuối cùng. Nhờ vào phép thuật của cà ri, điều này tương đương với một hàm lấy ba đối số.

Lấy danh sách các hệ số thay vì đối số hàm:

Haskell , 53 byte

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

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

Mã này giống như đoạn mã trên, nhưng được tạo bởi hàm lambda chuyển đổi danh sách các hệ số thành hàm đa thức. Các hệ số được lấy theo thứ tự ngược lại từ các ví dụ - như các quyền hạn tăng dần của x.

APL (Dyalog) , 20 9 byte

{⊥∘⍵⍣⎕⊢⍺}

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

Điều này lấy xlàm đối số bên trái, các hệ số của hàm làm đối số bên phải vàn từ STDIN.

Nhìn lại điều này sau nhiều thời gian, tôi nhận ra rằng tôi có thể đơn giản hóa việc tính toán bằng cách sử dụng chuyển đổi cơ sở ⊥.

APL (Dyalog), 5 byte

Nếu chúng ta có thể lấy hàm làm hàm APL của Dyalog, thì đây có thể là 5 byte.

⎕⍣⎕⊢⎕

Lấy x, nvà sau đó là chức năng như đầu vào từ STDIN.

R , 96 58 55 52 byte

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

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

Giải trình:

seq(p)tạo danh sách 1, 2, ..., length(p)khi plà vectơ, seq(p)-1số mũ của đa thức cũng vậy, do đó x^(seq(p)-1)tương đương với x^0(luôn bằng 1) , x^1, x^2, ...và tính toán một sản phẩm dấu chấm %*%với việc pđánh giá đa thức tạix .

Ngoài ra, nếu Pđược coi là một hàm, thì đây sẽ là 38 byte:

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

Và tất nhiên chúng ta có thể luôn luôn tạo ra PbởiP=function(a)function(x)sum(x^(seq(a)-1)*a)

Thạch , 10 byte

*⁹LḶ¤×⁹Sµ¡

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

Lấy x, hệ số theo thứ tự tăng dần, n theo thứ tự này.

4 byte

⁹v$¡

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

Đưa x, liên kết Jelly (có thể cần được trích dẫn / thoát), n theo thứ tự này.

Python 3 , 70 69 byte

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

Lấy ptheo thứ tự tăng dần, tức là nếu plà [0, 1, 2]thì đa thức tương ứng là p(x) = 0 + 1*x + 2*x^2. Giải pháp đệ quy đơn giản.

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

C # (.NET Core) , 82 byte

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

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

Đưa ra một danh sách các hệ số theo thứ tự ngược lại từ các trường hợp thử nghiệm (tăng thứ tự?) Để chỉ số của chúng trong mảng bằng với công suất x nên được nâng lên.

Và phiên bản tầm thường trong 30 byte:

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

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

Đưa một đại biểu và áp dụng đệ quy n lần.

MATL , 11 byte

ii:"ZQ6Mw]&

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

Hơi ít thú vị hơn câu trả lời Octave của tôi, mặc dù tôi nghĩ rằng có một số cách xử lý đầu vào thông minh để đảm bảo n=0hoạt động như mong đợi.

Julia 0,6.0 (78 byte)

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

Giải thích:

Gói đa thức là khá tự giải thích: nó tạo ra đa thức. Sau đó, nó là một đệ quy khá cơ bản.

Để có đa thức: -4.0 - 2.3 * x + 0.1 * x ^ 2, đầu vào aphải như thếa = [-4, -2.3, 0.1]

Tiên đề, 91 byte

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)

thụt lề

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

đầu vào cho đa thức g nó là một danh sách các số ngược lại với ví dụ về bài tập. ví dụ

[1,2,3,4,5]  

nó sẽ đại diện cho chính trị

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

kiểm tra:

(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 byte

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

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

Một phiên bản tầm thường:

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

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

Nó nhận giá trị xtừ luồng.

C ++ 14, 71 byte

Là lambda chưa được đặt tên chung, trở lại thông qua xThông số:

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

Ungolfed và 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 byte

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

Có đầu vào như

• Số lần lặp lại
• giá trị bắt đầu của x
• Sau đó là 3 phần của đa thức

Đầu ra mẫu:

Command line: 8 2.3 0.1 -2.3 -4
 59.30772

Clojure, 66 byte

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

Ví dụ đầy đủ:

(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

Soạn một hàm là 26 byte:

#(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 byte

Khá đơn giản, làm những gì thách thức nói trên tin.

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.

Đưa đầu vào theo thứ tự n, p, x.

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