Count Houses in a Circular Street - Practice Coding Problems

Count Houses in a Circular Street - Problem

Array Interactive Easy

Imagine you're a census taker walking through a mysterious circular neighborhood where you need to count the total number of houses. You start at a random house and can only interact with the street through a limited Street API.

The street forms a perfect circle - if you keep walking in one direction, you'll eventually return to where you started. Each house has a door that can be either open or closed, and you have the power to manipulate these doors as you move around.

Your Mission: Determine the exact number of houses on this circular street using the minimal number of API calls.

Available Street API Methods:

openDoor() - Open the current house's door
closeDoor() - Close the current house's door
isDoorOpen() - Check if current door is open (returns boolean)
moveRight() - Move to the next house clockwise
moveLeft() - Move to the next house counter-clockwise

You know there are at most k houses on the street, but the exact count is what you need to discover. The challenge is to do this efficiently while working with an interactive environment.

Input & Output

example_1.py — Small Circle

$ Input: Street with 4 houses: [Open, Closed, Open, Open], k = 10

› Output: 4

💡 Note: Starting at any house, we close it to mark our position, then walk around counting until we return to the closed door. The circle has exactly 4 houses.

example_2.py — Single House

$ Input: Street with 1 house: [Open], k = 2

› Output: 1

💡 Note: Edge case with only one house. We close it, move right (which brings us back to the same house since it's circular), and immediately find the closed door, so count = 1.

example_3.py — All Doors Closed

$ Input: Street with 6 houses: [Closed, Closed, Closed, Closed, Closed, Closed], k = 10

› Output: 6

💡 Note: Even when all doors are initially closed, our algorithm works because we're looking for the specific door we closed at the starting position after making a complete circle.

Visualization

Tap to expand

Understanding the Visualization

Mark Your Starting Point

Close the door at your current position to create a unique landmark

Begin the Journey

Move to the next house and start counting (count = 1)

Walk and Count

Continue moving clockwise, incrementing counter for each house with an open door

Detect the Return

When you encounter a closed door, you've returned to your starting landmark

Complete the Census

Return the total count - you've counted every house exactly once

Key Takeaway

🎯 Key Insight: By creating our own landmark at the starting position, we can detect when we've completed exactly one full circle, ensuring we count every house exactly once.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass around the circle, visiting each house exactly once

✓ Linear Growth

Space Complexity

O(1)

Only need a counter variable, no additional data structures

✓ Linear Space

Constraints

1 ≤ number of houses ≤ k
k ≤ 10³
Each house door is initially either open or closed
The street forms a perfect circle
You start at an arbitrary house position

Asked in

G Google 42 f Facebook 28 a Amazon 35 ⊞ Microsoft 19

The optimal solution uses a mark and count strategy: close the starting door as a landmark, then walk clockwise counting houses until returning to the closed door. This guarantees exactly one complete lap in O(n) time with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Attempts)	O(n²)	O(n)	Try different strategies without clear termination condition
Mark and Count (Optimal)	O(n)	O(1)	Mark starting position and count houses until returning to the mark

Brute Force (Multiple Attempts) — Algorithm Steps

Record initial door states as we walk
Keep walking and comparing current states with recorded ones
Hope to detect when we've returned to the starting position
Count houses based on recorded states

Visualization

Tap to expand

Step-by-Step Walkthrough

Record Initial States

Walk around recording each door's state

Second Pass

Walk again trying to match recorded pattern

Pattern Matching

Compare current observations with recorded states

Code -

solution.c — C

int countHousesInCircularStreet(Street* street, int k) {
    // Record initial states
    bool* initialStates = (bool*)malloc(k * sizeof(bool));
    for (int i = 0; i < k; i++) {
        initialStates[i] = isDoorOpen(street);
        moveRight(street);
    }
    
    // Walk again and count until we match the pattern
    int count = 0;
    while (count < k) {
        if (isDoorOpen(street) == initialStates[count % k]) {
            count++;
            moveRight(street);
        } else {
            // Pattern doesn't match, try different approach
            break;
        }
    }
    
    free(initialStates);
    // This approach is flawed and unreliable
    return count < k ? count : k;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

May need to walk around multiple times, with each lap taking O(n) operations

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store door states for comparison

⚡ Linearithmic Space

Constraints

1 ≤ number of houses ≤ k
k ≤ 10³
Each house door is initially either open or closed
The street forms a perfect circle
You start at an arbitrary house position

38.2K Views

Medium Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Multiple Attempts) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler