प्रतीकात्मक मैट्रिक्स गुणन


26

मैट्रिक्स गुणन को समझाने के लिए विभिन्न तरीके हैं। मैं एक ही आकृति के साथ रहूँगा क्योंकि मेरा मानना ​​है कि यहाँ अधिकांश लोग इससे परिचित हैं (और यह चित्र बहुत ही वर्णनात्मक है)। यदि आप अधिक विस्तृत जानकारी चाहते हैं, तो मेरा सुझाव है कि आप विकिपीडिया-लेख , या वुल्फराम मैथवर्ल्ड पर स्पष्टीकरण पर जाएँ

सरल स्पष्टीकरण:

मान लीजिए कि आपके पास दो मेट्रिस हैं, और बी , जहां 3-बाय -2 है, और बी 2-बाय -3 है। यदि आप मैट्रिक्स पर इन गुणा को मेट्रिसेस पर करते हैं, तो AB या BA से आपको नीचे परिणाम मिलेंगे:

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

चुनौती:

आप में सांकेतिक मैट्रिक्स गुणन को लागू करें । आप इनपुट के रूप में दो मेट्रिक्स लेंगे, जहां मैट्रिसेस में प्रत्येक तत्व एक गैर-व्हाट्सएप ASCII- वर्ण (कोड अंक 33-126) द्वारा दर्शाया गया है। आपको इन मेट्रिसेस के उत्पाद का उत्पादन करना होगा।

उत्पादन से संबंधित नियम:

दो प्रविष्टियों के उत्पाद के बीच कोई प्रतीक नहीं होगा। यह ab, नहीं a*b, a·b, times(a,b)या ऐसा ही कुछ। यह aaनहीं है a^2

शब्दों के योग के बीच में एक स्थान (ASCII कोड बिंदु 32) होना चाहिए। यह a b, ऐसा नहीं है a+b, plus(a,b)या कुछ समान है।

उन दो नियमों के लिए तर्क है: सभी गैर-सफेद अंतरिक्ष वर्णों को प्रतीकों में प्रतीक के रूप में अनुमति दी जाती है, इस प्रकार उन्हें गणितीय प्रतीकों के रूप में उपयोग करना गड़बड़ होगा। तो, जो आप सामान्य रूप से लिख सकते हैं a*b+c*dवह होगा ab cd

आप शर्तों का क्रम चुन सकते हैं। ab cd, dc abऔर cd baगणितीय रूप से वही बोल रहे हैं, इसलिए आप यहां भी आदेश चुन सकते हैं। जब तक यह गणितीय रूप से सही न हो जाए तब तक आदेश के अनुरूप होने की आवश्यकता नहीं है।

मैट्रिक्स प्रारूपण के बारे में नियम:

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

"ab;cd"     <- This will look awful, but it's still accepted.

"a,b\nc,d"

[[a,b],[c,d]] 

[a, b]
[c, d]

मुझे पता है कि यह बहुत सारे प्रारूपों की अनुमति देता है जो गड़बड़ दिखेंगे, लेकिन चुनौती मैट्रिसेस को गुणा करने के बारे में है, आउटपुट को स्वरूपित करने में नहीं।

सामान्य नियम:

  • आप मान्य इनपुट मान सकते हैं। मैट्रिक्स गुणन हमेशा दिए गए आयामों से संभव होगा।
  • केवल दो मैट्रेस होंगे।
  • आप यह मान सकते हैं कि मेट्रिसेस नॉन-खाली हैं
  • अंतर्निहित कार्य स्वीकार किए जाते हैं (लेकिन स्वरूपण आवश्यकताओं के कारण शायद थोड़ा बोझिल)।
  • यदि आवश्यक हो ( \'इसके बजाय ') इनपुट में आप निश्चित रूप से एस्केप पात्रों का उपयोग कर सकते हैं ।
  • किसी भी मानक इनपुट और आउटपुट विधि ठीक है

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

दो इनपुट मैट्रिस को बीच में एक खाली लाइन के साथ दिखाया गया है। आउटपुट के बाद दिखाया गया है Output:। जब दो आउटपुट मैट्रिस होते हैं तो यह केवल अन्य आउटपुट दिखाने के लिए होता है जिसे स्वीकार किया जाएगा।

टेस्ट केस # 1

Inputs:
[a]

[b]

