Convert given upper triangular Matrix to 1D Array

Last Updated : 21 Dec, 2022

Given an upper triangular matrix M[][] of dimensions N * N, the task is to convert it into an one-dimensional array storing only non-zero elements from the matrix.

Examples:

Input: M[][] = {{1, 2, 3, 4}, {0, 5, 6, 7}, {0, 0, 8, 9}, {0, 0, 0, 10}}
Output: Row-wise: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
Column-wise: {1, 2, 5, 3, 6, 8, 4, 7, 9, 10}
Explanation: All the non-zero elements of the matrix are {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Input: M[][] = {{1, 2, 3, }, {0, 4, 5}, {0, 0, 6}}
Output: Row-wise: {1, 2, 3, 4, 5, 6}
Column-wise: {1, 2, 4, 3, 5, 6}
Explanation: All the non-zero elements of the matrix are {1, 2, 3, 4, 5, 6}

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

Row - Major Order:

In this method, elements are stored such that consecutive elements of a row are placed consecutively in the array.

The following formula is used to find the correct position of non-zero matrix elements in the array:

Element present at index (i, j) in the matrix is placed at [N * (i - 1) - (i - 2) * (i -1) /2] + (j - i)
where 1 ? i, j ? N and i ? j

Column-Major Order:

In this method, elements are stored such that consecutive elements of a column are placed consecutively in the array.

The following formula is used to find out the correct position of non-zero matrix elements:

Element present at index (i, j) in the matrix is placed at [j * (j - 1) / 2] + i - 1
where 1 ? i, j ? N and i ? j.

Follow the steps below to solve the problem:

Initialize an array A[] to store non-zero matrix elements.
Traverse the matrix M[][].
Find the correct indices of non-zero matrix elements in the array A[] using the above formulas.
Place the non-zero elements at the correct indices of A[] accordingly.
Finally, print the array A[] obtained.

Below is the implementation of the above approach:

C++

// C++ Program to convert a given
// upper triangular matrix to 1D array

#include <iostream>
using namespace std;

// Create a class of Upper
// Triangular Matrix
class UTMatrix {

private:
    // Size of Matrix
    int n;

    // Pointer
    int* A;

    // Stores count of
    // non-zero elements
    int tot;

public:
    // Constructor
    UTMatrix(int N)
    {
        this->n = N;
        tot = N * (N + 1) / 2;
        A = new int[N * (N + 1) / 2];
    }

    // Destructor
    ~UTMatrix() { 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 return size of array
    int getN() { return n; }
};

// Function to generate array from given matrix
// by storing elements in column major order
void UTMatrix::setColMajor(int i, int j, int x)
{
    if (i <= j) {
        int index = ((j * (j - 1)) / 2) + i - 1;
        A[index] = x;
    }
}

// Function to generate array from given matrix
// by storing elements in row major order
void UTMatrix::setRowMajor(int i, int j, int x)
{
    if (i <= j) {
        int index
            = (n * (i - 1) - (((i - 2) * (i - 1)) / 2))
              + (j - i);
        A[index] = x;
    }
}

// Function to display array elements
void UTMatrix::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)
{
    UTMatrix rm(N);

    // Generate array in
    // row-major form
    rm.setRowMajor(1, 1, 1);
    rm.setRowMajor(1, 2, 2);
    rm.setRowMajor(1, 3, 3);
    rm.setRowMajor(1, 4, 4);
    rm.setRowMajor(2, 2, 5);
    rm.setRowMajor(2, 3, 6);
    rm.setRowMajor(2, 4, 7);
    rm.setRowMajor(3, 3, 8);
    rm.setRowMajor(3, 4, 9);
    rm.setRowMajor(4, 4, 10);

    // Display array elements in
    // row-major order
    cout << "Row-Wise: ";

    rm.Display();
}

// Function to generate and display
// array in Column-Major Order
void displayColMajor(int N)
{
    UTMatrix cm(N);

    // Generate array in
    // column-major form
    cm.setColMajor(1, 1, 1);
    cm.setColMajor(1, 2, 2);
    cm.setColMajor(1, 3, 3);
    cm.setColMajor(1, 4, 4);
    cm.setColMajor(2, 2, 5);
    cm.setColMajor(2, 3, 6);
    cm.setColMajor(2, 4, 7);
    cm.setColMajor(3, 3, 8);
    cm.setColMajor(3, 4, 9);
    cm.setColMajor(4, 4, 10);

    // Display array elements in
    // column-major form
    cout << "Column-wise: ";
    cm.Display(false);
}

// Driver Code
int main()
{
    // Size of row or column
    // of square matrix
    int N = 4;

    displayRowMajor(N);

    displayColMajor(N);

    return 0;
}

Java

// Java program to convert a given
// upper triangular matrix to 1D array

// Create a class of Upper
// Triangular Matrix
class UTMatrix{
    
// Size of Matrix
private int n;

private int[] A = new int[n];

// Stores count of
// non-zero elements
private int tot;

// Constructor
public UTMatrix(int N)
{
    this.n = N;
    tot = N * (N + 1) / 2;
    A = new int[N * (N + 1) / 2];
}

// Function to display array
void Display(boolean row)
{
    for(int i = 0; i < tot; i++)
    {
        System.out.print(A[i] + " ");
    }
    System.out.println();
}

// Function to generate array in
// Row - Major order
void setRowMajor(int i, int j, int x)
{
    if (i <= j)
    {
        int index = (n * (i - 1) - (((i - 2) * 
                         (i - 1)) / 2)) + (j - i);
        A[index] = x;
    }
}

// Function to generate array in
// Column - Major order
void setColMajor(int i, int j, int x)
{
    if (i <= j) {
        int index = ((j * (j - 1)) / 2) + i - 1;
        A[index] = x;
    }
}

// Function to return size of array
int getN()
{
    return n;
}
}

class GFG{

// Function to generate and
// display array in Row-Major Order
static void displayRowMajor(int N)
{
    UTMatrix rm = new UTMatrix(N);

    // Generate array in
    // row-major form
    rm.setRowMajor(1, 1, 1);
    rm.setRowMajor(1, 2, 2);
    rm.setRowMajor(1, 3, 3);
    rm.setRowMajor(1, 4, 4);
    rm.setRowMajor(2, 2, 5);
    rm.setRowMajor(2, 3, 6);
    rm.setRowMajor(2, 4, 7);
    rm.setRowMajor(3, 3, 8);
    rm.setRowMajor(3, 4, 9);
    rm.setRowMajor(4, 4, 10);

    // Display array elements in
    // row-major order
    System.out.print("Row-Wise: ");

    rm.Display(false);
}

// Function to generate and display
// array in Column-Major Order
static void displayColMajor(int N)
{
    UTMatrix cm = new UTMatrix(N);

    // Generate array in
    // column-major form
    cm.setColMajor(1, 1, 1);
    cm.setColMajor(1, 2, 2);
    cm.setColMajor(1, 3, 3);
    cm.setColMajor(1, 4, 4);
    cm.setColMajor(2, 2, 5);
    cm.setColMajor(2, 3, 6);
    cm.setColMajor(2, 4, 7);
    cm.setColMajor(3, 3, 8);
    cm.setColMajor(3, 4, 9);
    cm.setColMajor(4, 4, 10);

    // Display array elements in
    // column-major form
    System.out.print("Column-wise: ");
    cm.Display(false);
}

// Driver Code
public static void main(String[] args)
{
    
    // Size of row or column
    // of square matrix
    int N = 4;

    displayRowMajor(N);

    displayColMajor(N);
}
}

// This code is contributed by dharanendralv23

Python3

# Javascript program to convert a given
# upper triangular matrix to 1D array

# Create a class of Upper
# Triangular Matrix
class UTMatrix :

    # Constructor
    def __init__(self, N): 
        self.n = N;
        self.tot = int(N * (N + 1) / 2);
        self.A = [0] * (int(N * (N + 1) / 2));
    

    # Function to display array
    def Display(self, row) :
        print(*self.A[:int(self.tot)])
        
    

    # Function to generate array in
    # Row - Major order
    def setRowMajor(self, i, j, x):
        if (i <= j) :
            index = (self.n * (i - 1) - (((i - 2) * (i - 1)) / 2)) + (j - i);
            self.A[int(index)] = x;
        
    

    # Function to generate array in
    # Column - Major order
    def setColMajor(self, i, j, x) :
        if (i <= j) :
            index = int((j * (j - 1)) / 2) + i - 1;
            self.A[index] = x;
        
    

    # Function to return size of array
    def getN(self):
        return n;
    


# Function to generate and
# display array in Row-Major Order
def displayRowMajor(N) :
    rm = UTMatrix(N);

    # Generate array in
    # row-major form
    rm.setRowMajor(1, 1, 1);
    rm.setRowMajor(1, 2, 2);
    rm.setRowMajor(1, 3, 3);
    rm.setRowMajor(1, 4, 4);
    rm.setRowMajor(2, 2, 5);
    rm.setRowMajor(2, 3, 6);
    rm.setRowMajor(2, 4, 7);
    rm.setRowMajor(3, 3, 8);
    rm.setRowMajor(3, 4, 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 = UTMatrix(N);

    # Generate array in
    # column-major form
    cm.setColMajor(1, 1, 1);
    cm.setColMajor(1, 2, 2);
    cm.setColMajor(1, 3, 3);
    cm.setColMajor(1, 4, 4);
    cm.setColMajor(2, 2, 5);
    cm.setColMajor(2, 3, 6);
    cm.setColMajor(2, 4, 7);
    cm.setColMajor(3, 3, 8);
    cm.setColMajor(3, 4, 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;

displayRowMajor(N);
displayColMajor(N);

# This code is contributed by phasing17

// C# program to convert a given
// upper triangular matrix to 1D array
using System;

// Create a class of Upper
// Triangular Matrix
public class UTMatrix{

  // Size of Matrix
  public int n;

  public int[] A;

  // Stores count of
  // non-zero elements
  public int tot;

  // Constructor
  public UTMatrix(int N)
  {
    this.n = N;
    tot = N * (N + 1) / 2;
    A = new int[N * (N + 1) / 2];
  }

  // Function to display array
  public void Display(bool row)
  {
    for(int i = 0; i < tot; i++)
    {
      Console.Write(A[i] + " ");
    }
    Console.WriteLine();
  }

  // Function to generate array in
  // Row - Major order
  public void setRowMajor(int i, int j, int x)
  {
    if (i <= j)
    {
      int index = (n * (i - 1) - (((i - 2) * 
                                   (i - 1)) / 2)) + (j - i);
      A[index] = x;
    }
  }

  // Function to generate array in
  // Column - Major order
  public void setColMajor(int i, int j, int x)
  {
    if (i <= j) {
      int index = ((j * (j - 1)) / 2) + i - 1;
      A[index] = x;
    }
  }

  // Function to return size of array
  public int getN()
  {
    return n;
  }
}

class GFG{

  // Function to generate and
  // display array in Row-Major Order
  static void displayRowMajor(int N)
  {
    UTMatrix rm = new UTMatrix(N);

    // Generate array in
    // row-major form
    rm.setRowMajor(1, 1, 1);
    rm.setRowMajor(1, 2, 2);
    rm.setRowMajor(1, 3, 3);
    rm.setRowMajor(1, 4, 4);
    rm.setRowMajor(2, 2, 5);
    rm.setRowMajor(2, 3, 6);
    rm.setRowMajor(2, 4, 7);
    rm.setRowMajor(3, 3, 8);
    rm.setRowMajor(3, 4, 9);
    rm.setRowMajor(4, 4, 10);

    // Display array elements in
    // row-major order
    Console.Write("Row-Wise: ");

    rm.Display(false);
  }

  // Function to generate and display
  // array in Column-Major Order
  static void displayColMajor(int N)
  {
    UTMatrix cm = new UTMatrix(N);

    // Generate array in
    // column-major form
    cm.setColMajor(1, 1, 1);
    cm.setColMajor(1, 2, 2);
    cm.setColMajor(1, 3, 3);
    cm.setColMajor(1, 4, 4);
    cm.setColMajor(2, 2, 5);
    cm.setColMajor(2, 3, 6);
    cm.setColMajor(2, 4, 7);
    cm.setColMajor(3, 3, 8);
    cm.setColMajor(3, 4, 9);
    cm.setColMajor(4, 4, 10);

    // Display array elements in
    // column-major form
    Console.Write("Column-wise: ");
    cm.Display(false);
  }

  // Driver Code
  public static void Main(string[] args)
  {

    // Size of row or column
    // of square matrix
    int N = 4;

    displayRowMajor(N);

    displayColMajor(N);
  }
}

// This code is contributed by phasing17

JavaScript

<script>
// Javascript program to convert a given
// upper triangular matrix to 1D array

// Create a class of Upper
// Triangular Matrix
class UTMatrix {

    // Constructor
    constructor(N) {
        this.n = N;
        this.tot = Math.floor(N * (N + 1) / 2);
        this.A = new Array(Math.floor(N * (N + 1) / 2));
    }

    // Function to display array
    Display(row) {
        for (let i = 0; i < this.tot; i++) {
            document.write(this.A[i] + " ");
        }
        document.write("<br>");
    }

    // Function to generate array in
    // Row - Major order
    setRowMajor(i, j, x) {
        if (i <= j) {
            let index = (this.n * (i - 1) - (((i - 2) *
                (i - 1)) / 2)) + (j - i);
            this.A[index] = x;
        }
    }

    // Function to generate array in
    // Column - Major order
    setColMajor(i, j, x) {
        if (i <= j) {
            let index = Math.floor((j * (j - 1)) / 2) + i - 1;
            this.A[index] = x;
        }
    }

    // Function to return size of array
    getN() {
        return n;
    }
}

// Function to generate and
// display array in Row-Major Order
function displayRowMajor(N) {
    let rm = new UTMatrix(N);

    // Generate array in
    // row-major form
    rm.setRowMajor(1, 1, 1);
    rm.setRowMajor(1, 2, 2);
    rm.setRowMajor(1, 3, 3);
    rm.setRowMajor(1, 4, 4);
    rm.setRowMajor(2, 2, 5);
    rm.setRowMajor(2, 3, 6);
    rm.setRowMajor(2, 4, 7);
    rm.setRowMajor(3, 3, 8);
    rm.setRowMajor(3, 4, 9);
    rm.setRowMajor(4, 4, 10);

    // Display array elements in
    // row-major order
    document.write("Row-Wise: ");

    rm.Display(false);
}

// Function to generate and display
// array in Column-Major Order
function displayColMajor(N) {
    let cm = new UTMatrix(N);

    // Generate array in
    // column-major form
    cm.setColMajor(1, 1, 1);
    cm.setColMajor(1, 2, 2);
    cm.setColMajor(1, 3, 3);
    cm.setColMajor(1, 4, 4);
    cm.setColMajor(2, 2, 5);
    cm.setColMajor(2, 3, 6);
    cm.setColMajor(2, 4, 7);
    cm.setColMajor(3, 3, 8);
    cm.setColMajor(3, 4, 9);
    cm.setColMajor(4, 4, 10);

    // Display array elements in
    // column-major form
    document.write("Column-wise: ");
    cm.Display(false);
}

// Driver Code

// Size of row or column
// of square matrix
let N = 4;

displayRowMajor(N);
displayColMajor(N);

// This code is contributed by Saurabh Jaiswal
</script>

Output:

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

Time Complexity: O(N*N)
Auxiliary Space: O(N*N)

Swap upper and lower triangular halves of a given Matrix

shahid1024

Improve

Article Tags :

Practice Tags :

Convert given upper triangular Matrix to 1D Array

Similar Reads

Thank You!

What kind of Experience do you want to share?