మ్యాట్రిక్స్ యొక్క బదిలీ


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

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

“ట్రాన్స్‌పోజ్ ఆఫ్ ఎ మ్యాట్రిక్స్” సమస్యలో, మేము మాతృక ఇచ్చాము. మేము ట్రాన్స్పోజ్ను కనుగొనాలి మాత్రిక మరియు దానిని ముద్రించండి.

గమనిక:  ట్రాన్స్‌పోస్_ఆఫ్ మ్యాట్రిక్స్ ఒక మ్యాట్రిక్స్, దీని వరుసలు నిలువు వరుసలు మరియు నిలువు వరుసలు అసలు_మాట్రిక్స్ యొక్క వరుసలు.

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

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

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

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

ప్రతి అడ్డు వరుస కొత్త పంక్తి నుండి మొదలవుతుంది మరియు ప్రతి అడ్డు వరుసలో ఖాళీతో వేరు చేయబడిన ప్రతి మూలకం మార్పిడి చేసిన తరువాత ఫైనల్_మాట్రిక్స్ ముద్రించండి.

అవరోధాల

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

ఉదాహరణ

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

వివరణ: ఇచ్చిన_మాట్రిక్స్ యొక్క పారదర్శకతను కనుగొనటానికి n * m మాతృక యొక్క సాధారణ ప్రక్రియను నేను క్రింద వివరించాను.

మ్యాట్రిక్స్ యొక్క బదిలీ

మ్యాట్రిక్స్ యొక్క బదిలీ

మాతృక యొక్క బదిలీ కోసం అల్గోరిథం

  1. The_matrix యొక్క పారదర్శకతను నిల్వ చేసే సహాయక డమ్మీ_మాట్రిక్స్ సృష్టించండి.
  2. మొదటి మాతృకలోని వరుస కోసం, కొత్తగా నిర్మించిన మాతృకలోని మొదటి నిలువు వరుసగా చేయండి.
  3. తదుపరి వరుసకు తరలించి, అన్ని అడ్డు వరుసల కోసం చేయండి.
    3.1 B [i] [j] = A [j] [i], B అనేది A యొక్క ట్రాన్స్పోజ్.
  4. అన్ని అడ్డు వరుసలను పూర్తి చేసిన తరువాత, క్రొత్త_మాట్రిక్స్ను ముద్రించండి, ఇది ఇచ్చిన_మాట్రిక్స్ యొక్క మార్పిడి.

అమలు

సి ++ ప్రోగ్రామ్ ఫర్ ట్రాన్స్పోజ్ ఫర్ ఎ మ్యాట్రిక్స్

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int r1,c1;
    cin>>r1>>c1;
    int a[r1][c1];
    for(int i=0;i<r1;i++)
    {
        for(int j=0;j<c1;j++)
        {
            cin>>a[i][j];
        }
    }
    int b[c1][r1];
    for(int i=0;i<r1;i++)
    {
        for(int j=0;j<c1;j++)
        {
            b[j][i]=a[i][j];
        }
    }
    for(int i=0;i<c1;i++)
    {
        for(int j=0;j<r1;j++)
        {
            cout<<b[i][j]<<" ";
        }
        cout<<endl;
    }
    return 0;
}

జావా ప్రోగ్రామ్ ఫర్ ట్రాన్స్పోస్ ఫర్ ఎ మ్యాట్రిక్స్

import java.io.*; 
import java.util.Scanner;
class sum
{ 
    // Driver code 
    public static void main(String[] args) 
    { 
        int r1,c1;
        Scanner inp = new Scanner(System.in);
        r1 = inp.nextInt();
        c1 = 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[c1][r1];
        for(int i=0;i<r1;i++)
        {
             for(int j=0;j<c1;j++)
             {
                 b[j][i]=a[i][j];
             }
        }
        for(int i=0;i<c1;i++)
        {
             for(int j=0;j<r1;j++)
             {
                 System.out.print(b[i][j]+" ");
             }
             System.out.println();
        }
    } 
}
2 4
1 2 3 4
5 6 7 8
1 5 
2 6 
3 7 
4 8

మ్యాట్రిక్స్ యొక్క బదిలీ కోసం సంక్లిష్టత విశ్లేషణ

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

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

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

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

సూచన