Flipping an Image

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]

Constraints

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

Visualization

Tap to expand

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

✓ Hash Map

⏱️ Time: N/A Space: N/A

One-Pass Two Pointers (Optimal)

⏱️ Time: O(n²) Space: O(1)

This optimized approach combines both operations into a single pass. For each row, we use two pointers starting from both ends, swap the elements, and invert them simultaneously. This is more efficient as we only traverse the matrix once.

Two-Pass Solution (Flip then Invert)

⏱️ Time: O(n²) Space: O(1)

This approach performs the two operations separately: first we reverse each row to flip the image horizontally, then we go through the entire matrix again to invert each bit (0→1, 1→0).

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_LAMPS 20000
#define MAX_QUERIES 20000
#define HASH_SIZE 100000

typedef struct HashNode {
    int key;
    int value;
    struct HashNode* next;
} HashNode;

typedef struct {
    HashNode* buckets[HASH_SIZE];
} HashMap;

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

void mapPut(HashMap* map, int key, int value) {
    int h = hash(key);
    HashNode* node = map->buckets[h];
    while (node) {
        if (node->key == key) {
            node->value = value;
            return;
        }
        node = node->next;
    }
    node = malloc(sizeof(HashNode));
    node->key = key;
    node->value = value;
    node->next = map->buckets[h];
    map->buckets[h] = node;
}

int mapGet(HashMap* map, int key) {
    int h = hash(key);
    HashNode* node = map->buckets[h];
    while (node) {
        if (node->key == key) {
            return node->value;
        }
        node = node->next;
    }
    return 0;
}

typedef struct {
    int r, c;
} Lamp;

int* solution(int n, Lamp* lamps, int lampsSize, int queries[][2], int queriesSize, int* returnSize) {
    HashMap rows = {0}, cols = {0}, diag1 = {0}, diag2 = {0};
    bool lampActive[MAX_LAMPS];
    
    // Initialize all lamps as active and update counters
    for (int i = 0; i < lampsSize; i++) {
        lampActive[i] = true;
        int r = lamps[i].r, c = lamps[i].c;
        mapPut(&rows, r, mapGet(&rows, r) + 1);
        mapPut(&cols, c, mapGet(&cols, c) + 1);
        mapPut(&diag1, r - c, mapGet(&diag1, r - c) + 1);
        mapPut(&diag2, r + c, mapGet(&diag2, r + c) + 1);
    }
    
    int* result = malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int q = 0; q < queriesSize; q++) {
        int qr = queries[q][0], qc = queries[q][1];
        
        // Check if cell is illuminated
        bool illuminated = (mapGet(&rows, qr) > 0) ||
                          (mapGet(&cols, qc) > 0) ||
                          (mapGet(&diag1, qr - qc) > 0) ||
                          (mapGet(&diag2, qr + qc) > 0);
        result[q] = illuminated ? 1 : 0;
        
        // Turn off lamps in 3x3 area
        for (int i = 0; i < lampsSize; i++) {
            if (!lampActive[i]) continue;
            int lr = lamps[i].r, lc = lamps[i].c;
            if (abs(lr - qr) <= 1 && abs(lc - qc) <= 1) {
                lampActive[i] = false;
                mapPut(&rows, lr, mapGet(&rows, lr) - 1);
                mapPut(&cols, lc, mapGet(&cols, lc) - 1);
                mapPut(&diag1, lr - lc, mapGet(&diag1, lr - lc) - 1);
                mapPut(&diag2, lr + lc, mapGet(&diag2, lr + lc) - 1);
            }
        }
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[100000];
    scanf(" %[^\n]", line);
    
    Lamp lamps[MAX_LAMPS];
    int lampsSize = 0;
    
    if (strcmp(line, "[]") != 0) {
        // Parse lamps array
        char* ptr = line + 1; // Skip opening bracket
        while (*ptr && *ptr != ']') {
            if (*ptr == '[') {
                ptr++;
                int r = 0, c = 0;
                while (*ptr && *ptr != ',') {
                    r = r * 10 + (*ptr - '0');
                    ptr++;
                }
                ptr++; // Skip comma
                while (*ptr && *ptr != ']') {
                    c = c * 10 + (*ptr - '0');
                    ptr++;
                }
                lamps[lampsSize].r = r;
                lamps[lampsSize].c = c;
                lampsSize++;
                ptr++; // Skip closing bracket
            }
            if (*ptr == ',') ptr++;
        }
    }
    
    scanf(" %[^\n]", line);
    int queries[MAX_QUERIES][2];
    int queriesSize = 0;
    
    if (strcmp(line, "[]") != 0) {
        // Parse queries array
        char* ptr = line + 1; // Skip opening bracket
        while (*ptr && *ptr != ']') {
            if (*ptr == '[') {
                ptr++;
                int r = 0, c = 0;
                while (*ptr && *ptr != ',') {
                    r = r * 10 + (*ptr - '0');
                    ptr++;
                }
                ptr++; // Skip comma
                while (*ptr && *ptr != ']') {
                    c = c * 10 + (*ptr - '0');
                    ptr++;
                }
                queries[queriesSize][0] = r;
                queries[queriesSize][1] = c;
                queriesSize++;
                ptr++; // Skip closing bracket
            }
            if (*ptr == ',') ptr++;
        }
    }
    
    int returnSize;
    int* result = solution(n, lamps, lampsSize, queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

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