असतत रूपांतरण या बहुपद गुणन

Question

पूर्णांकों की दो गैर-रिक्त सूचियों को देखते हुए , आपके जमा को गणना करना चाहिए और दो का असतत संलयन वापस करना चाहिए । दिलचस्प बात यह है कि यदि आप सूची तत्वों को बहुपद के गुणांक के रूप में मानते हैं, तो दो सूचियों का दृढ़ीकरण दो बहुपद के उत्पाद के गुणांक का प्रतिनिधित्व करता है।

परिभाषा

सूचियों A=[a(0),a(1),a(2),...,a(n)]और B=[b(0),b(1),b(2),...,b(m)](सेटिंग a(k)=0 for k<0 and k>nऔर b(k)=0 for k<0 and k>m) को देखते हुए दोनों के दृढ़ संकल्प को A*B=[c(0),c(1),...,c(m+n)]जहां के रूप में परिभाषित किया गया हैc(k) = sum [ a(x)*b(y) for all integers x y such that x+y=k]

नियम

• आपकी भाषा के लिए किसी भी सुविधाजनक इनपुट और आउटपुट स्वरूपण की अनुमति है।
• कनवल्शन के लिए बिल्ट-इन, कन्वेंशन मैट्रिसेस बनाने, सहसंबंध और बहुपद गुणन की अनुमति नहीं है।

उदाहरण

[1,1]*[1] = [1,1]
[1,1]*[1,1] = [1,2,1]
[1,1]*[1,2,1] = [1,3,3,1]
[1,1]*[1,3,3,1] = [1,4,6,4,1]
[1,1]*[1,4,6,4,1] = [1,5,10,10,5,1]

[1,-1]*[1,1,1,1,1] = [1,0,0,0,0,-1]
[80085,1337]*[-24319,406] = [-1947587115,7,542822]

Comments

विनिर्देश का तात्पर्य है कि लंबाई n, m का इनपुट लंबाई n + m - 1 के आउटपुट का उत्पादन करना चाहिए, लेकिन यह आपके परीक्षण के मामले में पकड़ नहीं रखता है [1,1]*[] = [], और संभवतः पकड़ नहीं सकता है []*[] = ?। खाली सूचियों पर वार्तालाप अच्छी तरह से परिभाषित नहीं है। मुझे लगता है कि आपको इस बात की गारंटी देनी चाहिए कि इनपुट सूची गैर-रिक्त हैं।

— एंडर्स कासोर्ग

@AndersKaseorg आप सही हैं, मैं इसे बदलूंगा।

— दोष

संबंधित: codegolf.stackexchange.com/q/67289/29325

— sergiol

Answer 1

जे, 10 8 बाइट्स

