Number of Ways to Select Buildings - Practice Coding Problems

Number of Ways to Select Buildings - Problem

Building Selection Challenge

You are a city inspector tasked with selecting exactly 3 buildings for random inspection along a street. The street is represented by a binary string s where:

• '0' represents an office building
• '1' represents a restaurant

To ensure variety in your inspections, no two consecutive buildings in your selection can be of the same type. This means you must select buildings that form an alternating pattern.

Valid patterns: "010" or "101"
Invalid patterns: "000", "111", "001", "011", "100", "110"

Example: Given street s = "001101", you cannot select buildings at indices 1, 2, 4 (forming "011") because positions 1 and 2 are consecutive and both are '1'.

Goal: Return the total number of valid ways to select 3 buildings for inspection.

Input & Output

example_1.py — Basic Pattern

$ Input: s = "001101"

› Output: 6

💡 Note: Valid selections are: (0,2,4), (0,2,5), (0,3,4), (1,2,4), (1,2,5), (1,3,4). Each forms either '010' or '101' pattern.

example_2.py — Simple Alternating

$ Input: s = "101"

› Output: 1

💡 Note: Only one way to select 3 buildings: positions (0,1,2) forming pattern '101'.

example_3.py — All Same Type

$ Input: s = "111"

› Output: 0

💡 Note: No valid selections possible since all buildings are restaurants. Any selection would violate the alternating constraint.

Constraints

3 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
Must select exactly 3 buildings
Selected buildings must form alternating pattern

Visualization

Tap to expand

Understanding the Visualization

Identify Valid Patterns

Only '010' and '101' patterns are valid

Choose Middle Building

Each middle building determines the required pattern type

Count Combinations

Multiply available buildings of the required type on left and right

Key Takeaway

🎯 Key Insight: By recognizing that only two patterns ('010' and '101') are valid and treating each position as a potential middle building, we can count all valid combinations mathematically without generating them explicitly.

Asked in

a Amazon 45 ⊞ Microsoft 32 G Google 28 f Meta 22

The optimal solution uses dynamic programming to recognize that valid patterns are only '010' and '101'. For each position as the middle building, we multiply the count of appropriate building types on the left and right sides, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(n)	Count valid patterns by tracking building types and positions in one pass
Brute Force (Triple Nested Loop)	O(n³)	O(1)	Check all possible combinations of 3 buildings

Dynamic Programming (Optimal) — Algorithm Steps

For each position j (potential middle building), determine if it should be part of pattern '010' or '101'
Count buildings of type '0' and '1' to the left and right of position j
If s[j] = '1': count ways to form '010' = (zeros_left * zeros_right)
If s[j] = '0': count ways to form '101' = (ones_left * ones_right)
Sum all valid combinations across all middle positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Pattern Analysis

Recognize that valid patterns are only '010' and '101'

Middle Building

For each position, check if it can be the middle of a valid pattern

Count Combinations

Multiply count of valid buildings on left and right

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

long long numberOfWays(char* s) {
    int n = strlen(s);
    if (n < 3) return 0;
    
    // Count total 0s and 1s
    int totalZeros = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] == '0') totalZeros++;
    }
    int totalOnes = n - totalZeros;
    
    long long result = 0;
    int zerosLeft = 0;
    int onesLeft = 0;
    
    for (int i = 0; i < n; i++) {
        // Calculate zeros and ones to the right
        int zerosRight = totalZeros - zerosLeft - (s[i] == '0' ? 1 : 0);
        int onesRight = totalOnes - onesLeft - (s[i] == '1' ? 1 : 0);
        
        // If current building is '1', it can be middle of '010' pattern
        if (s[i] == '1') {
            result += (long long) zerosLeft * zerosRight;
        }
        
        // If current building is '0', it can be middle of '101' pattern
        if (s[i] == '0') {
            result += (long long) onesLeft * onesRight;
        }
        
        // Update left counts
        if (s[i] == '0') {
            zerosLeft++;
        } else {
            onesLeft++;
        }
    }
    
    return result;
}

int main() {
    char s[100005];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = 0;
    }
    printf("%lld\n", numberOfWays(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to precompute prefix counts, then another pass to calculate results

✓ Linear Growth

Space Complexity

O(n)

Arrays to store prefix counts of 0s and 1s at each position

⚡ Linearithmic Space

62.4K Views

Medium Frequency

~15 min Avg. Time

2.8K 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler