Add planting flowers problem

Author: sudheerj

README.md

@@ -57,6 +57,7 @@ List of Programs related to data structures and algorithms
 | 16  | Two missing numbers                   |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/16.twoMissingNumbers/twoMissingNumbers.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/16.twoMissingNumbers/twoMissingNumbers.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/16.twoMissingNumbers/twoMissingNumbers.md)        | Medium | Sum and average calculations |
 | 17  | Pascal's Triangle                  |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/17.pascalsTriangle/pascalsTriangle.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/17.pascalsTriangle/pascalsTriangle.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/17.pascalsTriangle/pascalsTriangle.md)        | Easy | Array traversal and sequential sum |
 | 18  | Remove Element                   |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/18.removeElement/removeElement.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/18.removeElement/removeElement.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/18.removeElement/removeElement.md)        | Easy | Array traversal |
+| 19  | Can place flowers                  |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/19.canPlaceFlowers/canPlaceFlowers.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/19.canPlaceFlowers/canPlaceFlowers.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/19.canPlaceFlowers/canPlaceFlowers.md)        | Easy | Array traversal and comparison |
 
 ### String
 

src/java1/algorithms/array/canPlaceFlowers/CanPlaceFlowers.java

@@ -0,0 +1,29 @@
+package java1.algorithms.array.canPlaceFlowers;
+
+public class CanPlaceFlowers {
+    private static boolean canPlaceFlowers(int[] flowersbed, int n){
+        int count = 0;
+
+        for (int i = 0; i < flowersbed.length; i++) {
+            if(flowersbed[i] == 0 && (i == 0 || flowersbed[i-1] == 0) && (i == flowersbed.length-1 || flowersbed[i+1] == 0)) {
+                flowersbed[i] = 1;
+                count++;
+
+                if(count >= n) {
+                    return true;
+                }
+
+                i++;
+            }
+        }
+        return count >= n;
+    }
+    public static void main(String[] args) {
+        int[] flowerbed1 = new int[]{1,0,0,1}; int n1= 1;
+        int[] flowerbed2 = new int[]{1,0,0,0,1}; int n2= 1;
+        int[] flowerbed3 = new int[]{1,0,0,0,1}; int  n3= 2;
+        System.out.println(canPlaceFlowers(flowerbed1, n1));
+        System.out.println(canPlaceFlowers(flowerbed2, n2));
+        System.out.println(canPlaceFlowers(flowerbed3, n3));
+    }
+}

src/java1/algorithms/array/canPlaceFlowers/CanPlaceFlowers.md

@@ -0,0 +1,39 @@
+**Description:**
+Given an array of integers `flowerbed` in which some of the plots are planted, and others are not considering the fact that flowers cannot be planted in adjacent plots. Here, the number `0` represent an empty plot and `1` represent non-empty plot. Return `true` if `n` new flowers can be planted inside flowerbed without violating the adjaceny plots rule.
+
+### Examples
+Example 1:
+
+Input: flowerbed = [1,0,0,1], n = 1
+Output: false
+
+Example 2:
+
+Input: flowerbed = [1,0,0,0,1], n = 1
+Output: true
+
+Example 3:
+
+Input: flowerbed = [1,0,0,0,1], n = 2
+Output: false
+
+**Algorithmic Steps**
+This problem is solved with the help of iteration over an array and compare adjacent elements. The algorithmic approach can be summarized as follows:
+
+1. Create a function(`canPlaceFolowers`) by accepting flower bed array(`flowerbed`) and number of flowers to plant(`n`).
+
+2. Initialize the counting variable(`count`) to determine number of flowers can be planted.
+
+3. Iterate over the array and compare each value with their adjacent values if the current value is 0. 
+    1. If either the adjancent value is zero or a boundary value(i.e, first or last element in an array), the flower bed can be planted with a flower by updating it's value to 1. The counter can be incremented. 
+
+    2. Perform a early exit by returning `true` if the count is greater than or equal to given number `n`.
+   
+    3. Skip the next iteration by incrementing index variable(`i`). Since the flower is planted at the current position, it won't be planted for next adjacent position.
+   
+ 4. After completion of iteration, return expression `count >=n` to indicate given number of flowers can be planted or not.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of elements in an array. This is because we need to iterate over all the elements at most once.
+ 
+It takes constant time complexity of `O(1)` due to no additional datastructure been used other than counting variable.

src/javascript/algorithms/array/19.canPlaceFlowers/canPlaceFlowers.js

@@ -0,0 +1,25 @@
+function canPlaceFlowers(flowerbed, n){
+    let count = 0;
+
+    for (let i = 0; i < flowerbed.length; i++) {
+        if(flowerbed[i] === 0 && (i === 0 || flowerbed[i-1] === 0) && (i === flowerbed.length-1 || flowerbed[i+1] === 0)) {
+            flowerbed[i] = 1;
+            count++;
+
+            if(count >= n) {
+                return true;
+            }
+            i++;
+        }
+        
+    }
+
+    return count >= n;
+}
+
+const flowerbed1 = [1,0,0,1], n1= 1;
+const flowerbed2 = [1,0,0,0,1], n2= 1;
+const flowerbed3 = [1,0,0,0,1], n3= 2;
+console.log(canPlaceFlowers(flowerbed1, n1));
+console.log(canPlaceFlowers(flowerbed2, n2));
+console.log(canPlaceFlowers(flowerbed3, n3));

src/javascript/algorithms/array/19.canPlaceFlowers/canPlaceFlowers.md

@@ -0,0 +1,39 @@
+**Description:**
+Given an array of integers `flowerbed` in which some of the plots are planted, and others are not considering the fact that flowers cannot be planted in adjacent plots. Here, the number `0` represent an empty plot and `1` represent non-empty plot. Return `true` if `n` new flowers can be planted inside flowerbed without violating the adjaceny plots rule.
+
+### Examples
+Example 1:
+
+Input: flowerbed = [1,0,0,1], n = 1
+Output: false
+
+Example 2:
+
+Input: flowerbed = [1,0,0,0,1], n = 1
+Output: true
+
+Example 3:
+
+Input: flowerbed = [1,0,0,0,1], n = 2
+Output: false
+
+**Algorithmic Steps**
+This problem is solved with the help of iteration over an array and compare adjacent elements. The algorithmic approach can be summarized as follows:
+
+1. Create a function(`canPlaceFolowers`) by accepting flower bed array(`flowerbed`) and number of flowers to plant(`n`).
+
+2. Initialize the counting variable(`count`) to determine number of flowers can be planted.
+
+3. Iterate over the array and compare each value with their adjacent values if the current value is 0. 
+    1. If either the adjancent value is zero or a boundary value(i.e, first or last element in an array), the flower bed can be planted with a flower by updating it's value to 1. The counter can be incremented. 
+
+    2. Perform a early exit by returning `true` if the count is greater than or equal to given number `n`.
+   
+    3. Skip the next iteration by incrementing index variable(`i`). Since the flower is planted at the current position, it won't be planted for next adjacent position.
+   
+ 4. After completion of iteration, return expression `count >=n` to indicate given number of flowers can be planted or not.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of elements in an array. This is because we need to iterate over all the elements at most once.
+ 
+It takes constant time complexity of `O(1)` due to no additional datastructure been used other than counting variable.