Search in Rotated Sorted Array

Challenge-1/two-sum.js

@@ -0,0 +1,15 @@
+var twoSum = function (nums, target) {
+    let obj = {}
+    for (i = 0; i < nums.length; i++) {
+        let diff = target - nums[i]
+        if (obj[diff] != null) {
+            return [obj[diff], i]
+        } else {
+            obj[nums[i]] = i
+            console.log(obj)
+        }
+    }
+};
+const nums = [2, 7, 11, 15];
+const target = 9;
+console.log(twoSum(nums, target));

Challenge-10/Search in Rotated Sorted Array.js

@@ -0,0 +1,47 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+
+function getPivot(arr) {
+    var s = 0, e = arr.length - 1;
+    while (s < e) {
+        var mid = Math.floor(s + (e - s) / 2)
+
+        if (arr[mid] >= arr[0]) {
+            s = mid + 1
+        } else {
+            e = mid
+        }
+    }
+    return s;
+}
+
+function binarySearch(arr, start, end, key) {
+    var s = start, e = end;
+
+    while (s <= e) {
+        var mid = Math.floor(s + (e - s) / 2)
+        if (arr[mid] == key) {
+            return mid
+        }
+        if (key > arr[mid]) {
+            s = mid + 1;
+        } else {
+            e = mid - 1
+        }
+    }
+    return -1;
+}
+var search = function (arr, target) {
+    var n = arr.length
+    var pivot = getPivot(arr)
+
+    if (target >= arr[pivot] && target <= arr[n - 1]) {
+        return binarySearch(arr, pivot, n - 1, target)
+    } else {
+        return binarySearch(arr, 0, pivot - 1, target)
+    }
+
+};

Challenge-11/3sum.js

@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+    let n = nums.length;
+    const ans = [];
+
+    nums.sort((a, b) => a - b);
+
+    for (let i = 0; i < n - 2; i++) {
+        if (i > 0 && nums[i] === nums[i - 1]) continue;
+
+        let j = i + 1, k = n - 1;
+
+        while (j < k) {
+            let sum = nums[i] + nums[j] + nums[k];
+
+            if (sum < 0) {
+                j++;
+            } else if (sum > 0) {
+                k--;
+            } else {
+                ans.push([nums[i], nums[j], nums[k]]);
+                // Skip duplicate values for 'j'
+                while (j < k && nums[j] === nums[j + 1]) j++;
+                // Skip duplicate values for 'k'
+                while (j < k && nums[k] === nums[k - 1]) k--;
+
+                j++;
+                k--;
+            }
+        }
+    }
+
+    return ans;
+};

Challenge-12/Container With Most Water.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} height
+ * @return {number}
+ * https://leetcode.com/problems/container-with-most-water/
+ */
+
+var maxArea = function (h) {
+    let left = 0
+    let right = h.length - 1
+    let maxWater = 0
+    while (left < right) {
+        let minH = Math.min(h[left], h[right])
+        maxWater = Math.max(maxWater, minH * (right - left))
+        if (h[left] < h[right]) left++
+        else right--
+
+    }
+
+
+
+
+    return maxWater
+};

Challenge-13/Number of 1 Bits.js

@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} height
+ * @return {number}
+ * https://leetcode.com/problems/number-of-1-bits/
+ */
+
+var hammingWeight = function (n) {
+    var count = 0;
+    while (n != 0) {
+        if (n & 1) {
+            count++;
+        }
+        n = n >> 1;
+    }
+    return count;
+
+};

Challenge-14/Counting Bits.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number} n
+ * @return {number[]}
+ * https://leetcode.com/problems/counting-bits/
+ */
+var countBits = function (n) {
+    const ans = []
+    for (var i = 0; i <= n; i++) {
+        const binary = i.toString(2);
+        let count = 0
+        console.log("binary", binary)
+        for (let i = 0; i < binary.length; i++) {
+            if (binary[i] === '1') count++;
+        }
+        ans.push(count)
+    }
+    return ans
+};

Challenge-15/Missing Number.js

@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var missingNumber = function (nums) {
+    let n = nums.length;
+    let expectedSum = (n * (n + 1)) / 2;
+    let actualSum = nums.reduce((acc, num) => acc + num, 0);
+    return expectedSum - actualSum;
+
+};

Challenge-16/Reverse Bits.js

@@ -0,0 +1,14 @@
+/**
+ * @param {number} n - a positive integer
+ * @return {number} - a positive integer
+ * https://leetcode.com/problems/reverse-bits/
+ */
+
+var reverseBits = function (n) {
+    let result = n.toString(2)
+    result = result.padStart(32, '0');
+    let reversedString = result.split('').reverse().join('');
+    let ans = parseInt(reversedString, 2)
+    return ans
+};
+console.log(reverseBits(43261596)) // 964176192

Challenge-17/Climbing Stairs.js

@@ -0,0 +1,27 @@
+/**
+ * @param {number} n
+ * @return {number}
+ * https://leetcode.com/problems/climbing-stairs/submissions/713423865/
+ */
+function numberOfWays(n, memo) {
+    if (n == 0)
+        return 1;
+    if (n < 0) {
+        return 0
+    };
+    if (n == 1)
+        return 1
+
+    if (memo[n] != -1)
+        return memo[n]
+
+    return memo[n] = numberOfWays(n - 1, memo) + numberOfWays(n - 2, memo)
+}
+var climbStairs = function (n) {
+    var cur = 0
+    var memo = new Array(n + 1).fill(-1)
+    var ans = numberOfWays(n, memo)
+
+
+    return ans
+};

Challenge-18/Coin Change.js

@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} coins
+ * @param {number} amount
+ * @return {number}
+ * https://leetcode.com/problems/coin-change/description/
+ */
+function ANS(arr, index, T, dp) {
+
+    if (index == 0) {
+        if (T % arr[0] == 0) return T / arr[0];
+        else return 1e9;
+    }
+    if (dp[index][T] !== -1) return dp[index][T]
+    var notTaken = 0 + ANS(arr, index - 1, T, dp)
+
+    var taken = 1e9;
+    if (arr[index] <= T)
+        taken = 1 + ANS(arr, index, T - arr[index], dp);
+
+    return dp[index][T] = Math.min(notTaken, taken);
+}
+var coinChange = function (arr, target) {
+    var n = arr.length
+    var dp = []
+    for (var i = 0; i <= n; i++) {
+        dp[i] = new Array(target + 1).fill(-1)
+    }
+
+    var ans = ANS(arr, n - 1, target, dp)
+    if (ans >= 1e9) return -1;
+    return ans
+
+};

Challenge-2/best-time-to-buy-and-sell-stock.js

@@ -0,0 +1,11 @@
+function maxProfit(prices) {
+    let minPrice = Infinity;
+    let maxProfit = 0;
+
+    for (let price of prices) {
+        minPrice = Math.min(minPrice, price);
+        maxProfit = Math.max(maxProfit, price - minPrice);
+    }
+
+    return maxProfit;
+}

Challenge-3/contain-duplicate.js

@@ -0,0 +1,13 @@
+var containsDuplicate = function (nums) {
+    const obj = {}
+    for (let i = 0; i < nums.length; i++) {
+        if (obj[nums[i]]) {
+            return true
+        }
+        obj[nums[i]] = true
+    }
+
+    return false
+
+};
+containsDuplicate([1, 2, 3, 1]); 

Challenge-4/Sum-of-Two-Integers.js

@@ -0,0 +1,9 @@
+var getSum = function (a, b) {
+    while (b !== 0) {
+        let carry = (a & b) << 1;
+        a = a ^ b;
+        b = carry;
+    }
+    return a;
+};
+getSum(1, 2);

Challenge-5/Product of Array Except Self.js

@@ -0,0 +1,31 @@
+var productExceptSelf = function (nums) {
+    const arr = []
+    const prefixArr = []
+    const suffixArr = []
+    for (let i = 0; i < nums.length; i++) {
+        if (i === 0) {
+            prefixArr[i] = 1
+
+
+        } else {
+            prefixArr[i] = prefixArr[i - 1] * nums[i - 1]
+        }
+
+    }
+    for (var i = nums.length - 1; i >= 0; i--) {
+        if (i === nums.length - 1) {
+            suffixArr[i] = 1
+        } else {
+            suffixArr[i] = suffixArr[i + 1] * nums[i + 1]
+        }
+    }
+    for (let i = 0; i < nums.length; i++) {
+        arr[i] = prefixArr[i] * suffixArr[i]
+
+
+    };
+    return arr
+}
+
+console.log(productExceptSelf([1, 2, 3, 4])); 
+

Challenge-8/Product-sub-array.js

@@ -0,0 +1,12 @@
+var maxProduct = function (arr) {
+    let res = arr[0];
+    let currMin = 1
+    let currMax = 1
+    for (var i = 0; i < arr.length; i++) {
+        let temp = currMax
+        currMax = Math.max(arr[i], arr[i] * currMax, arr[i] * currMin)
+        currMin = Math.min(arr[i], arr[i] * temp, arr[i] * currMin)
+        res = Math.max(res, currMax)
+    }
+    return res
+};

Challenge-9/Find Minimum in Rotated Sorted Array.js

@@ -0,0 +1,20 @@
+var findMin = function (nums) {
+    var s = 0, e = nums.length - 1;
+    var res = nums[0];
+
+    while (s <= e) {
+        if (nums[s] < nums[e]) {
+            res = nums[s];
+            break
+        }
+        var mid = Math.floor((s + e) / 2);
+        res = Math.min(res, nums[mid]);
+        if (nums[s] <= nums[mid]) { //left sort
+            s = mid + 1; //got to right
+        } else {
+            e = mid;
+        }
+    }
+    return res ;
+
+};