Problem Solving

Author: amanjain89

LC-151_reverse-words-in-a-string.cpp

@@ -0,0 +1,79 @@
+LC:151 : Reverse Words in a String
+https://leetcode.com/problems/reverse-words-in-a-string/
+//Using sstream Method that works as a split method of Java
+class Solution {
+public:
+    string reverseWords(string s) {
+        vector<string> res;
+        
+        stringstream str(s);
+        
+        string word;
+        
+        string ans;
+        
+        while(str>>word){
+            res.push_back(word);
+        }
+        
+        for(int i = res.size()-1 ; i>=0 ;i--){
+            ans =ans+" "+ res[i];
+        }
+            
+        ans.erase(0,1);
+            
+        return ans;
+    }
+};
+//Using without any Function
+/*
+class Solution {
+public:
+    string reverseWords(string s) {
+         stack<string>st;
+        int start = 0;
+        int end = s.length();
+        while(s[start]==' '){
+            start++;
+        }
+        while(s[end]==' '){
+            end--;
+        }
+        for(int i = start ; i<end ; i++){
+            string word = " ";
+            while(i<end && s[i]!=' '){
+                word = word + s[i];
+                
+                i++;
+                if(i==end){
+                    st.push(word);
+                    break;
+                
+                }
+                
+                if(s[i]==' ' && i<end){
+                    st.push(word);
+                    st.push("");
+                }
+                
+                
+                
+            }
+            while(i<end && s[i+1]==' ' ){
+                i++;
+            }
+            
+        }
+       
+        string ans;
+        while(!st.empty()){
+            ans = ans + st.top();
+            st.pop();
+            
+        }
+        ans.erase(0, 1);
+        return ans;
+        
+    }
+};
+*/

LC-15_ThreeSum.cpp

@@ -0,0 +1,69 @@
+LC-15: Three Sum Problem
+https://leetcode.com/problems/3sum/
+//Brute Force Approach O(n^3) 
+//TLE
+/*
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+       //create set of vecto<int> type
+        set<vector<int>> set ;
+        
+        // Check if i!=j , i !=k ,  j!=k and sum to 0.
+        for(int i = 0 ; i< nums.size()-2 ; i++){
+            for(int j = 0 ; j<nums.size()-1 ;j++){
+                for(int k=0 ; k<nums.size() ;k++){
+                    
+                    if((i != j && i!=k && j!=k) && nums[i] + nums[j] + nums[k] == 0){
+                      //Creating vector with 3 values
+                       vector<int> v = {nums[i] , nums[j] , nums[k]};
+                       
+                       //Sorting Vector
+                       sort(v.begin() , v.end());
+                       
+                       //inserting into set of vector<int> type
+                       set.insert(v);
+                    }
+                }
+            }
+        }
+            //Copy set to vector of same type
+            vector<vector<int>> res(set.begin() , set.end());
+            
+            return res;
+            
+        }
+};
+*/
+
+// Two Pointer solution using Sorting TC : O(nlogn + n)
+
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        set<vector<int>> set ;
+        //Sort Vector
+        sort(nums.begin() , nums.end());
+        
+        for(int i =0 ; i< nums.size()-2 ;i++){
+            
+            int start = i+1;
+            int end = nums.size()-1;
+            
+            while(start < end){
+                int sum = nums[i] + nums[start] + nums[end];
+                if(sum  == 0){
+                    set.insert({nums[i] , nums[start++] , nums[end--]});
+                }else if(sum < 0)
+                    start++;
+                else
+                    end--;
+            }
+        }
+            
+            vector<vector<int>> res(set.begin() , set.end());
+            
+            return res;
+            
+        }
+};

LC-1_TwoSum.cpp

@@ -0,0 +1,83 @@
+//1. Problem : TwoSum :
+//LC: https://leetcode.com/problems/two-sum/
+
+// BruteForce TC: O(n^2) , SC: O(1)
+/*class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        vector<int> res;
+        
+        for(int i = 0 ; i< nums.size()-1 ; i++){
+            
+            for(int j = i+1 ; j<nums.size() ; j++){
+                
+                if(nums[i]+nums[j]  == target)
+                    res.push_back(i);
+                    res.push_back(j);
+                    
+                    return res;
+            }
+        }
+        
+        return res;
+    }
+};*/
+
+
+// Sorting and Two Pointer TC: O(nlogn + n) , SC : O(1)
+/*
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& v, int target) {
+        vector<int> res;
+        
+        sort(v.begin() , v.end());
+        
+        int start = 0 , end = v.size()-1;
+        
+        while(start < end){
+            
+            if(v[start] + v[end] < target)
+                start++;
+            else if(v[start]+v[end]>target)
+                end--;
+            else
+            {
+                res.push_back(start);
+                res.push_back(end);
+                
+                return res;
+            }
+        }
+        
+        return res;
+    }
+};*/
+
+
+// Using Unorder_map  TC: O(n) , SC : O(1)
+
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& v, int target) {
+       // vector<int> res;
+        unordered_map<int,int> mp;
+        
+        for(int i = 0 ; i < v.size() ; i++){
+            
+            if(mp.find(target - v[i]) == mp.end())
+                mp.insert({v[i] , i});
+           /* else
+            {
+                res.push_back(i);
+                res.push_back(mp[target-v[i]]);
+                
+                return res;
+            }*/
+            else
+                return {i , mp[target-v[i]]} ; 
+        }
+        //return res;
+        return {};
+    }
+};

LC-3_Longest_Substring_Without_Repeatition_Character.cpp

@@ -0,0 +1,110 @@
+//LC3 : Longest Substring without Repeating Character
+
+
+//BruteForce Approach : Enumerate over all the substring and check if there exists duplicate character
+// SC : O(n^3) , TC : O(k) where k is size of set
+//TLE
+/*class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        int res = 0;
+        
+        for(int i = 0 ; i <s.length() ;i++){
+            
+            for(int j = i ; j<s.length();j++ ){
+                
+                if(checkDuplicate(s , i , j))
+                    res = max(res , j-i+1);
+            }
+        }
+        
+        return res;
+    }
+    
+    bool checkDuplicate(string& s , int i , int j){
+        // we will use unordered set to check duplicate character.
+        
+        unordered_set<char> set;
+        
+        while(i<=j){
+            
+            char ch = s[i];
+            
+            //set.count(ch) gives presence of character or not. returns either 0 or 1
+            
+            if(set.count(ch))
+                return false;
+            set.insert(ch);
+        }
+        return true;       
+    }
+}; */
+
+
+
+//Sliding Window Approach: Using Hash Map and Sliding Window Approach using 2 Pointers 
+// TC : O(2n) , In worst case each element will be visited twice by left and right pointer
+// SC : O(k) , Size of HashMap
+
+/*
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        int res = 0;
+        unordered_map<char ,int> um;
+        
+        int left = 0 , right = 0;
+        
+        int len = s.length();
+        
+        while(right < len){
+            
+            char ch = s[right];
+            um[ch]++;
+            
+            while(um[ch] > 1){
+                char chl = s[left];
+                um[chl]--;
+                left++;
+            }
+            
+            res = max(res , right - left + 1);
+            
+            right++;
+        }
+        
+        return res;
+    } 
+}; */
+
+// Approach Sliding Window but we can avoid 2n visits to n visits only by mapping in map
+// we have s[j] duplicate in range of (i,j) with index j' so we can directly move i to j'+1 instead of
+// moving slowly by 1 and check like above case
+
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        int res = 0;
+        vector<int> um(256, -1);
+        
+        int left = 0 , right = 0;
+        
+        while(right < s.length()){
+            char ch = s[right];
+            
+            if(um[ch]!=-1)
+                left = max(left, um[ch] + 1);
+        
+            
+            
+            std::cout<<res;
+            
+            um[ch] = right;
+            
+            res = max(res, right-left+1);
+            
+            right++;
+        }
+        return res;
+    }
+};