In der Mathematik ist die Matrixmultiplikation oder das Matrixprodukt eine binäre Operation, die eine Matrix aus zwei Matrizen erzeugt. Die Definition wird durch lineare Gleichungen und lineare Transformationen auf Vektoren motiviert, die zahlreiche Anwendungen in der angewandten Mathematik, Physik und Technik haben. Genauer gesagt, wenn A eine n × m-Matrix und B eine m × p-Matrix ist, ist ihr Matrixprodukt AB eine n × p-Matrix, in der die m Einträge über eine Reihe von A mit den m Einträgen nach a multipliziert werden Spalten von B und summiert, um einen Eintrag von AB zu erzeugen. Wenn zwei lineare Transformationen durch Matrizen dargestellt werden, repräsentiert das Matrixprodukt die Zusammensetzung der beiden Transformationen.

^{Quelle: Wikipedia}

Mit anderen Worten, um zwei Matrizen zu multiplizieren, zum Beispiel:

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

Nehmen Sie zuerst die Zeilennummer 1 in der ersten Matrix, die Spaltennummer 1 in der zweiten Matrix und multiplizieren Sie 1mit 1, 2mit 3und 3mit 4.

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

Addiere sie nun zu deinem ersten Gegenstand:

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

Für die zweite Zahl in der ersten Spalte des Ergebnisses müssen Sie anstelle der Zeilennummer 1 die Zeilennummer 2 verwenden und dasselbe tun.

1 × 2 = 2
3 × 3 = 9
4 × 4 = 16
      = 27

Nachdem Sie die gesamte erste Spalte erstellt haben, sieht das Ergebnis folgendermaßen aus:

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

Machen Sie jetzt genau dasselbe noch einmal, aber nehmen Sie die zweite Spalte anstelle der ersten, was zur Folge hat:

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

Deine Aufgabe

Wenn zwei Matrizen (maximale Abmessungen 200 x 200) mit Zahlen im Bereich von -10000 bis 10000 gegeben sind, wobei die Anzahl der Spalten in der ersten der Anzahl der Zeilen in der zweiten entspricht, multiplizieren Sie die erste mit der zweiten. (Matrixmultiplikation ist nicht kommutativ.)

Sie können Eingaben und Ausgaben als Array von Arrays (oder Äquivalente), als Matrix (wenn Ihre Sprache dieses Format hat) oder als mehrzeilige Zeichenfolge angeben.

Sie dürfen keine eingebauten Funktionen für die Matrixmultiplikation verwenden.

Testfälle

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

Denken Sie daran, das ist Code-Golf , also gewinnt der Code mit den wenigsten Bytes.

Gelee , 7 5 Bytes

Z×þḅ1

Nimmt B und A als Argumente und gibt A × B zurück .

Probieren Sie es online!

Wie es funktioniert

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.

05AB1E , 13 Bytes

vyU²øvyX*O})ˆ

Probieren Sie es online!

Erläuterung

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

Python 2, 69 66 Bytes

Dies folgt nur der Standardformel, aber Lambda-D für die Prägnanz :) Der Code ohne Golf ist extrem einfach!

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

^{Vielen Dank an Alexi Torhamo für das Speichern von 3 Bytes! :)}

Ungolfed-Code:

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

J, 13 9 Bytes

Dank Meilen 4 Bytes gespart!

[:+/*"#:~

Dies ist eine Gabel mit Kappe:

[: +/ *"#:~

Welches ist gleichbedeutend mit:

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

Welches führt die gewünschte Multiplikation; diese werden dann aufsummiert.

Bei eingebautem Skalarprodukt 5 Bytes: +/ .*

Testfälle

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

Haskell , 57 56 54 Bytes

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

Probieren Sie es online!

Verwendung:

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(:))emit e=[]:eist eine kürzere Form von transpose.

Haskell , 45 Bytes

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

Probieren Sie es online!

Argumentiert in umgekehrter Reihenfolge.

R, 66 Bytes

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

Unbenannte Funktion, die zwei R-Matrizen als Eingabe verwendet und das Produkt zurückgibt. Es applywird verwendet, um Funktionen über Array-Ränder hinweg anzuwenden. forIn diesem Fall funktioniert es wie eine Doppelschleife: Geben Sie für jede Spalte Bund für jede Zeile von Adie Summe der (vektorisierten) Produkte zurück.

Vergleichen Sie mit dem reinen for-Loop-Ansatz ( 101Bytes):

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}

Mathematica, 20 Bytes

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

Anonyme Funktion. Nimmt zwei Rang-2-Listen von Zahlen als Eingabe und gibt eine Rang-2-Liste von Zahlen als Ausgabe zurück. Für die Neugierigen Innerist eine Funktion, die eine matrixmultiplikationsartige Anwendung von zwei Funktionen auf zwei Tensoren ausführt.

C #, 168 167 Bytes

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

Vielen Dank an @Mukul Kumar für das Speichern von 1 Byte, die while-Schleife war dieses Mal tatsächlich kürzer: P

Volles Programm mit Testfällen:

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;
    }
}

MATL , 12 11 Bytes

7L&!*Xs6Be!

Matrizen werden ;als Zeilentrennzeichen eingegeben .

Probieren Sie es online!

Die Matrixmultiplikation ohne eingebauten Code war Teil meiner Antwort auf Showcase of languages . Als ich jedoch versuchte, den ursprünglichen Code für diese Antwort wiederzuverwenden, stellte ich fest, dass er einen Fehler aufwies (die Zeilenvektorausgabe wurde falsch in einen Spaltenvektor konvertiert). Dies ist jetzt korrigiert, hier und da. Eine Erklärung der Funktionsweise des Codes finden Sie im entsprechenden Beitrag (Länge-11-Snippet).

C ++ 14, 173 168 156 146 Bytes

• -5 Bytes für die Rückgabe über Referenzparameter
• -12 Byte für die Verwendung von foreach und C.back()stattdessen aufi
• -10 Bytes zum Löschen C.clear()und BenötigenC , beim Start leer zu sein

Als unbenanntes Lambda:

[](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]);}}

Benötigt Ein- und Ausgabe als vector<vector<int>> und Ausgabe muss vorher leer sein.

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]
   );
 }
}
;

Stichprobe:

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";
 }
}

Schale , 7 6 Bytes

mMδṁ*T

Bitte beachten Sie die Argumentationsreihenfolge, versuchen Sie es online!

-1 Byte dank @Zgarb!

Erläuterung

Grundsätzlich tun, was die Definition der Matrixmultiplikation besagt:

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

JavaScript (ES6), 66 Byte

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

C # 131 Bytes

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

Ich habe Yodles Lösung mit der Annahme gestohlen, dass ich dies effizienter mit LINQ schreiben könnte (im Gegensatz zu for-Schleifen). Ich habe ein paar Versuche unternommen, es aber etwas zerkleinert.

Hier ist es etwas aufgeschlüsselt:

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

Der einzige wirkliche "Trick" ist hier die Matrixtransponierung B.First().Select((f, i) => B.Select(r => r.ElementAt(i))). Sobald wir die zweite Matrix transponieren, haben wir zwei Arrays A[i,x]und B[j,x]. Nehmen Sie das kartesische Produkt ( i*j) und packen Sie jedes dieser xLängen-Arrays zusammen.

Testcode:

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;
    }

}

Haskell , 49 Bytes

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

Probieren Sie es online!

Eingabe und Ausgabe sind Spaltenlisten. Ordnet jede Spalte der zweiten Matrix dieser Zeile zu, zippt mit den Spalten der ersten Matrix und skaliert jede Spalte, summiert als Vektor.

Ich habe das Gefühl, dass es eine gute Möglichkeit geben muss, dies zu korrigieren und eine Handvoll Bytes zu sparen, aber ich sehe es noch nicht.

Javascript, 128 Bytes

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++}}

Sie erhalten das Ergebnis, indem Sie nur $ überprüfen - es ist ein bisschen Betrug, aber hey, es hat ein paar Bytes gespart.

PHP, 110 Bytes

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;}

Drei Loops für die Elven Arrays. Das ist so einfach ... aber es gibt nicht viel zum Golfen.

Eigentlich 14 Bytes

Golfvorschläge willkommen! Probieren Sie es online!

┬@;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.

C 618 Bytes

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");};}

Eine benannte Funktion und bei weitem die längste Einreichung hier, zum Teil aufgrund der Tatsache, dass das Konvertieren der Zeichenarray-Eingaben in C 2-dimensionale Ganzzahl-Arrays die meisten Bytes in Anspruch nimmt, und auch, weil ich in C die längste Zeit nicht Golf gespielt habe. Ich arbeite immer noch daran, dies so weit wie möglich zu verkürzen, und alle Tipps dazu sind sehr willkommen.

Damit wird die Eingabe über die Befehlszeile mit den zwei durch zwei Zeichenfolgen dargestellten Matrizen durchgeführt, wobei jede Zeile durch Kommas und jede Zeile durch durch Leerzeichen getrennte Ganzzahlen getrennt ist. Zum Beispiel die Matrizen:

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

würde eingegeben werden als:

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

Die resultierende Matrix wird als mehrzeilige Zeichenfolge an STDOUT ausgegeben. Die Ausgabe für die obige Eingabe wäre beispielsweise:

 427 164 
1009 353 
1591 542 

Clojure, 60 Bytes

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

Viele Bytes für die Umsetzung des zweiten Arguments.

Ruby , 59 Bytes

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

Probieren Sie es online!