added time complexity and polyfill video

Author: Vishal-raj-1

Array/Polyfill.md

@@ -0,0 +1,181 @@
+# Map, Filter & Reduce & their Polyfills
+
+<p align="center">
+  <a href="https://youtu.be/NFvpyWQRMKQ">
+  <img src="https://img.youtube.com/vi/NFvpyWQRMKQ/0.jpg" alt="Map, Filter & Reduce & their Polyfills" />
+  </a>
+</p>
+
+Sure, here's the complete text converted into Markdown:
+
+## Map in JavaScript
+
+```javascript
+const employees = [
+    { name: 'John', age: 32 },
+    { name: 'Sarah', age: 28 },
+    { name: 'Michael', age: 40 },
+];
+
+const employeesName = employees.map(employee => employee.name);
+
+// Polyfill of map()
+if (!Array.prototype.myMap) {
+    Array.prototype.myMap = function (callback) {
+        const result = [];
+        for (let i = 0; i < this.length; i++) {
+            result.push(callback(this[i], i, this));
+        }
+        return result;
+    };
+}
+
+const myEmployeesName = employees.myMap(employee => employee.name);
+
+console.log(myEmployeesName); // ["John", "Sarah", "Michael"]
+```
+
+## Filter In JavaScript
+
+```javascript
+const products = [
+    { name: 'iPhone', price: 999, inStock: true },
+    { name: 'Samsung Galaxy', price: 899, inStock: false },
+    { name: 'Google Pixel', price: 799, inStock: true },
+];
+
+const availableProducts = products.filter(product => product.inStock);
+
+// Polyfill of filter()
+if (!Array.prototype.myFilter) {
+    Array.prototype.myFilter = (callback) => {
+        const result = [];
+        for (let i = 0; i < this.length; i++) {
+            if (callback(this[i], i, this)) {
+                result.push(this[i]);
+            }
+        }
+        return result;
+    };
+}
+
+const myAvailableProducts = products.myFilter(product => product.inStock);
+
+console.log(availableProducts); 
+// [
+//     { name: 'iPhone', price: 999, inStock: true },
+//     { name: 'Google Pixel', price: 799, inStock: true },
+// ]
+```
+
+## Reduce in JavaScript
+
+```javascript
+const orders = [
+    { product: 'iPhone', price: 999, quantity: 2 },
+    { product: 'Samsung Galaxy', price: 899, quantity: 1 },
+    { product: 'Google Pixel', price: 799, quantity: 3 },
+];
+
+const totalAmount = orders.reduce(function (accumulator, order) {
+    return accumulator + order.price * order.quantity;
+}, 0);
+
+// Polyfill of reduce()
+if (!Array.prototype.myFilter) {
+    Array.prototype.myReduce = (callback, initialValue) => {
+        let accumulator = initialValue === undefined ? this[0] : initialValue;
+        for (let i = initialValue === undefined ? 1 : 0; i < this.length; i++) {
+            accumulator = callback(accumulator, this[i], i, this);
+        }
+        return accumulator;
+    };
+}
+
+const myTotalAmount = orders.myReduce(function (accumulator, order) {
+    return accumulator + order.price * order.quantity;
+}, 0);
+
+console.log(totalAmount);
+```
+
+### Question 1: Find the longest word length
+
+```javascript
+const words = ['apple', 'banana', 'cherry', 'dragonfruit', 'elderberry'];
+
+const longestWordLength = words.reduce((maxLength, word) => {
+    const currentLength = word.length;
+    return currentLength > maxLength ? currentLength : maxLength;
+}, 0);
+
+console.log(longestWordLength); // Output: 12
+```
+
+### Question 2: Find the longest word
+
+```javascript
+const longestWord = words.reduce((longestWord, word) => {
+    return word.length > longestWord.length ? word : longestWord;
+}, "");
+
+console.log(longestWord); // Output: 'dragonfruit'
+```
+
+### Question 3: Calculate the factorial of the largest number in the array
+
+```javascript
+const numbers = [5, 2, 8, 4, 3];
+
+const largestFactorial = numbers.reduce((largest, num) => {
+    const currentFactorial = Array
+    .from({ length: num })
+    .map((_, i) => i + 1)
+    .reduce((fact, val) => fact * val, 1);
+
+    return currentFactorial > largest ? currentFactorial : largest;
+}, 1);
+
+console.log(largestFactorial); // Output: 40320 (8!)
+```
+
+### Question 4: Calculate the average score of students who scored above 90
+
+```javascript
+const students = [
+    { name: 'John', score: 85 },
+    { name: 'Sarah', score: 92 },
+    { name: 'Michael', score: 88 },
+    { name: 'Emma', score: 95 },
+    { name: 'Daniel', score: 90 },
+];
+
+const above90StudentsAverage = students
+    .filter((student) => student.score > 90)
+    .reduce((acc, student, i, arr) => acc + student.score / arr.length, 0);
+
+console.log(above90StudentsAverage); // Output: 93.5 (average of 95 and 92)
+```
+
+## Practice Questions
+
+### Question 5: Filter out books published before the year 2000 and return their titles
+
+```javascript
+const books = [
+    { title: 'Book 1', year: 1998 },
+    { title: 'Book 2', year: 2003 },
+    { title: 'Book 3', year: 1995 },
+    { title: 'Book 4', year: 2001 },
+];
+
+// Expected Output: ['Book 2', 'Book 4']
+```
+
+### Question 6: Capitalize the first letter of each word in the array
+
+```javascript
+const strings = ['hello world', 'i am openai', 'welcome to javascript'];
+
+// Expected Output: ['Hello World', 'I Am Openai', 'Welcome To Javascript']
+```

Array/README.md

@@ -194,7 +194,7 @@ const positiveNumber = x.find((ele, i) => ele > 0);
 console.log(positiveNumber);
 ```
 
-# Practice Questions
+## Practice Questions
 
 - [Two Sum](https://leetcode.com/problems/two-sum/)
 - [Majority Element](https://leetcode.com/problems/majority-element/)

Basics/README.md

@@ -115,7 +115,7 @@ console.log(missingNumber([3,0,1])); // 2
 console.log(missingNumber([9,6,4,2,3,5,7,0,1])); // 8
 ```
 
-# Practice Questions
+## Practice Questions
 
 - [Count Odd Numbers in an Interval Range](https://leetcode.com/problems/count-odd-numbers-in-an-interval-range/)
 - [Fizz Buzz](https://leetcode.com/problems/fizz-buzz/)

Time Complexity/README.md

@@ -0,0 +1,11 @@
+# Struggling with Time Complexity? Watch this
+
+<p align="center">
+  <a href="https://youtu.be/I9BNxqZSShk">
+  <img src="https://img.youtube.com/vi/I9BNxqZSShk/0.jpg" alt="Struggling with Time Complexity? Watch this" />
+  </a>
+</p>
+
+## Practice Questions
+
+- Solve time complexity of all upcoming questions you solve in this series.