Added Challenge-01 two sum solution

Challenge-01/two-sum.js

@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+
+ /**
+ Approach : hashmap
+
+  */
+ var twoSum = function(nums, target) {
+    const prevMap = new Map()
+
+
+    for(let i= 0 ; i < nums.length ; i++){
+        let answer = target - nums[i]
+        if(prevMap.has(answer)){
+            return [prevMap.get(answer),i]
+        }else{
+            prevMap.set(nums[i],i)
+        }
+    }
+
+};

Challenge-03/best-timeTo-buy-sell.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function(prices) {
+    let minPrice = Infinity
+    let maxPrice = 0
+
+    for(let i of prices){
+        minPrice = Math.min(minPrice,i)
+        const profit = i-minPrice
+        maxPrice = Math.max(maxPrice,profit)
+    }
+    return maxPrice
+};

Challenge-04/contains-duplicate.py

@@ -0,0 +1,8 @@
+class Solution(object):
+  def containsDuplicate(self,nums):
+      seen = set()
+      for i in nums:
+          if i in seen:
+              return True
+          seen.add(i)
+      return False

Challenge-05/sum-without-arithematic-operator.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number} a
+ * @param {number} b
+ * @return {number}
+ */
+var getSum = function(a, b) {
+
+    while (b !== 0) {
+        let carry = a & b; // Find carry bits
+        a = a ^ b;         // Add without carry
+        b = carry << 1;    // Shift carry left
+    }
+    return a;
+
+};

Challenge-06/product-of-arrayExcept-selft.js

@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+
+/**
+approach : prefix , sufix 
+step1 : calculate all prefix in one loop and create an array of prefix
+step 2 : in second loop modify prefix[i] *= suffix
+       : make sufix *= original[i]
+ */
+       var productExceptSelf = function(nums) {
+        let answer = []
+        let len = nums.length
+        let productofPrifix = 1
+        let productofSufix = 1
+        for(let i = 0 ; i < len ; i++){
+            answer[i] = productofPrifix
+            productofPrifix *= nums[i]
+        }
+
+        for(let j = len-1 ; j >= 0 ; j--){
+            answer[j] *= productofSufix
+            productofSufix *= nums[j]
+        }
+
+    return answer
+
+
+
+    };

Challenge-07/subarray-sum.js

@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSubArray = function(nums) {
+    let curSum = 0;
+    let maxSum = nums[0];
+
+    for (let i of nums) {
+        if (curSum < 0) curSum = 0;
+        curSum += i;
+        maxSum = Math.max(maxSum, curSum);
+    }
+
+    return maxSum;
+};

Challenge-08/max-prod-of-subArray.js

@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+
+var maxProduct = function(nums) {
+    let curMin = 1
+    let curMax = 1
+    let result = nums[0]
+
+
+    for(let i of nums){
+
+        let temp = curMin* i
+        curMin = Math.min(i,curMax*i,temp,)
+        curMax = Math.max(i,curMax*i,temp)
+        result = Math.max(result,curMax)
+    }
+
+    return result
+};

Challenge-09/minimumIn-rotated-sortedArray.js

@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+
+ /**
+ Approach : Binary search since solution needs to be in o(log n)
+
+ step 1 : loop till left < right
+ step 2 : mid = fllor((left+right)/2)
+ step 2 : if(mid > right) it means smaller value is in right so we mode left to mid + 1 
+        : else right = mid and find its mid and continue
+        : when the left > right loop exits and last nums[left] will be the smallest
+
+  */
+
+
+// condition the solution should be of o(log n) time complexity
+        var findMin = function(nums) {
+            let left = 0
+            let right = nums.length-1
+            while(left < right){
+             let mid = Math.floor((left+right)/2)
+
+             if(nums[mid] > nums[right]){
+                 left = mid+1
+             }else{
+                 right = mid
+             }
+            }
+
+            return nums[left]
+
+         };

Challenge-10/searchIn-sortedArray.js

@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function(nums, target) {
+    let left = 0, right = nums.length - 1;
+
+    while (left <= right) {
+        let mid = Math.floor((left + right) / 2);
+
+        if (nums[mid] === target) return mid;
+
+        // Identify which half is sorted
+        if (nums[left] <= nums[mid]) { // Left half is sorted
+            if (nums[left] <= target && target < nums[mid]) {
+                right = mid - 1; // Search in left half
+            } else {
+                left = mid + 1; // Search in right half
+            }
+        } else { // Right half is sorted
+            if (nums[mid] < target && target <= nums[right]) {
+                left = mid + 1; // Search in right half
+            } else {
+                right = mid - 1; // Search in left half
+            }
+        }
+    }
+
+    return -1; // Target not found
+};

Challenge-11/three-sum.js

@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function(num) {
+    let res = []
+    let len = num.length
+    let nums = num.sort((a,b)=> a-b)
+
+    for(let i = 0 ; i< nums.length ; i++){
+        if(i>0 && nums[i] ==nums[i-1]) continue;
+
+        let L = i+1;
+        let R = len-1
+
+        while(L<R){
+            let sum = nums[i]+nums[L]+nums[R]
+            if(sum>0){
+                R -= 1
+            }
+            else if(sum<0){
+                L += 1
+            }
+            else{
+                res.push([nums[i],nums[L],nums[R]])
+                L+=1;
+                while(L<R && nums[L] === nums[L-1]){
+                    L+=1;
+                }
+            }
+        }
+    }
+    return res
+};

Challenge-12/container-with-most-water.js

@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var maxArea = function(height) {
+    let left = 0, right = height.length - 1;
+    let maxWater = 0;
+
+    while (left < right) {
+        // Calculate the area with the current left and right pointers
+        const minHeight = Math.min(height[left], height[right]);
+        const width = right - left;
+        const area = minHeight * width;
+
+        // Update the maximum area
+        maxWater = Math.max(maxWater, area);
+
+        // Move the pointer pointing to the smaller height
+        if (height[left] < height[right]) {
+            left++;
+        } else {
+            right--;
+        }
+    }
+
+    return maxWater;
+};

Challenge-13/find-setBits.js

@@ -0,0 +1,8 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var hammingWeight = function(n) {
+
+    return n.toString(2).split('0').join('').length
+ };

Challenge-14/counting_bits.js

@@ -0,0 +1,14 @@
+const { count } = require("console");
+
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+var countBits = function (n) {
+  let result = [];
+  for (let i = 0; i <= n; i++) {
+    result.push(i.toString(2).split("0").join("").length);
+  }
+
+  return result;
+};

Challenge-15/missing-numbers.js

@@ -0,0 +1,7 @@
+var missingNumber = function(nums) {
+    let arrLen = nums.length
+    let expectedNumsSum = (arrLen * (arrLen+1))/2
+
+    let currentSum = nums.reduce((acc,cur)=> acc+cur,0)
+    return expectedNumsSum - currentSum
+};