How do I practice coding and algorithm questions?

Use PracHub's coding console to write, test, and debug your solutions in Python or JavaScript. View hints, test against sample inputs, and compare with official solutions.

What difficulty level is this coding question?

This is a medium difficulty Coding & Algorithms question, commonly asked during Technical Screen rounds at Robinhood.

What role is this question designed for?

This question is commonly asked for Software Engineer candidates at Robinhood during technical interviews.

Compute nearest gate distance in grid | Robinhood Coding Question

Quick Overview

This question evaluates grid traversal, distance propagation, obstacle handling, and in-place matrix update competencies within the Coding & Algorithms domain. It is commonly asked in technical interviews to assess algorithmic problem-solving and traversal strategies under obstacle and complexity constraints, representing a practical application-level problem rather than purely conceptual theory.

Compute nearest gate distance in grid

Company: Robinhood

Role: Software Engineer

Category: Coding & Algorithms

Difficulty: medium

Interview Round: Technical Screen

You are given an `m x n` grid representing a floor plan. - `0` = a gate - `-1` = a blocked cell (wall/obstacle); cannot be entered - `INF` = an empty cell (a large integer such as `2^31 - 1`) For every empty cell, fill it with the Manhattan distance (number of up/down/left/right steps) to its **nearest gate**. If an empty cell cannot reach any gate, leave it as `INF`. ### Requirements - Update the grid **in place**. - Movement is only in 4 directions. ### Example Input: ``` INF -1 0 INF INF INF INF -1 INF -1 INF -1 0 -1 INF INF ``` Output: ``` 3 -1 0 1 2 2 1 -1 1 -1 2 -1 0 -1 3 4 ``` ### Constraints (typical) - `1 <= m, n <= 200` - Grid values are only in `{ -1, 0, INF }`

Quick Answer: This question evaluates grid traversal, distance propagation, obstacle handling, and in-place matrix update competencies within the Coding & Algorithms domain. It is commonly asked in technical interviews to assess algorithmic problem-solving and traversal strategies under obstacle and complexity constraints, representing a practical application-level problem rather than purely conceptual theory.

You are given an `m x n` grid representing a floor plan. Each cell contains one of three values: - `0` for a gate - `-1` for a wall/blocked cell - `INF` for an empty cell, where `INF = 2147483647` For every empty cell, fill it with the Manhattan distance to its nearest gate using only 4-directional movement (up, down, left, right). If an empty cell cannot reach any gate, leave it as `INF`. You must update the grid in place. For testing purposes, return the updated grid as well.

Constraints

1 <= m, n <= 200
Each grid value is one of {-1, 0, 2147483647}
Movement is allowed only in 4 directions: up, down, left, right

Examples

Input: ([[2147483647, -1, 0, 2147483647], [2147483647, 2147483647, 2147483647, -1], [2147483647, -1, 2147483647, -1], [0, -1, 2147483647, 2147483647]],)

Expected Output: [[3, -1, 0, 1], [2, 2, 1, -1], [1, -1, 2, -1], [0, -1, 3, 4]]

Explanation: Starting BFS from both gates fills each empty cell with the distance to the nearest gate.

Input: ([[0]],)

Expected Output: [[0]]

Explanation: A single gate already has distance 0.

Input: ([[2147483647, -1], [2147483647, 2147483647]],)

Expected Output: [[2147483647, -1], [2147483647, 2147483647]]

Explanation: There are no gates, so no empty cell can be updated.

Input: ([[0, 2147483647, 2147483647, 0, 2147483647]],)

Expected Output: [[0, 1, 1, 0, 1]]

Explanation: With multiple gates, each empty cell takes the distance to the closer gate.

Hints

Running a separate BFS from every empty cell is too slow. Can you start from all gates at once instead?
In an unweighted grid, the first time BFS reaches a cell is the shortest distance to that cell.

Last updated: May 4, 2026

Loading coding console...