Đa thức Ch Quashev là một họ của đa thức trực giao xuất hiện ở tất cả các nơi trong toán học, và chúng có rất nhiều tính chất khá thú vị. Một đặc điểm của chúng là chúng là các đa thức duy nhất thỏa mãn .Tn(cos(x)) = cos(n*x)

Thử thách

Cho một số nguyên không âm n, bạn nên xuất nđa thức Chithershev. .Tn(x)

Định nghĩa

Các n-thứ Đa thức Chebyshev được đưa ra bằng cách làm theo ba đệ quy hạn:

T0(x) = 1
T1(x) = x
Tn+1(x) = 2*x*Tn(x) - Tn-1(x)

Chi tiết

Nếu ngôn ngữ của bạn có loại đa thức riêng, bạn có thể sử dụng loại đó làm đầu ra, nếu không, bạn nên xuất danh sách các hệ số theo thứ tự tăng dần hoặc giảm dần hoặc dưới dạng chuỗi đại diện cho đa thức.

Ví dụ

T0(x) = 1
T1(x) = x 
T2(x) = 2x^2 - 1
T3(x) = 4x^3 - 3 x
T4(x) = 8x^4 - 8x^2 + 1
T5(x) = 16x^5 - 20x^3 + 5x
T10(x) = 512x^10 - 1280x^8 + 1120x^6 - 400x^4 + 50x^2 - 1

Trong định dạng danh sách mức độ giảm dần chúng tôi sẽ nhận được và ở định dạng mức độ tăng dần chúng tôi sẽ nhận đượcT3(x) = [4,0,-3,0]T3(x) = [0,-3,0,4]

Toán học, 15 byte

#~ChebyshevT~x&

Tất nhiên, Mathicala có một nội dung.

Nếu một hình thức đầu vào thay thế được cho phép (10 byte):

ChebyshevT

lấy một số nguyên nvà một biến.

Octave , 39 byte

@(n)round(2^n/2*poly(cos((.5:n)/n*pi)))

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

Giải trình

cos((.5:n)/n*pi)xây dựng một vectơ với các gốc của đa thức , được cho bởi

polyđưa ra đa thức monic với các gốc đó. Nhân với 2^n/2tỷ lệ các hệ số theo yêu cầu. roundđảm bảo rằng các kết quả là số nguyên mặc dù có độ chính xác bằng số.

Pari / GP , 12 byte

Vâng, một nội dung. Ngắn hơn Mathicala.

polchebyshev

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

Không có nội dung:

Pari / GP , 34 byte

f(n)=if(n<2,x^n,2*x*f(n-1)-f(n-2))

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

Haskell , 62 byte

t n|n<2=1:[0|n>0]|x<-(*2)<$>t(n-1)++[0]=zipWith(-)x$0:0:t(n-2)

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

flawr lưu một byte.

CJam (21 byte)

1a2,qi{0X$+2f*@.-}*;`

Đây là một chương trình đầy đủ: tương đương như một khối ẩn danh có cùng độ dài:

{1a2,@{0X$+2f*@.-}*;}

Bản demo trực tuyến

Python + SymPy , 66 byte

from sympy.abc import*
T=lambda n:n<2and x**n or 2*x*T(n-1)-T(n-2)

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

Với đại diện hệ số giảm dần

from sympy import*
x=symbols('x')
T=lambda n:n<2and x**n or expand(2*x*T(n-1)-T(n-2))

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

SageMath, 25 byte

lambda n:chebyshev_T(n,x)

Dùng thử trực tuyến

MATL , 17 byte

lFTi:"0yhEbFFh-]x

Các hệ số là đầu ra theo thứ tự tăng dần của mức độ.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Đối với đầu vào n , mã áp dụng quan hệ đệ quy n lần. Hai đa thức gần đây nhất luôn được giữ trên ngăn xếp. Khi một đa thức mới được tính toán, cái cũ nhất sẽ bị loại bỏ.

Cuối cùng, đa thức cuối cùng thứ hai được hiển thị (đa thức cuối cùng bị xóa), vì chúng ta đã thực hiện quá nhiều lần lặp.

l        % Push 1
FT       % Push [0 1]. These are the first two polynomials
i:"      % Input n. Do the following n times
  0      %   Push 0
  y      %   Duplicate most recent polynomial
  h      %   Concatenate: prepends 0 to that polynomial
  E      %   Multiply coefficients by 2
  b      %   Bubble up. This moves second-most recent polynomial to top
  FF     %   Push [0 0]
  h      %   Concatenate: appends [0 0] to that polynomial
  -      %   Subtract coefficients
]        % End
x        % Delete. Implicitly display

Thạch , 18 byte

Cr1µ’ßḤ0;_’’$ß$µỊ?

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

Trả về một danh sách các hệ số theo thứ tự tăng dần.

Có một giải pháp khác cho 17 byte với điểm không chính xác.

RḤ’÷Ḥ-*ḞÆṛæ«’µ1Ṡ?

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

Giải trình

Cr1µ’ßḤ0;_’’$ß$µỊ?  Input: integer n
                Ị   Insignificant - abs(n) <= 1
                    If true, n = 0 or n = 1
   µ                  Monadic chain
C                       Complement, 1-x
 r1                     Range to 1
                    Else
               µ      Monadic chain
    ’                   Decrement
     ß                  Call itself recursively
      Ḥ                 Double
       0;               Prepend 0
         _              Subtract with
            $             Monadic chain
          ’’                Decrement twice
              $           Monadic chain
             ß              Call itself recursively

Đa thức Ruby + , 59 58 + 13 = 72 71 byte

Sử dụng -rpolynomialcờ.

f=->n{x=Polynomial.new 0,1;n<2?[1,x][n]:2*x*f[n-1]-f[n-2]}

J , 33 byte

(0>.<:)2&*1:p.@;9:o._1^+:%~1+2*i.

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

Giả sử rằng độ không chính xác của dấu phẩy động được chấp nhận và tạo biểu tượng cảm xúc (0>.<:)

Đối với 41 byte , có một giải pháp khác là tránh nổi.

(0&,1:)`(-&2((-,&0 0)~2*0&,)&$:<:)@.(>&1)

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

Python 2 , 79 byte

f=lambda n:n>1and[2*a-b for a,b in zip([0]+f(n-1),f(n-2)+[0,0])]or range(1-n,2)

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

Tiên đề, 40 byte

f(n,x)==(n<2=>x^n;2*x*f(n-1,x)-f(n-2,x))

các kết quả

(9) -> for i in [0,1,2,3,4,5,10] repeat output ["f(y)",i,"=", f(i,y)]
   ["f(y)",0,"=",1]
   ["f(y)",1,"=",y]
                   2
   ["f(y)",2,"=",2y  - 1]
                   3
   ["f(y)",3,"=",4y  - 3y]
                   4     2
   ["f(y)",4,"=",8y  - 8y  + 1]
                    5      3
   ["f(y)",5,"=",16y  - 20y  + 5y]
                      10        8        6       4      2
   ["f(y)",10,"=",512y   - 1280y  + 1120y  - 400y  + 50y  - 1]
                                                               Type: Void

có thể định nghĩa một luật thay thế cho công thức trong Axiom sử dụng hàm f () trên để mở rộng cos (n * x) trong đó n là một số nguyên

(9) -> o:=rule cos(n*%y)==f(n,cos(%y))
   (9)  cos(%y n) == 'f(n,cos(%y))
                    Type: RewriteRule(Integer,Integer,Expression Integer)
                                                              Time: 0 sec
(10) -> b:=o cos(20*x)
   (10)
                 20                18                16                14
     524288cos(x)   - 2621440cos(x)   + 5570560cos(x)   - 6553600cos(x)
   +
                  12                10               8              6
     4659200cos(x)   - 2050048cos(x)   + 549120cos(x)  - 84480cos(x)
   +
               4            2
     6600cos(x)  - 200cos(x)  + 1
                                                 Type: Expression Integer
                       Time: 0.48 (EV) + 0.02 (OT) + 0.10 (GC) = 0.60 sec

C # (.NET Core) , 126 byte

f=n=>n==0?new[]{1}:n==1?new[]{0,1}:new[]{0}.Concat(f(n-1)).Select((a,i)=>2*a-(i<n-1?f(n-2)[i]:0)).ToArray();

Số lượng byte cũng bao gồm:

using System.Linq;

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

Hàm trả về đa thức dưới dạng một mảng các hệ số theo thứ tự tăng dần (từ x^0đếnx^n )

Giải trình:

f = n =>                          // Create a function taking one parameter (int)
    n == 0 ? new[] { 1 } :        // If it's 0, return collection [1]
    n == 1 ? new[] { 0, 1 } :     // If it's 1, return collection [0,1] (so x + 0)
    new[] { 0 }                   // Else create new collection, starting with 0
        .Concat(f(n - 1))         // Concatenate with f(n-1), effectively multiplying polynomial by x
        .Select((a, i) => 2 * a - (i < n - 1 ? f(n - 2)[i] : 0))
                                  // Multiply everything by 2 and if possible, subtract f(n-2)
        .ToArray();               // Change collection to array so we have a nice short [] operator
                                  // Actually omitting this and using .ElementAt(i) is the same length, but this is my personal preference

JavaScript (ES6), 65 byte

f=n=>n?n>1?[0,...f(n-1)].map((e,i)=>e+e-(f(n-2)[i]||0)):[0,1]:[1]

Không hiệu quả cho lớn n. Thú vị nhưng đáng buồn cũng không hiệu quả:

n=>[...Array(n+1)].map(g=(m=n,i)=>i<0|i>m?0:m<2?i^m^1:g(m-1,i-1)*2-g(m-2,i))

Rất hiệu quả cho 68 byte:

f=(n,a=[1],b=[0,1])=>n?f(n-1,b,[0,...b].map((e,i)=>e+e-(a[i]||0))):a

Trả về một mảng các hệ số theo thứ tự tăng dần.