Многочлены Чебыш (ва (चेबिशेव पॉलिनॉमिअल्स)

26

चेबिशेव पोलिनॉमिअल्स ऑर्थोगोनल पॉलीओनियम्स का एक परिवार है जो गणित में सभी प्रकार के स्थानों में पॉप अप करते हैं, और उनके पास काफी दिलचस्प गुण हैं। उनमें से एक लक्षण यह है कि वे अद्वितीय बहुपद हैं जो संतुष्ट करते हैं ।Tn(cos(x)) = cos(n*x)

चुनौती

एक nonnegative पूर्णांक को देखते हुए n, आपको n-th Chebyshev Polynomial आउटपुट करना चाहिए । ।Tn(x)

परिभाषा

nमई के Chebyshev बहुपद तीन अवधि प्रत्यावर्तन का पालन करते हुए दी गई है:

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

विवरण

यदि आपकी भाषा में एक मूल बहुपद है, तो आप उस एक आउटपुट के रूप में उपयोग कर सकते हैं, अन्यथा आपको आरोही या अवरोही क्रम में गुणांक की एक सूची का उत्पादन करना चाहिए, या एक बहुपद का प्रतिनिधित्व करने वाले स्ट्रिंग के रूप में करना चाहिए।

उदाहरण

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

अवरोही डिग्री सूची प्रारूप में हमें मिलेगा और आरोही डिग्री प्रारूप में हमें मिलेगाT3(x) = [4,0,-3,0]T3(x) = [0,-3,0,4]

code-golf  math  sequence  polynomials  recursion 
— flawr
स्रोत
यदि मैं एक सूची का उत्पादन करता हूं, तो क्या मैं 0 1(यानी 0*x+1) आउटपुट कर सकता हूं T_0?
— लुइस मेंडो
जब तक मोनोमेयल्स का क्रम सुसंगत है जो ठीक है!
— 20
@flawr पोलीयनोम 2*x*(2*x**2 - 1) - xसपोर्टिव लैंग के लिए 3 के आउटपुट के रूप में ठीक है, या क्या हमें desc coeffs के रूप में प्रतिनिधित्व की आवश्यकता है?
— एरियल
11
— मेगो
2
क्या फ्लोटिंग-पॉइंट गलतियाँ स्वीकार्य हैं? यानीT_5(n) = [0, 5, 3.55271e-15, -20, 0, 16]
— मील

जवाबों:

15

मैथेमेटिका, 15 बाइट्स

#~ChebyshevT~x&

बेशक, मैथेमेटिका में एक बिलिन है।

यदि एक वैकल्पिक इनपुट फॉर्म की अनुमति है (10 बाइट्स):

ChebyshevT

एक पूर्णांक nऔर एक चर लेता है ।

— जंगहवान मिन
स्रोत
3
अनुमान लगाया नहीं जा सका, हुह। : पी
— हायपरनेट्रिनो
14

ऑक्टेव , 39 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

cos((.5:n)/n*pi)द्वारा दी गई बहुपद की जड़ों के साथ एक वेक्टर बनाता है

यहाँ छवि विवरण दर्ज करें

polyउन जड़ों के साथ मोनोनिक बहुपद देता है। से गुणा 2^n/2की आवश्यकता के रूप में तराजू गुणांक। roundयह सुनिश्चित करता है कि परिणाम संख्यात्मक परिशुद्धता के बावजूद पूर्णांक हैं।

— लुइस मेंडो
स्रोत
1
चतुर हमेशा की तरह :)
— दोष
11

परी / जीपी , 12 बाइट्स

हाँ, एक बिलिन। गणितज्ञ की तुलना में छोटा।

polchebyshev

इसे ऑनलाइन आज़माएं!

बिना बिलिन:

परी / जीपी , 34 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— alephalpha
स्रोत
क्या polchebyshevकेवल एक इनपुट लेता है और बहुपद लौटाता है?
— जुंगह्वान मिन
@ जुंगहवनम यस। xडिफ़ॉल्ट अनिश्चित है।
— alephalpha
10

हास्केल , 62 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बाइट ने बाइट को बचा लिया।

— लिन
स्रोत
यह बहुत सुरुचिपूर्ण है! (मैं zipWithवेक्टर ऑपरेशन के बारे में भूल जाता हूं ।)
— 10
1
मुझे लगता है कि आप गार्ड का उपयोग करके एक और बाइट को भी बचा सकते हैं: t n|n<2=1:[0|n>0]|x<-(*2)<$>t(n-1)++[0]=zipWith(-)x$0:t(n-2)इस तरह आप अंतिम पंक्ति में कोष्ठक की मध्य जोड़ी को हटा सकते हैं :)
— त्रुटी
मुझे लगता है कि आपको बदलना 0:होगा 0:0:- ओपी ने इस तरह की जीरो को छोड़ दिया।
— अर्जन जोहान्सन
5

MATL , 17 बाइट्स

lFTi:"0yhEbFFh-]x

गुणांक डिग्री के बढ़ते क्रम में आउटपुट हैं।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

इनपुट n के लिए , कोड पुनरावर्ती संबंध n बार लागू होता है । दो सबसे हाल के बहुपदों को हमेशा स्टैक पर रखा जाता है। जब एक नई बहुपद की गणना की जाती है, तो सबसे पुराना हटा दिया जाता है।

अंत में, दूसरा-अंतिम बहुपद प्रदर्शित होता है (अंतिम बहुपद हटा दिया जाता है), जैसा कि हमने कई पुनरावृत्तियों को किया है।

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
— लुइस मेंडो
स्रोत
4

जेली , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आरोही क्रम में गुणांक की एक सूची देता है।

फ्लोटिंग-पॉइंट अशुद्धियों के साथ 17 बाइट्स के लिए एक और समाधान है।

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

इसे ऑनलाइन आज़माएं!

व्याख्या

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
— मील की दूरी पर
स्रोत
— लीकी नून
2

जे , 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मान लेता है कि फ्लोटिंग-पॉइंट गलतियाँ स्वीकार्य हैं और इमोजी बनाती हैं (0>.<:)

के लिए 41 बाइट्स , वहाँ एक और समाधान है कि तैरता से बचा जाता है है।

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

इसे ऑनलाइन आज़माएं!

— मील की दूरी पर
स्रोत
2

Axiom, 40 बाइट्स

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

परिणाम

(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

यह संभव है कि एफ के ऊपर एऑसोम उपयोग में सूत्र के लिए एक प्रतिस्थापन कानून को परिभाषित किया जाए () * विस्तार के लिए cos (n * x) जहां 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
— RosLuP
स्रोत
1

C # (.NET Core) , 126 बाइट्स

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

बाइट काउंट में ये भी शामिल हैं:

using System.Linq;

इसे ऑनलाइन आज़माएं!

समारोह रिटर्न आरोही क्रम में गुणांक की एक सरणी के रूप में बहुपद (से x^0करने के लिए x^n)

स्पष्टीकरण:

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
— ग्रेज़गोरज़ पुलावस्की
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 65 बाइट्स

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

बड़े के लिए अक्षम n। दिलचस्प लेकिन दुखद भी अक्षम:

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

68 बाइट्स के लिए बहुत कुशल:

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

आरोही क्रम में गुणांक का एक सरणी देता है।

— नील
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.