Zigzag Grid Traversal With Skip - Practice Coding Problems

Zigzag Grid Traversal With Skip - Problem

Imagine you're navigating through a 2D grid following a specific zigzag pattern, but with a twist - you must skip every alternate cell during your journey!

Given an m x n 2D array grid of positive integers, your task is to traverse the grid in a zigzag pattern while collecting values from only every other cell you encounter.

Zigzag Traversal Rules:

🚀 Start at the top-left corner (0, 0)
➡️ Move right across the first row until you reach the end
⬇️ Drop down to the next row
⬅️ Move left across this row until you reach the beginning
🔄 Continue alternating between right and left traversal for each row
⏭️ Skip every alternate cell during the entire traversal

Return an array containing the values of the cells you visit (not skip) in the order you encounter them.

Input & Output

example_1.py — Basic 3x3 Grid

$ Input: grid = [[1,2,3],[6,5,4],[7,8,9]]

› Output: [1,3,5]

💡 Note: Zigzag order: 1→2→3→6→5→4→7→8→9. With skipping alternates: positions 0,2,4 give us [1,3,5]

example_2.py — 2x4 Rectangle Grid

$ Input: grid = [[1,2,3,4],[8,7,6,5]]

› Output: [1,3,8,6]

💡 Note: Zigzag order: 1→2→3→4→5→6→7→8. Taking positions 0,2,4,6 gives us [1,3,5,7]. Wait, let me recalculate: 1→2→3→4→8→7→6→5, so [1,3,8,6]

example_3.py — Single Row Edge Case

$ Input: grid = [[1,2,3,4,5]]

› Output: [1,3,5]

💡 Note: Single row traversal left-to-right: 1→2→3→4→5. Taking alternate positions 0,2,4 gives us [1,3,5]

Visualization

Tap to expand

Understanding the Visualization

Start Top-Left

Begin at position (0,0) with counter = 0

Read First Line Left→Right

Move right across first row, collecting at even positions

Drop to Next Line

Move down to second row, continue position counter

Read Second Line Right→Left

Move left across second row, still collecting at even positions

Continue Pattern

Alternate row directions until complete

Key Takeaway

🎯 Key Insight: Use a single position counter across the entire zigzag traversal to determine which cells to collect, making it a clean O(m×n) single-pass solution

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Visit each cell exactly once in the grid

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of collected elements (roughly half of total elements)

✓ Linear Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 10⁴
1 ≤ grid[i][j] ≤ 10⁵
The grid will always have at least one element

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses a single-pass traversal with a position counter. As we traverse the grid in zigzag pattern (alternating left-to-right and right-to-left for each row), we track our overall position and collect values only when the position is even. This gives us O(m×n) time and O(k) space complexity where k is the number of collected elements.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Single-Pass Solution	O(m × n)	O(k)	Traverse in zigzag pattern while tracking position counter to skip alternates

Optimal Single-Pass Solution — Algorithm Steps

Initialize result array and position counter
For each row, determine traversal direction (even=left-to-right, odd=right-to-left)
Traverse the row in appropriate direction
For each cell, check if position counter is even
If even, add cell value to result; always increment position counter
Return the collected result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position Counter

Initialize position = 0, traverse first row left-to-right

Collect on Even Positions

When position % 2 == 0, add value to result array

Continue Zigzag

Move to next row, reverse direction, keep tracking position

Complete Traversal

Continue pattern until all rows are processed

Code -

solution.c — C

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

int* zigzagTraversal(int** grid, int gridSize, int* gridColSize, int* returnSize) {
    if (gridSize == 0 || gridColSize[0] == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int m = gridSize, n = gridColSize[0];
    int totalElements = m * n;
    int* result = (int*)malloc((totalElements + 1) / 2 * sizeof(int));
    int resultIdx = 0, position = 0;
    
    for (int i = 0; i < m; i++) {
        if (i % 2 == 0) { // Even row: left to right
            for (int j = 0; j < n; j++) {
                if (position % 2 == 0) { // Collect alternate cells
                    result[resultIdx++] = grid[i][j];
                }
                position++;
            }
        } else { // Odd row: right to left
            for (int j = n - 1; j >= 0; j--) {
                if (position % 2 == 0) { // Collect alternate cells
                    result[resultIdx++] = grid[i][j];
                }
                position++;
            }
        }
    }
    
    *returnSize = resultIdx;
    return result;
}

int main() {
    // Example usage
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Visit each cell exactly once in the grid

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of collected elements (roughly half of total elements)

✓ Linear Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 10⁴
1 ≤ grid[i][j] ≤ 10⁵
The grid will always have at least one element

41.3K Views

Medium Frequency

~12 min Avg. Time

1.8K 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

Optimal Single-Pass Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler