다항 함수 f (예 : 오름차순 또는 내림차순의 실제 계수 목록 p ), 음이 아닌 정수 n 및 실수 x가 주어지면 다음을 반환합니다.

   F  ^N ( X )

즉, 값 F ( F ( F (... F ( X 용) ...))) N 의 애플리케이션 F 에 X .

적당한 정밀도와 반올림을 사용하십시오.

f 를 계수 목록으로 취하는 솔루션이 가장 흥미로울 것입니다. 그러나 f 를 실제 함수로 취할 수있는 경우 (이는 "사소한 함수 n 번" 에 대한이 문제를 줄임 ) 자유롭게 포함하십시오. 사소한 해결책 후에.

사례

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

옥타브 , 49 바이트

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

온라인으로 사용해보십시오!

또는 계수를 복용 :

옥타브 , 75 57 바이트

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

온라인으로 사용해보십시오!

이상에 StackOverflow에서 Suever에 대한 특별 감사에 대한 이 답변 익명의 순환 기능이 가능하다는 것을 증명하는 내 질문에 몇 시간 전에.

재귀 익명 함수 의 래퍼 인 익명 함수를 정의합니다 . 네이티브 옥타브 개념이 아니며 멋진 셀 배열 인덱싱이 필요합니다.

보너스로 두 번째 버전은 Octave의 변수 범위 지정에 대한 훌륭한 교훈입니다. 의 모든 인스턴스 r는 합법적으로로 대체 될 수 있으며 f, 이는 f가장 로컬 범위에있는 기존 을 덮어 씁니다 (와 유사 n).

설명

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

이것의 핵심은 익명 함수 가 정의 될 때 평가 되지 않는다는 것 입니다. 따라서 바로 @()호출되는 익명 함수를 정의하므로 약간 불필요하게 보이는 ()은 실제로 필요합니다. 인덱싱 문에서 선택 하지 않으면 호출 되지 않습니다 .

옥타브 , 39 바이트 (지루한 방식)

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

완전성을 위해 가장 짧은 바이트 수를 가진 Octave 솔루션. 하품. .

매스 매 티카, 56 47 28 바이트

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

\[Function] UTF-8에서 3 바이트를 사용합니다.

순서대로 매개 변수를 취하십시오 p,x,n.

p (파라미터 1)은 차수가 증가합니다.

분명히 f함수로 취할 수 있다면 이 값은로 줄일 수 있습니다 Nest.

껍질 , 5 바이트

