Trong toán học, phép nhân ma trận hoặc sản phẩm ma trận là một phép toán nhị phân tạo ra ma trận từ hai ma trận. Định nghĩa được thúc đẩy bởi các phương trình tuyến tính và biến đổi tuyến tính trên các vectơ, có nhiều ứng dụng trong toán học ứng dụng, vật lý và kỹ thuật. Chi tiết hơn, nếu A là ma trận n × m và B là ma trận m × p, thì sản phẩm ma trận AB của họ là ma trận n × p, trong đó các mục nhập m trên một hàng của A được nhân với các mục nhập m các cột của B và được tổng hợp để tạo ra một mục AB. Khi hai phép biến đổi tuyến tính được biểu diễn bằng ma trận, thì sản phẩm ma trận đại diện cho thành phần của hai phép biến đổi.

^{Nguồn: Wikipedia}

Nói cách khác, để nhân hai ma trận, ví dụ:

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

Đầu tiên, lấy hàng số 1 trong ma trận đầu tiên, cột số 1 trong ma trận thứ hai và nhân 1với 1, 2bởi 3và 3bởi 4.

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

Bây giờ thêm chúng lại với nhau để có được mục đầu tiên của bạn:

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

Đối với số thứ hai trong cột đầu tiên của kết quả, bạn sẽ cần lấy hàng số 2 thay vì hàng số 1 và làm điều tương tự.

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

Sau khi bạn thực hiện toàn bộ cột đầu tiên, kết quả sẽ như sau:

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

Bây giờ, làm lại chính xác điều đó một lần nữa, nhưng lấy cột thứ hai thay vì cột thứ nhất, dẫn đến:

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

Nhiệm vụ của bạn

Cho hai ma trận (kích thước tối đa 200x200), chứa các số trong phạm vi -10000 đến 10000, trong đó số cột trên cột đầu tiên bằng số lượng hàng trên giây, nhân số thứ nhất với số thứ hai. (Phép nhân ma trận là không giao hoán.)

Bạn có thể lấy đầu vào và đưa ra đầu ra dưới dạng một mảng các mảng (hoặc tương đương), một ma trận (nếu ngôn ngữ của bạn có định dạng đó) hoặc một chuỗi nhiều dòng.

Bạn không được sử dụng bất kỳ tích hợp nào để nhân ma trận.

Các trường hợp thử nghiệm

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

Hãy nhớ rằng, đây là mã golf , vì vậy mã có ít byte nhất sẽ thắng.

Thạch , 7 5 byte

Z×þḅ1

Đưa B và A như các đối số và trả về A × B .

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

vyU²øvyX*O})ˆ

Hãy thử trực tuyến!

Giải trình

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 byte

Điều này chỉ tuân theo công thức tiêu chuẩn, nhưng lambda-d cho sự đồng nhất :) Mã không mã hóa là cực kỳ đơn giản!

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

^{Cảm ơn Alexi Torhamo vì đã tiết kiệm 3 byte! :)}

Mã bị đánh cắp:

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 byte

Saved 4 byte nhờ dặm!

