Snail Traversal - Practice Coding Problems

Snail Traversal - Problem

JavaScript Medium

Snail Traversal Matrix Transformation

You need to enhance JavaScript arrays with a special method called snail(rowsCount, colsCount) that transforms a 1D array into a 2D matrix following a unique "snail traversal" pattern.

🐌 How Snail Traversal Works:
• Start at the top-left corner with the first array element
• Fill the entire first column from top to bottom
• Move to the second column and fill from bottom to top
• Continue alternating direction for each column until all elements are placed

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:

19  8  1  6
10  5  17 13
3   2  16 11
7   1  14 20
9   17 12 4
    ↓  ↑  15

Invalid Input: Return an empty array [] if rowsCount × colsCount ≠ array.length

Input & Output

example_1.js — Basic 3×4 Matrix

$ Input: arr = [1,2,3,4,5,6,7,8,9,10,11,12], rowsCount = 3, colsCount = 4

› Output: [[1,6,7,12],[2,5,8,11],[3,4,9,10]]

💡 Note: Column 0: [1,2,3] (top-to-bottom), Column 1: [6,5,4] (bottom-to-top), Column 2: [7,8,9] (top-to-bottom), Column 3: [12,11,10] (bottom-to-top)

example_2.js — Single Row

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

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

💡 Note: With only one row, all elements are placed in the same row, alternating columns but same position

example_3.js — Invalid Dimensions

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

› Output: []

💡 Note: 3 × 2 = 6, but array length is 3. Since 6 ≠ 3, return empty array

Visualization

Tap to expand

Understanding the Visualization

Start at Top-Left

Begin placing elements in the first column from top to bottom

Alternate Directions

Move to next column and fill from bottom to top

Continue Pattern

Keep alternating direction for each subsequent column

Complete Matrix

All elements are placed following the snail traversal pattern

Key Takeaway

🎯 Key Insight: Use modular arithmetic to determine column direction - even columns (0,2,4...) go top-to-bottom, odd columns (1,3,5...) go bottom-to-top.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through input array with constant time position calculations

✓ Linear Growth

Space Complexity

O(rowsCount × colsCount)

Space needed to store the output 2D matrix

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 250
1 ≤ rowsCount, colsCount ≤ 250
arr contains distinct integers from 1 to arr.length
Must implement as Array.prototype.snail method

Asked in

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

The optimal approach uses direct position calculation with O(n) time complexity. For each element, determine its column using integer division, then calculate the row based on whether it's an even column (top-to-bottom) or odd column (bottom-to-top). This eliminates the need for complex traversal logic while maintaining the snail pattern.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Position Calculation	O(n)	O(rowsCount × colsCount)	Calculate each element's position by determining column direction and row offset

Direct Position Calculation — Algorithm Steps

Validate input: check if rowsCount * colsCount equals array length
Create empty 2D matrix with given dimensions
For each element, calculate which column it belongs to
Determine if column is even (top-to-bottom) or odd (bottom-to-top)
Calculate the exact row position within that column
Place the element at the calculated position

Visualization

Tap to expand

Step-by-Step Walkthrough

Validate Input

Check if rowsCount × colsCount equals array length

Create Matrix

Initialize empty 2D matrix with given dimensions

Fill Even Columns

Place elements in even columns (0,2,4...) from top to bottom

Fill Odd Columns

Place elements in odd columns (1,3,5...) from bottom to top

Code -

solution.c — C

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

int** snail(int* arr, int arrSize, int rowsCount, int colsCount, int* returnSize, int** returnColumnSizes) {
    // Validate input
    if (rowsCount * colsCount != arrSize) {
        *returnSize = 0;
        return NULL;
    }
    
    // Allocate 2D matrix
    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;
    }
    
    // Fill matrix following snail pattern
    for (int i = 0; i < arrSize; i++) {
        int col = i / rowsCount;
        int posInCol = i % rowsCount;
        
        int row;
        if (col % 2 == 0) {
            // Even column: top to bottom
            row = posInCol;
        } else {
            // Odd column: bottom to top
            row = rowsCount - 1 - posInCol;
        }
        
        result[row][col] = arr[i];
    }
    
    *returnSize = rowsCount;
    return result;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
    int returnSize;
    int* returnColumnSizes;
    
    int** result = snail(arr, 12, 3, 4, &returnSize, &returnColumnSizes);
    
    for (int i = 0; i < returnSize; i++) {
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
        free(result[i]);
    }
    
    free(result);
    free(returnColumnSizes);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through input array with constant time position calculations

✓ Linear Growth

Space Complexity

O(rowsCount × colsCount)

Space needed to store the output 2D matrix

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 250
1 ≤ rowsCount, colsCount ≤ 250
arr contains distinct integers from 1 to arr.length
Must implement as Array.prototype.snail method

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Direct Position Calculation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler