Spiral Matrix Traversal in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Spiral Traversal on 3x3 Matrix

What is the output of the spiral traversal on the following 3x3 matrix?

Matrix:
1 2 3
4 5 6
7 8 9

DSA Go

matrix := [][]int{{1,2,3},{4,5,6},{7,8,9}}
result := SpiralTraverse(matrix)
fmt.Println(result)

A [1 2 3 4 5 6 7 8 9]

B [1 2 3 6 9 8 7 4 5]

C [1 4 7 8 9 6 3 2 5]

D [1 3 5 7 9 2 4 6 8]

💡 Hint

Start from the top-left corner and move right, then down, then left, then up, shrinking the boundaries each time.

The spiral traversal starts at 1, moves right to 3, then down to 9, left to 7, up to 4, and finally the center 5.

❓ Predict Output

intermediate

Spiral Traversal Output for 2x4 Matrix

What is the output of spiral traversal on this 2x4 matrix?

Matrix:
1 2 3 4
5 6 7 8

DSA Go

matrix := [][]int{{1,2,3,4},{5,6,7,8}}
result := SpiralTraverse(matrix)
fmt.Println(result)

A [1 2 3 4 8 7 6 5]

B [1 5 6 7 8 4 3 2]

C [1 2 3 4 5 6 7 8]

D [1 4 8 7 6 5 2 3]

💡 Hint

Traverse right across the top row, then down the last column, then left across the bottom row.

The spiral traversal goes 1 2 3 4 (top row), then 8 (down last column), then 7 6 5 (bottom row reversed).

🔧 Debug

advanced

Identify the Bug in Spiral Traversal Code

Given this Go code snippet for spiral traversal, what is the bug causing incorrect output?

DSA Go

func SpiralTraverse(matrix [][]int) []int {
  var result []int
  top, bottom := 0, len(matrix)-1
  left, right := 0, len(matrix[0])-1

  for top <= bottom && left <= right {
    for i := left; i <= right; i++ {
      result = append(result, matrix[top][i])
    }
    top++

    for i := top; i <= bottom; i++ {
      result = append(result, matrix[i][right])
    }
    right--

    if top <= bottom {
      for i := right; i >= left; i-- {
        result = append(result, matrix[bottom][i])
      }
      bottom--
    }

    if left <= right {
      for i := bottom; i >= top; i-- {
        result = append(result, matrix[i][left])
      }
      left++
    }
  }
  return result
}

A The code appends elements in wrong order, reversing the spiral direction.

B The initial values of top and bottom are swapped, causing index out of range error.

C The loop conditions use '<' instead of '<=' causing missing elements in traversal.

D The code does not check if top <= bottom before traversing bottom row and left column, causing duplicates.

💡 Hint

Check if the boundaries have crossed before traversing bottom row and left column inside the loop.

After moving top and right boundaries, bottom and left may cross top and right, so we must check before traversing bottom row and left column to avoid duplicates.

🧠 Conceptual

advanced

Time Complexity of Spiral Matrix Traversal

What is the time complexity of performing a spiral traversal on an MxN matrix?

A O(M*N*log(M*N)) due to nested loops and boundary checks.

B O(M+N) because traversal moves along rows and columns only once.

C O(M*N) because each element is visited exactly once.

D O(max(M, N)) because traversal depends on the larger dimension.

💡 Hint

Think about how many times each element is processed during traversal.

Each element in the matrix is visited exactly once in spiral traversal, so the time complexity is proportional to the total number of elements M*N.

🚀 Application

expert

Spiral Traversal Output for Non-Rectangular Matrix

Given this jagged matrix (rows of different lengths), what is the output of spiral traversal if implemented naively without boundary checks?

Matrix:
[ [1, 2, 3],
[4, 5],
[6, 7, 8, 9] ]

DSA Go

matrix := [][]int{{1,2,3},{4,5},{6,7,8,9}}
result := SpiralTraverse(matrix)
fmt.Println(result)

A Runtime error due to index out of range when accessing missing elements.

B [1 2 3 5 9 8 7 6 4]

C [1 2 3 4 5 6 7 8 9]

D [1 3 5 7 9 2 4 6 8]

💡 Hint

Consider what happens when the code tries to access elements beyond the length of shorter rows.

Naive spiral traversal assumes all rows have equal length. Accessing missing elements in shorter rows causes runtime index out of range error.

Practice

1. What is the main idea behind Spiral Matrix Traversal?

easy

A. Traverse the matrix in a circular pattern starting from the outer layer moving inward

B. Traverse the matrix row by row from top to bottom

C. Traverse the matrix column by column from left to right

D. Traverse only the diagonal elements of the matrix

Solution

1. Step 1: Understand traversal pattern

   Spiral traversal means moving around the edges of the matrix and gradually moving inward in a circular way.

2. Step 2: Compare options with spiral pattern

   Only Traverse the matrix in a circular pattern starting from the outer layer moving inward describes moving in a circular pattern from outer to inner layers, which matches spiral traversal.

3. Final Answer:

   Traverse the matrix in a circular pattern starting from the outer layer moving inward -> Option A

4. Quick Check:

   Spiral traversal = circular outer to inner [OK]

Hint: Think of peeling an onion layer by layer [OK]

Common Mistakes:

• Confusing spiral with row-wise traversal
• Thinking spiral means diagonal traversal
• Ignoring the inward movement after outer layer

2. Which of the following Go code snippets correctly initializes the boundaries for spiral traversal of a matrix named matrix?

easy

A. top, bottom := 0, len(matrix)-1; left, right := 0, len(matrix[0])-1

B. top, bottom := 1, len(matrix); left, right := 1, len(matrix[0])

C. top, bottom := 0, len(matrix); left, right := 0, len(matrix[0])

D. top, bottom := -1, len(matrix)-1; left, right := -1, len(matrix[0])-1

Solution

1. Step 1: Identify correct boundary initialization

   For spiral traversal, top and left start at 0, bottom and right are last indices (length - 1).

2. Step 2: Check each option

   top, bottom := 0, len(matrix)-1; left, right := 0, len(matrix[0])-1 correctly sets top=0, bottom=len(matrix)-1, left=0, right=len(matrix[0])-1. Others have off-by-one or negative values.

3. Final Answer:

   top, bottom := 0, len(matrix)-1; left, right := 0, len(matrix[0])-1 -> Option A

4. Quick Check:

   Boundaries start at 0 and end at length-1 [OK]

Hint: Remember Go slices are 0-indexed, so last index is length-1 [OK]

Common Mistakes:

• Using length instead of length-1 for boundaries
• Starting boundaries at 1 instead of 0
• Using negative indices incorrectly

3. What is the output of the following Go code snippet for spiral traversal?

matrix := [][]int{
  {1, 2, 3},
  {4, 5, 6},
  {7, 8, 9},
}
result := []int{}
top, bottom := 0, 2
left, right := 0, 2
for top <= bottom && left <= right {
  for i := left; i <= right; i++ {
    result = append(result, matrix[top][i])
  }
  top++
  for i := top; i <= bottom; i++ {
    result = append(result, matrix[i][right])
  }
  right--
  for i := right; i >= left; i-- {
    result = append(result, matrix[bottom][i])
  }
  bottom--
  for i := bottom; i >= top; i-- {
    result = append(result, matrix[i][left])
  }
  left++
}
fmt.Println(result)

medium

A. [9 8 7 6 5 4 3 2 1]

B. [1 2 3 4 5 6 7 8 9]

C. [1 4 7 8 9 6 3 2 5]

D. [1 2 3 6 9 8 7 4 5]

Solution

1. Step 1: Trace the spiral traversal steps

   Traverse top row left to right: 1,2,3; then right column top to bottom: 6,9; then bottom row right to left: 8,7; then left column bottom to top: 4; then inner layer top row: 5.

2. Step 2: Collect elements in order

   Order is [1,2,3,6,9,8,7,4,5].

3. Final Answer:

   [1 2 3 6 9 8 7 4 5] -> Option D

4. Quick Check:

   Spiral order matches [1 2 3 6 9 8 7 4 5] [OK]

Hint: Follow edges clockwise, then move inward [OK]

Common Mistakes:

• Not updating boundaries correctly after each loop
• Repeating elements or missing inner elements
• Confusing row and column indices

4. Identify the bug in this Go code snippet for spiral traversal:

top, bottom := 0, len(matrix)
left, right := 0, len(matrix[0])
for top <= bottom && left <= right {
  for i := left; i <= right; i++ {
    fmt.Print(matrix[top][i], " ")
  }
  top++
  // ... rest of traversal
}

medium

A. Missing initialization of top and left variables

B. Using len(matrix) and len(matrix[0]) instead of len(matrix)-1 and len(matrix[0])-1 for boundaries

C. Incorrect loop condition using <= instead of <

D. Using fmt.Print instead of fmt.Println

Solution

1. Step 1: Check boundary initialization

   len(matrix) gives count, but last index is len(matrix)-1. Using len(matrix) causes out-of-range error.

2. Step 2: Confirm loop indices

   Loop uses i <= right, so right must be last valid index, not length.

3. Final Answer:

   Using len(matrix) and len(matrix[0]) instead of len(matrix)-1 and len(matrix[0])-1 for boundaries -> Option B

4. Quick Check:

   Boundaries must be last index = length-1 [OK]

Hint: Remember last index is length minus one [OK]

Common Mistakes:

• Setting boundaries to length instead of length-1
• Looping beyond matrix size causing runtime error
• Ignoring zero-based indexing

5. Given a rectangular matrix:

matrix := [][]int{
  {1, 2, 3, 4},
  {5, 6, 7, 8},
  {9, 10, 11, 12},
}

What is the spiral traversal output?

hard

A. [1 2 3 4 8 12 11 10 9 5 6 7 0]

B. [1 5 9 10 11 12 8 4 3 2 6 7]

C. [1 2 3 4 8 12 11 10 9 5 6 7]

D. [1 2 3 4 5 6 7 8 9 10 11 12]

Solution

1. Step 1: Traverse top row left to right

   Elements: 1, 2, 3, 4

2. Step 2: Traverse right column top to bottom (excluding top row)

   Elements: 8, 12

3. Step 3: Traverse bottom row right to left (excluding right column)

   Elements: 11, 10, 9

4. Step 4: Traverse left column bottom to top (excluding top and bottom rows)

   Element: 5

5. Step 5: Traverse inner top row left to right

   Elements: 6, 7

6. Final Answer:

   [1 2 3 4 8 12 11 10 9 5 6 7] -> Option C

7. Quick Check:

   Spiral order matches [1 2 3 4 8 12 11 10 9 5 6 7] [OK]

Hint: Follow edges clockwise, then move inward layer by layer [OK]

Common Mistakes:

• Adding extra elements not in matrix
• Mixing row and column traversal order
• Forgetting to shrink boundaries after each layer