[Swift]LeetCode605. 种花问题 | Can Place Flowers

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10455207.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Suppose you have a long flowerbed in which some of the plots are planted and some are not. However, flowers cannot be planted in adjacent plots - they would compete for water and both would die.

Given a flowerbed (represented as an array containing 0 and 1, where 0 means empty and 1 means not empty), and a number n, return if n new flowers can be planted in it without violating the no-adjacent-flowers rule.

Example 1:

Input: flowerbed = [1,0,0,0,1], n = 1
Output: True 

Example 2:

Input: flowerbed = [1,0,0,0,1], n = 2
Output: False 

Note:

1. The input array won't violate no-adjacent-flowers rule.
2. The input array size is in the range of [1, 20000].
3. n is a non-negative integer which won't exceed the input array size.

---

假设你有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花卉不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给定一个花坛（表示为一个数组包含0和1，其中0表示没种植花，1表示种植了花），和一个数 n 。能否在不打破种植规则的情况下种入 n 朵花？能则返回True，不能则返回False。

示例 1:

输入: flowerbed = [1,0,0,0,1], n = 1
输出: True

示例 2:

输入: flowerbed = [1,0,0,0,1], n = 2
输出: False

注意:

1. 数组内已种好的花不会违反种植规则。
2. 输入的数组长度范围为 [1, 20000]。
3. n 是非负整数，且不会超过输入数组的大小。

---

Runtime: 128 ms

Memory Usage: 19.3 MB

class Solution {
    func canPlaceFlowers(_ flowerbed: [Int], _ n: Int) -> Bool {
        var flowerbed = flowerbed
        var n = n
        flowerbed.insert(0,at:0)
        flowerbed.append(0)
        var i:Int = 1
        while(i < flowerbed.count - 1)
        {
            if n == 0 {return true}
            if flowerbed[i - 1] + flowerbed[i] + flowerbed[i + 1] == 0
            {
                n -= 1
                i += 1  
            }
            i += 1            
        }
        return n <= 0
    }
}

---

132ms

class Solution {
    func canPlaceFlowers(_ flowerbed: [Int], _ n: Int) -> Bool {
        if n == 0{
            return true
        }
        var pending = n
        
        var currentIndex = 0
        var foundOne = false
        while currentIndex < flowerbed.count{
            if flowerbed[currentIndex] == 0{
                if foundOne || (currentIndex < flowerbed.count - 1 && flowerbed[currentIndex + 1] == 1){
                    foundOne = false
                    currentIndex += 1
                }
                else{
                    pending -= 1
                    if pending == 0{
                        return true
                    }
                    currentIndex += 2
                }
            }
            else if flowerbed[currentIndex] == 1{
                foundOne = true
                currentIndex += 1
            }
            else{
                currentIndex += 1
            }
        }
        return pending == 0
    }
}

---

136ms

class Solution {
    func canPlaceFlowers(_ flowerbed: [Int], _ n: Int) -> Bool {
        guard n > 0 else {
            return true
        }

        var left = n
        var newArray = [0]
        newArray.append(contentsOf: flowerbed)
        newArray.append(0)
        var i = 0
        while i < newArray.count - 2 {
            if newArray[i] == 0 && newArray[i+1] == 0 && newArray[i+2] == 0 {
                left -= 1
                i += 1
                if left == 0 {
                    return true
                }
            }
            i += 1
        }
        return left == 0
    }
}

---

140ms

class Solution {
    func canPlaceFlowers(_ flowerbed: [Int], _ n: Int) -> Bool {
        var flowerbed = flowerbed
        var n = n
        var i = 0
        while i < flowerbed.count && n > 0 {
            if flowerbed[i] == 0 && (i == 0 || flowerbed[i - 1] == 0) && (i == flowerbed.count - 1 || flowerbed[i + 1] == 0) {
                n -= 1
                flowerbed[i] = 1
            }
            i += 1
        }
        return n == 0
    }
}

---

144ms

class Solution {
    func canPlaceFlowers(_ flowerbed: [Int], _ n: Int) -> Bool {
        var result = 0
        var count = 1
        for b in flowerbed {
            if b == 0 {
                count += 1
            } else if b == 1 {
                result += (count-1)/2
                count = 0
            }
        }
        result += count / 2
        return result >= n
    }
}

---

152ms

class Solution {
    func canPlaceFlowers(_ flowerbed: [Int], _ n: Int) -> Bool {
        if n == 0 {return true}
        
        
        var pre = -2
        var count = n
        for (index, num) in flowerbed.enumerated() {
            if num == 1 {
                count -= (index - pre - 1 - 1) / 2
                pre = index
            }
        }
        count -= (flowerbed.count - pre - 1) / 2
        return count <= 0
    }
}

---

172ms

class Solution {
    func canPlaceFlowers(_ flowerbed: [Int], _ n: Int) -> Bool {
        // how many possible position
         var adjcent = 0 
        // how many consequent 0 start with 1 because plant can be placed at first position it means the left of first position.
        var c = 1
        for i in 0..<flowerbed.count{
            if flowerbed[i] == 0 {
                c += 1
            }else{
                adjcent += (c-1)/2
                c = 0
            }
        }
        // last consequent 0 won't be calculated within the loop if last position is 0. Like first position, last position'right is 0 as well.
        adjcent += c/2 
        return adjcent >= n
    }
}

---

180ms

class Solution {
  func canPlaceFlowers(_ flowerbed: [Int], _ n: Int) -> Bool {
    var flowerPlaced = 0
    
    var lastOne = -1
    var i = 0
    while i < flowerbed.count {
      while i < flowerbed.count && flowerbed[i] == 0 {
        i += 1
      }
      
      let space = i - lastOne - 1
      
      if lastOne >= 0 && i < flowerbed.count {
        flowerPlaced += (space - 1) / 2
      } else if lastOne == -1 && i == flowerbed.count {
        flowerPlaced += (space + 1) / 2
      } else {
        flowerPlaced += space / 2
      }
      
      if flowerPlaced >= n {
        return true
      }
      
      while i < flowerbed.count && flowerbed[i] == 1 {
        i += 1
      }
      lastOne = i - 1
    }
    
    return false
  }
}

---

196ms

class Solution {
  func canPlaceFlowers(_ flowerbed: [Int], _ n: Int) -> Bool {
    var planted = 0
    
    var space = 1
    
    for plot in flowerbed {
      if plot == 0 {
        space += 1
      } else {
        planted += (space - 1) / 2
        space = 0
      }
    }
    
    return (planted + space / 2) >= n
  }
}