←↓¡`B

온라인으로 사용해보십시오!

여기서 핵심 아이디어는 x 지점에서 정치를 평가하는 것은 기본 x 에서 기본 변환을 수행하는 것과 같습니다 .

B기본과 자릿수가 주어지면 기본 변환을 수행합니다. 여기에서 우리는 먼저 숫자 목록을 가져 와서이 기능을 부분적으로 적용하기 위해 뒤집힌 버전을 사용합니다. 우리는 주어진 다항식의 값을 한 지점에서 계산하는 함수를 얻습니다.이 솔루션의 두 번째 부분은이 함수를 올바른 횟수만큼 반복 처리합니다.

껍질 , 3 바이트

←↓¡

¡ "iterate"함수이며 함수와 시작점을 가져 와서 함수를 반복하여 얻은 무한한 값 목록을 반환합니다.

↓ 숫자 (이 도전의 세 번째 주장)를 취하고 목록의 시작 부분에서 많은 요소를 삭제합니다.

← 결과 목록의 첫 번째 요소를 반환합니다.

Pari / GP , 31 바이트

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

온라인으로 사용해보십시오!

루비 , 42 바이트

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

C는 내림차순으로 계수 목록입니다

간단한 버전. 여기서 f는 람다 함수 ( 26 바이트 )입니다.

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6),  52 49 44  42 바이트

GB 덕분에 5 바이트 , Neil 덕분에 2 바이트 더 절약

같은 구문을 무두질에서 입력을 받고, (p)(n)(x)여기서, p는 내림차순 계수들의 목록이다.

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

테스트 사례

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 바이트

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

온라인으로 사용해보십시오!

다항식을 오름차순 계수 목록으로 취합니다.

설명

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 바이트

Outgolfer Erik 덕분에 -1 바이트

sF³gݨm*O

온라인으로 사용해보십시오!

x를 첫 번째 인수로, n을 두 번째로, p를 오름차순으로 세 번째로 취합니다.

설명

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

하스켈 , 15 바이트

((!!).).iterate

온라인으로 사용해보십시오!

두 솔루션 모두에서 11 바이트 떨어져 완전히 인간적 덕분에

이것은 함수를 첫 번째 인수와 n두 번째 인수로 취하는 암묵적 함수를 정의 하고 해당 함수를 자체 n시간으로 구성합니다 . 그런 다음 인수와 함께 호출 x하여 최종 값을 얻을 수 있습니다. 카레의 마술 덕분에 이것은 세 가지 인수를 취하는 하나의 함수와 같습니다.

함수 인수 대신 계수 목록을 가져옵니다.

하스켈 , 53 바이트

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

온라인으로 사용해보십시오!

이것은 위의 코드와 동일하지만 계수 목록을 다항 함수로 변환하는 람다 함수로 구성됩니다. 계수는 예제의 역순으로 오름차순으로 취 x합니다.

APL (Dyalog) , 20 9 바이트

{⊥∘⍵⍣⎕⊢⍺}

온라인으로 사용해보십시오!

이것은 x왼쪽 인수로, 함수 계수를 오른쪽 인수로, nSTDIN에서 가져옵니다.

오랜 시간이 지난 후에 이것을 되돌아 보면 기본 변환을 사용하여 계산을 단순화 할 수 있음을 깨달았습니다 ⊥.

APL (Dyalog), 5 바이트

함수를 Dyalog APL 함수로 사용할 수 있으면 5 바이트가 될 수 있습니다.

⎕⍣⎕⊢⎕

취하고 x, n다음 STDIN로부터 입력으로서의 기능을하고.

R , 96 58 55 52 바이트

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

온라인으로 사용해보십시오!

설명:

seq(p)리스트 생성 하며,이 벡터이다 따라서, 다항식의 지수이다 동등 (항상 1과 동일) 및 내적 계산 과 들을 평가에서 다항식1, 2, ..., length(p)pseq(p)-1x^(seq(p)-1)x^0, x^1, x^2, ...%*%px .

또한 P함수로 사용하면 38 바이트가됩니다.

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

그리고 우리는 물론 항상 생성 할 수 있습니다 P에 의해P=function(a)function(x)sum(x^(seq(a)-1)*a)

젤리 , 10 바이트

*⁹LḶ¤×⁹Sµ¡

온라인으로 사용해보십시오!

이 순서대로 x, 계수를 오름차순으로 취합니다.

4 바이트

⁹v$¡

온라인으로 사용해보십시오!

Takes x, Jelly link (may need to be quoted/escaped), n in this order.

Python 3, 70 69 bytes

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

Takes p in ascending order, i.e. if p is [0, 1, 2] then the corresponding polynomial is p(x) = 0 + 1*x + 2*x^2. Simple recursion solution.

Try it online!

C# (.NET Core), 82 bytes

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

Try it online!

Takes a list of coefficients in the opposite order from the test cases (increasing order?) so that their index in the array is equal to the power x should be raised to.

And the trivial version in 30 bytes:

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

Try it online!

Takes a delegate and applies it recursively n times.

MATL, 11 bytes

ii:"ZQ6Mw]&

Try it online!

Slightly less interesting than my Octave answer, although I think there's some clever juggling of inputs to make sure n=0 works as expected.

Julia 0.6.0 (78 bytes)

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

Explainations:

The package Polynomials is pretty self explanatory: it creates polynomials. After that it's a pretty basic recursion.

In order to have a polynomial: -4.0 - 2.3*x + 0.1*x^2 the input a must be like a = [-4, -2.3, 0.1]

Axiom, 91 bytes

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)

indented

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

the input for polynomy g it is one list of numbers in the reverse of the example of exercise. for example

[1,2,3,4,5]  

it would represent the polinomy

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

test:

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

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

Try it online!

A trivial version:

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

Try it online!

It takes the the value for x from the stream.

C++14, 71 bytes

As generic unnamed lambda, returning via the x Parameter:

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

Ungolfed and 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 bytes

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

Takes inputs as

• Number of iterations
• starting value of x
• Then the 3 parts of the polynomial

Sample output:

Command line: 8 2.3 0.1 -2.3 -4
 59.30772

Clojure, 66 bytes

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

Full example:

(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

Composing a function is 26 bytes:

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

Pretty straightforward, does what the challenge says on the 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.

Takes inputs in order n, p, x.

Try it online!