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 Palantir.

What role is this question designed for?

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

Solve two algorithm problems from a menu | Palantir Coding Question

Quick Overview

This question evaluates algorithmic problem-solving, practical coding implementation, complexity analysis, testing rigor, and the ability to discuss design trade-offs across topics such as arrays, strings, hash maps, and graphs.

Loading coding console...

Part 2: Number of Islands

Given a rectangular grid of 0s and 1s, count how many islands it contains. An island is a maximal group of 1 cells connected horizontally or vertically. Diagonal cells do not connect islands. Assume an empty grid, or a grid with zero columns, contains 0 islands.

Constraints

0 <= number of rows <= 1000
0 <= number of columns <= 1000
For non-empty grids, rows * columns <= 200000
The grid is rectangular
Connectivity is 4-directional only: up, down, left, right

Examples

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

Expected Output: 3

Explanation: There are three separate groups of connected land cells.

Input: ([],)

Expected Output: 0

Explanation: An empty grid contains no land and therefore no islands.

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

Expected Output: 0

Explanation: All cells are water, so the island count is 0.

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

Expected Output: 1

Explanation: A single land cell forms exactly one island.

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

Expected Output: 6

Explanation: Diagonal adjacency does not count, so each 1 cell is isolated.

Solution

def solution(grid):
    if not grid or not grid[0]:
        return 0

    rows = len(grid)
    cols = len(grid[0])
    visited = [[False] * cols for _ in range(rows)]
    islands = 0

    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == 1 and not visited[r][c]:
                islands += 1
                stack = [(r, c)]
                visited[r][c] = True

                while stack:
                    cr, cc = stack.pop()
                    for nr, nc in ((cr + 1, cc), (cr - 1, cc), (cr, cc + 1), (cr, cc - 1)):
                        if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] == 1 and not visited[nr][nc]:
                            visited[nr][nc] = True
                            stack.append((nr, nc))

    return islands

Time complexity: O(r * c), where r is the number of rows and c is the number of columns.. Space complexity: O(r * c).

Hints

Treat each land cell as a node in a graph and explore its connected component.
Each time you discover an unvisited land cell, traverse its whole island and increment the answer once.

Quick Overview