రెండు మాత్రికల చేరిక


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది అలేషన్ asana విష్
అర్రే మాట్రిక్స్ స్కూల్ ప్రోగ్రామింగ్

సమస్యల నివేదిక

“రెండు మాత్రికల సంకలనం” సమస్యలో, మేము రెండు మాత్రికలను a మరియు b ఇచ్చాము. మేము ఫైనల్ను కనుగొనాలి మాత్రిక మాతృకలో మాతృక b ని జోడించిన తరువాత a. రెండు మాత్రికలకు ఆర్డర్ ఒకేలా ఉంటే, మనం మాత్రమే వాటిని జోడించగలము, లేకపోతే మనం చేయలేము. మేము వాటిని జోడించలేకపోతే, “మేము ఈ మాత్రికలను జోడించలేము” అని ముద్రించండి.

ఇన్‌పుట్ ఫార్మాట్

మొదటి పంక్తి నాలుగు పూర్ణాంక విలువలు r1, c1, r2, c2. ఇక్కడ r1 మరియు c1 మొదటి మాతృక యొక్క అడ్డు వరుసలు మరియు నిలువు వరుసల సంఖ్యను సూచిస్తాయి. మరియు r2, c2 వరుసల సంఖ్యను, రెండవ మాతృక యొక్క నిలువు వరుసలను సూచిస్తుంది.

C1 పూర్ణాంక విలువలను కలిగి ఉన్న తదుపరి r1 పంక్తులు.

మరియు సి 2 పూర్ణాంక విలువలను కలిగి ఉన్న తదుపరి r2 పంక్తులు.

అవుట్పుట్ ఫార్మాట్

ప్రతి అడ్డు వరుస కొత్త పంక్తి నుండి మొదలయ్యే విధంగా మరియు ప్రతి అడ్డు వరుసలో ఖాళీతో వేరు చేయబడిన ప్రతి మూలకాన్ని జోడించిన తర్వాత తుది మాతృకను ముద్రించండి.

అవరోధాల

  • 1 <= r1, c1, r2, c2 <= 5000.
  • 1 <= | మ [i] [జ] | <= 10 ^ 9 ఇక్కడ m అనేది మాతృక మరియు ith అడ్డు వరుస మరియు jth కాలమ్ వద్ద మూలకం యొక్క స్థానం.

ఉదాహరణ

2 2 2 2
4 8
3 7
1 0
5 2
5 8
8 9

వివరణ: మ్యాట్రిక్స్ A మరియు B లలో సంబంధిత ఎంట్రీలను జోడించడం ద్వారా మేము మాత్రికల చేరికను కనుగొనవచ్చు.

రెండు మాత్రికల చేరిక

రెండు మాత్రికల చేరిక

రెండు మాత్రికల చేరిక

రెండు మాత్రికల చేరిక

రెండు మాత్రికలను చేర్చడానికి అల్గోరిథం

1. రెండు మాత్రికలలోని ప్రతి అడ్డు వరుసకు.

1.1 మాతృక A లోని మూలకాలతో మ్యాట్రిక్స్ B లోని సంబంధిత అంశాలను జోడించండి.

1.2 ఫలితాన్ని కొన్ని సహాయక మాతృకలో ఒకే స్థానంలో నిల్వ చేయండి.

2. తదుపరి అడ్డు వరుసకు వెళ్లి, మాత్రికల ముగింపు వరకు 1.1 మరియు 1.2 దశలను అనుసరించండి.

3. సహాయక మాతృకను ముద్రించండి.

అమలు

రెండు మాత్రికలను చేర్చడానికి సి ++ ప్రోగ్రామ్

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int r1,c1,r2,c2;
    cin>>r1>>c1>>r2>>c2;
    int a[r1][c1];
    int b[r2][c2];
    for(int i=0;i<r1;i++)
    {
        for(int j=0;j<c1;j++)
        {
            cin>>a[i][j];
        }
    }
    for(int i=0;i<r2;i++)
    {
        for(int j=0;j<c2;j++)
        {
            cin>>b[i][j];
        }
    }
    if(c1!=c2 || r1!=r2)
    {
        cout<<"We can’t add these matrices";
    }
    else
    {
    int c[r1][c2];
    for(int i=0;i<r1;i++)
    {
        for(int j=0;j<c2;j++)
        {
            c[i][j]=a[i][j]+b[i][j];
            cout<<c[i][j]<<"  ";
        }
        cout<<endl;
    }
    }
    return 0;
}

రెండు మాత్రికలను చేర్చడానికి జావా ప్రోగ్రామ్

import java.io.*; 
import java.util.Scanner;
class TutorialCup
{ 
    // Driver code 
    public static void main(String[] args) 
    { 
        int r1,c1,r2,c2;
        Scanner inp = new Scanner(System.in);
        r1 = inp.nextInt();
        c1 = inp.nextInt();
        r2 = inp.nextInt();
        c2 = inp.nextInt();
        int a[][] = new int[r1][c1];
        for(int i=0;i<r1;i++)
        {
            for(int j=0;j<c1;j++)
            {
                a[i][j]=inp.nextInt();
            }
        }
        int b[][] = new int[r2][c2];
        for(int i=0;i<r2;i++)
        {
            for(int j=0;j<c2;j++)
            {
                b[i][j]=inp.nextInt();
            }
        }
        if(r1!=r2 && c1!=c2) 
        { 
            System.out.println("\nWe can’t add these matrices."); 
        } 
        else
        {
            int c[][] = new int[r1][c1];
            for(int i=0;i<r1;i++)
            {
                for(int j=0;j<c1;j++)
                {
                    c[i][j]=a[i][j]+b[i][j];
                    System.out.print(c[i][j] + " ");
                }
                System.out.println();
            }
        }
    } 
}
2 2 2 2
2 8 
0 9 
5 6 
11 3
7 14
11 12

రెండు మాత్రికలను చేర్చడానికి సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

O (n ^ 2) ఇక్కడ n అనేది గరిష్టంగా r1 మరియు c1. ఇక్కడ మనం రెండు లూప్‌లను మొదటి లూప్ రన్ r1 సార్లు మరియు రెండవ లూప్ c1 సార్లు రన్ చేస్తాము.

అంతరిక్ష సంక్లిష్టత

O (మ ^ 2) ఇక్కడ m అనేది గరిష్టంగా r1 మరియు c1. ఇచ్చిన మెట్రిక్‌ల కలయిక ఫలితాన్ని నిల్వ చేయడానికి ఇక్కడ మేము అదనపు స్థలాన్ని సృష్టిస్తాము. ఇక్కడ మేము ఇన్పుట్ తీసుకోవటానికి మొదటి మాతృకను r1 * c1 పరిమాణాన్ని మరియు రెండవ మాతృకను ఇన్పుట్ తీసుకోవటానికి r2 * c2 పరిమాణాన్ని కూడా ప్రకటించాము.

సూచన