14

गणित में, मैट्रिक्स गुणन या मैट्रिक्स उत्पाद एक बाइनरी ऑपरेशन है जो दो मैट्रिक्स से मैट्रिक्स का उत्पादन करता है। परिभाषा वैक्टर पर रैखिक समीकरणों और रैखिक परिवर्तनों से प्रेरित है, जिसमें लागू गणित, भौतिकी और इंजीनियरिंग में कई अनुप्रयोग हैं। अधिक विस्तार से, यदि A एक n × m मैट्रिक्स है और B एक m × p मैट्रिक्स है, तो उनका मैट्रिक्स उत्पाद AB एक n × p मैट्रिक्स है, जिसमें A की एक पंक्ति में m प्रविष्टियाँ m प्रविष्टियों के साथ गुणा की जाती हैं। बी के कॉलम और एबी की एक प्रविष्टि का निर्माण करने के लिए अभिव्यक्त किया गया। जब दो रेखीय परिवर्तनों को मैट्रिक्स द्वारा दर्शाया जाता है, तो मैट्रिक्स उत्पाद दो परिवर्तनों की संरचना का प्रतिनिधित्व करता है।

^{स्रोत: विकिपीडिया}

दूसरे शब्दों में, उदाहरण के लिए दो मैट्रिसेस को गुणा करना:

1 2 3   1 4
2 3 4 × 3 1 = 
3 4 5   4 6

सबसे पहले, दूसरे मैट्रिक्स में पहली मैट्रिक्स में पंक्ति संख्या 1, स्तंभ संख्या 1 लेते हैं, और गुणा 1द्वारा 1, 2द्वारा 3, और 3से 4।

1 × 1 = 1
2 × 3 = 6
3 × 4 = 12

अब अपना पहला आइटम पाने के लिए उन्हें एक साथ जोड़ें:

1 2 3   1 4   19
2 3 4 × 3 1 = 
3 4 5   4 6

परिणाम के पहले कॉलम में दूसरे नंबर के लिए, आपको पंक्ति संख्या 1 के बजाय पंक्ति संख्या 2 को लेना होगा और वही काम करना होगा।

जब आप संपूर्ण पहला कॉलम करते हैं, तो परिणाम इस तरह दिखता है:

1 2 3   1 4   19
2 3 4 × 3 1 = 27
3 4 5   4 6   35

अब, फिर से वही सटीक काम करें, लेकिन पहले कॉलम के बजाय दूसरा कॉलम लें, जिसके परिणामस्वरूप:

1 2 3   1 4   19 24
2 3 4 × 3 1 = 27 35
3 4 5   4 6   35 46

आपका कार्य

दो मैट्रिसेस (अधिकतम आयाम 200x200) को देखते हुए, रेंज -10000 से 10000 में संख्याएं, जहां पहले एक पर कॉलम की संख्या दूसरी पर पंक्तियों की संख्या के बराबर होती है, दूसरे से पहले एक को गुणा करें। (मैट्रिक्स गुणन गैर-कम्यूटेटिव है।)

आप इनपुट ले सकते हैं और एरे (या समतुल्य) की एक सरणी के रूप में आउटपुट दे सकते हैं, एक मैट्रिक्स (यदि आपकी भाषा में वह प्रारूप है) या एक बहुस्तरीय स्ट्रिंग है।

आप मैट्रिक्स गुणन के लिए किसी भी अंतर्निहित इन्स का उपयोग नहीं कर सकते हैं।

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

1 2   1 2 3 4 5    13 16 19 22 25
3 4 × 6 7 8 9 10 = 27 34 41 48 55
5 6                41 52 63 74 85

2 3   3 5   15 13
3 4 × 3 1 = 21 19

5 3            11    27
1 3      1 3   7     15
9 3    × 2 4 = 15    39
1 -1000        -1999 -3997

याद रखें, यह कोड-गोल्फ है , इसलिए सबसे कम बाइट्स वाला कोड जीत जाता है।

code-golf math matrix

— ओलिवर नी
स्रोत

क्या हम बिल्ट-इन डॉट उत्पादों का उपयोग कर सकते हैं? वे वैक्टर पर काम करते हैं, मैट्रिसेस पर नहीं।

— डेनिस

1

इनपुट क्रम तय हो गई है या हम ले जा सकते हैं एक और ख है कि आदेश और उत्पादन में ख × एक ?

— डेनिस

@ डेनिस आप इनपुट को उल्टा कर सकते हैं, लेकिन कोई भी डॉट उत्पाद

— ओलिवर नी

4

के बारे में चुनौतियां वाई बिना एक्स कर रहे हैं हतोत्साहित ।

— 0

क्या इनपुट मैट्रिस में फ्लोटिंग पॉइंट नंबर हो सकते हैं? यदि हां, तो मैं कुछ के साथ एक परीक्षण मामले को जोड़ने की सलाह देता हूं।

— आर। काप

5

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

Z×þḅ1

बी और ए को तर्क के रूप में लेता है और ए × बी लौटाता है ।

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

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

Z×þḅ1  Main link. Left argument: B. Right argument: A

Z      Zip; transpose B's rows and columns.
 ×þ    Table multiplication; multiply all columns of B (rows of B's transpose) by
       all rows of A, element by element. Results are grouped by the rows of A.
   ḅ1  Unbase 1; compute the sum of all flat arrays in the result.

— डेनिस
स्रोत

3

तो प्रतीक्षा करें, बिल्ट-इन और मैन्युअल तरीके से मैट्रिसेस को गुणा करने के लिए जेली में बाइट्स की संख्या कितनी है? यह भ्रामक है, लेकिन शांत है।

— योदले

@ योडल बिल्ट-इन है æ×, जो 2 बाइट्स है।

— एरिक आउटफोलर

@EriktheOutgolfer वह संशोधन 2 के संदर्भ में था, जिसमें æ.परमाणु का उपयोग किया गया था ।

— डेनिस

4

05AB1E , 13 बाइट्स

vyU²øvyX*O})ˆ

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

व्याख्या

v               # for each row in the first matrix
 yU             # save the row in X
   ²øv          # for each row in the transposition of the second matrix
      yX*       # multiply the rows
         O      # sum the elements of the resulting row
          }     # end inner loop
           )    # wrap elements of the new row in a list
            ˆ   # push to global list
                # implicitly output global list

— Emigna
स्रोत

ठीक उसी दृष्टिकोण के साथ अब 7 बाइट्स हो सकते हैं:εUøεX*O

— केविन क्रूज़सेन

4

पायथन 2, 69 66 बाइट्स

यह सिर्फ मानक फार्मूला का पालन करता है, लेकिन संगति के लिए लैम्ब्डा-डी :) असम्बद्ध कोड बेहद सीधा है!

lambda x,y:[[sum(map(int.__mul__,r,c))for c in zip(*y)]for r in x]

^{3 बाइट्स बचाने के लिए अलेक्सी तोहारामो को धन्यवाद! :)}

अघोषित कोड:

x = [[1,2],[3,4],[5,6]]
y = [[1,2,3,4,5],[6,7,8,9,10]]

output = []
for row in x:
    nrow = []
    for col in zip(*y):                             # zip(*[]) transposes a matrix
        nrow += [sum(a*b for a,b in zip(row,col))]  # multiplication for each pair summed
    output += [nrow]

print output

— Kade
स्रोत

आप sum(map(int.__mul__,r,c))3 बाइट्स को बचाने के लिए उपयोग कर सकते हैं । (फ्लोटिंग पॉइंट के साथ काम नहीं करेंगे, लेकिन इसकी आवश्यकता नहीं थी, या तो)

— अलेक्सी तोरहमो

3

जे, १३ ९ बाइट्स

मीलों तक 4 बाइट्स बचाए!

