Island Perimeter - Practice Coding Problems

Island Perimeter - Problem

Imagine you're a surveyor tasked with measuring the coastline of a mysterious island! You have a grid map where each cell represents either land (1) or water (0).

Your mission: Calculate the total perimeter of the island - that is, count how many unit edges of land cells are exposed to water or the boundary.

Key Details:

Each cell is a 1×1 square
Cells connect horizontally and vertically only (no diagonal connections)
There's exactly one island (connected land cells)
The island has no lakes (no internal water)
The entire grid is surrounded by water

Goal: Return the perimeter as an integer representing the number of unit edges exposed to water.

Input & Output

example_1.py — Basic Island

$ Input: grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]

› Output: 16

💡 Note: The island perimeter is 16. Each land cell contributes edges that face water or boundaries. The island has an irregular shape with several external edges exposed to water.

example_2.py — Single Cell Island

$ Input: grid = [[1]]

› Output: 4

💡 Note: A single land cell has 4 edges, all of which are exposed to the boundary (treated as water), so the perimeter is 4.

example_3.py — Linear Island

$ Input: grid = [[1,0],[1,0]]

› Output: 6

💡 Note: Two vertically connected land cells. Top cell contributes 3 external edges, bottom cell contributes 3 external edges, but they share 1 internal edge, so total perimeter is 6.

Constraints

row == grid.length
col == grid[i].length
1 ≤ row, col ≤ 100
grid[i][j] is 0 or 1
There is exactly one island in grid

Visualization

Tap to expand

Understanding the Visualization

Identify the Island

Locate all land cells (1s) in the grid - they form one connected island

Count External Edges

For each land cell, count edges that face water (0s) or grid boundaries

Sum Up Perimeter

Add all external edges to get the total island perimeter

Key Takeaway

🎯 Key Insight: The perimeter equals the total number of land cell edges that face water or grid boundaries. Use the mathematical approach (4 × land_cells - 2 × adjacent_pairs) for optimal efficiency!

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal approach uses a mathematical insight: each land cell contributes 4 edges initially, but we subtract 2 for each shared edge with adjacent land cells. This requires only one pass through the grid with O(m×n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Cell-by-Cell Edge Counting	O(m×n)	O(1)	Check each land cell and count all edges that face water or boundaries
Mathematical Edge Optimization	O(m×n)	O(1)	Count land cells × 4, then subtract shared edges between adjacent land cells

Cell-by-Cell Edge Counting — Algorithm Steps

Iterate through every cell (i, j) in the grid
Skip if current cell is water (0)
For each land cell, check all 4 directions: up, down, left, right
Add 1 to perimeter count if neighbor is water or out of bounds
Return total perimeter count

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Land Cell

Locate a land cell (value = 1) in the grid

Check 4 Directions

For each direction (up, down, left, right), check if neighbor is water or out of bounds

Count Exposed Edges

Add 1 to perimeter count for each edge that faces water or boundary

Repeat for All Cells

Continue this process for every cell in the grid

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int islandPerimeter(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) return 0;
    
    int rows = gridSize;
    int cols = gridColSize[0];
    int perimeter = 0;
    
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (grid[i][j] == 1) {
                // Check all 4 directions
                // Up
                if (i == 0 || grid[i-1][j] == 0) {
                    perimeter++;
                }
                // Down
                if (i == rows-1 || grid[i+1][j] == 0) {
                    perimeter++;
                }
                // Left
                if (j == 0 || grid[i][j-1] == 0) {
                    perimeter++;
                }
                // Right
                if (j == cols-1 || grid[i][j+1] == 0) {
                    perimeter++;
                }
            }
        }
    }
    
    return perimeter;
}

int main() {
    int grid[4][4] = {{0,1,0,0},{1,1,1,0},{0,1,0,0},{1,1,0,0}};
    int* gridRows[4];
    int gridColSize[4] = {4,4,4,4};
    
    for (int i = 0; i < 4; i++) {
        gridRows[i] = grid[i];
    }
    
    printf("%d\n", islandPerimeter(gridRows, 4, gridColSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Visit each cell once, perform constant work (4 direction checks) per cell

✓ Linear Growth

Space Complexity

O(1)

Only use a few variables to track position and count

✓ Linear Space

89.0K Views

Medium Frequency

~12 min Avg. Time

2.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Cell-by-Cell Edge Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler