Added README file - day1

Challenge-1/two_sum.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map <int ,int> mpp;
+        for (int i=0; i<nums.size(); i++){
+            int more = target-nums[i];
+            if (mpp.find(more)!=mpp.end()){
+                return {mpp[more],i};
+            }
+            mpp[nums[i]] = i;
+        }
+        return {-1,-1};
+    }
+};

Challenge-10/search_rot_array.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int search(vector<int>& nums, int target) {
+
+        int low = 0;
+        int high = nums.size()-1;
+        while(low<=high){
+            int mid = (low + high)/2;
+            if (nums[mid]==target) return mid;
+            if (nums[low]<= nums[mid]){
+                if (nums[low]<= target && nums[mid]>target){
+                    high = mid-1;
+                }
+                else {
+                    low = mid+1;
+                }
+            }
+            else{
+                if(nums[mid]<target && nums[high]>=target){
+                    low = mid+1;
+                }
+                else{
+                    high = mid-1;
+                }
+            }
+        }
+        return -1;
+
+    }
+};

Challenge-11/3sum.cpp

@@ -0,0 +1,33 @@
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+
+        int n = nums.size();
+        sort(nums.begin(),nums.end());
+        vector<vector<int>> res;
+        for (int i=0; i<n; i++){
+            if (i>0 && nums[i]==nums[i-1]) continue;
+            int j = i + 1;
+            int k = n - 1;
+            while (j<k){
+                int sum = nums[i]+nums[j]+nums[k];
+                if (sum<0){
+                    j++;
+                }
+                else if (sum>0){
+                    k--;
+                }
+                else {
+                    vector <int> ans = {nums[i],nums[j],nums[k]};
+                    res.push_back(ans);
+                    j++;
+                    k--;
+                    while(j<k && nums[j]==nums[j-1])j++;
+                    while(j<k && nums[k]==nums[k+1])k--;
+                }
+            }
+        }
+        return res;
+
+    }
+};

Challenge-12/max_water_contain.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int maxArea(vector<int>& height) {
+        int left = 0;
+        int right = height.size()-1;
+        int maxVol = 0;
+
+        for (int i = left;i<height.size();i++){
+            int vol = min(height[left],height[right])*(right-left);
+            maxVol = max(vol,maxVol);
+            if (height[left]<height[right])left++;
+            else right--;
+        }
+
+        return maxVol;
+
+    }
+};

Challenge-13/no_of_set_bits.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int hammingWeight(int n) {
+
+        int count = 0;
+        while(n>0){
+            n &= (n-1);
+            count ++;
+        }
+
+        return count;
+
+    }
+};

Challenge-14/counting_bits.cpp

@@ -0,0 +1,10 @@
+class Solution {
+public:
+    vector<int> countBits(int n) {
+        vector <int> ans(n+1);
+        for (int i=0;i<=n;i++){
+            ans[i]=ans[i/2]+(i%2);
+        }
+        return ans;
+    }
+};

Challenge-15/missing_no.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int missingNumber(vector<int>& nums) {
+        int n = nums.size();
+        int sum = (n*(n+1))/2;
+        int curr = 0;
+
+        for (int num: nums){
+            curr+=num;
+        }
+        return sum-curr;
+
+    }
+};

Challenge-16/reverse_bits.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    uint32_t reverseBits(uint32_t n) {
+        uint32_t res = 0;
+        for (int i=0;i<32;i++){
+            res = (res << 1) | (n&1);
+            n>>=1;
+        }
+        return res;
+
+    }
+};

Challenge-17/climbing_stairs.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int climbStairs(int n) {
+
+        static int memo[46] = {0};
+
+        if (n==1)return 1;
+        if(n==2)return 2;
+        if(memo[n]!=0)return memo[n];
+
+        memo[n] = climbStairs(n-1) + climbStairs(n-2);
+        return memo[n];
+
+    }
+};

Challenge-18/coin_change.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int coinChange(vector<int>& coins, int amount) {
+        vector<int> dp(amount + 1, INT_MAX);
+        dp[0] = 0;
+
+        for (int coin : coins) {
+            for (int i = coin; i <= amount; i++) {
+                if (dp[i - coin] != INT_MAX) { 
+                    dp[i] = min(dp[i], dp[i - coin] + 1);
+                }
+            }
+        }
+        return (dp[amount] == INT_MAX) ? -1 : dp[amount];
+    }
+};

Challenge-19/longest_incr_subseq.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int lengthOfLIS(vector<int>& nums) {
+        int n = nums.size();
+        vector <int> temp;
+        temp.push_back(nums[0]);
+
+        for (int i=1;i<n;i++){
+            if (nums[i]>temp.back()){
+                temp.push_back(nums[i]);
+            }else{
+                int idx = lower_bound(temp.begin(),temp.end(),nums[i])-temp.begin();
+                temp[idx] = nums[i];
+            }
+        }
+
+        return temp.size();
+
+
+    }
+};

Challenge-2/two_sum.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+
+        unordered_map <int,int> mpp;
+        for (int i=0;i<nums.size();i++){
+            int more = target-nums[i];
+            if(mpp.find(more)!=mpp.end()){
+                return {mpp[more],i};
+            }
+            mpp[nums[i]]=i;
+        }
+
+        return {-1,-1};
+    }
+};

Challenge-20/long_common_subseq.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+
+    int f(int i, int j, string &text1, string &text2,vector<vector<int>> &dp){
+        if(i<0 || j<0) return 0;
+
+        if(dp[i][j]!=-1) return dp[i][j];
+        if(text1[i]==text2[j])  return dp[i][j] =  1 + f(i-1,j-1,text1,text2,dp);
+
+        return dp[i][j] = max(f(i-1,j,text1,text2,dp),f(i,j-1,text1,text2,dp));
+    }
+
+
+    int longestCommonSubsequence(string text1, string text2) {
+
+        int n = text1.size();
+        int m = text2.size();
+
+        vector<vector<int>>dp(n,vector<int>(m,-1));
+
+        return f(n-1,m-1,text1,text2,dp);
+
+    }
+};

Challenge-21/word_break.cpp

@@ -0,0 +1,27 @@
+class Solution {
+public:
+    int dp[301];
+
+    int helper(int i, string s, set<string>&wordDict){
+
+        if(s.size()==i) return 1;
+        string temp;
+        if(dp[i]!=-1) return dp[i];
+        for (int j= i;j<s.size();j++){
+            temp+=s[j];
+            if(wordDict.find(temp)!=wordDict.end()){
+                if(helper(j+1,s,wordDict))return dp[i] = 1;
+            }
+        }
+        return dp[i] = 0;
+    }
+
+
+    bool wordBreak(string s, vector<string>& wordDict) {  
+
+        set<string>st;
+        memset(dp, -1, sizeof dp);
+        for (auto a:wordDict) st.insert(a);
+        return helper(0,s,st);
+    }
+};

Challenge-22/combination_sum_iv.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    int combinationSum4(vector<int>& nums, int target) {
+
+        vector<int>dp (target+1,-1);
+        dp[0]=1;
+        return helper(nums,target,dp);
+
+    }
+
+    int helper (vector<int>&nums, int target, vector<int>& dp){
+        if(dp[target]!=-1) return dp[target];
+
+        int res = 0;
+        for (int num : nums){
+            if (target>=num){
+                res += helper(nums,target-num, dp);
+            }
+        }
+
+        dp[target] = res;
+        return res;
+
+    }
+};

Challenge-23/house_robber.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int rob(vector<int>& nums) {
+
+        int pre1,pre2 = 0;
+        for(int num : nums){
+            int temp = pre1;
+            pre1 = max ((num + pre2),pre1);
+            pre2 = temp;
+
+        }
+        return pre1;
+
+    }
+};

Challenge-24/house_robber2.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+
+    int helper(vector<int> &nums,int start, int end){
+        int prev1 =0, prev2 = 0;
+        for (int i=start; i<=end; i++){
+            int temp = prev1;
+            prev1 = max(prev2 + nums[i], prev1);
+            prev2 = temp;
+        }
+        return prev1;
+    }
+    int rob(vector<int>& nums) {
+
+        int n = nums.size();
+        if (n==0) return 0;
+        if (n==1) return nums[0];
+        if (n==2) return max (nums[0],nums[1]);
+
+        return max(helper(nums,0,n-2), helper(nums,1,n-1));
+
+
+    }
+};

Challenge-25/decode_ways.cpp

@@ -0,0 +1,23 @@
+int numDecodings(string s) {
+    if (s.empty() || s[0] == '0') return 0;
+
+    int prev = 1, curr = 1;
+
+    for (int i = 1; i < s.length(); i++) {
+        int temp = 0;
+
+
+        if (s[i] != '0') {
+            temp += curr;
+        }
+        int twoDigit = stoi(s.substr(i - 1, 2));
+        if (twoDigit >= 10 && twoDigit <= 26) {
+            temp += prev;
+        }
+
+        prev = curr;
+        curr = temp;
+    }
+
+    return curr;
+}