[:+/*"#:~

Đây là một ngã ba giới hạn:

[: +/ *"#:~

Tương đương với:

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

Mà thực hiện phép nhân mong muốn; những cái này sau đó được tóm tắt

Với một sản phẩm chấm được tích hợp sẵn, 5 byte: +/ .*

Các trường hợp thử nghiệm

   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 byte

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

Hãy thử trực tuyến!

Sử dụng:

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(:))evới e=[]:elà một hình thức ngắn hơn transpose.

Haskell , 45 byte

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

Hãy thử trực tuyến!

Đưa ra các đối số theo thứ tự đảo ngược.

R, 66 byte

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

Hàm không tên lấy hai ma trận R làm đầu vào và trả về sản phẩm. Nó sử dụng applyđược sử dụng để áp dụng các hàm trên các lề của mảng. Nó hoạt động giống như một forvòng lặp kép trong trường hợp này: cho mỗi cột của Bvà cho mỗi hàng của A, trả về tổng của các sản phẩm (được vector hóa).

So sánh với cách tiếp cận vòng lặp thuần ( 101byte):

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}

Toán học, 20 byte

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

Chức năng ẩn danh. Lấy hai danh sách số thứ hạng 2 làm đầu vào và trả về danh sách số thứ hạng 2 làm đầu ra. Đối với những người tò mò, Innerlà một hàm thực hiện một ứng dụng giống như ma trận của hai hàm cho hai tenxơ.

C #, 168 167 byte

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

Cảm ơn bạn @Mukul Kumar vì đã tiết kiệm 1 byte, vòng lặp while thực sự ngắn hơn lần này: P

Chương trình đầy đủ với các trường hợp thử nghiệm:

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 byte

7L&!*Xs6Be!

Ma trận được nhập vào bằng cách sử dụng ;dấu phân cách hàng.

Hãy thử trực tuyến!

Phép nhân ma trận mà không có nội dung là một phần câu trả lời của tôi cho Showcase của các ngôn ngữ . Tuy nhiên, khi thử sử dụng lại mã gốc cho câu trả lời này, tôi nhận ra rằng nó có một lỗi (đầu ra vectơ hàng được chuyển đổi không chính xác thành một vectơ cột). Điều này bây giờ được sửa chữa, cả ở đây và ở đó. Để biết giải thích về cách thức hoạt động của mã, hãy xem bài đăng được giới thiệu (đoạn dài 11 đoạn).

C ++ 14, 173 168 156 146 byte

• -5 byte để trả về qua tham số tham chiếu
• -12 byte để sử dụng foreach và C.back()thay vào đó là dựa vàoi
• -10 byte để thả C.clear()và yêu cầu Ctrống khi bắt đầu

Như lambda chưa được đặt tên:

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

Yêu cầu đầu vào và đầu ra như vector<vector<int>>và đầu ra phải trống trước.

Ung dung:

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

Mẫu vật:

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

Husk , 7 6 byte

mMδṁ*T

Xin lưu ý thứ tự đối số, thử trực tuyến!

-1 byte nhờ @Zgarb!

Giải trình

Về cơ bản chỉ làm những gì định nghĩa của sais nhân ma trận:

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 byte

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

Tôi đã đánh cắp giải pháp của Yodle với giả định rằng tôi có thể viết điều này hiệu quả hơn bằng cách sử dụng LINQ (trái ngược với các vòng lặp). Mất một vài nỗ lực nhưng đã giảm nó xuống một chút.

Ở đây nó bị phá vỡ phần nào:

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í quyết' thực sự duy nhất ở đây là ma trận chuyển vị , B.First().Select((f, i) => B.Select(r => r.ElementAt(i))). Khi chúng ta hoán chuyển ma trận thứ hai, chúng ta có hai mảng A[i,x]và B[j,x]. Lấy sản phẩm cartesian ( i*j) và Zip mỗi cáix mảng có độ dài đó cùng nhau.

Mã kiểm tra:

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 byte

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

Hãy thử trực tuyến!

Đầu vào và đầu ra là danh sách các cột. Ánh xạ từng cột của ma trận thứ hai vào hàng đó, được nén với các cột của ma trận thứ nhất và chia tỷ lệ từng cột, được tóm tắt dưới dạng một vectơ.

Tôi cảm thấy rằng phải có một cách hay để biến điều này thành vô nghĩa và tiết kiệm được một số byte, nhưng tôi chưa thấy nó.

Javascript, 128 byte

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

Bạn nhận được kết quả chỉ bằng cách kiểm tra $ - thật là gian lận, nhưng này, nó đã lưu một vài byte.

PHP, 110 byte

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

Ba vòng cho các mảng elven. Điều này rất đơn giản ... nhưng có rất nhiều môn đánh gôn.

Trên thực tế , 14 byte

Gợi ý chơi golf chào mừng! Hãy thử trực tuyến!

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

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

Một chức năng được đặt tên và cho đến nay lần gửi dài nhất ở đây, một phần là do việc chuyển đổi các đầu vào mảng ký tự thành mảng số nguyên 2 chiều C chiếm nhiều byte nhất và cũng vì tôi đã không chơi golf trong C trong thời gian dài nhất. Tôi vẫn đang làm việc để rút ngắn điều này nhiều nhất có thể, và bất kỳ lời khuyên nào trong việc này đều được đánh giá cao.

Bây giờ, theo cách đó, điều này đưa đầu vào qua dòng lệnh với hai ma trận được biểu thị bằng hai chuỗi, với mỗi chuỗi chứa các hàng được phân tách bằng dấu phẩy và mỗi hàng được biểu thị bằng các số nguyên cách nhau bằng dấu cách. Ví dụ: ma trận:

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

sẽ là đầu vào như:

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

Ma trận kết quả là đầu ra cho STDOUT dưới dạng một chuỗi nhiều dòng. Ví dụ: đầu ra cho đầu vào trên sẽ là:

 427 164 
1009 353 
1591 542 

Clojure, 60 byte

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

Nhiều byte dành cho việc hoán chuyển đối số thứ 2.

Ruby , 59 byte

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

Hãy thử trực tuyến!