Zigzag Conversion - Practice Coding Problems

Zigzag Conversion - Problem

String Medium

Imagine you're an ancient scribe trying to encode a secret message! The Zigzag Conversion problem asks you to write a string in a zigzag pattern across multiple rows, then read it line by line to create an encoded string.

Given a string s and a number of rows numRows, you need to:

Write the string in a zigzag pattern going down and up alternately
Read line by line from top to bottom to get the final result

Example: The string "PAYPALISHIRING" with numRows = 3 becomes:

P   A   H   N
A P L S I I G  
Y   I   R

Reading line by line gives us: "PAHNAPLSIIGYIR"

Think of it like writing on lined paper while riding a roller coaster - your pen goes down the lines, then back up, creating this distinctive zigzag pattern!

Input & Output

example_1.py — Basic Zigzag

$ Input: s = "PAYPALISHIRING", numRows = 3

› Output: "PAHNAPLSIIGYIR"

💡 Note: The string is written in zigzag pattern across 3 rows: P-A-H-N on row 0, A-P-L-S-I-I-G on row 1, and Y-I-R on row 2. Reading line by line gives us the result.

example_2.py — Four Rows

$ Input: s = "PAYPALISHIRING", numRows = 4

› Output: "PINALSIGYAHRPI"

💡 Note: With 4 rows, the pattern becomes: P-I-N on row 0, A-L-S-I-G on row 1, Y-A-H-R on row 2, and P-I on row 3. The zigzag goes down 4 rows then up 3 rows repeatedly.

example_3.py — Edge Case

$ Input: s = "A", numRows = 1

› Output: "A"

💡 Note: When numRows is 1, there's no zigzag pattern possible, so we return the original string unchanged.

Constraints

1 ≤ s.length ≤ 1000
s consists of English letters (a-z, A-Z), ',', and '.'
1 ≤ numRows ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Discover the Cycle

Every (2*numRows-2) characters, the pattern repeats. For 3 rows: cycle = 4 characters

Map Positions

Character position % cycle_length tells us where we are in the pattern

Calculate Row

Use simple formulas to convert cycle position to target row

Build Result

Collect characters by row, then concatenate for the final answer

Key Takeaway

🎯 Key Insight: The zigzag pattern is actually a predictable mathematical cycle! By recognizing that characters repeat their row positions every (2*numRows-2) positions, we can skip the simulation entirely and directly compute where each character belongs.

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22

The optimal solution recognizes that the zigzag pattern follows a mathematical cycle of length (2 * numRows - 2). Instead of simulating the zigzag movement, we can directly calculate which row each character belongs to using modular arithmetic. This approach achieves O(n) time complexity with clean, elegant code that avoids the overhead of tracking direction and boundaries.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Pattern Recognition (Optimal)	O(n)	O(n)	Calculate which row each character belongs to using mathematical formulas without simulation
Simulate the Zigzag Pattern	O(n)	O(n)	Create a 2D grid and simulate the zigzag movement character by character

Mathematical Pattern Recognition (Optimal) — Algorithm Steps

Handle edge cases: if numRows is 1, return original string
Calculate cycle length: cycleLen = 2 * numRows - 2
Create arrays to store characters for each row
For each character at position i:
Calculate position in cycle: i % cycleLen
Determine target row based on cycle position
If in first half of cycle: row = cycle_pos
If in second half: row = numRows - 1 - (cycle_pos - numRows + 1)
Add character to appropriate row and concatenate results

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Cycle

The pattern repeats every (2*numRows-2) characters

Calculate Position

For each character, find its position within the cycle

Map to Row

Use cycle position to directly determine target row

Build Result

Concatenate rows to get final zigzag conversion

Code -

solution.c — C

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

char* convert(char* s, int numRows) {
    int len = strlen(s);
    if (numRows == 1 || numRows >= len) {
        char* result = (char*)malloc((len + 1) * sizeof(char));
        strcpy(result, s);
        return result;
    }
    
    // Calculate cycle length
    int cycleLen = 2 * numRows - 2;
    
    // Create arrays to store each row
    char** rows = (char**)malloc(numRows * sizeof(char*));
    int* rowSizes = (int*)calloc(numRows, sizeof(int));
    
    for (int i = 0; i < numRows; i++) {
        rows[i] = (char*)malloc((len + 1) * sizeof(char));
        rows[i][0] = '\0';
    }
    
    // Process each character using mathematical pattern
    for (int i = 0; i < len; i++) {
        int cyclePos = i % cycleLen;
        
        // Determine which row based on cycle position
        int row;
        if (cyclePos < numRows) {
            row = cyclePos;
        } else {
            row = numRows - 1 - (cyclePos - numRows + 1);
        }
        
        rows[row][rowSizes[row]++] = s[i];
        rows[row][rowSizes[row]] = '\0';
    }
    
    // Combine all rows
    char* result = (char*)malloc((len + 1) * sizeof(char));
    result[0] = '\0';
    
    for (int i = 0; i < numRows; i++) {
        strcat(result, rows[i]);
        free(rows[i]);
    }
    
    free(rows);
    free(rowSizes);
    return result;
}

int main() {
    char s[1001];
    int numRows;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &numRows);
    
    char* result = convert(s, numRows);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, where n is the length of input string

✓ Linear Growth

Space Complexity

O(n)

Space for storing characters in row arrays, plus the final result string

⚡ Linearithmic Space

38.4K Views

Medium Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Mathematical Pattern Recognition (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler