# Generate a Matrix such that given Matrix elements are equal to Bitwise OR of all corresponding row and column elements of generated Matrix

• Difficulty Level : Medium
• Last Updated : 03 Jun, 2021

Given a matrix B[][] of dimensions N * M, the task is to generate a matrix A[][] of same dimensions that can be formed such that for any element B[i][j] is equal to Bitwise OR of all elements in the ith row and jth column of A[][]. If no such matrix exists, print “Not Possible“. Otherwise, print the matrix A[][].

Examples:

Input: B[][] = {{1, 1, 1},  {1, 1, 1}}
Output:
1 1 1
1 1 1
Explanation:
B = 1 = bitwise OR of all elements in 0th row and 0th column of A[][].
B = 1 = bitwise OR of all elements in 0th row and 1th column of A[][].
B = 1 = bitwise OR of all elements in 0th row and 2th column of A[][].
B = 1 = bitwise OR of all elements in 1th row and 0th column of A[][].
B = 1 = bitwise OR of all elements in 1th row and 1th column of A[][].
B = 1 = bitwise OR of all elements in 1th row and 2th column of A[][].

Input: B[][] = {{1, 0, 0}, {0, 0, 0}}
Output: Not Possible

Approach: The idea is based on the observation that if any element B[i][j] = 0, then all the elements in the ith row and jth column of matrix A[][] will be 0 since only the Bitwise OR of combinations of 0s results in 0. Follow the steps below to solve the problem:

• Create a matrix A[][] of size N*M and initialize all its elements with 1.
• Traverse the matrix B[][] row-wise, using variables i and j and if B[i][j] = 0, then make all the elements of ith row and jth column of matrix A[][] as 0.
• Traverse the matrix A[][] row-wise, using variables i and j and for every index (i, j), find the bitwise OR of the elements in the ith row and jth column of matrix A[][] and store it in variable c. If c is not equal to B[i][j], print “Not Possible” and break out of the loop.
• After the above steps, if the break statement is not encountered then print the generated matrix A[][].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the matrix, A[][]``// satisfying the given conditions``void` `findOriginalMatrix(``    ``vector > B, ``int` `N, ``int` `M)``{``    ``// Store the final matrix``    ``int` `A[N][M];` `    ``// Initialize all the elements of``    ``// the matrix A with 1``    ``for` `(``int` `i = 0; i < N; ++i) {``        ``for` `(``int` `j = 0; j < M; ++j) {``            ``A[i][j] = 1;``        ``}``    ``}` `    ``// Traverse the matrix B[][] row-wise``    ``for` `(``int` `i = 0; i < N; ++i) {``        ``for` `(``int` `j = 0; j < M; ++j) {` `            ``// If B[i][j] is equal to 0``            ``if` `(B[i][j] == 0) {` `                ``// Mark all the elements of``                ``// ith row of A[][] as 0``                ``for` `(``int` `k = 0; k < M; ++k) {``                    ``A[i][k] = 0;``                ``}` `                ``// Mark all the elements of``                ``// jth column of A[][] as 0``                ``for` `(``int` `k = 0; k < N; ++k) {``                    ``A[k][j] = 0;``                ``}``            ``}``        ``}``    ``}` `    ``// Check if the matrix B[][] can``    ``// be made using matrix A[][]``    ``for` `(``int` `i = 0; i < N; ++i) {``        ``for` `(``int` `j = 0; j < M; ++j) {` `            ``// Store the bitwise OR of``            ``// all elements of A[][] in``            ``// ith row and jth column``            ``int` `c = 0;` `            ``// Traverse through ith row``            ``for` `(``int` `k = 0; k < M; ++k) {``                ``if` `(c == 1)``                    ``break``;``                ``c += A[i][k];``            ``}` `            ``// Traverse through jth column``            ``for` `(``int` `k = 0; k < N; ++k) {``                ``if` `(c == 1)``                    ``break``;``                ``c += A[k][j];``            ``}` `            ``// If B[i][j] is not equal to``            ``// c, print "Not Possible"``            ``if` `(c != B[i][j]) {``                ``cout << ``"Not Possible"``;``                ``return``;``            ``}``        ``}``    ``}` `    ``// Print the final matrix A[][]``    ``for` `(``int` `i = 0; i < N; ++i) {``        ``for` `(``int` `j = 0; j < M; ++j) {``            ``cout << A[i][j] << ``" "``;``        ``}``        ``cout << ``"\n"``;``    ``}``}` `// Driver Code``int` `main()``{``    ``vector > B{ { 1, 1, 1 }, { 1, 1, 1 } };` `    ``int` `N = B.size();``    ``int` `M = B.size();` `    ``// Function Call``    ``findOriginalMatrix(B, N, M);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG{` `// Function to find the matrix, A[][]``// satisfying the given conditions``static` `void` `findOriginalMatrix(``int``[][] B, ``int` `N,``                               ``int` `M)``{``    ` `    ``// Store the final matrix``    ``int``[][] A = ``new` `int``[N][M];` `    ``// Initialize all the elements of``    ``// the matrix A with 1``    ``for``(``int` `i = ``0``; i < N; ++i)``    ``{``        ``for``(``int` `j = ``0``; j < M; ++j)``        ``{``            ``A[i][j] = ``1``;``        ``}``    ``}` `    ``// Traverse the matrix B[][] row-wise``    ``for``(``int` `i = ``0``; i < N; ++i)``    ``{``        ``for``(``int` `j = ``0``; j < M; ++j)``        ``{``            ` `            ``// If B[i][j] is equal to 0``            ``if` `(B[i][j] == ``0``)``            ``{``                ` `                ``// Mark all the elements of``                ``// ith row of A[][] as 0``                ``for``(``int` `k = ``0``; k < M; ++k)``                ``{``                    ``A[i][k] = ``0``;``                ``}` `                ``// Mark all the elements of``                ``// jth column of A[][] as 0``                ``for``(``int` `k = ``0``; k < N; ++k)``                ``{``                    ``A[k][j] = ``0``;``                ``}``            ``}``        ``}``    ``}` `    ``// Check if the matrix B[][] can``    ``// be made using matrix A[][]``    ``for``(``int` `i = ``0``; i < N; ++i)``    ``{``        ``for``(``int` `j = ``0``; j < M; ++j)``        ``{``            ` `            ``// Store the bitwise OR of``            ``// all elements of A[][] in``            ``// ith row and jth column``            ``int` `c = ``0``;` `            ``// Traverse through ith row``            ``for``(``int` `k = ``0``; k < M; ++k)``            ``{``                ``if` `(c == ``1``)``                    ``break``;``                    ` `                ``c += A[i][k];``            ``}` `            ``// Traverse through jth column``            ``for``(``int` `k = ``0``; k < N; ++k)``            ``{``                ``if` `(c == ``1``)``                    ``break``;``                    ` `                ``c += A[k][j];``            ``}` `            ``// If B[i][j] is not equal to``            ``// c, print "Not Possible"``            ``if` `(c != B[i][j])``            ``{``                ``System.out.println(``"Not Possible"``);``                ``return``;``            ``}``        ``}``    ``}` `    ``// Print the final matrix A[][]``    ``for``(``int` `i = ``0``; i < N; ++i)``    ``{``        ``for``(``int` `j = ``0``; j < M; ++j)``        ``{``            ``System.out.print(A[i][j] + ``" "``);``        ``}``        ``System.out.println();``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int``[][] B = ``new` `int``[][]{ { ``1``, ``1``, ``1` `},``                             ``{ ``1``, ``1``, ``1` `} };` `    ``int` `N = B.length;``    ``int` `M = B[``0``].length;` `    ``// Function Call``    ``findOriginalMatrix(B, N, M);``}``}` `// This code is contributed by Dharanendra L V`

