सभी चुनौतियाँ
आसान 0 हल किए गए 0% स्वीकृति

मैट्रिक्स गुणन

दो मैट्रिक्स का गुणा करें, जो न्यूरल नेटवर्क की हर लेयर के पीछे की गणना है।

आप क्या सीखेंगे

  • पंक्ति गुणा कॉलम से मैट्रिक्स गुणा करना
  • जाँचना कि आकार मेल खाते हैं
  • समझना कि लेयर मैट्रिक्स गुणन क्यों हैं

समस्या

न्यूरल नेटवर्क की लेयर, अटेंशन और मशीन लर्निंग का ज़्यादातर हिस्सा अंत में मैट्रिक्स गुणन पर आता है। n × k मैट्रिक्स A और k × m मैट्रिक्स B का गुणनफल C = A × B, n × m का होता है, और हर तत्व A की एक पंक्ति और B के एक कॉलम का डॉट प्रोडक्ट है:

C[i][j] = A[i][0] × B[0][j] + A[i][1] × B[1][j] + … + A[i][k-1] × B[k-1][j]

matmul(a, b) लागू करें।

इनपुट

a: एक n × k मैट्रिक्स।

b: एक k × m मैट्रिक्स (इसकी पंक्तियों की संख्या a के कॉलम की संख्या के बराबर)।

आउटपुट

n × m गुणनफल मैट्रिक्स लौटाएँ।

सीमाएँ

1 ≤ n, k, m ≤ 50

-100 ≤ हर मान ≤ 100

उदाहरण

उदाहरण 1
इनपुट:
a = [
    [1.0, 2.0],
    [3.0, 4.0]
]
b = [
    [5.0, 6.0],
    [7.0, 8.0]
]

अपेक्षित आउटपुट:
expected = [
    [19.0, 22.0],
    [43.0, 50.0]
]
इनपुट:
std::vector<std::vector<double>> a = {
    {1.0, 2.0},
    {3.0, 4.0}
};
std::vector<std::vector<double>> b = {
    {5.0, 6.0},
    {7.0, 8.0}
};

अपेक्षित आउटपुट:
std::vector<std::vector<double>> expected = {
    {19.0, 22.0},
    {43.0, 50.0}
};
इनपुट:
double[][] a = new double[][] {
    new double[] {1.0, 2.0},
    new double[] {3.0, 4.0}
};
double[][] b = new double[][] {
    new double[] {5.0, 6.0},
    new double[] {7.0, 8.0}
};

अपेक्षित आउटपुट:
double[][] expected = new double[][] {
    new double[] {19.0, 22.0},
    new double[] {43.0, 50.0}
};

व्याख्या

C[0][0] = 1×5 + 2×7 = 19, C[0][1] = 1×6 + 2×8 = 22, C[1][0] = 3×5 + 4×7 = 43 और C[1][1] = 3×6 + 4×8 = 50।

उदाहरण 2
इनपुट:
a = [
    [1.0, 0.0, 2.0]
]
b = [
    [3.0],
    [4.0],
    [5.0]
]

अपेक्षित आउटपुट:
expected = [
    [13.0]
]
इनपुट:
std::vector<std::vector<double>> a = {
    {1.0, 0.0, 2.0}
};
std::vector<std::vector<double>> b = {
    {3.0},
    {4.0},
    {5.0}
};

अपेक्षित आउटपुट:
std::vector<std::vector<double>> expected = {
    {13.0}
};
इनपुट:
double[][] a = new double[][] {
    new double[] {1.0, 0.0, 2.0}
};
double[][] b = new double[][] {
    new double[] {3.0},
    new double[] {4.0},
    new double[] {5.0}
};

अपेक्षित आउटपुट:
double[][] expected = new double[][] {
    new double[] {13.0}
};

व्याख्या

1 × 3 मैट्रिक्स को 3 × 1 मैट्रिक्स से गुणा करने पर 1 × 1 मैट्रिक्स मिलता है: 1×3 + 0×4 + 2×5 = 13।

कैसे हल करें

पहले खुद कोशिश करें, फिर एक-एक करके संकेत खोलें।

संकेत 1

हर output cell पहली matrix की एक row और दूसरी matrix के एक column से बनता है।

संकेत 2

Shared inner dimension के across products accumulate करें, फिर result को matching output position में रखें।

संकेत 3

Shapes का ध्यान रखें: पहली matrix का column count दूसरी matrix के row count के बराबर होना चाहिए।

अपेक्षित जटिलता

समय O(n k m), अतिरिक्त स्थान O(n m)

संदर्भ

यह चुनौती CodeUtility के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।

हर कोडर का सबसे अच्छा पास हुआ समाधान। तेज़, कम मेमोरी वाले और बेहतर रेटिंग वाले समाधान ऊपर रहते हैं।

अभी कोई पास हुआ समाधान नहीं है। इसे हल करें और पहला स्थान पाएँ।

दूसरों से सीखें

समुदाय समाधान

अभी तक कोई प्रकाशित समाधान नहीं। पहला साझा करने के लिए इस चुनौती को हल करें।