Related Articles

# Horizontally Flip a Binary Matrix

• Difficulty Level : Easy
• Last Updated : 21 May, 2021

Given a binary matrix. The task is to flip the matrix horizontally(find the image of the matrix), then invert it.

Note

• To flip a matrix horizontally means that reversing each row of the matrix. For example, flipping [1, 1, 0, 0] horizontally results in [0, 0, 1, 1].
• To invert a matrix means that replacing each 0 by 1 and vice-versa. For example, inverting [0, 0, 1] results in [1, 1, 0].

Examples

```Input: mat[][] = [[1, 1, 0],
[1, 0, 1],
[0, 0, 0]]
Output: [[1, 0, 0],
[0, 1, 0],
[1, 1, 1]]
Explanation:
First reverse each row: [[0, 1, 1], [1, 0, 1], [0, 0, 0]]
Then, invert the image: [[1, 0, 0], [0, 1, 0], [1, 1, 1]]

Input: mat[][] = [[1, 1, 0, 0],
[1, 0, 0, 1],
[0, 1, 1, 1],
[1, 0, 1, 0]]
Output: [[1, 1, 0, 0],
[0, 1, 1, 0],
[0, 0, 0, 1],
[1, 0, 1, 0]]
Explanation:
First reverse each row:
[[0, 0, 1, 1], [1, 0, 0, 1], [1, 1, 1, 0], [0, 1, 0, 1]].
Then invert the image:
[[1, 1, 0, 0], [0, 1, 1, 0], [0, 0, 0, 1], [1, 0, 1, 0]]```

Approach: We can do this in-place. On observing carefully, it can be deduced that in each row in the final matrix, the i-th value from the left is equal to the inverse of the i-th value from the right of the input binary matrix.

Thus, we use (Column + 1) / 2 (with floor division) to iterate over all indexes in the first half of the row, including the centre and updating the answer accordingly.

Below is the implementation of above approach:

## Python3

 `# Python3 implementation of above approach``# Function to return final Image` `def` `flipped_Invert_Image(mat):` `    ``for` `row ``in` `mat:``        ``for` `i ``in` `range``((``len``(row) ``+` `1``) ``/``/` `2``):` `            ``row[i] ``=` `row[``len``(row) ``-` `1` `-` `i] ^ ``1``            ``row[``len``(row) ``-` `1` `-` `i] ``=` `row[i] ^ ``1` `    ``# return Flipped and Inverted image``    ``return` `mat` `# Driver code``mat ``=` `[[``1``, ``1``, ``0``, ``0``], [``1``, ``0``, ``0``, ``1``], [``0``, ``1``, ``1``, ``1``], [``1``, ``0``, ``1``, ``0``]]` `print``(flipped_Invert_Image(mat))`
Output:
`[[1, 1, 0, 0], [0, 1, 0, 1], [0, 0, 1, 1], [1, 0, 1, 0]]`

Time Complexity: O(N*M), where N is the number of rows and M is the number of columns in the given binary matrix.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up