[:+//.*/

उपयोग:

ppc =: [:+//.*/    NB. polynomial product coefficients 
80085 1337 ppc _24319 406
_1947587115 7 542822

विवरण: कार्यक्रम दो सूचियों लेता है, एक गुणन तालिका बनाता है, फिर सकारात्मक विकर्णों पर संख्याओं को जोड़ता है।

Comments

बहुत चालाक दृष्टिकोण!

— लुइस मेंडो

आपको कोष्ठकों की गणना करने की आवश्यकता नहीं है। उनके अंदर की अभिव्यक्ति एक मौन क्रिया का मूल्यांकन करती है, जिसे एक चर को सौंपा जा सकता है।

— डेनिस

क्रियाविशेषण का महान उदाहरण!

— मीलों

Answer 2

MATL , 19 बाइट्स

PiYdt"TF2&YStpsw]xx

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

व्याख्या

यह दो आदानों के साथ एक ब्लॉक-विकर्ण मैट्रिक्स बनाता है, पहले को उलट देता है। उदाहरण के लिए, इनपुट के साथ [1 4 3 5], [1 3 2]मैट्रिक्स है

[ 5 3 4 1 0 0 0
  0 0 0 0 1 3 2 ]

प्रत्येक स्तंभ के उत्पाद की गणना करते हुए, पहली पंक्ति एक स्थिति को दाईं ओर स्थानांतरित करके, और सभी परिणामों को समेट कर कनवल्शन की प्रत्येक प्रविष्टि प्राप्त की जाती है।

सिद्धांत रूप में, शिफ्टिंग को बाईं ओर से शून्य के साथ पैडिंग किया जाना चाहिए। समान रूप से, परिपत्र स्थानांतरण का उपयोग किया जा सकता है, क्योंकि मैट्रिक्स में उपयुक्त प्रविष्टियों पर शून्य शामिल हैं।

उदाहरण के लिए, पहला परिणाम स्थानांतरित मैट्रिक्स से प्राप्त किया जाता है

[ 0 5 3 4 1 0 0
  0 0 0 0 1 3 2 ]

और इस प्रकार है 1*1 == 1। दूसरी से प्राप्त की है

[ 0 0 5 3 4 1 0
  0 0 0 0 1 3 2 ]

और इस प्रकार 4*1+1*3 == 7, आदि यह m+n-1बार किया जाना चाहिए , जहां mऔर nइनपुट लंबाई हैं। कोड m+nपुनरावृत्तियों के साथ एक लूप का उपयोग करता है (जो कुछ बाइट्स बचाता है) और अंतिम परिणाम को छोड़ देता है।

P          % Take first input (numeric vactor) implicitly and reverse it
i          % Take second input (numeric vactor) 
Yd         % Build diagonal matrix with the two vectors
t          % Duplicate
"          % For each column of the matrix
  TF2&YS   %   Circularly shift first row 1 step to the right
  t        %   Duplicate
  p        %   Product of each column
  s        %   Sum all those products
  w        %   Swap top two elements in stack. The shifted matrix is left on top
]          % End for
xx         % Delete matrix and last result. Implicitly display

Answer 3

हास्केल, 55 49 बाइट्स

(a:b)#c=zipWith(+)(0:b#c)$map(a*)c++[]#b
_#c=0<$c

एक ऑपरेटर को परिभाषित करता है #।

Comments

मुझे लगता है कि खाली आधार मामले की अनुमति देते हुए पैडिंग बिल्कुल आवश्यक लंबाई देने के लिए [0,0..]हो सकती (0<$b)है _#b=0<$b।

— xnor

@ एक्सनॉर दरअसल, जो 6 बाइट्स बचाता है।

— एंडर्स कासोर्ग

अब जब कि मैं अंत में आपके उत्तर को समझ गया हूं, तो मुझे कहना होगा कि यह सिर्फ इतना बहुत चालाक है! मैं प्रसन्न हूँ!

— 19

Answer 4

मतलाब / ऑक्टेव, 41 बाइट्स

@(p,q)poly([roots(p);roots(q)])*p(1)*q(1)

यह एक अनाम फ़ंक्शन को परिभाषित करता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल या यूज़ को असाइन करें ans।

इसे यहाँ आज़माएँ ।

व्याख्या

यह उन तथ्यों का शोषण करता है जो

• (संभवतः दोहराया) जड़ें बहुपद को उसके प्रमुख गुणांक तक चिह्नित करती हैं।
• दो बहुपद के उत्पाद में दोनों की जड़ें होती हैं।

कोड दो बहुपद (फंक्शन roots) की जड़ों की गणना करता है और उन्हें एक कॉलम ऐरे में समेटता है। इससे वह उत्पाद बहुपद के गुणांक को एक अग्रणी 1(फ़ंक्शन poly) के साथ प्राप्त करता है । अंत में परिणाम दो बहुपद के प्रमुख गुणांकों द्वारा गुणा किया जाता है।

Answer 5

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

@(p,q)ifft(fft([p q*0]).*fft([q p*0]))(1:end-1)

इसे यहाँ आज़माएँ ।

व्याख्या

असतत कनवल्शन (असतत समय) फूरियर रूपांतरण के गुणन से मेल खाती है। तो बहुपदों को गुणा करने का एक तरीका उन्हें रूपांतरित करना, रूपांतरित दृश्यों को गुणा करना और वापस रूपांतरित करना होगा।

यदि फूरियर ट्रांसफॉर्म के बजाय असतत फूरियर ट्रांसफॉर्म (डीएफटी) का उपयोग किया जाता है, तो परिणाम बहुपद गुणांक के मूल अनुक्रमों का गोलाकार रूपांतरण है। कोड इस मार्ग का अनुसरण करता है। मानक कनवल्शन के बराबर सर्कुलर कन्वेन्शन बनाने के लिए, सीक्वेंस ज़ीरो-पैडेड होते हैं और परिणाम को ट्रिम किया जाता है।

Comments

बेनाम: Damnit, मैं अभी भी बोना fft पर प्रतिबंध लगा दिया है, लेकिन अच्छी नौकरी!

— दोष

@flawr हां, मुझे लगता है कि हमने इस बारे में बात की है ...? :-P

— लुइस मेंडू

Answer 6

05AB1E , 18 17 बाइट्स

कोड

0Ev²¹g<Å0«y*NFÁ}+

व्याख्या

इसके पीछे सिद्धांत:

घुमाव के खोजने के लिए, का उदाहरण लेते हैं [1, 2, 3], [3, 4, 5]। हम पहले सरणी के मूल्यों को इस तरह उल्टा और सीधा रखते हैं:

3
2
1

अब, हम दूसरी सीढ़ी को सीढ़ी की तरह रखते हैं और इसे इसके द्वारा गुणा करते हैं:

3 ×       [3  4  5]
2 ×    [3  4  5]
1 × [3  4  5]

परिणाम में:

        9   12   15
    6   8   10
3   4   5

फिर, हम उन्हें जोड़ते हैं, जिसके परिणामस्वरूप:

        9   12   15
    6   8   10
3   4   5       

3   10  22  22   15

तो, दृढ़ संकल्प है [3, 10, 22, 22, 15]।

कोड ही:

हम का उपयोग कर कदम से इस कदम क्या करने जा रहे [1, 2, 3], [3, 4, 5]परीक्षण मामले के रूप में।

0Ev²¹g<Å0«y*NFÁ}+