Output:
[ab]
[ba]      <- Also OK

टेस्ट केस # 2

Inputs:
[a, b]
[1, 4] 
[y, {]

[%, 4, 1] 
[a, b, c]

Output:    
[a% ba, a4 bb, a1 bc] 
[1% 4a, 14 4b, 11 4c] 
[y% {a, y4 {b, y1 {c]

टेस्ट केस # 3:

Inputs:
[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 1, 2, 3]
[4, 5, 6, 7]

[a]
[b]
[c]
[d]

Output:
[1a 2b 3c 4d]
[5a 6b 7c 8d]
[9a 1b 2c 3d]
[4a 5b 6c 7d]

[d4 c3 b2 a1]      <-- Also OK
[d8 c7 b6 a5]
[1b 9a c2 3d]
[a4 b5 d7 6c]

यदि ab cdइसके बजाय नियमों की आवश्यकता के बारे में आपकी प्रतिक्रिया a*b+c*dहै: आपको बोझिल इनपुट / आउटपुट प्रारूपों से बचना चाहिए , तो मैं ध्यान देना चाहूंगा कि इनपुट और आउटपुट प्रारूप बहुत लचीले हैं। तथ्य यह है कि आप उपयोग नहीं कर सकते हैं *और +उत्पादों और रकमों के लिए एक साधारण निर्मित में उपयोग करना कठिन हो सकता है, लेकिन मैं उस नकारात्मक बात पर विचार नहीं करता हूं।


एक फ़ंक्शन के लिए, स्ट्रिंग्स के दो 2 डी सरणियों को लेना और स्वीकार्य स्ट्रिंग्स के 2 डी सरणी को वापस करना है?
डेनिस

हाँ कोई समस्या नहीं है। लेकिन आयाम मेल खाना चाहिए, आपके पास दूसरा इनपुट ट्रांसपोज़ नहीं हो सकता है। वह समझ में आया था?
स्टीवी ग्रिफिन

यह किया, स्पष्ट करने के लिए धन्यवाद। एक आखिरी सवाल: क्या मैं इनपुट के रूप में वर्णों का 2 डी सरणी भी ले सकता हूं और तार का 2 डी सरणी वापस कर सकता हूं ?
डेनिस

@ डेनिस, मैंने लिखा है: "दोनों मैट्रिसेस को एक ही प्रारूप पर इनपुट किया जाना चाहिए।" मैं वहां आउटपुट मैट्रिक्स का उल्लेख करना भूल गया, इसलिए मैं इसे इस तरह रखूंगा। इनपुट समान प्रारूप पर होने चाहिए, लेकिन आपके पास एक अलग आउटपुट स्वरूप हो सकता है। (मैं वास्तव में उस समाधान को पसंद नहीं करता हूं, लेकिन मैं अब सामान बदलना नहीं चाहता, मुझे लगता है कि एक उत्तर पहले से ही अलग इनपुट और आउटपुट स्वरूप है)
स्टीवी ग्रिफिन

यदि आपका मतलब रूबी के उत्तर से है, तो मैंने जाँच की और यह कि अक्षर के बजाय स्ट्रिंग्स के साथ ही काम करता है।
डेनिस

जवाबों:


9

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

e=[]:e
a!b=[unwords.zipWith(++)r<$>foldr(zipWith(:))e b|r<-a]

इसे ऑनलाइन आज़माएं! उदाहरण का उपयोग:

Prelude> [["a","b"],["c","e"]] ! [["f","g"],["h","i"]]
[["af bh","ag bi"],["cf eh","cg ei"]]

मुझे transposeआयात का उपयोग करने की तुलना में एक बाइट में एक फ़ंक्शन प्राप्त करने का एक तरीका मिला :

import Data.List;transpose
e=[]:e;foldr(zipWith(:))e

आयात के साथ पुराना संस्करण: (62 बाइट्स)

import Data.List
a!b=[unwords.zipWith(++)r<$>transpose b|r<-a]

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

यह काफी करने के लिए अपने जवाब के समान है गैर प्रतीकात्मक आव्यूह गुणन : a!b=[sum.zipWith(*)r<$>transpose b|r<-a], गुणन प्रतिस्थापन (*)स्ट्रिंग संयोजन के साथ (++)और sumसाथ unwordsजो बीच में एक स्थान के साथ स्ट्रिंग की एक सूची कोनकैटेनेट्स किया गया। आयात transposeफ़ंक्शन के लिए आवश्यक है , इसलिए सभी दूसरे मैट्रिक्स के ट्रांसपोज़िशन में बाइट्स के आधे हिस्से का उपयोग करते हैं ...


आयात के बिना पुराना संस्करण: (64 बाइट्स)

a![]=[];a!b=(unwords.zipWith(++)[h|h:_<-b]<$>a):a![s:t|_:s:t<-b]

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

आयात और transposeफ़ंक्शन के साथ बहुत अधिक बाइट्स लेने पर, मैंने आयात के बिना कार्य को हल करने का प्रयास किया। अब तक यह दृष्टिकोण दो बाइट्स से अधिक लंबा हो गया था, लेकिन यह अधिक गोल्फ हो सकता है। संपादित करें: शीर्ष पर अन्य दृष्टिकोण अब आयात धड़कता है!

सूची बोधक सूची [s:t|_:s:t<-b]में गैर-खाली पूंछ प्राप्त करता है b, केवल [t|_:t<-b]पूंछ प्राप्त करने के लिए 4 बाइट्स छोटा होगा (यहां तक ​​कि आयात संस्करण को हराकर) लेकिन ["","",""]मैट्रिक्स की तरह एक खाली पंक्ति को जोड़ दें जो मुझे लगता है कि अनुमति नहीं है।


6

गणितज्ञ, 36 बाइट्स

Inner[#<>#2&,##,StringRiffle@*List]&

InnerMathematica's Dot(यानी सामान्य मैट्रिक्स / वेक्टर उत्पाद) का सामान्यीकरण है । यह आपको दो फ़ंक्शन प्रदान करके डॉट उत्पाद को सामान्य करता है fऔर g, जिसका उपयोग क्रमशः सामान्य गुणा और जोड़ के स्थान पर किया जाएगा। हम गुणा को प्रतिस्थापित कर रहे हैं #<>#2&(जो दो वर्णों को एक स्ट्रिंग StringRiffle@*Listमें StringRiffleजोड़ता है ) और इसके साथ जोड़ देता है , जो पहले एक सूची में सभी सारांशों को लपेटता है, और फिर उन्हें रिक्त स्थान के साथ जोड़ देता है।

कोई संभावित रूप से Dotऑपरेटर का उपयोग कर सकता है .और फिर परिणाम बदल सकता है, लेकिन परेशानी यह है कि जैसी चीजें "a"*"a"तुरंत बदल जाएंगी "a"^2(रकम के लिए समान), जो फिर से अलग करने के लिए कष्टप्रद होगी।


6

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

->a,b{a.map{|x|b.transpose.map{|y|x.zip(y).map(&:join)*' '}}}

नमूना रन:

main(0):007> ->a,b{a.map{|x|b.transpose.map{|y|x.zip(y).map(&:join)*' '}}}[[[?a, ?b], [?1, ?4], [?y, ?{]], [[?%, ?4, ?1], [?a, ?b, ?c]]]
=> [["a% ba", "a4 bb", "a1 bc"], ["1% 4a", "14 4b", "11 4c"], ["y% {a", "y4 {b", "y1 {c"]]
->a,b{
a.map{|x|            # for each row of a
b.transpose.map{|y|  # and for each column of b
x.zip(y)             # match up corresponding elements
.map(&:join)         # join each pair together
*' '                 # join the entire thing on space
}}}

4

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

#(for[a %](for[b(apply map vector %2)](map str a b)))

तर्कों [["a" "b"]["c" "e"]]और [["f" "g"]["h" "i"]]रिटर्न के साथ चल रहा है ((("af" "bh") ("ag" "bi")) (("cf" "eh") ("cg" "ei")))। यह वास्तव में संख्यात्मक संस्करण से छोटा है ।


3

Dyalog एपीएल , 10 बाइट्स

बाएँ और दाएँ तर्कों के रूप में वर्णों की परिपक्वता लेता है। पात्रों की सूचियों का मैट्रिक्स लौटाता है। (एपीएल पात्रों की सूची के रूप में तार का प्रतिनिधित्व करता है।)

{∊⍺' '⍵}.,

TryAPL ऑनलाइन!

सामान्य आंतरिक उत्पाद एपीएल में है +.×, लेकिन इसके अलावा और गुणन कोई भी कार्य हो सकता है, विशेष रूप से:

जोड़ को
{ एक अनाम फ़ंक्शन द्वारा बदल दिया गया है :
 चपटा
⍺ ' ' ⍵ सूची जिसमें बाएं तर्क, एक स्थान और सही तर्क शामिल हैं
}

गुणन को स्थानापन्न द्वारा प्रतिस्थापित किया गया है, ,


2

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

Z;"þK€€

यह एक डाइएडिक लिंक है जो B और A को तर्क के रूप में लेता है (उस क्रम में) और AB को वापस करता है । इनपुट और आउटपुट स्ट्रिंग्स के 2 डी सरणियों के रूप में हैं, जो वास्तव में वर्णों के 3 डी सरणियां हैं। एक और बाइट को इनपुट के रूप में वर्णों के 2D सरणियों को लेने से बचाया जा सकता है । मुझे यकीन नहीं है कि अगर इसकी अनुमति है।

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

यह निर्धारित करना थोड़ा कठिन है कि स्ट्रिंग्स शामिल होने पर जेली हुड के नीचे क्या करती है, क्योंकि यह छपाई से पहले बहुत अधिक चकाचौंध करती है। यह जेली आंतरिक रूप से इनपुट और आउटपुट का प्रतिनिधित्व करता है।

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

Z;"þK€€  Dyadic link. Left argument: B. Right argument: A

Z        Zip/transpose B.
 ;"þ     Table vectorized concatenation; for each row in B' and each row in A,
         concatenate the corresponding strings.
    K€€  Join the arrays that correspond to the rows of A by spaces.

2

प्रस्तावना,> 256 बाइट्स

मैं {_ | _} जो एक खोजक / 3, _ [_, _] जो कुछ arg / 3 है, और योग (_) जो कुछ कुल है। वे सभी अंदर इस्तेमाल किया जा सकता है / 2:

*(X, Y, Z) :- functor(Y, matrice, _), L is len(X[1]), L =:= len(Y), !,
   M is len(X), N is len(Y[1]),
   Z is { { sum({ X[J,K] * Y[K,I] | between(1,L,K) })
                                  | between(1,N,I) }
                                  | between(1,M,J) }.

एक साथ पूर्वोक्त विधेय के लिए अतिरिक्त परिभाषाओं के साथ और गैर-मानक / 2 है जो संख्याओं से अधिक वापस आ सकता है, इसकी सुनिश्चित> 256 बाइट्स।


1

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

(a,b)=>a.map(c=>b[0].map((_,j)=>c.map((e,i)=>e+b[i][j]).join` `))

दो अक्षरों के वर्णों के रूप में इनपुट लेता है और स्ट्रिंग्स का 2 डी सरणी देता है। तार के दो 1D सरणियों के रूप में इनपुट का समर्थन करने के लिए 10 बाइट्स जोड़ें।


1

अजगर, 14 बाइट्स

clQmj;sMCd*QCE

एक प्रोग्राम जो दो न्यूलाइन-अलग-अलग द्वि-आयामी सूचियों का इनपुट लेता है और स्ट्रिंग्स की एक दो आयामी सूची प्रिंट करता है।

परीक्षण सूट

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

[स्पष्टीकरण बाद में आ रहा है]


1

पिप , 17 बाइट्स

{Y Zb{a._JsMy}Ma}

यह एक ऐसा फंक्शन है जिसमें दो नेस्टेड लिस्ट ऑफ (सिंगल-कैरेक्टर) स्ट्रिंग्स होती हैं और स्ट्रिंग्स की नेस्टेड लिस्ट वापस आती है। इसे ऑनलाइन आज़माएं! (दो परीक्षण मामलों के साथ)।

व्याख्या

{}-Delimited फ़ंक्शन के तर्क स्थानीय चर के aलिए असाइन किए गए हैं e। लैम्ब्डा फ़ंक्शन के पहले तर्क द्वारा दर्शाया गया है _

{               }  Define a function:
   Zb              Zip rows of b, transposing it
 Y                 Yank into global variable y for access in nested function
     {       }Ma   To the rows of a, map this function:
           My       To the rows of y (i.e. columns of b), map this function:
      a._           Concatenate, itemwise, the current row of a and row of y
         Js         Join the resulting list on space
                   The result of the outer map operation is returned
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.