Flipping an Image - Practice Coding Problems

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 still visit each element once, but in a single pass through the n×n matrix

⚠ Quadratic Growth

Space Complexity

O(1)

In-place transformation with only constant extra space for pointers

✓ 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
✓ 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)	O(n²)	O(1)	First flip all rows horizontally, then invert all values

One-Pass Two Pointers (Optimal) — Algorithm Steps

For each row in the matrix
Use two pointers: left starting at 0, right starting at n-1
Swap elements at left and right positions
Invert both swapped elements (0→1, 1→0)
Move pointers toward center until they meet
Handle middle element for odd-length rows

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Start with left=0, right=n-1 for current row

Swap & Invert

Swap elements and invert both simultaneously

Move Pointers

Move left pointer right, right pointer left

Handle Middle

If pointers meet, invert the middle element

Code -

solution.c — C

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

void flipAndInvertImage(int** image, int imageSize, int* imageColSize) {
    int n = imageSize;
    
    for (int i = 0; i < n; i++) {
        int left = 0, right = n - 1;
        
        // Process pairs from both ends
        while (left < right) {
            // Swap and invert simultaneously
            int temp = 1 - image[i][right];
            image[i][right] = 1 - image[i][left];
            image[i][left] = temp;
            left++;
            right--;
        }
        
        // Handle middle element for odd n
        if (left == right) {
            image[i][left] = 1 - image[i][left];
        }
    }
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We still visit each element once, but in a single pass through the n×n matrix

⚠ Quadratic Growth

Space Complexity

O(1)

In-place transformation with only constant extra space for pointers

✓ 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

One-Pass Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler