Finding Ideal Game Piece Positions in Go

Introduction

Hello, and welcome, code explorer! Today's journey takes us through the intricate paths within a 2-dimensional array, often likened to a game board. Our mission is to identify ideal spots for game piece placement. Does it sound like an adventure? Let's embark!

Task Statement

Visualize a chessboard in the form of a 2D array, where each cell could be marked E for empty or P for a piece. Our quest involves summoning a Go function named FindPositions() . Upon examining this 2D array, this function identifies all the spots where a new piece could be placed so that it can move to another empty cell in one move. The catch is that a piece can move only to an immediately neighboring cell directly above, below, to the left, or to the right, but not diagonally. Consider this 4x4 board, for instance: P E E P E P E P P E P P P E P E The function should output the following pairs representing positions: (0, 1), (0, 2), (1, 2), (2, 1), (3, 1) . This output represents the positions where a new piece can fit perfectly and then be able to move in the next turn.

Solution Building: Step 1

Stepping right into action, we start with an empty positions slice to help us log the sought positions. Understanding the dimensions of our "board" paves the way for defining boundaries in our exploration mission. Now, how does one determine the size of a 2D array in Go? The answer lies in the len function. Using a slice is crucial here because Go slices are dynamic and can resize themselves to accommodate any number of elements, making it a perfect choice for storing an unknown number of positions. Go package main import ("fmt") func FindPositions(board [][]rune) [][2]int {var positions [][2]int rows := len(board) cols := len(board[0]) // Further exploration follows

Solution Building: Step 2

With our boundary map, we begin our expedition across the board. We use two nested for loops to do this, traversing the entire board one cell at a time. Go package main import ("fmt") func FindPositions(board [][]rune) [][2]int {var positions [][2]int rows := len(board) cols := len(board[0]) for i := 0; i < rows; i++ {for j := 0; j < cols; j++ {// ensuing exploration

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

What's the plan for each cell, you ask? While exploring each cell, our trusty Go code inspects whether the cell is empty. If confirmed, it then peeks into the neighbors in the up, down, left, and right directions. If another vacant cell (E) is spotted, we jot down the main cell's position in our positions slice.

package main

import (
    "fmt"
)

func FindPositions(board [][]rune) [][2]int {
    var positions [][2]int

    rows := len(board)
    cols := len(board[0])

    for i := 0; i < rows; i++ {
        for j := 0; j < cols; j++ {
            if board[i][j] == 'E' {
                if (i > 0 && board[i-1][j] == 'E') ||
                    (i < rows-1 && board[i+1][j] == 'E') ||
                    (j > 0 && board[i][j-1] == 'E') ||
                    (j < cols-1 && board[i][j+1] == 'E') {
                    positions = append(positions, [2]int{i, j})
                }
            }
        }
    }
    return positions
}

func main() {
    board := [][]rune{
        {'P', 'E', 'E', 'P'},
        {'E', 'P', 'E', 'P'},
        {'P', 'E', 'P', 'P'},
        {'P', 'E', 'P', 'E'},
    }

    positions := FindPositions(board)

    for _, pos := range positions {
        fmt.Printf("(%d, %d)\n", pos[0], pos[1])
    }
}

// The output will be:
// (0, 1)
// (0, 2)
// (1, 2)
// (2, 1)
// (3, 1)

package main

import (
    "fmt"
)

func FindPositions(board [][]rune) [][2]int {
    var positions [][2]int

    rows := len(board)
    cols := len(board[0])

    for i := 0; i < rows; i++ {
        for j := 0; j < cols; j++ {
            if board[i][j] == 'E' {
                if (i > 0 && board[i-1][j] == 'E') ||
                    (i < rows-1 && board[i+1][j] == 'E') ||
                    (j > 0 && board[i][j-1] == 'E') ||
                    (j < cols-1 && board[i][j+1] == 'E') {
                    positions = append(positions, [2]int{i, j})
                }
            }
        }
    }
    return positions
}

func main() {
    board := [][]rune{
        {'P', 'E', 'E', 'P'},
        {'E', 'P', 'E', 'P'},
        {'P', 'E', 'P', 'P'},
        {'P', 'E', 'P', 'E'},
    }

    positions := FindPositions(board)

    for _, pos := range positions {
        fmt.Printf("(%d, %d)\n", pos[0], pos[1])
    }
}

// The output will be:
// (0, 1)
// (0, 2)
// (1, 2)
// (2, 1)
// (3, 1)