Codestin Search App

Flipping an Image - Problem

You're given an n x n binary matrix representing a black and white image. Your task is to flip the image horizontally, then invert it, and return the resulting image.

What does "flip horizontally" mean?
Each row of the image is reversed. For example, flipping [1,1,0] horizontally results in [0,1,1].

What does "invert" mean?
Each 0 is replaced by 1, and each 1 is replaced by 0. For example, inverting [0,1,1] results in [1,0,0].

Think of this like taking a photo negative and then flipping it like you would flip a pancake!

Input & Output

example_1.py — Basic 3x3 matrix

$ Input: image = [[1,1,0],[1,0,1],[0,0,0]]

› Output: [[1,0,0],[0,1,0],[1,1,1]]

💡 Note: First flip: [[0,1,1],[1,0,1],[0,0,0]], then invert: [[1,0,0],[0,1,0],[1,1,1]]

example_2.py — 4x4 matrix

$ Input: image = [[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]]

💡 Note: Each row is flipped horizontally then inverted: [1,1,0,0] → [0,0,1,1] → [1,1,0,0]

example_3.py — Single element

$ Input: image = [[1]]

› Output: [[0]]

💡 Note: Single element matrix: flip [1] → [1], then invert [1] → [0]

Visualization

Tap to expand

Understanding the Visualization

Original Photo

Start with your black and white photograph

Mirror Flip

Hold the photo up to a mirror - everything is reversed horizontally

Create Negative

Convert to negative - all black areas become white, white areas become black

Final Result

You now have a horizontally flipped negative of the original image

Key Takeaway

🎯 Key Insight: By using two pointers and combining both operations (flip + invert) in a single pass, we achieve optimal efficiency while maintaining clean, readable code.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We traverse the n×n matrix twice: once for flipping and once for inverting

⚠ Quadratic Growth

Space Complexity

O(1)

We modify the matrix in-place, using only constant extra space

✓ Linear Space

Constraints

n == image.length
n == image[i].length
1 ≤ n ≤ 20
image[i][j] is either 0 or 1

Asked in

G Google 25 a Amazon 18 Apple 15 ⊞ Microsoft 12

The optimal solution uses a two-pointer approach to flip and invert the image in a single pass. For each row, we use pointers at both ends, swap the elements while inverting them simultaneously. This achieves O(n²) time complexity with O(1) space complexity, making it more efficient than the naive two-pass approach.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Solution (Flip then Invert)	O(n²)	O(1)	First flip all rows horizontally, then invert all values
One-Pass Two Pointers (Optimal)	O(n²)	O(1)	Flip and invert simultaneously using two pointers from both ends of each row

Two-Pass Solution (Flip then Invert) — Algorithm Steps

Iterate through each row of the matrix
Reverse each row to flip horizontally
Iterate through the matrix again
Invert each element (0→1, 1→0)

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Matrix

Start with the given binary matrix

Flip Horizontally

Reverse each row to create horizontal mirror

Invert Values

Change all 0s to 1s and all 1s to 0s

Final Result

The transformed matrix is ready

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

void flipAndInvertImage(int** image, int imageSize, int* imageColSize) {
    int n = imageSize;
    
    // Step 1: Flip each row horizontally
    for (int i = 0; i < n; i++) {
        for (int left = 0, right = n-1; left < right; left++, right--) {
            int temp = image[i][left];
            image[i][left] = image[i][right];
            image[i][right] = temp;
        }
    }
    
    // Step 2: Invert each element
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            image[i][j] = 1 - image[i][j];
        }
    }
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We traverse the n×n matrix twice: once for flipping and once for inverting

⚠ Quadratic Growth

Space Complexity

O(1)

We modify the matrix in-place, using only constant extra space

✓ Linear Space

Constraints

n == image.length
n == image[i].length
1 ≤ n ≤ 20
image[i][j] is either 0 or 1

95.0K Views

Medium Frequency

~8 min Avg. Time

2.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Solution (Flip then Invert) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler