eze2017
diff --git a/‎articles/can-place-flowers.md
Lines changed: 178 additions & 0 deletions b/‎articles/can-place-flowers.md
Lines changed: 178 additions & 0 deletions
diff --git a/‎articles/concatenation-of-array.md
Lines changed: 135 additions & 0 deletions b/‎articles/concatenation-of-array.md
Lines changed: 135 additions & 0 deletions
@@ -0,0 +1,178 @@
+## 1. Iteration - I
+
+::tabs-start
+
+```python
+class Solution:
+    def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool:
+        f = [0] + flowerbed + [0]
+        
+        for i in range(1, len(f) - 1):
+            if f[i - 1] == 0 and f[i] == 0 and f[i + 1] == 0:
+                f[i] = 1
+                n -= 1
+        
+        return n <= 0
+```
+
+```java
+public class Solution {
+    public boolean canPlaceFlowers(int[] flowerbed, int n) {
+        int[] f = new int[flowerbed.length + 2];        
+        for (int i = 0; i < flowerbed.length; i++) {
+            f[i + 1] = flowerbed[i];
+        }
+        
+        for (int i = 1; i < f.length - 1; i++) {
+            if (f[i - 1] == 0 && f[i] == 0 && f[i + 1] == 0) {
+                f[i] = 1;
+                n--;
+            }
+        }
+        return n <= 0;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    bool canPlaceFlowers(vector<int>& flowerbed, int n) {
+        vector<int> f(flowerbed.size() + 2, 0);
+        for (int i = 0; i < flowerbed.size(); i++) {
+            f[i + 1] = flowerbed[i];
+        }
+        
+        for (int i = 1; i < f.size() - 1; i++) {
+            if (f[i - 1] == 0 && f[i] == 0 && f[i + 1] == 0) {
+                f[i] = 1;
+                n--;
+            }
+        }
+        return n <= 0;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} flowerbed
+     * @param {number} n
+     * @return {boolean}
+     */
+    canPlaceFlowers(flowerbed, n) {
+        const f = [0, ...flowerbed, 0];
+        
+        for (let i = 1; i < f.length - 1; i++) {
+            if (f[i - 1] === 0 && f[i] === 0 && f[i + 1] === 0) {
+                f[i] = 1;
+                n--;
+            }
+        }
+        return n <= 0;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 2. Iteration - II
+
+::tabs-start
+
+```python
+class Solution:
+    def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool:
+        empty = 0 if flowerbed[0] else 1
+        
+        for f in flowerbed:
+            if f:
+                n -= int((empty - 1) / 2)
+                empty = 0
+            else:
+                empty += 1
+        
+        n -= empty // 2
+        return n <= 0
+```
+
+```java
+public class Solution {
+    public boolean canPlaceFlowers(int[] flowerbed, int n) {
+        int empty = flowerbed[0] == 0 ? 1 : 0;
+        
+        for (int f : flowerbed) {
+            if (f == 1) {
+                n -= (empty - 1) / 2;
+                empty = 0;
+            } else {
+                empty++;
+            }
+        }
+        
+        n -= empty / 2;
+        return n <= 0;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    bool canPlaceFlowers(vector<int>& flowerbed, int n) {
+        int empty = flowerbed[0] == 0 ? 1 : 0;
+        
+        for (int f : flowerbed) {
+            if (f == 1) {
+                n -= (empty - 1) / 2;
+                empty = 0;
+            } else {
+                empty++;
+            }
+        }
+        
+        n -= empty / 2;
+        return n <= 0;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} flowerbed
+     * @param {number} n
+     * @return {boolean}
+     */
+    canPlaceFlowers(flowerbed, n) {
+        let empty = flowerbed[0] === 0 ? 1 : 0;
+        
+        for (let f of flowerbed) {
+            if (f === 1) {
+                n -= Math.floor(Math.max(0, empty - 1) / 2);
+                empty = 0;
+            } else {
+                empty++;
+            }
+        }
+        
+        n -= Math.floor(empty / 2);
+        return n <= 0;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$
@@ -0,0 +1,135 @@
+## 1. Iteration (Two Pass)
+
+::tabs-start
+
+```python
+class Solution:
+    def getConcatenation(self, nums: List[int]) -> List[int]:
+        ans = []
+        for i in range(2):
+            for num in nums:
+                ans.append(num)
+        return ans
+```
+
+```java
+public class Solution {
+    public int[] getConcatenation(int[] nums) {
+        int[] ans=new int[2 * nums.length];
+        int idx = 0;
+        for (int i = 0; i < 2; i++) {
+            for (int num : nums) {
+                ans[idx++] = num;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> getConcatenation(vector<int>& nums) {
+        vector<int> ans;
+        for (int i = 0; i < 2; ++i) {
+            for (int num : nums) {
+                ans.push_back(num);
+            }
+        }
+        return ans;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    getConcatenation(nums) {
+        let ans = [];
+        for (let i = 0; i < 2; i++) {
+            for (let num of nums) {
+                ans.push(num);
+            }
+        }
+        return ans;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$
+
+---
+
+## 2. Iteration (One Pass)
+
+::tabs-start
+
+```python
+class Solution:
+    def getConcatenation(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        ans = [0] * (2 * n)
+        for i, num in enumerate(nums):
+            ans[i] = ans[i + n] = num
+        return ans
+```
+
+```java
+public class Solution {
+    public int[] getConcatenation(int[] nums) {
+        int n = nums.length;
+        int[] ans = new int[2 * n];
+        for (int i = 0; i < n; i++) {
+            ans[i] = ans[i + n] = nums[i];
+        }
+        return ans;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> getConcatenation(vector<int>& nums) {
+        int n = nums.size();
+        vector<int> ans(2 * n);
+        for (int i = 0; i < n; ++i) {
+            ans[i] = ans[i + n] = nums[i];
+        }
+        return ans;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    getConcatenation(nums) {
+        let n = nums.length;
+        let ans = new Array(2 * n);
+        for (let i = 0; i < n; i++) {
+            ans[i] = ans[i + n] = nums[i];
+        }
+        return ans;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$