14

গণিতে, ম্যাট্রিক্স গুণ বা ম্যাট্রিক্স পণ্যটি একটি বাইনারি অপারেশন যা দুটি ম্যাট্রিক থেকে ম্যাট্রিক্স তৈরি করে। সংজ্ঞাটি রৈখিক সমীকরণ এবং ভেক্টরগুলিতে রৈখিক রূপান্তর দ্বারা অনুপ্রাণিত হয়, যার প্রয়োগকৃত গণিত, পদার্থবিজ্ঞান এবং প্রকৌশল ক্ষেত্রে অসংখ্য প্রয়োগ রয়েছে। আরও বিশদে, যদি A একটি এন × এম ম্যাট্রিক্স এবং বি একটি এম × পি ম্যাট্রিক্স হয় তবে তাদের ম্যাট্রিক্স পণ্য এবি একটি এন × পি ম্যাট্রিক্স হয়, যেখানে এ এর এক সারিতে জুড়ে এম এন্ট্রিগুলি এম এর এন্ট্রিগুলির সাথে নীচে গুণিত হয় বি এর কলাম এবং AB এর একটি এন্ট্রি উত্পাদন সংক্ষিপ্ত। যখন দুটি লিনিয়ার রূপান্তর ম্যাট্রিক্স দ্বারা প্রতিনিধিত্ব করা হয়, তখন ম্যাট্রিক্স পণ্য দুটি রূপান্তরগুলির সংমিশ্রণকে উপস্থাপন করে।

^{সূত্র: উইকিপিডিয়া}

অন্য কথায়, দুটি ম্যাট্রিককে গুণ করতে, উদাহরণস্বরূপ:

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

সম্পর্কে চ্যালেঞ্জ ওয়াই ছাড়া এক্স করছেন হয় নিরুৎসাহিত ।

— flawr

ইনপুট ম্যাট্রিকগুলিতে কি ভাসমান পয়েন্ট সংখ্যা থাকতে পারে? যদি তা হয় তবে আমি কয়েকজনের সাথে একটি পরীক্ষার কেস যুক্ত করার পরামর্শ দিচ্ছি।

— আর কাপ,

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

সুতরাং অপেক্ষা করুন, অন্তর্নির্মিত এবং ম্যাট্রিকগুলি গুণিত করার জন্য ম্যানুয়াল উপায় সমাপ্তি জেলিতে একই সংখ্যক বাইট? এটি বিভ্রান্তিকর, তবে দুর্দান্ত।

— Yodle

@ ইয়ডল বিল্ট-ইনটি æ×যা 2 বাইট।

— এরিক দ্য আউটগল্ফার

@ এরিকথ আউটগল্ফার এটি পুনর্বিবেচনা 2 এর সাথে সম্পর্কিত ছিল, যা æ.পরমাণুটি ব্যবহার করেছিল ।

— ডেনিস

4

05 এ বি 1 ই , 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

জে, 13 9 বাইট

মাইল থেকে 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

এটি অনলাইন চেষ্টা করুন!

বিপরীত ক্রমে যুক্তি নেয় T

— xnor
সূত্র

2

আর, 66 বাইট

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

নামহীন ফাংশন দুটি আর-ম্যাট্রিকিকে ইনপুট হিসাবে গ্রহণ করে এবং পণ্যটি ফেরত দেয়। এটি ব্যবহার করে 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কলগুলির চেয়ে কিছু করতে পারেন না ?

— rturnbull

@ আর্টারনবুল আমি নিশ্চিত নই যে বাইরের কীভাবে ম্যাট্রিক্সের সাথে মিলিতভাবে কাজ করে তবে এই ক্ষেত্রে এটি একটি 4-ডি অ্যারে তৈরি করতে পারে।

— বিলিওব

হ্যাঁ, এটি কিছুটা সমস্যাযুক্ত। ম্যাট্রিকগুলিকে লিনিয়ারাইজিং করতে এখানে আপনার পদ্ধতির চেয়ে বেশি বাইট লাগতে পারে

— rturnbull

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 মুকুল কুমার 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 বাইট।

— Yodle

1

for (;i <n;i++) -> while (i++<n)1 বাইট সংরক্ষণ করুন

— মুকুল কুমার

আমার যখন মোটামুটি আলাদা উত্তর হবে তখন শিষ্টাচার সম্পর্কে নিশ্চিত নই, তবে আমার বিকল্পটি অবশ্যই এ থেকে অনুপ্রাণিত হয়েছিল।

— কર્ક

2

এমএটিএল , 12 11 বাইট

7L&!*Xs6Be!

ম্যাট্রিকগুলি ;সারি বিভাজক হিসাবে ইনপুট হয় ।

এটি অনলাইন চেষ্টা করুন!

বিল্টিন ছাড়া ম্যাট্রিক্সের গুণটি ভাষার শোকেসে আমার জবাবের অংশ ছিল । তবে, এই উত্তরের জন্য মূল কোডটি পুনরায় ব্যবহার করার চেষ্টা করার সময় আমি বুঝতে পারলাম এটিতে একটি বাগ রয়েছে (সারি ভেক্টর আউটপুট ভুলভাবে একটি কলাম ভেক্টরে রূপান্তরিত হয়েছিল)। এটি এখন এখানে এবং সেখানে উভয়ই সংশোধন করা হয়েছে। কোডটি কীভাবে কাজ করে তার ব্যাখ্যার জন্য, উল্লিখিত পোস্টটি দেখুন (দৈর্ঘ্য -11 স্নিপেট)।

— লুইস মেন্ডো
সূত্র

2

সি ++ 14, 173 168 156 146 বাইট

রেফারেন্স প্যারামিটারের মাধ্যমে ফেরার জন্য -5 বাইট
ফোরচ ব্যবহার এবং C.back()পরিবর্তে গণনা করার জন্য -12 বাইটi
ড্রপ C.clear()এবং Cশুরুতে খালি থাকার জন্য -10 বাইট

নামবিহীন ল্যাম্বদা হিসাবে:

[](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 বাইট @ জগারবকে ধন্যবাদ!

ব্যাখ্যা

ম্যাট্রিক্স-গুণক সাইসের সংজ্ঞাটি মূলত যা করছেন:

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

জাভাস্ক্রিপ্ট (ES6), 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()))));

আমি লিনকিউ (লুপগুলির বিপরীতে) ব্যবহার করে আরও দক্ষতার সাথে এটি লিখতে পারি এই ধারণার সাথে আমি ইয়োডলের সমাধানটি চুরি করেছি । কয়েকবার চেষ্টা করেও কিছুটা কমে গিয়েছিল।

এখানে এটি কিছুটা ভেঙে গেছে:

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

— কर्क

আমি এখনই কিছুটা উত্তর দিচ্ছি, এবং যা আমি দেখেছি তা থেকে, আপনার উত্তরটি (আপনি যা যা বাইট গণনা সহ অন্তর্ভুক্ত করছেন) কাজ করতে হবে যদি আপনি এটি কেবল একটি প্রোগ্রামে আটকান তবে। সি # এর জন্য, যদি আপনি কেবল একটি ফাংশন লিখছেন তবে আপনার ক্লাস সংজ্ঞা বা স্ট্যাটিক শূন্যস্থানীয় মেইন () স্টাফ অন্তর্ভুক্ত করার দরকার নেই, তবে যদি আপনার সমাধানটি কনসোল.ওরাইটলাইন () এর মতো কোনও লাইব্রেরি স্টাফ ব্যবহার করে তবে আপনাকে অবশ্যই করতে হবে সিস্টেম.কনসোল.উরাইটলাইন () বা সিস্টেম ব্যবহার করে; যেহেতু একটি কম হতে পারে।

— Yodle

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

আপনি কেবল checking পরীক্ষা করে ফলাফলটি পেয়েছেন - এটি প্রতারক, তবে ওহে, এটি কয়েকটি বাইট সংরক্ষণ করেছে।

— মার্কাস দির
সূত্র

0

পিএইচপি, 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");};}

একটি নামকৃত ফাংশন এবং এ পর্যন্ত এখানে দীর্ঘতম জমা দেওয়া, আংশিকভাবে এই কারণে যে চরিত্রের অ্যারের ইনপুটগুলিকে সি-দ্বি মাত্রিক পূর্ণসংখ্যার অ্যারে রূপান্তর করা সর্বাধিক বাইট গ্রহণ করছে, এবং এটিও কারণ আমি দীর্ঘ সময় সিতে গল্ফ করিনি। আমি এখনও এটি যতটা পারি সংক্ষিপ্ত করতে কাজ করছি এবং এটি করার যে কোনও টিপসই অনেক প্রশংসাযোগ্য।

এখন, পথ ছাড়ার সাথে সাথে, কমান্ড লাইনের মধ্য দিয়ে দুটি ম্যাট্রিকের সাথে দুটি স্ট্রিং দ্বারা প্রতিনিধিত্ব করা ইনপুট নেবে, প্রতিটি কমা দ্বারা পৃথক করা সারি এবং প্রতিটি সারিতে স্থান পৃথক পূর্ণসংখ্য দ্বারা উপস্থাপিত হয়। উদাহরণস্বরূপ, ম্যাট্রিক্স:

   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

— আর কাপ
সূত্র

টিআইও 539 বাইট

— গিরোবুজ

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 বাইট

কিভাবে এটা কাজ করে

05 এ বি 1 ই , 13 বাইট

পাইথন 2, 69 66 বাইট

জে, 13 9 বাইট

পরীক্ষার মামলা

হাস্কেল , 57 56 54 বাইট

হাস্কেল , 45 বাইট

আর, 66 বাইট

গণিত, 20 বাইট

সি #, 168 167 বাইট

এমএটিএল , 12 11 বাইট

সি ++ 14, 173 168 156 146 বাইট

কান্ড , 7 6 বাইট

ব্যাখ্যা

জাভাস্ক্রিপ্ট (ES6), 66 বাইট

সি #, 131 বাইট

হাস্কেল , 49 বাইট

জাভাস্ক্রিপ্ট, 128 বাইট

পিএইচপি, 110 বাইট

আসলে , 14 বাইট

সি, 618 বাইট

ক্লোজার, 60 বাইট

রুবি , 59 বাইট