[:+/*"#:~

यह एक छाया हुआ कांटा है:

[: +/ *"#:~

जो इसके बराबर है:

[: +/ (*"#:)~
[: +/ (*"_ 1 0)~

जो वांछित गुणन करता है; फिर इन्हें समन किया जाता है।

5 बाइट्स में निर्मित डॉट उत्पाद के साथ: +/ .*

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

   f =: [: +/ *"#:~
   (3 3$1 2 3 2 3 4 3 4 5)f(3 2$1 4 3 1 4 6)
19 24
27 35
35 46
   (3 3$1 2 3 2 3 4 3 4 5);(3 2$1 4 3 1 4 6)
+-----+---+
|1 2 3|1 4|
|2 3 4|3 1|
|3 4 5|4 6|
+-----+---+
   (2 2$2 3 3 4)f(2 2$3 5 3 1)
15 13
21 19
   (2 2$2 3 3 4);(2 2$3 5 3 1)
+---+---+
|2 3|3 5|
|3 4|3 1|
+---+---+

— कोनोर ओ ब्रायन
स्रोत

मैं बस [:+/*"#:~9 बाइट्स के लिए ठोकर खाई

— मील

@ मीलों शानदार!

— कॉनर ओ'ब्रायन

3

हास्केल , 57 56 54 बाइट्स

e=[]:e
z=zipWith
a!b=[sum.z(*)r<$>foldr(z(:))e b|r<-a]

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

उपयोग:

Prelude> [[1,2],[3,4],[5,6]] ! [[1,2,3,4,5],[6,7,8,9,10]]
[[13,16,19,22,25],[27,34,41,48,55],[41,52,63,74,85]]

foldr(zipWith(:))eके साथ e=[]:eएक छोटा रूप है transpose।

— Laikoni
स्रोत

3

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

map.(foldr1(z(+)).).flip(z$map.(*))
z=zipWith

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

उलटे क्रम में तर्क देता है।

— XNOR
स्रोत

2

आर, 66 बाइट्स

function(A,B)apply(B,2,function(i)apply(A,1,function(j)sum(j*i)))

इनपुट के रूप में दो R-matrices ले रहे हैं और उत्पाद लौटाते हैं। यह उपयोग applyकरता है जिसका उपयोग सरणियों के मार्जिन पर कार्यों को लागू करने के लिए किया जाता है। यह forइस मामले में सिर्फ एक डबल लूप के रूप में काम करता है : के प्रत्येक कॉलम के लिए Bऔर प्रत्येक पंक्ति के लिए A, (वेक्टरकृत) उत्पादों का योग लौटाता है।

पाश दृष्टिकोण ( 101बाइट्स) के लिए शुद्ध की तुलना करें :

function(A,B){M=matrix(NA,m<-nrow(A),n<-ncol(B));for(i in 1:n)for(j in 1:m)M[j,i]=sum(A[j,]*B[,i]);M}

— Billywob
स्रोत

इस समय मेरे डेस्कटॉप पर नहीं है, लेकिन क्या आप outer(A,B,`*`)एम्बेडेड applyकॉल के बजाय ऐसा कुछ नहीं कर सकते हैं?

— 6

@rturnbull मुझे यकीन नहीं है कि मैट्रिस के संयोजन में बाहरी कैसे काम करता है लेकिन यह इस मामले में 4-डी सरणी का उत्पादन करेगा।

— बिल्वबॉव

आह हाँ, यह एक छोटी समस्या है।

— मैट्रिस का रेखांकन

2

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

Inner[1##&,##,Plus]&

अनाम फ़ंक्शन। इनपुट के रूप में संख्याओं की दो रैंक -2 सूची लेता है, और आउटपुट के रूप में संख्याओं की एक रैंक -2 सूची देता है। उन जिज्ञासुओं के लिए, Innerएक ऐसा कार्य है जो दो कार्यों को दो-दसियों तक मैट्रिक्स-गुणन-जैसा अनुप्रयोग करता है।

— LegionMammal978
स्रोत

मेरा मानना Inner[1##&,##]&है कि इसके बराबर है Inner[1##&,##,Plus]&...? और इसलिए 1##&~Inner~##&यह और भी बेहतर होगा।

— ग्रेग मार्टिन

2

सी #, 168 167 बाइट्स

(A,B)=>{int n=A.Length,p=B[0].Length,i=0,j=0,k=0,s;var R=new int[n,p];while(i++<n)for(j=0;j<p;){s=0;for(k=0;k<A[0].Length;)s+=A[i][k]*B[k++][j];R[i,j++]=s;}return R;};

1 बाइट बचाने के लिए @ मुकुल कुमार को धन्यवाद, जबकि लूप वास्तव में इस बार कम था: पी

परीक्षण मामलों के साथ पूरा कार्यक्रम:

using System;
class Matrix
{
    static void Main()
    {
        Func<int[][], int[][], int[,]> a = null;

        a = (A,B)=>
        {
            int n=A.Length,p=B[0].Length,i=0,j=0,k=0,s;
            var R=new int[n,p];
            while(i++<n)
                for(j=0;j<p;)
                {
                    s=0;
                    for(k=0;k<A[0].Length;)
                        s+=A[i][k]*B[k++][j];
                    R[i,j++]=s;
                }
            return R;
        };

        int[,] t1 = a(new int[][] { new int[] { 1, 2 }, new int[] { 3, 4 }, new int[] { 5, 6 } },
            new int[][] { new int[] { 1, 2, 3, 4, 5 }, new int[] { 6, 7, 8, 9, 10 } } );
        int[,] t2 = a(new int[][] { new int[] { 2, 3 }, new int[] { 3, 4 } },
            new int[][] { new int[] { 3, 5 }, new int[] { 3, 1 } });
        int[,] t3 = a(new int[][] { new int[] { 5, 3 }, new int[] { 1, 3 }, new int[] { 9, 3 }, new int[] { 1, -1000 } },
            new int[][] { new int[] { 1, 3 }, new int[] { 2, 4 } });

        Console.WriteLine(IsCorrect(t1, new int[,] { { 13, 16, 19, 22, 25 }, { 27, 34, 41, 48, 55 }, { 41, 52, 63, 74, 85 } } ));
        Console.WriteLine(IsCorrect(t2, new int[,] { { 15, 13 }, { 21, 19 } } ));
        Console.WriteLine(IsCorrect(t3, new int[,] { { 11, 27 }, { 7, 15 }, { 15, 39 }, { -1999, -3997 } } ));

        Console.Read();
    }

    static bool IsCorrect(int[,] answer, int[,] valid)
    {
        if (answer.Length != valid.Length)
            return false;
        for (int i = 0; i < answer.GetLength(0); i++)
            for (int j = 0; j < answer.GetLength(1); j++)
                if (answer[i, j] != valid[i, j])
                    return false;
        return true;
    }
}

— Yodle
स्रोत

आप लूप्स का उपयोग करके कुछ बाइट्स ट्रिम कर सकते हैं ....

— मुकुल कुमार

@ मुकुलकुमार रुको, मुझे ऐसा नहीं लगता। ज़्यादातर, वे सही भी तोड़ते हैं? for(;i<n;)-> while(i<n)दोनों 10 बाइट्स हैं।

— योडल

1

for (;i <n;i++) -> while (i++<n)1 बाइट बचाता है

— मुकुल कुमार

शिष्टाचार के बारे में निश्चित नहीं जब मेरे पास एक अलग उत्तर हो, लेकिन मेरा विकल्प निश्चित रूप से इससे प्रेरित था।

— किर्क ब्रॉडहर्स्ट

2

MATL , 12 11 बाइट्स

7L&!*Xs6Be!

;पंक्ति विभाजक के रूप में मैट्रिसेस इनपुट हैं ।

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

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

— लुइस मेंडो
स्रोत

2

सी ++ 14, 173 168 156 146 बाइट्स

संदर्भ पैरामीटर के माध्यम से लौटने के लिए -5 बाइट्स
-12 बाइट्स फॉरच का उपयोग करने के लिए और C.back()इसके बजाय गिनती परi
-10 बाइट छोड़ने के लिए C.clear()और Cशुरू में खाली होने की आवश्यकता होती है

अनाम लंबोदर के रूप में:

[](auto A,auto B,auto&C){int j,k,s=B[0].size();for(auto a:A){C.emplace_back(s);for(j=-1;++j<s;)for(k=-1;++k<B.size();C.back()[j]+=a[k]*B[k][j]);}}

इनपुट और आउटपुट की आवश्यकता है और आउटपुट vector<vector<int>>पहले से खाली होना चाहिए।

Ungolfed:

auto f=
[](auto A, auto B, auto&C){
 int j,k,s=B[0].size();
 for (auto a:A){
  C.emplace_back(s);
  for (j=-1;++j<s;)
   for (k=-1;++k<B.size();
    C.back()[j]+=a[k]*B[k][j]
   );
 }
}
;

नमूना:

int main() {
 using M=std::vector<std::vector<int>>;
 M a = {
  {1,2,3},
  {2,3,4},
  {3,4,5},
 };
 M b = {
  {1,4},
  {3,1},
  {4,6},
 };
 M c;
 f(a,b,c);
 for (auto&r:c){
  for (auto&i:r) std::cout << i << ", ";
  std::cout << "\n";
 }
}

— कार्ल नेफ
स्रोत

के push_back()बजाय का उपयोग क्यों नहीं emplace_back()?

— जी। स्लीपेन

2

भूसी , 7 6 बाइट्स

mMδṁ*T

कृपया तर्क आदेश पर ध्यान दें, इसे ऑनलाइन आज़माएं!

-1 बाइट @Zgarb को धन्यवाद!

व्याख्या

मूल रूप से सिर्फ वही कर रहे हैं जो मैट्रिक्स-गुणन साइस की परिभाषा है:

mMδṁ*T  -- takes arguments in reverse order, eg: [[1],[0],[-1]] [[1,2,3],[4,5,6]]
     T  -- transpose the first argument: [[1,0,-1]] [[1,2,3],[4,5,6]]
m       -- map the following function (example element [1,0,-1])
 M      --   map the following function applied to [1,0,-1] (example element [1,2,3])
  δṁ    --     accumulate a sum of element-wise..
    *    --    ..multiplication: -2
          -- [[-2],[-2]]

— ბიმო
स्रोत

1

oΣzहो सकता हैδṁ

— ज़गरब

1

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

(a,b)=>a.map(c=>b[0].map((_,i)=>b.reduce((s,d,j)=>s+d[i]*c[j],0)))

— नील
स्रोत

1

सी #, 131 बाइट्स

(A,B)=>new List<List<int>>(A.Select(x=>new List<int>
    (B[0].Select((f,i)=>B.Select(r=>r[i])).Select(y=>x.Zip(y,(p,q)=>p*q).Sum()))));

मैंने इस धारणा के साथ योडल के समाधान को चुरा लिया है कि मैं LINQ (लूप के लिए विरोध के रूप में) का उपयोग करके इसे अधिक कुशलता से लिख सकता हूं। कुछ प्रयास किए, लेकिन इसे कुछ हद तक कम कर दिया।

यहाँ यह कुछ हद तक टूट गया है:

a = (A, B) => new List<List<int>>(
            from x in A
            select new List<int>(
                from y in B.First().Select((f, i) => B.Select(r => r.ElementAt(i)))
                select x.Zip(y, (p, q) => p * q).Sum()));

यहाँ केवल वास्तविक 'ट्रिक' है मैट्रिक्स ट्रांसपोज़ B.First().Select((f, i) => B.Select(r => r.ElementAt(i))),। एक बार जब हम दूसरे मैट्रिक्स को स्थानांतरित करते हैं, तो हमारे पास दो सरणियाँ होती हैं A[i,x]और B[j,x]। कार्टेसियन उत्पाद ( i*j) लें और उन xलंबाई सरणियों में से प्रत्येक को एक साथ जिप करें ।

टेस्ट कोड:

using System;
class Matrix
{
    static void Main()
    {
        Func<int[][], int[][], List<List<int>>> a = null;
        a = (A, B) => new List<List<int>>(A.Select(x => new List<int>(B[0].Select((f, i) => B.Select(r => r[i])).Select(y => x.Zip(y, (p, q) => p * q).Sum()))));

        List<List<int>> t1 = a(new int[][] { new int[] { 1, 2 }, new int[] { 3, 4 }, new int[] { 5, 6 } },
            new int[][] { new int[] { 1, 2, 3, 4, 5 }, new int[] { 6, 7, 8, 9, 10 } });
        List<List<int>> t2 = a(new int[][] { new int[] { 2, 3 }, new int[] { 3, 4 } },
            new int[][] { new int[] { 3, 5 }, new int[] { 3, 1 } });
        List<List<int>> t3 = a(new int[][] { new int[] { 5, 3 }, new int[] { 1, 3 }, new int[] { 9, 3 }, new int[] { 1, -1000 } },
            new int[][] { new int[] { 1, 3 }, new int[] { 2, 4 } });

        Console.WriteLine(IsCorrect(t1, new int[,] { { 13, 16, 19, 22, 25 }, { 27, 34, 41, 48, 55 }, { 41, 52, 63, 74, 85 } }));
        Console.WriteLine(IsCorrect(t2, new int[,] { { 15, 13 }, { 21, 19 } }));
        Console.WriteLine(IsCorrect(t3, new int[,] { { 11, 27 }, { 7, 15 }, { 15, 39 }, { -1999, -3997 } }));

        Console.Read();
    }

    static bool IsCorrect(List<List<int>> answer, int[,] valid)
    {
        if (answer.Count*answer[0].Count != valid.Length)
            return false;
        for (int i = 0; i < answer.Count; i++)
            for (int j = 0; j < answer[0].Count; j++)
                if (answer[i][j] != valid[i, j])
                    return false;
        return true;
    }

}

— कर्क ब्रॉडहर्स्ट
स्रोत

नाइस: पी मैंने वास्तव में कभी भी लिनक को इतना अधिक इस्तेमाल नहीं किया है, इसलिए मुझे इसकी सभी क्षमताओं के बारे में पूरी तरह से पता नहीं है इसलिए मैं सिर्फ मानक छोरों और सामान का उपयोग करता हूं। हालाँकि, मुझे लगता है कि आपको सिस्टम का उपयोग करना है। अपने बाइट की गिनती में यह सुनिश्चित करें कि यह कितना प्रभाव डालता है।

— योडल

@ हाँ, मुझे शामिल करना होगा using System.Linq; मुझे यकीन नहीं है कि अगर यहाँ समाधानों को बॉयलरप्लेट जैसे using Systemऔरstatic void Main()

— किर्क ब्रॉडहर्स्ट

मैं अब थोड़ा सा उत्तर दे रहा हूं, और जो मैंने देखा है, उससे मूल रूप से आपका उत्तर (जो भी आप अपनी बाइट की गिनती में शामिल हैं) को काम करना होगा यदि आपने इसे केवल एक कार्यक्रम में चिपकाया है। C # के लिए, यदि आप केवल एक फ़ंक्शन लिख रहे हैं, तो आपको कक्षा परिभाषा या स्थिर शून्य () सामग्री शामिल करने की आवश्यकता नहीं है, लेकिन यदि आपका समाधान किसी भी लाइब्रेरी सामान जैसे Console.WriteLine () का उपयोग करता है, तो आपको करना होगा System.Console.WriteLine () या सिस्टम का उपयोग कर; चूंकि एक छोटा हो सकता है।

— योडल

1

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

z=zipWith
m a=map(\x->foldr1(z(+))$z(map.(*))x a)

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

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

मुझे लगता है कि इस बिंदु को बनाने और मुट्ठी भर बाइट्स को बचाने का एक अच्छा तरीका होगा, लेकिन मैं इसे अभी तक नहीं देख रहा हूं।

— खुल्द्रेसथ न’बैरी
स्रोत

0

जावास्क्रिप्ट, 128 बाइट्स

m=(a,b)=>{$=[];q=0;for(x in b){c=[];j=0;for(y in a[0]){_=i=0;for(z in b[0]){_+=a[i][j]*b[q][i];i++}c.push(_);j++}$.push(c);q++}}

आपको केवल $ चेक करके परिणाम मिलता है - यह थोड़े धोखा है, लेकिन हे, इसने कुछ बाइट्स बचाए।

— माक्र्स डायर
स्रोत

0

PHP, 110 बाइट्स

function f($a,$b){foreach($a as$n=>$x)foreach($b as$m=>$y)foreach($y as$p=>$v)$z[$n][$p]+=$v*$x[$m];return$z;}

एलवेन सरणियों के लिए तीन लूप। यह इतना सीधा आगे है ... लेकिन गोल्फ के लिए ज्यादा नहीं है।

— टाइटस
स्रोत

0

दरअसल , 14 बाइट्स

गोल्फ सुझाव का स्वागत करते हैं! इसे ऑनलाइन आज़माएं!

┬@;l)∙`i♀*Σ`M╡

Ungolfing

         Implicit input A, then B.
┬        Transpose B's rows and columns. Call it B_T.
@        Swap A to TOS.
;l)      Get len(A) and move to BOS for later.
∙        Push the Cartesian product of A and B_T. Call it cart_prod.
`...`M   Map the following function over cart_prod. Variable xs.
  i        Flatten xs onto the stack, getting a row of A and column of B.
  ♀*       Multiply each element of A_row by each element of B_column.
  Σ        Sum the resulting list to get an element of A*B.
         The result of the map returns every element of A*B, but in one flat list.
╡        Push a list containing len(A) non-overlapping sublists of A*B.
         This separates A*B into rows.
         Implicit return.

— Sherlock9
स्रोत

0

सी, 618 बाइट्स

M(char*a,char*b){char*P[2];P[0]=malloc(strlen(a));P[1]=malloc(strlen(b));for(int A=0;A<strlen(a);A++){P[0][A]=a[A];};for(int B=0;B<strlen(b);B++){P[1][B]=b[B];};int H[200][200],B[200][200];int O,N,m,J;for(int Y=0;Y<2;Y++){int y=0,z=0,r=0;char j[7];int p=strlen(P[Y]);for(int i=0;i<=p;i++){if(P[Y][i]==' '||P[Y][i]==','||i==p){(Y<1)?H[y][z]=atoi(j):(B[y][z]=atoi(j));memset(j,'\0',4);(P[Y][i]==' ')?z++:y++;z=(P[Y][i]==',')?0:z;r=0;}else{j[r]=P[Y][i];r++;};};(Y<1)?O=z+1,N=y:(m=y,J=z+1);};for(int U=0;U<N;U++){for(int F=0;F<J;F++){int T=0;for(int d=0;d<O;d++){T+=H[U][d]*B[d][F];};printf("%d ",T);T=0;};printf("\n");};}

एक नामित फ़ंक्शन और यहां तक कि सबसे लंबे समय तक प्रस्तुत करने के कारण, आंशिक रूप से इस तथ्य के कारण कि चरित्र सरणी इनपुट को सी 2-आयामी पूर्णांक सरणियों में परिवर्तित करना सबसे अधिक बाइट्स ले रहा है, और यह भी कि क्योंकि मैंने सबसे लंबे समय में सी में गोल्फ नहीं किया है। मैं अभी भी इसे छोटा करने पर काम कर रहा हूं जितना मैं कर सकता हूं, और ऐसा करने के किसी भी सुझाव की बहुत सराहना की जाती है।

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

   1 2 3     44 52
A= 4 5 6  B= 67 -79
   7 8 9     83 90

इनपुट के रूप में होगा:

./a.out "1 2 3,4 5 6,7 8 9" "44 52,67 -79,83 90"

परिणामस्वरूप मैट्रिक्स मल्टीलाइन स्ट्रिंग के रूप में STDOUT में आउटपुट होता है। उदाहरण के लिए, उपरोक्त इनपुट के लिए आउटपुट होगा:

 427 164 
1009 353 
1591 542

— आर। कप
स्रोत

TIO 539 बाइट्स

— girobuz

0

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

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

कई बाइट्स ने 2 तर्क को स्थानांतरित करने पर खर्च किया।

— NikoNyrh
स्रोत

0

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

->m,n{m.map{|r|n.transpose.map{|c|r.zip(c).sum{|i,j|i*j}}}}

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

— मान स्याही
स्रोत

मैट्रिक्स गुणा करें!

आपका कार्य

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

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

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

05AB1E , 13 बाइट्स

पायथन 2, 69 66 बाइट्स

जे, १३ ९ बाइट्स

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

हास्केल , 57 56 54 बाइट्स

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

आर, 66 बाइट्स

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

सी #, 168 167 बाइट्स

MATL , 12 11 बाइट्स

सी ++ 14, 173 168 156 146 बाइट्स

भूसी , 7 6 बाइट्स

व्याख्या

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

सी #, 131 बाइट्स

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

जावास्क्रिप्ट, 128 बाइट्स

PHP, 110 बाइट्स

दरअसल , 14 बाइट्स

सी, 618 बाइट्स

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

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