## Python3

 `# Python program for the above approach` `# Function to find the matrix, A[][]``# satisfying the given conditions``def` `findOriginalMatrix(B, N, M) :``  ` `    ``# Store the final matrix``    ``A ``=` `[[``0``]``*``M]``*``N` `    ``# Initialize all the elements of``    ``# the matrix A with 1``    ``for` `i ``in` `range``(N) :``        ``for` `j ``in` `range``(M):``            ``A[i][j] ``=` `1``        ` `    ``# Traverse the matrix B[][] row-wise``    ``for` `i ``in` `range``(N) :``        ``for` `j ``in` `range``(M):` `            ``# If B[i][j] is equal to 0``            ``if` `(B[i][j] ``=``=` `0``) :` `                ``# Mark all the elements of``                ``# ith row of A[][] as 0``                ``for` `k ``in` `range``(M):``                    ``A[i][k] ``=` `0``                ` `                ``# Mark all the elements of``                ``# jth column of A[][] as 0``                ``for` `k ``in` `range``(N):``                    ``A[k][j] ``=` `0``    ` `    ``# Check if the matrix B[][] can``    ``# be made using matrix A[][]``    ``for` `i ``in` `range``(N) :``        ``for` `j ``in` `range``(M):` `            ``# Store the bitwise OR of``            ``# all elements of A[][] in``            ``# ith row and jth column``            ``c ``=` `0` `            ``# Traverse through ith row``            ``for` `k ``in` `range``(M):``                ``if` `(c ``=``=` `1``) :``                    ``break``                ``c ``+``=` `A[i][k]``            ` `            ``# Traverse through jth column``            ``for` `k ``in` `range``(N):``                ``if` `(c ``=``=` `1``) :``                    ``break``                ``c ``+``=` `A[k][j]``            ` `            ``# If B[i][j] is not equal to``            ``# c, pr"Not Possible"``            ``if` `(c !``=` `B[i][j]) :``                ``print``(``"Not Possible"``)``                ``return` `    ``# Print the final matrix A[][]``    ``for` `i ``in` `range``(N) :``        ``for` `j ``in` `range``(M):``            ``print``(A[i][j], end ``=` `" "``)``        ` `        ``print``()``    ` `# Driver Code``B ``=` `[[ ``1``, ``1``, ``1` `], [ ``1``, ``1``, ``1` `]]` `N ``=` `len``(B)``M ``=` `len``(B[``0``])` `# Function Call``findOriginalMatrix(B, N, M)` `# This code is contributed by splevel62`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to find the matrix, A[][]``// satisfying the given conditions``static` `void` `findOriginalMatrix(``int``[,] B, ``int` `N,``                               ``int` `M)``{``    ` `    ``// Store the final matrix``    ``int``[,] A = ``new` `int``[N, M];` `    ``// Initialize all the elements of``    ``// the matrix A with 1``    ``for``(``int` `i = 0; i < N; ++i)``    ``{``        ``for``(``int` `j = 0; j < M; ++j)``        ``{``            ``A[i, j] = 1;``        ``}``    ``}` `    ``// Traverse the matrix B[][] row-wise``    ``for``(``int` `i = 0; i < N; ++i)``    ``{``        ``for``(``int` `j = 0; j < M; ++j)``        ``{``            ` `            ``// If B[i][j] is equal to 0``            ``if` `(B[i, j] == 0)``            ``{``                ` `                ``// Mark all the elements of``                ``// ith row of A[][] as 0``                ``for``(``int` `k = 0; k < M; ++k)``                ``{``                    ``A[i, k] = 0;``                ``}` `                ``// Mark all the elements of``                ``// jth column of A[][] as 0``                ``for``(``int` `k = 0; k < N; ++k)``                ``{``                    ``A[k, j] = 0;``                ``}``            ``}``        ``}``    ``}` `    ``// Check if the matrix B[][] can``    ``// be made using matrix A[][]``    ``for``(``int` `i = 0; i < N; ++i)``    ``{``        ``for``(``int` `j = 0; j < M; ++j)``        ``{``            ` `            ``// Store the bitwise OR of``            ``// all elements of A[][] in``            ``// ith row and jth column``            ``int` `c = 0;` `            ``// Traverse through ith row``            ``for``(``int` `k = 0; k < M; ++k)``            ``{``                ``if` `(c == 1)``                    ``break``;``                    ` `                ``c += A[i, k];``            ``}` `            ``// Traverse through jth column``            ``for``(``int` `k = 0; k < N; ++k)``            ``{``                ``if` `(c == 1)``                    ``break``;``                    ` `                ``c += A[k, j];``            ``}` `            ``// If B[i][j] is not equal to``            ``// c, print "Not Possible"``            ``if` `(c != B[i, j])``            ``{``                ``Console.WriteLine(``"Not Possible"``);``                ``return``;``            ``}``        ``}``    ``}` `    ``// Print the final matrix A[][]``    ``for``(``int` `i = 0; i < N; ++i)``    ``{``        ``for``(``int` `j = 0; j < M; ++j)``        ``{``            ``Console.Write(A[i, j] + ``" "``);``        ``}``        ``Console.WriteLine();``    ``}``}` `// Driver Code``static` `public` `void` `Main()``{``    ``int``[,] B = ``new` `int``[,]{ { 1, 1, 1 },``                           ``{ 1, 1, 1 } };` `    ``int` `N = B.GetLength(0);``    ``int` `M = B.GetLength(1);` `    ``// Function Call``    ``findOriginalMatrix(B, N, M);``}``}` `// This code is contributed by Dharanendra L V`

## Javascript

 ``

Output:

```1 1 1
1 1 1```

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

My Personal Notes arrow_drop_up