क्रॉंकर उत्पाद की गणना करें

11

संबंधित , लेकिन बहुत अलग।

नीचे दिए गए उदाहरणों में, Aऔर B2-बाय -2 मेट्रिसेस होंगे, और मैट्रिसेस एक-अनुक्रमित हैं।

एक क्रोनकर उत्पाद में निम्नलिखित गुण हैं:

A⊗B =  A(1,1)*B   A(1,2)*B
        A(2,1)*B   A(2,2)*B

     =  A(1,1)*B(1,1)   A(1,1)*B(1,2)   A(1,2)*B(1,1)   A(1,2)*B(1,2)
        A(1,1)*B(2,1)   A(1,1)*B(2,2)   A(1,2)*B(2,1)   A(1,2)*B(2,2)
        A(2,1)*B(1,1)   A(2,1)*B(1,2)   A(2,2)*B(1,1)   A(2,2)*B(1,2)
        A(2,2)*B(2,1)   A(2,2)*B(1,2)   A(2,2)*B(2,1)   A(2,2)*B(2,2)

चुनौती: दो मैट्रिसेस को देखते हुए, Aऔर B, वापसी A⊗B।

  • मेट्रिसेस का आकार कम से कम होगा 1-by-1। अधिकतम आकार वह होगा जो आपका कंप्यूटर / भाषा डिफ़ॉल्ट रूप से संभाल सकता है, लेकिन न्यूनतम 5-by-5इनपुट।
  • सभी इनपुट मान गैर-नकारात्मक पूर्णांक होंगे
  • बिल्टिन फ़ंक्शंस जो कि क्रोनकर उत्पादों या टेन्सर / बाहरी उत्पादों की गणना करते हैं, की अनुमति नहीं है
  • सामान्य तौर पर: I / O प्रारूप, कार्यक्रम और कार्य, कमियां आदि के बारे में मानक नियम

परीक्षण के मामलों:

A =   
     1     2
     3     4    
B =    
     5     6
     7     8    
A⊗B =    
     5     6    10    12
     7     8    14    16
    15    18    20    24
    21    24    28    32

B⊗A =    
     5    10     6    12
    15    20    18    24
     7    14     8    16
    21    28    24    32
------------------------
A =    
     1
     2
B =    
     1     2

A⊗B =    
     1     2
     2     4
------------------------
A =    
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1

B =    
     1     1
     0     1

A⊗B  =    
    16    16     2     2     3     3    13    13
     0    16     0     2     0     3     0    13
     5     5    11    11    10    10     8     8
     0     5     0    11     0    10     0     8
     9     9     7     7     6     6    12    12
     0     9     0     7     0     6     0    12
     4     4    14    14    15    15     1     1
     0     4     0    14     0    15     0     1

B⊗A =    
    16     2     3    13    16     2     3    13
     5    11    10     8     5    11    10     8
     9     7     6    12     9     7     6    12
     4    14    15     1     4    14    15     1
     0     0     0     0    16     2     3    13
     0     0     0     0     5    11    10     8
     0     0     0     0     9     7     6    12
     0     0     0     0     4    14    15     1
------------------------

A = 2
B = 5
A⊗B = 10
code-golf  math  linear-algebra  matrix 
— स्टीवी ग्रिफिन
स्रोत

जवाबों:

1

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

×€€;"/€;/

ब्यूटनर के एल्गोरिथ्म का उपयोग करता है ( üजब एक eeध्वनि बनाने की कोशिश करता है ( जैसे कि मिलते हैं] ध्वनि के मुंह के आकार में oo[जैसा कि बूट में])।

यह डेनिस मिशेल;"/€;/ से प्रेरित है । यह मूल रूप से (जिसकी कीमत एक और बाइट है)।Z€F€€;/

