Snail Traversal - Practice Coding Problems

Snail Traversal - Problem

JavaScript Medium

Write code that transforms a 1D array into a 2D array organized in snail traversal order.

Snail traversal pattern:

Start at top-left with first array element
Fill entire first column from top to bottom
Move to next column and fill from bottom to top
Continue alternating direction for each column
Return empty array if rowsCount * colsCount !== nums.length

Example: Array [19, 10, 3, 7, 9, 8, 5, 2, 1, 17, 16, 14, 12, 18, 6, 13, 11, 20, 4, 15] with rowsCount = 5, colsCount = 4 becomes a 5×4 matrix where column 0 fills top→bottom, column 1 fills bottom→top, etc.

Input & Output

Example 1 — Basic Snail Pattern

$ Input: nums = [1,2,3,4], rowsCount = 2, colsCount = 2

› Output: [[1,4],[2,3]]

💡 Note: Column 0: fill top-down [1,2]. Column 1: fill bottom-up [4,3]. Result matrix: [[1,4],[2,3]]

Example 2 — Invalid Dimensions

$ Input: nums = [1,2,3], rowsCount = 1, colsCount = 4

› Output: []

💡 Note: 1 × 4 = 4 ≠ 3 (array length), so input is invalid. Return empty array.

Example 3 — Single Column

$ Input: nums = [1,2,3], rowsCount = 3, colsCount = 1

› Output: [[1],[2],[3]]

💡 Note: Only one column (even), fill top-down: [[1],[2],[3]]

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
1 ≤ nums[i] ≤ 10⁶
1 ≤ rowsCount ≤ 1000
1 ≤ colsCount ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Input Array

Linear array [1,2,3,4] with dimensions 2×2

Snail Pattern

Fill columns alternately: down, up, down, up...

2D Result

Matrix [[1,4],[2,3]] following snail pattern

Key Takeaway

🎯 Key Insight: Even-indexed columns fill downward, odd-indexed columns fill upward, creating the snail pattern

Asked in

G Google 25 f Meta 18 a Amazon 15

Transform 1D array to 2D matrix using snail traversal - alternating column fill directions. Key insight: Even columns fill top-down, odd columns fill bottom-up. Best approach is sequential column filling. Time: O(n), Space: O(rows × cols)

Common Approaches

Approach	Time	Space	Notes
✓ Position Calculation	O(n)	O(rows × cols)	Calculate exact 2D position for each array element using mathematical formulas
Sequential Fill	O(n)	O(rows × cols)	Fill the 2D matrix column by column, tracking current position and direction

Position Calculation — Algorithm Steps

Calculate column number using element index
Determine if column fills top-down or bottom-up
Calculate exact row position within column
Place element at computed 2D coordinates

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Column

column = index ÷ rowsCount

Calculate Row Position

rowInCol = index % rowsCount

Adjust for Direction

If odd column, flip row position

Code -

solution.c — C

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

int** solution(int* nums, int numsSize, int rowsCount, int colsCount, int* returnSize, int** returnColumnSizes) {
    if (rowsCount * colsCount != numsSize) {
        *returnSize = 0;
        *returnColumnSizes = NULL;
        return NULL;
    }
    
    int** result = (int**)malloc(rowsCount * sizeof(int*));
    *returnColumnSizes = (int*)malloc(rowsCount * sizeof(int));
    
    for (int i = 0; i < rowsCount; i++) {
        result[i] = (int*)malloc(colsCount * sizeof(int));
        (*returnColumnSizes)[i] = colsCount;
    }
    
    for (int i = 0; i < numsSize; i++) {
        int col = i / rowsCount;
        int rowInCol = i % rowsCount;
        
        int row;
        if (col % 2 == 0) {  // Even column: top to bottom
            row = rowInCol;
        } else {  // Odd column: bottom to top
            row = rowsCount - 1 - rowInCol;
        }
        
        result[row][col] = nums[i];
    }
    
    *returnSize = rowsCount;
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int rowsCount, colsCount;
    scanf("%d", &rowsCount);
    scanf("%d", &colsCount);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(nums, numsSize, rowsCount, colsCount, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            if (j > 0) printf(",");
            printf("%d", result[i][j]);
        }
        printf("]");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, constant time calculation per element

✓ Linear Growth

Space Complexity

O(rows × cols)

2D result array of size rows × cols

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Position Calculation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler