Traversing Arrays from the Middle | CodeSignal Learn

Traversing Arrays from the Middle | CodeSignal Learn

Introduction

Greetings! Welcome to this unit's lesson, where we’ll dive into a fascinating aspect of array manipulation . Have you ever considered traversing an array from the middle, alternating toward both ends simultaneously? That’s exactly what we’ll explore today. By the end of this lesson, you’ll understand how to implement this unique traversal method in Ruby. Let’s jump right in!

Task Statement

You are tasked with creating a method that takes an array of integers and returns a new array. The new array is built by starting at the middle of the original array and alternating between elements to the left and right of the middle. Here’s the specific behavior: If the array has an odd length, the middle element is added first, followed by alternating elements to the left and right. If the array has an even length, alternation begins with the left middle element, then the right middle element, and continues outward. For example: Given numbers = [1, 2, 3, 4, 5], the output should be [3, 2, 4, 1, 5] . For numbers = [1, 2, 3, 4, 5, 6], the output should be [3, 4, 2, 5, 1, 6] . This approach works for arrays of varying lengths, from 1 to 100,000 . Let’s break down the solution step by step.

Step 1: Find the Middle

To start, we need to determine the middle of the array. Ruby’s integer division (/) makes it simple to calculate the middle index. If the array length is odd, the middle element will be included in the output first. Otherwise, we’ll prepare for alternation between the two middle elements. Here’s how we identify the middle: Ruby def traverse_from_middle(numbers) mid = numbers.length / 2 new_order = if numbers.length.odd? [numbers[mid]] # Start with the middle element for odd-length arrays else [] # Start with an empty array for even-length arrays end This initializes the new_order array based on whether the input array’s length is odd or even.

Step 2: Initialize Pointers

Next, we initialize two pointers, left and right, to keep track of the elements on either side of the middle. These pointers will guide us as we alternate between elements to the left and right of the middle. Here’s how we set up the pointers: Ruby left = mid - 1 right = mid if numbers.length.odd? right += 1 # Adjust right pointer for odd-length arrays end The left pointer starts just before the middle, and the right pointer starts just after the middle for odd-length arrays, or at the second middle element for even-length arrays.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Step 3: Traverse the Array

With our pointers set, we traverse the array and construct the new_order array. Using a while loop, we continue until both pointers move out of bounds. In each iteration: Add the element at the left pointer to new_order . Move the left pointer one step to the left. Add the element at the right pointer to new_order . Move the right pointer one step to the right. Here’s the complete traversal: while left >= 0 || right < numbers.length new_order << numbers[left] if left >= 0 # Add left element if in bounds new_order << numbers[right] if right < numbers.length # Add right element if in bounds left -= 1 right += 1 end This ensures we alternate between left and right elements until all elements are included in the new array.

Step 4: Return the Result

Finally, we return the new_order array containing the elements in the desired order. Here’s the complete method: def traverse_from_middle(numbers) mid = numbers.length / 2 new_order = if numbers.length.odd? [numbers[mid]] # Start with the middle element for odd-length arrays else [] # Start with an empty array for even-length arrays end left = mid - 1 right = mid right += 1 if numbers.length.odd? while left >= 0 || right < numbers.length new_order << numbers[left] if left >= 0 new_order << numbers[right] if right < numbers.length left -= 1 right += 1 end new_order end # Example usage: numbers_odd = [1, 2, 3, 4, 5] result_odd = traverse_from_middle(numbers_odd) puts result_odd.inspect # Output: [3, 2, 4, 1, 5] numbers_even = [1, 2, 3, 4, 5, 6] result_even = traverse_from_middle(numbers_even) puts result_even.inspect # Output: [3, 4, 2, 5, 1, 6] This method captures the essence of traversing an array from the middle, alternating toward the ends.

Ruby

  while left >= 0 || right < numbers.length
    new_order << numbers[left] if left >= 0 # Add left element if in bounds
    new_order << numbers[right] if right < numbers.length # Add right element if in bounds
    left -= 1
    right += 1
  end

Ruby

def traverse_from_middle(numbers)
  mid = numbers.length / 2
  new_order = if numbers.length.odd?
                [numbers[mid]] # Start with the middle element for odd-length arrays
              else
                [] # Start with an empty array for even-length arrays
              end

  left = mid - 1
  right = mid
  right += 1 if numbers.length.odd?

  while left >= 0 || right < numbers.length
    new_order << numbers[left] if left >= 0
    new_order << numbers[right] if right < numbers.length
    left -= 1
    right += 1
  end

  new_order
end

# Example usage:
numbers_odd = [1, 2, 3, 4, 5]
result_odd = traverse_from_middle(numbers_odd)
puts result_odd.inspect # Output: [3, 2, 4, 1, 5]

numbers_even = [1, 2, 3, 4, 5, 6]
result_even = traverse_from_middle(numbers_even)
puts result_even.inspect # Output: [3, 4, 2, 5, 1, 6]