Grid Traversal in Kotlin with Path Exploration

Introduction

Hello, and welcome back to our coding lesson series. In this unit, we have a fascinating problem at hand that uses the concept of 2D arrays or grids . What's interesting about this problem is that it involves the simple traversal of the grid, but also making this traversal in a unique manner. Initially, the concept might seem a bit tricky, but as we dissect the task and take it step by step, you're sure to enjoy how it unfolds. Are you ready to embark on this adventure? Let's dive right in!

Task Statement

The task before us involves the creation of a Kotlin function named pathTraverse . This function should perform a particularly ordered traversal through a 2D grid. The function will accept a grid represented as an Array<Array<Int>>, along with the starting cell coordinates as parameters. Starting from the provided cell, the function should move in any one of the four possible directions toward an adjacent cell. However, a condition governs this selection: the new cell value should be strictly greater than the current cell's value. Think of this as navigating a hiking trail, where you can only move to higher ground from your current position. This pattern would continue as we keep selecting the next available, larger cell value. The traversal would halt when there are no cells left that satisfy our criteria. The final result of the function will be a MutableList<Int> that includes all the visited cell values in the order of their visitation. Consider a 3x3 grid: text 1 2 3 4 5 6 7 8 9 If we start at the cell with the value 5, we can logically move to either 6 or 8 . Let's say we choose 6; the only cell that we can now move to is 9 . After this, we have no more moves left that fit our criteria. Hence, the function returns {5, 6, 9} .

Solution Building: Step 1

The first thing we need to do is determine the dimensions of our grid, which is relatively easy in Kotlin using property accessors. We can also establish the directions that our traversal can take. In the context of matrices, when we say we are moving "up," we are moving one step towards the first row (decreasing the row index). Similarly, moving "down" corresponds to moving one step towards the last row (increasing the row index), and moving left or right relates to decrementing or incrementing the column index, respectively. Kotlin fun pathTraverse(grid: Array<Array<Int>>, startRow: Int, startCol: Int): MutableList<Int> {val rows = grid.size val cols = grid[0].size val directions = arrayOf(intArrayOf(-1, 0), // Up intArrayOf(1, 0), // Down intArrayOf(0, -1), // Left intArrayOf(0, 1) // Right) In the directions array, each pair represents a direction in terms of a pair (rowOffset, colOffset) . So, if we are at a cell (r, c), moving up corresponds to going to the cell (r-1, c), moving down corresponds to (r+1, c), moving left corresponds to (r, c-1), and moving right corresponds to (r, c+1) .

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

Let's initiate the grid traversal process in our function. We first set up an infinite loop that will only stop when we break it based on a condition. Inside the infinite loop, for each iteration, we'll have the function try to select the next cell with the maximum value among the adjacent cells. If we find such a cell, we'll capture its value, and it will be our next cell.

Kotlin

fun pathTraverse(grid: Array<Array<Int>>, startRow: Int, startCol: Int): MutableList<Int> {
    val rows = grid.size
    val cols = grid[0].size

    // Check the validity of the input
    if (startRow < 0 || startRow >= rows || startCol < 0 || startCol >= cols) {
        println("Invalid input")
        return mutableListOf()
    }
    
    // Define all four possible directions of movement
    val directions = arrayOf(
        intArrayOf(1, 0), intArrayOf(-1, 0), intArrayOf(0, -1), intArrayOf(0, 1)
    )

    // Start with the value at the starting cell
    val visited = mutableListOf<Int>()
    visited.add(grid[startRow][startCol])

    var currentRow = startRow
    var currentCol = startCol

    while (true) {
        // Initialize the current maximum as current cell value
        var currMax = grid[currentRow][currentCol]
        var nextRow = -1
        var nextCol = -1

        // Loop over each adjacent cell in all the directions
        for (dir in directions) {
            // Calculate the new cell's row and column indices
            val newRow = currentRow + dir[0]
            val newCol = currentCol + dir[1]

            // If the new cell is in the grid boundary and has a higher value
            if (newRow in 0 until rows && newCol in 0 until cols && grid[newRow][newCol] > currMax) {
                // Save it as the next cell to visit
                nextRow = newRow
                nextCol = newCol
                currMax = grid[newRow][newCol]
            }
        }

        // If we don't have any valid cell to visit, break from the loop  
        if (nextRow == -1) break

        // Otherwise, go to the next cell
        currentRow = nextRow
        currentCol = nextCol

        // Append the cell's value to the result list
        visited.add(currMax)
    }

    // Return the list of visited cells' values    
    return visited
}

fun main() {
    val grid = arrayOf(
        arrayOf(1, 2, 3),
        arrayOf(4, 5, 6),
        arrayOf(7, 8, 9)
    )
    val res = pathTraverse(grid, 1, 1)
    for (value in res) {
        print("$value ")
    }
    // Expected output: 5 8 9
}

fun pathTraverse(grid: Array<Array<Int>>, startRow: Int, startCol: Int): MutableList<Int> {
    val rows = grid.size
    val cols = grid[0].size

    // Check the validity of the input
    if (startRow < 0 || startRow >= rows || startCol < 0 || startCol >= cols) {
        println("Invalid input")
        return mutableListOf()
    }
    
    // Define all four possible directions of movement
    val directions = arrayOf(
        intArrayOf(1, 0), intArrayOf(-1, 0), intArrayOf(0, -1), intArrayOf(0, 1)
    )

    // Start with the value at the starting cell
    val visited = mutableListOf<Int>()
    visited.add(grid[startRow][startCol])

    var currentRow = startRow
    var currentCol = startCol

    while (true) {
        // Initialize the current maximum as current cell value
        var currMax = grid[currentRow][currentCol]
        var nextRow = -1
        var nextCol = -1

        // Loop over each adjacent cell in all the directions
        for (dir in directions) {
            // Calculate the new cell's row and column indices
            val newRow = currentRow + dir[0]
            val newCol = currentCol + dir[1]

            // If the new cell is in the grid boundary and has a higher value
            if (newRow in 0 until rows && newCol in 0 until cols && grid[newRow][newCol] > currMax) {
                // Save it as the next cell to visit
                nextRow = newRow
                nextCol = newCol
                currMax = grid[newRow][newCol]
            }
        }

        // If we don't have any valid cell to visit, break from the loop  
        if (nextRow == -1) break

        // Otherwise, go to the next cell
        currentRow = nextRow
        currentCol = nextCol

        // Append the cell's value to the result list
        visited.add(currMax)
    }

    // Return the list of visited cells' values    
    return visited
}

fun main() {
    val grid = arrayOf(
        arrayOf(1, 2, 3),
        arrayOf(4, 5, 6),
        arrayOf(7, 8, 9)
    )
    val res = pathTraverse(grid, 1, 1)
    for (value in res) {
        print("$value ")
    }
    // Expected output: 5 8 9
}

Introduction

Task Statement

Solution Building: Step 1

Join the 1M+ learners on CodeSignal

Solution Building: Step 2

Solution Building: Step 3

Lesson Summary