2006. Count Number of Pairs With Absolute Difference K

Author: bibhuti9

Easy/20. Valid Parentheses.js

@@ -4,7 +4,7 @@ https://leetcode.com/problems/valid-parentheses/
 
 */
 
-/*  TIME COMPLEXITY IS O(logn) */
+/*  TIME COMPLEXITY IS O(N) */
 /*
 Example 1:
 
@@ -54,5 +54,4 @@ var isValid = function (s) {
     }
     return contain.length > 0 ? "false" : "true";
 };
-var str = "()";
-console.log(isValid(str));
+console.log(isValid("({"));

Easy/2006. Count Number of Pairs With Absolute Difference K.js

@@ -0,0 +1,44 @@
+/*
+    2006. Count Number of Pairs With Absolute Difference K
+    https://leetcode.com/problems/count-number-of-pairs-with-absolute-difference-k/
+*/
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+
+/*  METHOD 1 TIME COMPLEXITY O(NLogN) */
+var countKDifference = function (nums, k) {
+    var count = 0;  // Create a count 
+    for (let i = 0; i < nums.length; i++) {
+        // here if the current index value is 2
+        // then 2 + 2 = 4
+        // 2 - 2 = 0
+        // if 4 and 0 is exists in next slice array then count how many the total number of accurence in that array.
+        var val1 = nums[i] - k;
+        var val2 = nums[i] + k;
+        // slice array and count that number
+        nums.slice(i + 1).forEach((v) => ((v == val1 || v == val2) && count++));
+    }
+    return count;
+};
+
+/*  METHOD 2 TIME COMPLEXITY O(NLogN) */
+var countKDifference2 = function (nums, k) {
+    var count = 0;
+    for (let i = 0; i < nums.length; i++) {
+        for (let j = 1; j < nums.length; j++) {
+            // direct check with constraints.
+            if (i < j && (Math.abs(nums[i] - nums[j]) == k)) {
+                count++;
+            }
+        }
+    }
+    return count;
+};
+
+
+
+console.log(countKDifference([3, 2, 1, 5, 4], 2));

Easy/26. Remove Duplicates from Sorted Array.js

@@ -1,4 +1,24 @@
 function removeDuplicates(nums) {
     return Array.from(new Set(nums));
 };
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+
+/*  TIME COMPLEXITY O(N) */
+
+//  nums is sorted in non-decreasing order.
+
+var removeDuplicates = function (nums) {
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] === nums[i + 1]) {  // If the next element is same than remove from the array
+            nums.splice(i, 1);
+            i--;
+        }
+    }
+    return nums.length;
+};
+
 console.log(removeDuplicates([0, 0, 1, 1, 1, 2, 2, 3, 3, 4]));

Easy/414. Third Maximum Number.js

@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var thirdMax = function (nums) {
+    nums.sort((a, b) => { return b - a });
+    var set = new Set(nums);
+    nums = [...set];
+    return nums[2] === undefined ? nums[0] : nums[2];
+
+};
+
+console.log(thirdMax([3, 2, 1, 4]));
+console.log(thirdMax([2, 2, 3, 1]));

Easy/448. Find All Numbers Disappeared in an Array.js

@@ -0,0 +1,39 @@
+/*
+    448. Find All Numbers Disappeared in an Array
+    https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/
+*/
+
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+
+
+/*
+    Method 1 TIME COMPEXITY O(N)
+*/
+var findDisappearedNumbers = function (nums) {
+    var set = new Set(nums);    // make a set
+    var ansArray = [];  // create a extra array which store the ans array
+    for (let i = 1; i <= nums.length; i++) {
+        if (!set.has(i)) {  // check that if the set contain Ith element then dont't add it to the ans Array
+            ansArray.push(i);
+        }
+    }
+    return ansArray;
+};
+
+/*  Method 2 TIME COMPLEXITY O(N) */
+
+var findDisappearedNumbers2 = function (nums) {
+    var ansArray = [];
+    for (let i = 1; i <= nums.length; i++) {
+        if (!nums.includes(i)) {
+            ansArray.push(i);
+        }
+    }
+    return ansArray;
+};
+
+console.log(findDisappearedNumbers([4, 3, 2, 7, 8, 2, 3, 1]));

Easy/485. Max Consecutive Ones.js

@@ -0,0 +1,27 @@
+/*
+    485. Max Consecutive Ones
+    https://leetcode.com/problems/max-consecutive-ones/
+*/
+
+/*  TIME COMPLEXITY O(N) */
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMaxConsecutiveOnes = function (nums) {
+    var max = 0;    // Create a max which contain recent count 1 value
+    var maxSoFar = 0;   // Create a maxSoFar which contain heighest max value
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] === 1) {    // if the current value is 1 increment the max
+            max++;
+        } else {
+            if (max > maxSoFar) {   // when the max is greater then the mazSoFar modify the maxSoFar
+                maxSoFar = max;
+            }
+            max = 0; // When the condition is false modify the max to 0
+        }
+    }
+    return max > maxSoFar ? max : maxSoFar; // Here If the max greater then the maxSoFar return max else maxSoFae
+};
+console.log(findMaxConsecutiveOnes([1, 0, 1, 1, 0, 1]));

Easy/509. Fibonacci Number.js

@@ -0,0 +1,18 @@
+/*
+    509. Fibonacci Number
+    https://leetcode.com/problems/fibonacci-number/
+
+*/
+
+/*  TIME COMPLEXITY O(N) */
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var fib = function (n) {
+    if (n == 0) return 0;   // 1 Base case. 
+    if (n == 1) return 1;   // 2 Base case.
+    return fib(n - 1) + fib(n - 2);
+};
+console.log(fib(1));