new stuff

Author: shaurya019

CodingInterviewQuestions/FindOccurenceInArr.js

@@ -0,0 +1,9 @@
+const valueToFind = parseInt(input, 10);
+const array = [1, 2, 3, 4, 2, 5, 2];
+
+const firstIndex = array.indexOf(valueToFind);
+if (firstIndex !== -1) {
+  console.log(`First occurrence of ${valueToFind} is at index ${firstIndex}`);
+} else {
+  console.log(`${valueToFind} not found in the array`);
+}

CodingInterviewQuestions/FindOccurenceInObject.js

@@ -0,0 +1,18 @@
+const obj = {
+    a: 'apple',
+    b: 'banana',
+    c: 'apple',
+    d: 'orange',
+    e: 'banana',
+};
+
+const m = new Map();
+
+for (const x in obj) {
+    const v = obj[x];
+    if (m.has(v)) {
+        m.set(v, m.get(v)+1);
+    } else {
+        m.set(v, 1);
+    }
+}

CodingInterviewQuestions/ForeachPolyfil.js

@@ -0,0 +1,27 @@
+// Creating a polyfill for Array.prototype.forEach in JavaScript is a great exercise to understand how this method works. The forEach method iterates over each element in an array and executes a provided function once for each element.
+
+//     Here's a basic polyfill for Array.prototype.forEach:
+
+
+    if (!Array.prototype.forEach) {
+        Array.prototype.forEach = function(callback, thisArg) {
+          // Check if callback is a function
+          if (typeof callback !== 'function') {
+            throw new TypeError(callback + ' is not a function');
+          }
+      
+          // Get the array that forEach was called on
+          var array = Object(this);
+          var length = array.length >>> 0; // Convert to unsigned 32-bit integer
+      
+          // Iterate over the array
+          for (var i = 0; i < length; i++) {
+            // Check if the index exists in the array (to handle sparse arrays)
+            if (i in array) {
+              // Call the callback with the current element, index, and array
+              callback.call(thisArg, array[i], i, array);
+            }
+          }
+        };
+      }
+      

CodingInterviewQuestions/Polyfill.js

@@ -0,0 +1,38 @@
+// A polyfill is a piece of code (usually JavaScript) that provides functionality that is not natively supported by certain browsers or environments. It's used to ensure that web applications work consistently across different browsers and versions.
+
+// For example, if you're using a new JavaScript feature like Array.prototype.includes that isn't available in older browsers, you can include a polyfill to add this method to those browsers.Here's a simple polyfill for Array.prototype.includes:
+
+
+if (!Array.prototype.includes) {
+    Array.prototype.includes = function(searchElement, fromIndex) {
+      var list = Object(this);
+      var length = list.length >>> 0;
+      var i = fromIndex || 0;
+      
+      if (i < 0) {
+        i = Math.max(length + i, 0);
+      }
+      
+      for (; i < length; i++) {
+        if (list[i] === searchElement) {
+          return true;
+        }
+      }
+      
+      return false;
+    };
+}
+  
+
+
+// This code checks if Array.prototype.includes is already defined. If not, it adds a custom implementation so that the feature is available even in environments where it's not natively supported.
+
+// Polyfills are essential for maintaining compatibility with older browsers and ensuring that modern web applications function correctly across a wide range of environments.
+
+
+
+
+
+
+
+  

CodingInterviewQuestions/SortObjects.js

@@ -0,0 +1,11 @@
+const people = [
+    { name: 'John', age: 25 },
+    { name: 'Jane', age: 30 },
+    { name: 'Alice', age: 22 },
+    { name: 'Bob', age: 28 }
+  ];
+  
+  // Sorting in ascending order (youngest to oldest)
+  people.sort((a, b) => a.age - b.age);
+  
+  console.log('Ascending:', people);