Codestin Search App

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.

Constraints

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

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.

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
✓ Greedy One-Pass (Optimal)	O(n)	O(1)	Walk through once, plant greedily whenever possible
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) — Algorithm Steps

Initialize a counter for planted flowers
Iterate through each position in the flowerbed
For each empty position, check if both neighbors are empty/non-existent
If safe, plant a flower and increment counter
Return true if we planted enough flowers

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Left

Begin iterating from the leftmost position

Check Safety

For each empty spot, verify both neighbors are empty

Plant Greedily

If safe, immediately plant a flower and continue

Count & Return

Return true if we planted enough flowers

Code -

solution.c — C

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

bool canPlaceFlowers(int* flowerbed, int flowerbedSize, int n) {
    int count = 0;
    
    for (int i = 0; i < flowerbedSize; i++) {
        // Check if current position is empty
        if (flowerbed[i] == 0) {
            // Check left neighbor (or treat as empty if at start)
            bool leftEmpty = (i == 0) || (flowerbed[i-1] == 0);
            // Check right neighbor (or treat as empty if at end)
            bool rightEmpty = (i == flowerbedSize-1) || (flowerbed[i+1] == 0);
            
            // If both neighbors are empty, we can plant here
            if (leftEmpty && rightEmpty) {
                flowerbed[i] = 1;  // Plant the flower
                count++;
                
                // Early termination optimization
                if (count >= n) {
                    return true;
                }
            }
        }
    }
    
    return count >= n;
}

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(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

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

Constraints

Visualization

Related Problems

Common Approaches

Greedy One-Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler