Open In App
Related Articles

Convert given lower triangular Matrix to 1D array

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given a lower triangular matrix M[][] of dimension N * N, the task is to convert it into a one-dimensional array by storing only non-zero elements.

Examples:

Input: M[][] = {{1, 0, 0, 0}, {2, 3, 0, 0}, {4, 5, 6, 0}, {7, 8, 9, 10}} 
Output:
Row-wise: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
Column-wise: {1, 2, 4, 7, 3, 5, 8, 6, 9, 10}
Explanation: All the non-zero elements of the matrix are {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}. 
Arranging these elements in row-wise manner in a 1D array generates the sequence {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}.
Arranging these elements in column-wise manner in a 1D array generates the sequence {1, 2, 4, 7, 3, 5, 8, 6, 9, 10}.

Input: M[][] = {{1, 0, 0, }, {2, 3, 0}, {4, 5, 6}}
Output:
Row-wise: {1, 2, 3, 4, 5, 6}
Column-wise: {1, 2, 4, 3, 5, 6}

Approach:To convert a 2-dimensional matrix to a 1-dimensional array following two methods are used:

Row – Major Order:

  • In this method, adjacent elements of a row are placed next to each other in the array.

  • The following formula is used to find out the respective positions of the non-zero elements of the lower triangular matrix in the 1-dimensional array. 
     

Index of matrix element at position (i, j) = ((i * (i – 1))/2 + j – 1)
where 1 ? i, j ? N and i ? j

Column – Major Order:

  • In this method, consecutive elements of a column are placed adjacently in the array.

  • The following formula is used to find out the respective positions of the non-zero elements of the lower triangular matrix in the 1-dimensional array. 
     

Index of matrix element at position (i, j) = (N * (j – 1) – ((j – 2) * (j – 1))/2) + (i – j)
where 1 ? i, j ? N and i ? j
 


  •  

Follow the steps below to solve the problem:

  • Initialize an array, say A[], to store the non-zero elements of the matrix.
  • Traverse the matrix M[][] and find the index of non-zero elements of the matrix in the array A[] using the formula for row-major mapping and insert each non-zero element in the array A[].
  • After completing the above step, print the array A[] for row-major mapping.
  • Again, traverse the matrix M[][] and find the index of non-zero elements of the matrix in the array A[] using the formula for column-major mapping and insert each non-zero element in the array A[].
  • After completing the above steps, print the array A[] for column-major mapping.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <iostream>
using namespace std;
 
// Class of Lower Triangular Matrix
class LTMatrix {
 
private:
    // Size of Matrix
    int n;
 
    // Pointer
    int* A;
 
    // Stores the count of non-zero
    // elements
    int tot;
 
public:
    // Constructor
    LTMatrix(int N)
    {
        this->n = N;
        tot = N * (N + 1) / 2;
        A = new int[N * (N + 1) / 2];
    }
 
    // Destructor
    ~LTMatrix() { delete[] A; }
 
    // Function to display array
    void Display(bool row = true);
 
    // Function to generate array
    // in Row - Major order
    void setRowMajor(int i, int j, int x);
 
    // Function to generate array
    // in Column - Major order
    void setColMajor(int i, int j, int x);
 
    // Function to find size of array
    int getN() { return n; }
};
 
// Function to generate array from
// given matrix by storing elements
// in column major order
void LTMatrix::setColMajor(int i, int j, int x)
{
    if (i >= j) {
 
        int index
            = (n * (j - 1) - (((j - 2) * (j - 1)) / 2))
              + (i - j);
 
        A[index] = x;
    }
}
 
// Function to generate array from
// given matrix by storing elements
// in row major order
void LTMatrix::setRowMajor(int i, int j, int x)
{
    if (i >= j) {
        int index = (i * (i - 1)) / 2 + j - 1;
        A[index] = x;
    }
}
 
// Function to display array elements
void LTMatrix::Display(bool row)
{
    for (int i = 0; i < tot; i++) {
        cout << A[i] << " ";
    }
    cout << endl;
}
 
// Function to generate and display
// array in Row-Major Order
void displayRowMajor(int N)
{
    LTMatrix rm(N);
 
    // Generate the array in the
    // row-major form
    rm.setRowMajor(1, 1, 1);
    rm.setRowMajor(2, 1, 2);
    rm.setRowMajor(2, 2, 3);
    rm.setRowMajor(3, 1, 4);
    rm.setRowMajor(3, 2, 5);
    rm.setRowMajor(3, 3, 6);
    rm.setRowMajor(4, 1, 7);
    rm.setRowMajor(4, 2, 8);
    rm.setRowMajor(4, 3, 9);
    rm.setRowMajor(4, 4, 10);
 
    // Display array elements
    // in row-major order
    cout << "Row-Wise:\n";
 
    rm.Display();
}
 
// Function to generate and display
// array in Column-Major Order
void displayColMajor(int N)
{
    LTMatrix cm(N);
 
    // Generate array in
    // column-major form
    cm.setColMajor(1, 1, 1);
    cm.setColMajor(2, 1, 2);
    cm.setColMajor(2, 2, 3);
    cm.setColMajor(3, 1, 4);
    cm.setColMajor(3, 2, 5);
    cm.setColMajor(3, 3, 6);
    cm.setColMajor(4, 1, 7);
    cm.setColMajor(4, 2, 8);
    cm.setColMajor(4, 3, 9);
    cm.setColMajor(4, 4, 10);
 
    // Display array elements
    // in column-major form
    cout << "Column-Wise:\n";
    cm.Display(false);
}
 
// Driver Code
int main()
{
    // Size of row or column
    // of square matrix
    int N = 4;
 
    // Function Call for row major
    // mapping
    displayRowMajor(N);
 
    // Function Call for column
    // major mapping
    displayColMajor(N);
 
    return 0;
}

                    

Java

// Java program for the above approach
import java.io.*;
class GFG {
 
    // Class of Lower Triangular Matrix
    static class LTMatrix {
 
        // Size of Matrix
        static int n;
 
        // Pointer
        static int A[];
 
        // Stores the count of non-zero
        // elements
        static int tot;
 
        // Constructor
        LTMatrix(int N)
        {
            this.n = N;
            tot = N * (N + 1) / 2;
            A = new int[N * (N + 1) / 2];
        }
 
        // Function to display array elements
        static void Display(boolean row)
        {
            for (int i = 0; i < tot; i++) {
                System.out.print(A[i] + " ");
            }
            System.out.println();
        }
 
        // Function to generate array from
        // given matrix by storing elements
        // in row major order
        static void setRowMajor(int i, int j, int x)
        {
            if (i >= j) {
                int index = (i * (i - 1)) / 2 + j - 1;
                A[index] = x;
            }
        }
 
        // Function to generate array from
        // given matrix by storing elements
        // in column major order
        static void setColMajor(int i, int j, int x)
        {
            if (i >= j) {
 
                int index = (n * (j - 1)
                             - (((j - 2) * (j - 1)) / 2))
                            + (i - j);
                A[index] = x;
            }
        }
 
        // Function to find size of array
        static int getN() { return n; }
    }
 
    // Function to generate and display
    // array in Row-Major Order
    static void displayRowMajor(int N)
    {
        LTMatrix rm = new LTMatrix(N);
 
        // Generate the array in the
        // row-major form
        rm.setRowMajor(1, 1, 1);
        rm.setRowMajor(2, 1, 2);
        rm.setRowMajor(2, 2, 3);
        rm.setRowMajor(3, 1, 4);
        rm.setRowMajor(3, 2, 5);
        rm.setRowMajor(3, 3, 6);
        rm.setRowMajor(4, 1, 7);
        rm.setRowMajor(4, 2, 8);
        rm.setRowMajor(4, 3, 9);
        rm.setRowMajor(4, 4, 10);
 
        // Display array elements
        // in row-major order
        System.out.println("Row-Wise:");
        rm.Display(false);
    }
 
    // Function to generate and display
    // array in Column-Major Order
    static void displayColMajor(int N)
    {
        LTMatrix cm = new LTMatrix(N);
 
        // Generate array in
        // column-major form
        cm.setColMajor(1, 1, 1);
        cm.setColMajor(2, 1, 2);
        cm.setColMajor(2, 2, 3);
        cm.setColMajor(3, 1, 4);
        cm.setColMajor(3, 2, 5);
        cm.setColMajor(3, 3, 6);
        cm.setColMajor(4, 1, 7);
        cm.setColMajor(4, 2, 8);
        cm.setColMajor(4, 3, 9);
        cm.setColMajor(4, 4, 10);
 
        // Display array elements
        // in column-major form
        System.out.println("Column-Wise:");
        cm.Display(false);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // Size of row or column
        // of square matrix
        int N = 4;
 
        // Function Call for row major
        // mapping
        displayRowMajor(N);
 
        // Function Call for column
        // major mapping
        displayColMajor(N);
    }
}
 
// This code is contributed by Dharanendra L V.

                    

Python3

# Python3 program for the above approach
 
# Class of Lower Triangular Matrix
class LTMatrix:
     
    # Constructor
    def __init__(self, N):
     
        self.n = N;
        self.tot = N * (N + 1) // 2;
        self.A = [None] * (int(N * (N + 1) / 2));
     
    # Function to display array elements
    def Display(self, row):
        for i in range(int(self.tot)):
            print(self.A[i], end = " ")
        print()
 
    # Function to generate array from
    # given matrix by storing elements
    # in row major order
    def setRowMajor(self, i, j, x):
     
        if (i >= j):
            index = (i * (i - 1)) // 2 + j - 1;
            self.A[index] = x;
         
    # Function to generate array from
    # given matrix by storing elements
    # in column major order
    def setColMajor(self, i, j, x):
     
        if (i >= j) :
 
            index =int((self.n * (j - 1)
                              - (((j - 2) * (j - 1)) / 2))
                             + (i - j));
            self.A[index] = x;
         
    # Function to find size of array
    def getN(self):
        return self.n;
 
# Function to generate and display
# array in Row-Major Order
def displayRowMajor(N):
 
    rm = LTMatrix(N);
 
    # Generate the array in the
    # row-major form
    rm.setRowMajor(1, 1, 1);
    rm.setRowMajor(2, 1, 2);
    rm.setRowMajor(2, 2, 3);
    rm.setRowMajor(3, 1, 4);
    rm.setRowMajor(3, 2, 5);
    rm.setRowMajor(3, 3, 6);
    rm.setRowMajor(4, 1, 7);
    rm.setRowMajor(4, 2, 8);
    rm.setRowMajor(4, 3, 9);
    rm.setRowMajor(4, 4, 10);
 
    # Display array elements
    # in row-major order
    print("Row-Wise:");
    rm.Display(False);
 
# Function to generate and display
# array in Column-Major Order
def displayColMajor(N):
 
    cm = LTMatrix(N);
 
    # Generate array in
    # column-major form
    cm.setColMajor(1, 1, 1);
    cm.setColMajor(2, 1, 2);
    cm.setColMajor(2, 2, 3);
    cm.setColMajor(3, 1, 4);
    cm.setColMajor(3, 2, 5);
    cm.setColMajor(3, 3, 6);
    cm.setColMajor(4, 1, 7);
    cm.setColMajor(4, 2, 8);
    cm.setColMajor(4, 3, 9);
    cm.setColMajor(4, 4, 10);
 
    # Display array elements
    # in column-major form
    print("Column-Wise:");
    cm.Display(False);
 
 
# Driver Code
 
# Size of row or column
# of square matrix
N = 4;
 
# Function Call for row major
# mapping
displayRowMajor(N);
 
# Function Call for column
# major mapping
displayColMajor(N);
 
# This code is contributed by phasing17

                    

C#

// C# program for the above approach
using System;
 
public class LTMatrix {
 
    // Size of Matrix
    static int n;
 
    // Pointer
    static int[] A;
 
    // Stores the count of non-zero
    // elements
    static int tot;
 
    // Constructor
    public LTMatrix(int N)
    {
        n = N;
        tot = N * (N + 1) / 2;
        A = new int[N * (N + 1) / 2];
    }
 
    // Function to display array elements
    public void Display(Boolean row)
    {
        for (int i = 0; i < tot; i++) {
            Console.Write(A[i] + " ");
        }
        Console.Write("");
    }
 
    // Function to generate array from
    // given matrix by storing elements
    // in row major order
    public void setRowMajor(int i, int j, int x)
    {
        if (i >= j) {
            int index = (i * (i - 1)) / 2 + j - 1;
            A[index] = x;
        }
    }
 
    // Function to generate array from
    // given matrix by storing elements
    // in column major order
    public void setColMajor(int i, int j, int x)
    {
        if (i >= j) {
 
            int index
                = (n * (j - 1) - (((j - 2) * (j - 1)) / 2))
                  + (i - j);
            A[index] = x;
        }
    }
 
    // Function to find size of array
    static int getN() { return n; }
}
class GFG {
 
    // Class of Lower Triangular Matrix
 
    // Function to generate and display
    // array in Row-Major Order
    static void displayRowMajor(int N)
    {
        LTMatrix rm = new LTMatrix(N);
 
        // Generate the array in the
        // row-major form
        rm.setRowMajor(1, 1, 1);
        rm.setRowMajor(2, 1, 2);
        rm.setRowMajor(2, 2, 3);
        rm.setRowMajor(3, 1, 4);
        rm.setRowMajor(3, 2, 5);
        rm.setRowMajor(3, 3, 6);
        rm.setRowMajor(4, 1, 7);
        rm.setRowMajor(4, 2, 8);
        rm.setRowMajor(4, 3, 9);
        rm.setRowMajor(4, 4, 10);
 
        // Display array elements
        // in row-major order
        Console.WriteLine("Row-Wise:");
        rm.Display(false);
    }
 
    // Function to generate and display
    // array in Column-Major Order
    static void displayColMajor(int N)
    {
        LTMatrix cm = new LTMatrix(N);
 
        // Generate array in
        // column-major form
        cm.setColMajor(1, 1, 1);
        cm.setColMajor(2, 1, 2);
        cm.setColMajor(2, 2, 3);
        cm.setColMajor(3, 1, 4);
        cm.setColMajor(3, 2, 5);
        cm.setColMajor(3, 3, 6);
        cm.setColMajor(4, 1, 7);
        cm.setColMajor(4, 2, 8);
        cm.setColMajor(4, 3, 9);
        cm.setColMajor(4, 4, 10);
 
        // Display array elements
        // in column-major form
        Console.WriteLine("\nColumn-Wise:");
        cm.Display(false);
    }
 
    // Driver Code
    public static void Main()
    {
 
        // Size of row or column
        // of square matrix
        int N = 4;
 
        // Function Call for row major
        // mapping
        displayRowMajor(N);
 
        // Function Call for column
        // major mapping
        displayColMajor(N);
    }
}
 
// This code is contributed by Saurabh Jaiswal

                    

Javascript

// JS program for the above approach
 
// Class of Lower Triangular Matrix
class LTMatrix {
    // Constructor
    constructor(N)
    {
        this.n = N;
        this.tot = N * (N + 1) / 2;
        this.A = new Array(Math.floor(N * (N + 1) / 2));
    }
 
    // Function to display array elements
    Display(row)
    {
        for (var i = 0; i < this.tot; i++) {
            process.stdout.write(this.A[i] + " ");
        }
        console.log();
    }
 
    // Function to generate array from
    // given matrix by storing elements
    // in row major order
    setRowMajor(i, j, x)
    {
        if (i >= j) {
            let index = (i * (i - 1)) / 2 + j - 1;
            this.A[index] = x;
        }
    }
 
    // Function to generate array from
    // given matrix by storing elements
    // in column major order
    setColMajor(i, j, x)
    {
        if (i >= j) {
 
            var index
                = Math.floor((this.n * (j - 1)
                              - (((j - 2) * (j - 1)) / 2))
                             + (i - j));
            this.A[index] = x;
        }
    }
 
    // Function to find size of array
    getN() { return this.n; }
}
 
// Function to generate and display
// array in Row-Major Order
function displayRowMajor(N)
{
    let rm = new LTMatrix(N);
 
    // Generate the array in the
    // row-major form
    rm.setRowMajor(1, 1, 1);
    rm.setRowMajor(2, 1, 2);
    rm.setRowMajor(2, 2, 3);
    rm.setRowMajor(3, 1, 4);
    rm.setRowMajor(3, 2, 5);
    rm.setRowMajor(3, 3, 6);
    rm.setRowMajor(4, 1, 7);
    rm.setRowMajor(4, 2, 8);
    rm.setRowMajor(4, 3, 9);
    rm.setRowMajor(4, 4, 10);
 
    // Display array elements
    // in row-major order
    console.log("Row-Wise:");
    rm.Display(false);
}
 
// Function to generate and display
// array in Column-Major Order
function displayColMajor(N)
{
    let cm = new LTMatrix(N);
 
    // Generate array in
    // column-major form
    cm.setColMajor(1, 1, 1);
    cm.setColMajor(2, 1, 2);
    cm.setColMajor(2, 2, 3);
    cm.setColMajor(3, 1, 4);
    cm.setColMajor(3, 2, 5);
    cm.setColMajor(3, 3, 6);
    cm.setColMajor(4, 1, 7);
    cm.setColMajor(4, 2, 8);
    cm.setColMajor(4, 3, 9);
    cm.setColMajor(4, 4, 10);
 
    // Display array elements
    // in column-major form
    console.log("Column-Wise:");
    cm.Display(false);
}
 
// Driver Code
 
// Size of row or column
// of square matrix
let N = 4;
 
// Function Call for row major
// mapping
displayRowMajor(N);
 
// Function Call for column
// major mapping
displayColMajor(N);
 
// This code is contributed by phasing17

                    

Output: 
Row-Wise:
1 2 3 4 5 6 7 8 9 10 
Column-Wise:
1 2 4 7 3 5 8 6 9 10

 

Time Complexity: O(N2)
Auxiliary Space: O(N2)



Last Updated : 23 Dec, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads