all

Author: bibhuti9

Medium/503. Next Greater Element II.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+
+
+
+function findMax(currentElement, arr) {
+    for (let i = 0; i < arr.length; i++) {
+        if (currentElement < arr[i]) {
+            return arr[i];
+        }
+    }
+    return -1;
+}
+var nextGreaterElements = function (nums) {
+    let ansArr = [];
+    for (let i = 0; i < nums.length; i++) {
+        ansArr.push(findMax(nums[i], nums));
+    }
+    return ansArr;
+};
+console.log(nextGreaterElements([1, 5, 3, 6, 8]));
+
+// [1, 2, 3, 5,4, 3]=[1, 2, 3, 4, 3  1, 2, 3, 4, 3]
+// [1, 2, 1] = [1, 2, 1  1, 2, 1]
+// [1, 2, 3, 2, 1] = [1, 2, 3, 2, 1  1, 2, 3, 2, 1]
+// [5,4,3,2,1] = [5,4,3,2,1  5,4,3,2,1]

Medium/532. K-diff Pairs in an Array.js

@@ -0,0 +1,37 @@
+/*
+
+    532. K-diff Pairs in an Array
+    https://leetcode.com/problems/k-diff-pairs-in-an-array/discuss/?currentPage=1&orderBy=hot&query=
+
+*/
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+//  0 <= i, j < nums.length
+// i != j
+// nums[i] - nums[j] == k
+
+var findPairs = function (nums, k) {
+    var map = new Map();    // we make a map to store key pair index value
+    var length = nums.length;
+    for (let i = 0; i < nums.length; i++) {
+        for (let j = i; j < nums.length; j++) {
+            // These are the constraints
+            if (
+                i >= 0
+                && j < length
+                && i != j
+                && (Math.abs(nums[i] - nums[j]) === k)) {
+                if ((!map.has(`${nums[j]}${nums[i]}`) && (!map.has(`${nums[i]}${nums[j]}`)))) {
+                    map.set(`${nums[i]}${nums[j]}`, 1);
+                }
+            }
+        }
+    }
+    // console.log(map);
+    return map.size;
+};
+console.log(findPairs([0, 0, 1, 0, 0], 1));

Medium/54. Spiral Matrix.js

@@ -0,0 +1,43 @@
+/**
+ * @param {number[][]} matrix
+ * @return {number[]}
+ */
+var spiralOrder = function (matrix) {
+
+    var ansArray = [];
+    var row = matrix.length;
+    var col = matrix[0].length;
+
+    var startingRow = 0;
+    var startingCol = 0;
+    var endRow = matrix.length - 1;
+    var endCol = matrix[0].length - 1;
+
+    var count = 0;
+    var total = row * col;
+    while (count < total) {
+        for (let index = startingCol; count < total && index <= endCol; index++) {
+            ansArray.pop(matrix[startingRow][index]);
+            count++;
+        }
+        startingRow++;
+        for (let index = startingRow; count < total && index <= endRow; index++) {
+            ansArray.push(matrix[index][endCol]);
+            count++;
+        }
+        endCol--;
+        for (let index = endCol; count < total && index >= startingCol; index--) {
+            ansArray.push(matrix[endRow][index]);
+            count++;
+        }
+        endRow--;
+        for (let index = endRow; count < total && index >= startingRow; index--) {
+            ansArray.push(matrix[index][startingCol]);
+            count++;
+        }
+        startingCol++;
+    }
+    console.log(ansArray);
+};
+
+spiralOrder([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);

Medium/56. Merge Intervals.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+var merge = function (intervals) {
+    var ansArr = [[]];
+    for (let i = 0; i < intervals.length - 1; i++) {
+
+        if (intervals[i][0] >= intervals[i + 1][0]) {
+            intervals[i][0] = intervals[i + 1][0];
+            intervals.splice(i + 1, 1);
+        }
+        else if (intervals[i][1] >= intervals[i + 1][0]) {
+            intervals[i][1] = intervals[i + 1][1];
+            intervals.splice(i + 1, 1);
+        }
+    }
+    return intervals;
+};
+merge([[1, 4], [0, 4]]);

Medium/74. Search a 2D Matrix.js

@@ -0,0 +1,79 @@
+/*
+    74. Search a 2D Matrix
+    https://leetcode.com/problems/search-a-2d-matrix/
+*/
+
+/*  TIME COMPLEXITY O(LogN) */
+
+/**
+ * @param {number[][]} matrix
+ * @param {number} target
+ * @return {boolean}
+ */
+var searchMatrix = function (matrix, target) {
+    var row = matrix.length;    // how many row in 2D array
+    var col = matrix[0].length; // how many column in 2D array
+
+    var start = 0;  // make a start pointer
+    var end = row * col - 1;    // make a end pointer
+    var mid = Math.floor((start + end) / 2);    // To find mid element
+    while (start <= end) {
+        mid = Math.floor((start + end) / 2);
+
+        // row = mid / col;
+        // col = mid % col;
+
+        var elementIndex = matrix[Math.floor(mid / col)][Math.floor(mid % col)];
+
+        if (elementIndex == target) {
+            return true;    // when target is find
+        }
+        if (elementIndex > target) {
+            end = mid - 1;  // when mid element is greater then target
+        } else {
+            start = mid + 1;
+        }
+    }
+    return false;
+};
+console.log(searchMatrix([
+    [1, 3, 5, 7],
+    [10, 11, 16, 20],
+    [23, 30, 34, 60]
+],
+    13));
+
+/*
+    Explanation:
+
+    how to find total row = martix.length
+    how to find total column = matrinx[0].length
+
+    how to find particular index value with linear array
+    (col * i) + j  = linear array index value
+    (3*1)+1 = [4] = 5
+    like:
+    [
+          0  1  2
+       0 [1, 2, 3],
+       1 [4, 5, 6],
+       2 [7, 8, 9],
+    ];
+    [1,2,3,4,5,6,7,8,9]
+
+
+    how to find 2D array index value with linear array
+    like:
+    [1,2,3,4,5,6,7,8,9]
+    [
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9],
+    ];
+
+    row = mid / col;
+    col = mid % col;
+
+* /
+
+// [1, 2, 5, 7, 10, 11, 16, 20, 23, 30, 34, 60]

Practice Problems/2Darray.js

@@ -0,0 +1,67 @@
+/*
+
+    how to find total row = martix.length
+    how to find total column = matrinx[0].length
+
+    how to find particular index value with linear array
+    (col * i) + j  = linear array index value
+    like:
+    [
+          0  1  2
+       0 [1, 2, 3],
+       1 [4, 5, 6],
+       2 [7, 8, 9],
+    ];
+    [1,2,3,4,5,6,7,8,9]
+
+
+    how to find 2D array index value with linear array
+    like:
+    [1,2,3,4,5,6,7,8,9]
+    [
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9],
+    ];
+
+    row = mid / col;
+    col = mid % col;
+
+*/
+
+// Print Rom Sum
+function PrintSum(arr, row, col) {
+    for (let i = 0; i < row; i++) {
+        var sum = 0;
+        for (let j = 0; j < col; j++) {
+            sum += arr[i][j];
+        }
+        console.log(sum);
+    }
+}
+
+// Print Col Sum
+function PrintSum(arr, row, col) {
+    for (let i = 0; i < col; i++) {
+        if (i % 2 == 0) {
+            for (let j = 0; j < row; j++) {
+                console.log(arr[j][i]);
+            }
+        } else {
+            for (let j = row - 1; j >= 0; j--) {
+                console.log(arr[j][i]);
+            }
+        }
+    }
+}
+
+function array2D() {
+    var arr = [
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 7, 8],
+    ];
+    // console.log(arr);
+    PrintSum(arr, 3, 3);
+}
+array2D();

Practice Problems/Next Greater Element (NGE).js

@@ -0,0 +1,55 @@
+/*
+Next Greater Element (NGE) for every element in given Array
+
+Given an array, print the Next Greater Element (NGE) for every element.
+
+The Next greater Element for an element x is the first greater element on the right side of x in the array. Elements for which no greater element exist, consider the next greater element as -1.
+
+Example:
+
+Input: arr[] = [ 4 , 5 , 2 , 25 ]
+
+Output: 4 –> 5
+
+5 –> 25
+
+2 –> 25
+
+25 –> -1
+
+Explanation: except 25 every element has an element greater than them present on the right side
+
+Input: arr[] = [ 13 , 7, 6 , 12 ]
+
+Output: 13 –> -1
+
+7 –> 12
+
+6 –> 12
+
+12 –> -1
+
+Explanation: 13 and 12 don’t have any element greater than them present on the right side
+
+*/
+
+
+function NextGreaterElement(arr) {
+    var max;
+    var soFarMax;
+    var map = new Map();
+    for (let i = arr.length - 1; i >= 0; i--) {
+        if (arr[i] < soFarMax) {
+            map.set(arr[i], soFarMax);
+            soFarMax = arr[i];
+        } else if (arr[i] < max) {
+            map.set(arr[i], max);
+            soFarMax = arr[i];
+        } else {
+            max = arr[i];
+            map.set(arr[i], -1);
+        }
+    }
+    console.log(map);
+}
+NextGreaterElement([1, 2, 1]);