— लीक नन
स्रोत
1
या, आईपीए में, / y /
— लुइस मेंडो
हर व्यक्ति आईपीए नहीं जानता है।
— लीक नून
4
मार्टिन के अंतिम नाम का उच्चारण कैसे करें, इसकी व्याख्या के लिए धन्यवाद। यह सुपर प्रासंगिक है। : पी
— एलेक्स ए।
खैर यह है कि मैं सम्मान कैसे दिखाता हूं ...
— लीक नं।
;/Ẏअब हो सकता है। (फ़ीचर
— पोस्टडेट्स
6

सीजेएम, 13 बाइट्स

{ffff*::.+:~}

यह एक अनाम ब्लॉक है जो स्टैक के शीर्ष पर दो मैट्रिसेस की अपेक्षा करता है और उनके स्थान पर उनके क्रोनकर उत्पाद को छोड़ देता है।

परीक्षण सूट।

व्याख्या

यह पिछले उत्तर से केवल क्रोनकर उत्पाद हिस्सा है , इसलिए मैं यहां पिछले स्पष्टीकरण के प्रासंगिक भागों को फिर से प्रस्तुत कर रहा हूं:

यहाँ सूची हेरफेर के लिए CJam के infix ऑपरेटरों का त्वरित अवलोकन है:

  • fएक सूची और स्टैक पर कुछ और की अपेक्षा करता है और सूची में निम्नलिखित बाइनरी ऑपरेटर को मैप करता है , दूसरे तत्व में दूसरे तर्क के रूप में गुजरता है। जैसे [1 2 3] 2 f*और 2 [1 2 3] f*दोनों देते हैं [2 4 6]। यदि दोनों तत्व सूचीबद्ध हैं, तो पहले एक को मैप किया जाता है और दूसरे को बाइनरी ऑपरेटर को करीने के लिए उपयोग किया जाता है।
  • :इसके दो उपयोग हैं: यदि इसका अनुसरण करने वाला ऑपरेटर एकमत है, तो यह एक सरल मानचित्र है। ईजी [1 0 -1 4 -3] :zहै [1 0 1 4 3], जहां zएक संख्या के मापांक मिलते हैं। यदि इसका अनुसरण करने वाला ऑपरेटर बाइनरी है, तो यह ऑपरेटर को इसके बजाय मोड़ देगा । जैसे [1 2 3 4] :+है 10।
  • .एक बाइनरी ऑपरेटर वेक्टर करता है। यह तर्क के रूप में दो सूचियों की अपेक्षा करता है और ऑपरेटर को संबंधित जोड़े पर लागू करता है। जैसे [1 2 3] [5 7 11] .*देता है [5 14 33]।
ffff*  e# This is the important step for the Kronecker product (but
       e# not the whole story). It's an operator which takes two matrices
       e# and replaces each cell of the first matrix with the second matrix
       e# multiplied by that cell (so yeah, we'll end up with a 4D list of
       e# matrices nested inside a matrix).
       e# Now the ffff* is essentially a 4D version of the standard ff* idiom
       e# for outer products. For an explanation of ff*, see the answer to
       e# to the Kronecker sum challenge.
       e# The first ff maps over the cells of the first matrix, passing in the 
       e# second matrix as an additional argument. The second ff then maps over 
       e# the second matrix, passing in the cell from the outer map. We 
       e# multiply them with *.
       e# Just to recap, we've essentially got the Kronecker product on the
       e# stack now, but it's still a 4D list not a 2D list.
       e# The four dimensions are:
       e#   1. Columns of the outer matrix.
       e#   2. Rows of the outer matrix.
       e#   3. Columns of the submatrices.
       e#   4. Rows of the submatrices.
       e# We need to unravel that into a plain 2D matrix.
::.+   e# This joins the rows of submatrices across columns of the outer matrix.
       e# It might be easiest to read this from the right:
       e#   +    Takes two rows and concatenates them.
       e#   .+   Takes two matrices and concatenates corresponding rows.
       e#   :.+  Takes a list of matrices and folds .+ over them, thereby
       e#        concatenating the corresponding rows of all matrices.
       e#   ::.+ Maps this fold operation over the rows of the outer matrix.
       e# We're almost done now, we just need to flatten the outer-most level
       e# in order to get rid of the distinction of rows of the outer matrix.
:~     e# We do this by mapping ~ over those rows, which simply unwraps them.
— मार्टिन एंडर
स्रोत
3
आपका कोड लगभग IPv6 पते की तरह दिखता है
— डिजिटल ट्रामा
4

MATLAB / ऑक्टेव, 83 42 बाइट्स

सहेजे गए 41 बाइट्स, FryAmTheEggman करने के लिए धन्यवाद!

@(A,B)cell2mat(arrayfun(@(n)n*B,A,'un',0))

यह यहाँ परीक्षण!

टूट - फूट

arrayfunदूसरे तर्क द्वारा परिभाषित n*Bएक चर के लिए एक प्रच्छन्न लूप है जो गुणा nकरता है। यह काम करता है क्योंकि 2 डी मैट्रिक्स के माध्यम से लूपिंग एक वेक्टर के माध्यम से लूपिंग के समान है। यानी के for x = Aरूप में ही है for x = A(:)।

'un',0अधिक क्रिया के समतुल्य है 'UniformOutput', False, और निर्दिष्ट करता है कि आउटपुट में स्केलर के बजाय कोशिकाएं हैं।

cell2mat इसका उपयोग कोशिकाओं को एक संख्यात्मक मैट्रिक्स में परिवर्तित करने के लिए किया जाता है, जिसे तब आउटपुट किया जाता है।

— स्टीवी ग्रिफिन
स्रोत
आपको स्पष्ट करना चाहिए कि arrayfunलूप्स को रैखिक रूप से आप कहते हैं, जैसे कि मैट्रिक्स एक वेक्टर था, लेकिन forऐसा नहीं है (यह सरणी के स्तंभों पर छोरों )
— लुइस मेंडो
1

पायथ, 14 12 11 बाइट्स

JEsMs*RRRRJ

जेली उत्तर का अनुवाद , जो कि ब्यूटनर के एल्गोरिथ्म पर आधारित है ( üउच्चारण में eeध्वनि के रूप में [मीट में] ooध्वनि के रूप में [बूट में]।

इसे ऑनलाइन आज़माएं (टेस्ट केस 1)!

बोनस: B⊗Aबाइट्स की समान संख्या में गणना करें

JEsMs*LRLRJ

इसे ऑनलाइन आज़माएं (टेस्ट केस 1)!

— लीक नन
स्रोत
1

जूलिया, 40 39 37 बाइट्स

A%B=hvcat(sum(A^0),map(a->a*B,A')...)

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

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

  • मैट्रिक्स ए और बी के लिए , map(a->a*B,A')क्रोनकर उत्पाद ए⊗बी की गणना करता है ।

    परिणाम बी के आयामों के साथ मैट्रिक्स ब्लॉक का एक वेक्टर है ।

    चूंकि कॉलम प्रमुख क्रम में संग्रहीत हैं, इसलिए हमें A (के साथ ') को स्थानांतरित करना होगा ।

  • sum(A^0)पहचान मैट्रिक्स के सभी प्रविष्टियों के योग को A के आयामों की गणना करता है । एक के लिए n × n मैट्रिक्स एक , इस पैदावार एन ।

  • पहला तर्क के साथ n , hvcatसंयोजित n मैट्रिक्स ब्लॉक क्षैतिज, और जिसके परिणामस्वरूप (बड़ा) खड़ी ब्लॉक।

— डेनिस
स्रोत
0

जे, 10 बाइट्स

यह एक संभव कार्यान्वयन है।

[:,./^:2*/

जे, 13 बाइट्स

यह एक समान कार्यान्वयन है, लेकिन इसके बजाय रैंक को परिभाषित करने की जे की क्षमता का उपयोग करता है। यह *पूरे आरएचएस के साथ एलएचएस पर प्रत्येक तत्व के बीच लागू होता है ।

[:,./^:2*"0 _

प्रयोग

   f =: <either definition>
    (2 2 $ 1 2 3 4) f (2 2 $ 5 6 7 8)
 5  6 10 12
 7  8 14 16
15 18 20 24
21 24 28 32
   (2 1 $ 1 2) f (1 2 $ 1 2)
1 2
2 4
   2 f 5
10
— मील की दूरी पर
स्रोत
0

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

नेस्टेड लूपिंग के साथ सीधा कार्यान्वयन

(a,b)=>a.map(a=>b.map(b=>a.map(y=>b.map(x=>r.push(y*x)),t.push(r=[]))),t=[])&&t

परीक्षा

f=(a,b)=>a.map(a=>b.map(b=>a.map(y=>b.map(x=>r.push(y*x)),t.push(r=[]))),t=[])&&t

console.log=x=>O.textContent+=x+'\n'

function show(label, mat)
{
  console.log(label)
  console.log(mat.join`\n`)
}

;[ 
  {a:[[1,2],[3,4]],b:[[5,6],[7,8]] },
  {a:[[1],[2]],b:[[1,2]]},
  {a:[[16,2,3,13],[5,11,10,8],[9,7,6,12],[4,14,15,1]],b:[[1,1],[0,1]]},
  {a:[[2]],b:[[5]]}
].forEach(t=>{
  show('A',t.a)  
  show('B',t.b)
  show('A⊗B',f(t.a,t.b))
  show('B⊗A',f(t.b,t.a))  
  console.log('-----------------')
})
<pre id=O></pre>
स्निपेट का विस्तार करें

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