Snail Traversal

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

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

✓ Position Calculation

⏱️ Time: O(n) Space: O(rows × cols)

For each element, calculate which column it belongs to and its row position within that column. Use division and modulo operations to determine if column direction is downward or upward.

Sequential Fill

⏱️ Time: O(n) Space: O(rows × cols)

Create the result matrix and fill it sequentially. For each column, track whether we're moving down or up. Use row and column pointers to place elements directly without complex calculations.

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>
#include <ctype.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 [1,2,3,4]
    int nums[1000];
    int numsSize = 0;
    
    char* p = line;
    // Find opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p && (*p == ' ' || *p == ',' || *p == '\t' || *p == '\n')) p++;
        
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        if (isdigit(*p) || *p == '-') {
            char* endp;
            int num = (int)strtol(p, &endp, 10);
            nums[numsSize++] = num;
            p = endp;
        } else {
            p++;
        }
    }
    
    int rowsCount, colsCount;
    scanf("%d", &rowsCount);
    scanf("%d", &colsCount);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(nums, numsSize, rowsCount, colsCount, &returnSize, &returnColumnSizes);
    
    if (returnSize == 0) {
        printf("[]\n");
    } else {
        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");
        
        // Free memory
        for (int i = 0; i < returnSize; i++) {
            free(result[i]);
        }
        free(result);
        free(returnColumnSizes);
    }
    
    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