Can Place Flowers - Practice Coding Problems

Can Place Flowers - Problem

Array Greedy Easy

Imagine you're a gardener tasked with planting flowers in a long flowerbed! You have a flowerbed represented as an integer array where 0 means an empty plot and 1 means a plot already has a flower planted.

Here's the catch: flowers cannot be planted in adjacent plots - they need space to grow! Your goal is to determine if you can plant n new flowers without violating this no-adjacent-flowers rule.

Input: An integer array flowerbed containing 0's and 1's, and an integer n representing the number of flowers you want to plant.

Output: Return true if you can successfully plant all n flowers, false otherwise.

Example: Given flowerbed = [1,0,0,0,1] and n = 1, you can plant one flower in the middle position (index 2) since it's not adjacent to any existing flowers.

Input & Output

example_1.py — Basic Case

$ Input: flowerbed = [1,0,0,0,1], n = 1

› Output: true

💡 Note: We can plant 1 flower at index 2. The position is safe because both neighbors (index 1 and 3) are empty.

example_2.py — Cannot Plant

$ Input: flowerbed = [1,0,0,0,1], n = 2

› Output: false

💡 Note: We can only plant 1 flower at index 2. After planting there, no other positions are safe due to adjacency constraints.

example_3.py — Edge Case

$ Input: flowerbed = [0], n = 1

› Output: true

💡 Note: Single empty plot can accommodate one flower since there are no adjacent positions to worry about.

Visualization

Tap to expand

Understanding the Visualization

Survey the Garden

Start from the leftmost plot and examine each position

Check Neighbors

For empty plots, verify both left and right neighbors are safe

Plant Greedily

If position is safe, plant immediately - don't wait!

Continue Forward

Move to next position and repeat until done

Key Takeaway

🎯 Key Insight: The greedy approach works because planting flowers from left to right, whenever possible, maximizes our planting opportunities without any negative consequences for future decisions.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the flowerbed array of length n

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables regardless of input size

✓ Linear Space

Constraints

1 ≤ flowerbed.length ≤ 2 × 10⁴
flowerbed[i] is 0 or 1
There are no two adjacent flowers in flowerbed
0 ≤ n ≤ flowerbed.length

Asked in

in LinkedIn 15 a Amazon 12 G Google 8 f Meta 6

The optimal solution uses a greedy one-pass approach. Walk through the flowerbed from left to right, and at each empty position, check if both neighbors are empty (treating boundaries as empty). If safe, plant immediately. This works because planting earlier never reduces future opportunities. Time complexity: O(n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n × m)	O(n)	Generate all possible ways to plant n flowers and check validity
Greedy One-Pass (Optimal)	O(n)	O(1)	Walk through once, plant greedily whenever possible

Brute Force (Try All Combinations) — Algorithm Steps

Find all empty positions in the flowerbed
Generate all combinations of n positions from empty spots
For each combination, check if any two positions are adjacent
Return true if any valid combination exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Empty Spots

Identify all positions where flowers could potentially be planted

Generate Combinations

Create all possible ways to choose n positions from empty spots

Validate Each

Check each combination for adjacency violations

Return Result

Return true if any valid combination exists

Code -

solution.c — C

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

bool isValid(int* flowerbed, int flowerbedSize, int* positions, int posSize) {
    for (int i = 0; i < posSize; i++) {
        for (int j = i + 1; j < posSize; j++) {
            if (abs(positions[i] - positions[j]) == 1) {
                return false;
            }
        }
        int pos = positions[i];
        if ((pos > 0 && flowerbed[pos-1] == 1) || 
            (pos < flowerbedSize-1 && flowerbed[pos+1] == 1)) {
            return false;
        }
    }
    return true;
}

bool generateCombinations(int* flowerbed, int flowerbedSize, int* emptyPositions, 
                          int emptySize, int start, int* currentCombo, int comboSize, int targetSize) {
    if (comboSize == targetSize) {
        return isValid(flowerbed, flowerbedSize, currentCombo, comboSize);
    }
    
    for (int i = start; i < emptySize; i++) {
        currentCombo[comboSize] = emptyPositions[i];
        if (generateCombinations(flowerbed, flowerbedSize, emptyPositions, emptySize, 
                                 i + 1, currentCombo, comboSize + 1, targetSize)) {
            return true;
        }
    }
    
    return false;
}

bool canPlaceFlowers(int* flowerbed, int flowerbedSize, int n) {
    if (n == 0) return true;
    
    int* emptyPositions = (int*)malloc(flowerbedSize * sizeof(int));
    int emptyCount = 0;
    
    for (int i = 0; i < flowerbedSize; i++) {
        if (flowerbed[i] == 0) {
            emptyPositions[emptyCount++] = i;
        }
    }
    
    if (emptyCount < n) {
        free(emptyPositions);
        return false;
    }
    
    int* currentCombo = (int*)malloc(n * sizeof(int));
    bool result = generateCombinations(flowerbed, flowerbedSize, emptyPositions, emptyCount, 0, currentCombo, 0, n);
    
    free(emptyPositions);
    free(currentCombo);
    return result;
}

int main() {
    int flowerbed[] = {1, 0, 0, 0, 1};
    int n = 1;
    printf("%s\n", canPlaceFlowers(flowerbed, 5, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × m)

Need to check 2^n possible combinations, each taking O(m) time to validate where m is flowerbed length

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current combination and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ flowerbed.length ≤ 2 × 10⁴
flowerbed[i] is 0 or 1
There are no two adjacent flowers in flowerbed
0 ≤ n ≤ flowerbed.length

125.0K Views

Medium Frequency

~12 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler