Center-Out List Traversal in Kotlin

Introduction

Greetings! Welcome to our lesson today, where we'll unravel a fascinating aspect of list manipulation . Here's the question: How would you traverse a list not from the beginning to the end, or vice versa, but from the center outward in either direction? Today's lesson is all about exploring this concept with Kotlin . Brace yourself for a captivating learning journey.

Task Statement

Our task is to produce a new list, given a list of integers, that starts from the center of the original list and alternates direction towards both ends. That is, the first element of our new list will be the middle element of the original one. After defining the starting point, we will alternate between elements to the left and to the right of this center until all elements have been included. If the length of the initial list is even, we first take the element to the left of the center, then the one to the right of the center, and then do the alternation as described above. For example, for numbers = listOf(1, 2, 3, 4, 5), the output would be [3, 2, 4, 1, 5] . We will break down this seemingly complex task into manageable pieces to progressively build our Kotlin solution. Keep in mind an additional condition: the length of the list — represented as n — can range from 1 to 100,000, inclusive.

Solution Building: Step 1

First, let's establish the midpoint of our list. Our task requires us to expand our list from the center to the ends, so we divide its length by 2 using integer division in Kotlin . If we find that the list's length is odd, we include the middle element in the newOrder list, given it has no counterpart. If the list's length is even, newOrder initially remains empty. Here is how it looks in Kotlin : Kotlin fun iterateMiddleToEnd(numbers: List<Int>): MutableList<Int> {val mid = numbers.size / 2 // index of the left middle element val newOrder = mutableListOf<Int>() // MutableList to store new order if (numbers.size % 2 == 1) {newOrder.add(numbers[mid]) // Adding the middle element to the resulting MutableList if length is odd} // newOrder remains empty for now if length is even return newOrder}

Solution Building: Step 2

Join the 1M+ learners on CodeSignal

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

Solution Building: Step 3

With our pointers initialized, it's time to navigate the list and form our new order. In Kotlin, while loops provide the necessary control structure to iterate from the center of the list to both ends. In each iteration, we push the elements at indices left and right to the newOrder list, decrement left by one, and increment right by one.

Here's how it looks when we put together the full Kotlin method:

Kotlin

fun iterateMiddleToEnd(numbers: List<Int>): MutableList<Int> {
    val mid = numbers.size / 2 // index of the left middle element
    var left: Int
    var right: Int
    val newOrder = mutableListOf<Int>()  // MutableList to store new order

    if (numbers.size % 2 == 1) {
        left = mid - 1 // Pointing to the left of the middle element
        right = mid + 1 // Pointing to the right of the middle element
        newOrder.add(numbers[mid]) // Adding the middle element to the resulting MutableList
    } else {
        left = mid - 1 // Pointing to the left of the middle element
        right = mid // Pointing to the middle element
    }

    while (left >= 0 || right < numbers.size) {
        if (left >= 0) newOrder.add(numbers[left--])
        if (right < numbers.size) newOrder.add(numbers[right++])
    }

    return newOrder
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    
    val result = iterateMiddleToEnd(numbers)
    println(result)  // Output should be [3, 2, 4, 1, 5]
}

fun iterateMiddleToEnd(numbers: List<Int>): MutableList<Int> {
    val mid = numbers.size / 2 // index of the left middle element
    var left: Int
    var right: Int
    val newOrder = mutableListOf<Int>()  // MutableList to store new order

    if (numbers.size % 2 == 1) {
        left = mid - 1 // Pointing to the left of the middle element
        right = mid + 1 // Pointing to the right of the middle element
        newOrder.add(numbers[mid]) // Adding the middle element to the resulting MutableList
    } else {
        left = mid - 1 // Pointing to the left of the middle element
        right = mid // Pointing to the middle element
    }

    while (left >= 0 || right < numbers.size) {
        if (left >= 0) newOrder.add(numbers[left--])
        if (right < numbers.size) newOrder.add(numbers[right++])
    }

    return newOrder
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    
    val result = iterateMiddleToEnd(numbers)
    println(result)  // Output should be [3, 2, 4, 1, 5]
}

By implementing this approach, we have successfully created a new list, starting from the middle and alternating to the left and right ends of the original list, effectively fulfilling the requirements of our task!