हम पहले पुश करते हैं 0और फिर हम Eपहले इनपुट ऐरे को वेल्यू करते हैं। हम प्रत्येक तत्व का उपयोग करके नक्शा करते हैं v।

इसलिए, प्रत्येक तत्व के लिए, हम दूसरे सरणी को धक्का देते हैं ²और फिर पहली सरणी की लंबाई का उपयोग करते हुए ¹gइसे 1 (साथ <) घटाते हैं । हम इसे शून्य की एक सूची (लंबाई 1 सरणी - 1) शून्य के साथ एक सूची में परिवर्तित करते हैं , इसका उपयोग करते हुए Å0और इसे हमारी सूची में जोड़ते हैं। हमारा स्टैक अब इनपुट सूची में पहले आइटम के लिए इस तरह दिखता है:

[3, 4, 5, 0, 0]

हम इस सरणी को वर्तमान आइटम के साथ गुणा करते हैं, जिसके साथ किया जाता है y*। उसके बाद, हम धक्का देते हैं N, जो वर्तमान वस्तु (शून्य-अनुक्रमित) के सूचकांक को इंगित करता है और सरणी को घुमाता है जो कई बार सही उपयोग करता है FÁ}। अंत में, हम इसे अपने प्रारंभिक मूल्य ( 0) में जोड़ते हैं । तो, मूल रूप से जो किया जाता है वह निम्नलिखित है:

[0, 0, 9, 12, 15] +
[0, 6, 8, 10, 0] +
[3, 4, 5, 0, 0] =

[3, 10, 22, 22, 15]

जिसे बाद में छापा जाता है। CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

Answer 7

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

0;+
×'Ṛç/

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

यह काम किस प्रकार करता है

×'Ṛç/  Main link. Arguments: p, q (lists)

×'     Spawned multiplication; multiply each item of p with each item of q.
  Ṛ    Reverse the rows of the result.
   ç/  Reduce the rows by the helper link.


0;+    Helper link. Arguments: p, q (lists)

0;     Prepend a 0 to p.
  +    Perform vectorized addition of the result and q.

Comments

What‽ जेली J‽ से अधिक लंबी है जो कि परिभाषा से असंभव है!

— एडम

Answer 8

भूसी , 5 बाइट्स

mΣ∂Ṫ*

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

नोट: शून्य-बहुपद / खाली सूची की आपूर्ति करते समय, आपको इसके प्रकार (यानी। []:LN) को निर्दिष्ट करने की आवश्यकता है !

व्याख्या

mΣ∂Ṫ*  -- implicit inputs xs ys, for example: [1,-1] [1,1]
   Ṫ*  -- compute the outer product xsᵀ·ys: [[1,1],[-1,-1]]
  ∂    -- diagonals: [[1],[1,-1],[-1]]
mΣ     -- map sum: [1,0,1]

Answer 9

मतलाब, 33 बाइट्स

@(x,y)sum(spdiags(flip(x').*y),1)

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

इनपुट के सभी तत्व-वार उत्पादों का एक मैट्रिक्स बनाता है, फिर विकर्णों के साथ बैठता है। जब ,1अंत में इनपुट वैक्टर की लंबाई 1 होती है, तो सही दिशा के साथ योग करने के लिए अंत में मजबूर करता है।

ओक्टेव spdiagsवैक्टर के लिए काम नहीं करता है, जिसके परिणामस्वरूप एक त्रुटि होती है जब इनपुट में लंबाई 1 होती है। तत्व-वार उत्पाद के स्पष्ट विस्तार के लिए मैटलैब 2016 बी या नए की आवश्यकता होती है।

Comments

अच्छा तरीका !!

— लुइस मेंडू

Answer 10

रूबी, 83 बाइट्स

एक बहुपद में जड़ों का विस्तार करने के संबंध में मैंने पहले किए गए लगभग एक उत्तर को सीधे खींच लिया ।

->a,b{q=a.map{|c|r=b.map{|e|e*c};b=[0]+b;r}
q.pop.zip(*q).map{|e|(e-[p]).reduce:+}}

Answer 11

पायथन, 90 बाइट्स

lambda p,q:[sum((p+k*[0])[i]*(q+k*[0])[k-i]for i in range(k+1))for k in range(len(p+q)-1)]

Answer 12

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

(a,b)=>a.map((n,i)=>b.map((m,j)=>r[j+=i]=m*n+(r[j]||0)),r=[])&&r

यदि इनपुट खाली है, तो खाली सरणी लौटाता है। Polynomialception के मेरे जवाब के आधार पर ।

Answer 13

जूलिया, 62 55 बाइट्स

~=endof
p%q=[sum(diag(p*rot180(q'),-k))for k=1-~q:~p-1]

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

Answer 14

क्लोजर, 104 बाइट्स

#(vals(apply merge-with +(sorted-map)(for[i(range(count %))j(range(count %2))]{(+ i j)(*(% i)(%2 j))})))

यह sorted-mapसुनिश्चित करने के लिए विलय कि मान सही क्रम में लौटाए गए हैं। काश कुछ और टेस्ट केस होते।