Codestin Search App

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
✓ Simulate the Zigzag Pattern	O(n)	O(n)	Create a 2D grid and simulate the zigzag movement character by character
Mathematical Pattern Recognition (Optimal)	O(n)	O(n)	Calculate which row each character belongs to using mathematical formulas without simulation

Simulate the Zigzag Pattern — Algorithm Steps

Create an array of strings to represent each row
Initialize current row to 0 and direction as 'going down'
For each character in the input string:
Add the character to the current row
Move to next row based on current direction
Change direction when hitting row boundaries (0 or numRows-1)
Concatenate all rows to get the final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Rows

Create empty arrays for each row and start at row 0

Add Characters

Place each character in the current row

Change Direction

When hitting boundaries (top/bottom), reverse direction

Combine Results

Concatenate all rows to get the 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;
    }
    
    // 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';
    }
    
    int currentRow = 0;
    int goingDown = 0;
    
    // Process each character
    for (int i = 0; i < len; i++) {
        rows[currentRow][rowSizes[currentRow]++] = s[i];
        rows[currentRow][rowSizes[currentRow]] = '\0';
        
        // Change direction at boundaries
        if (currentRow == 0 || currentRow == numRows - 1) {
            goingDown = !goingDown;
        }
        
        // Move to next row
        currentRow += goingDown ? 1 : -1;
    }
    
    // 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; // Remove newline
    scanf("%d", &numRows);
    
    char* result = convert(s, numRows);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each character exactly once, where n is the length of the input string

✓ Linear Growth

Space Complexity

O(n)

We store each character once in the 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

Simulate the Zigzag Pattern — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler