Mastering 2D Arrays and Type Safety with TypeScript | CodeSignal Learn

Mastering 2D Arrays and Type Safety with TypeScript | CodeSignal Learn

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. Sounds like an adventure, doesn't it? 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 TypeScript function named findPositions() . This function is defined as function findPositions(board: string[][]): [number, number][] . Upon examining this 2D array, it 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 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 piece could be placed (empty) and then be able to move to a new empty spot in the next turn.

Step 1: Initialize Positions Array and Determine Board Dimensions

Stepping right into action, we start with an empty positions array to help us log the sought positions. Understanding the dimensions of our "board" paves the way for defining boundaries in our exploration mission. The positions array is initialized as let positions: [number, number][] = []; . Additionally, we determine the size of the 2D array using the length property. Using an array is crucial here because we don't know beforehand how many positions will be found. An array in TypeScript can dynamically adjust its size to accommodate any number of elements, making it a perfect choice for storing an unknown number of positions. TypeScript function findPositions(board: string[][]): [number, number][] {let positions: [number, number][] = []; let rows: number = board.length; let cols: number = board[0].length; // Further exploration follows

Step 2: Traverse the Entire Board

With the dimensions defined, we begin our expedition across the board. We use two nested for loops to do this, employing TypeScript's static typing for loop variables (i: number, j: number) to traverse the entire board one cell at a time. TypeScript function findPositions(board: string[][]): [number, number][] {let positions: [number, number][] = []; let rows: number = board.length; let cols: number = board[0].length; for (let i: number = 0; i < rows; i++) {for (let j: number = 0; j < cols; j++) {// ensuing exploration

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

What's the plan for each cell, you ask? While exploring each cell, our trusty TypeScript code inspects if 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 array.

TypeScript

function findPositions(board: string[][]): [number, number][] {
    let positions: [number, number][] = [];

    let rows: number = board.length;
    let cols: number = board[0].length;

    for (let i: number = 0; i < rows; i++) {
        for (let j: number = 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.push([i, j]);
                }
            }
        }
    }
    return positions;
}

let board: string[][] = [
    ['P', 'E', 'E', 'P'],
    ['E', 'P', 'E', 'P'],
    ['P', 'E', 'P', 'P'],
    ['P', 'E', 'P', 'E']
];

let positions: [number, number][] = findPositions(board);

for (let i: number = 0; i < positions.length; i++) {
    console.log(`(${positions[i][0]}, ${positions[i][1]})`);
}

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