Adding new LC solutions

Author: ME-ON1

412268702_two-sum.cxx

@@ -0,0 +1,30 @@
+id = 412268702 
+lang = cpp 
+runtime  = 24 ms 
+memory = 10.9 MB
+title_slug = two-sum
+code =
+ ```class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        vector<int> v ;
+        map<int,int> mp ;
+        for(int i = 0 ; i < nums.size(); i++ ){
+            int j ;
+            j = nums[i];
+            pair<int, int > p ;
+            p = make_pair(j, i );
+            mp.insert(p);
+        }
+        
+        for(int i = 0 ; i < nums.size(); i++ ){
+            int difw = target - nums[i] ;
+            if(mp.find(difw) != mp.end() && mp[difw] != i){
+                v.push_back(mp[difw]);
+                v.push_back(i);
+                return v; 
+            }
+        }
+        return v ;
+    }
+};```

449428514_add-two-numbers.cxx

@@ -0,0 +1,37 @@
+id = 449428514 
+lang = cpp 
+runtime  = 20 ms 
+memory = 71.2 MB
+title_slug = add-two-numbers
+code =
+ ```/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+        ListNode  lk;
+        ListNode* tmp = &lk ;
+        int carry = 0 ;
+        while(l1  || l2){
+            int data = (l1 ? l1->val : 0) + (l2 ? l2->val: 0) + carry ;
+            carry = data/10;
+            tmp->next =new ListNode(data%10);
+            tmp = tmp->next ;
+            if(l1) l1 = l1->next ;
+            if(l2) l2 = l2->next ;
+        }
+        if(carry){
+            tmp->next = new ListNode(1) ;
+        }
+        
+        return lk.next ;
+    }
+};```

449756869_reverse-integer.cxx

@@ -0,0 +1,25 @@
+id = 449756869 
+lang = cpp 
+runtime  = 0 ms 
+memory = 5.9 MB
+title_slug = reverse-integer
+code =
+ ```class Solution {
+public:
+    int reverse(int x) {
+        int j = x;
+        int rev = 0 ;
+        while(x != 0 ) {
+            int rem = x %10 ;
+            x /= 10 ;
+            if(rev > INT_MAX/10 || (rev == INT_MAX/10 && rem > 7)){
+                return 0 ;
+            }
+            if(rev < INT_MIN/10 || (rev == INT_MAX/10 && rev < -8)){
+                return 0; 
+            }
+            rev = rem + rev*10 ;
+        }       
+        return rev ;
+    }
+};```

467529137_palindrome-number.cxx

@@ -0,0 +1,37 @@
+id = 467529137 
+lang = cpp 
+runtime  = 12 ms 
+memory = 6 MB
+title_slug = palindrome-number
+code =
+ ```class Solution {
+public:
+    bool isPalindrome(int x) {
+        if(x < 0) {
+            return false ;
+        }
+        //count the length of x 
+        int div = 1 ;
+        while(x / div >= 10) {
+            div *= 10 ; 
+            
+        }
+                
+        while(x != 0 ) {
+            int lead = x / div ;
+            int trail = x % 10 ;
+            
+            // cout <<lead << " " << trail << "\n " ;   
+            if(lead != trail ) {
+                return false ; 
+            }
+                        
+            x = (x % div ) / 10 ;
+            div /= 100 ;
+            // cout << x << " x \n" ;
+         }
+        
+        return true ;
+        
+    }
+};```

467576341_palindrome-linked-list.cxx

@@ -0,0 +1,43 @@
+id = 467576341 
+lang = cpp 
+runtime  = 224 ms 
+memory = 121 MB
+title_slug = palindrome-linked-list
+code =
+ ```/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    
+    bool checkPallin(ListNode * tail , ListNode* &head ) {
+        if(!tail ) {
+            return true ;
+        }        
+        bool che = checkPallin(tail->next , head ) /*&& tail->val == head->val */;
+        if(head->val == tail->val) {
+            che = che && true;
+        }else {
+            che = che && false ;
+        }
+        head = head->next ;
+        return che ;
+    }
+    
+    bool isPalindrome(ListNode* head) {
+        if(head == NULL || head->next ==  NULL) {
+            return true ;
+        }
+        ListNode * tail = head ; 
+        // cout << checkPallin(tail, head) << " sdf\n" ;
+        return checkPallin(tail , head) ;
+        
+    }
+};```

467576574_palindrome-linked-list.cxx

@@ -0,0 +1,38 @@
+id = 467576574 
+lang = cpp 
+runtime  = 204 ms 
+memory = 121.1 MB
+title_slug = palindrome-linked-list
+code =
+ ```/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    
+    bool checkPallin(ListNode * tail , ListNode* &head ) {
+        if(!tail ) {
+            return true ;
+        }        
+        bool che = checkPallin(tail->next , head ) && tail->val == head->val ;
+        head = head->next ;
+        return che ;
+    }
+    
+    bool isPalindrome(ListNode* head) {
+        if(head == NULL || head->next ==  NULL) {
+            return true ;
+        }
+        ListNode * tail = head ; 
+        // cout << checkPallin(tail, head) << " sdf\n" ;
+        return checkPallin(tail , head) ;
+        
+    }
+};```

467970028_roman-to-integer.cxx

@@ -0,0 +1,35 @@
+id = 467970028 
+lang = cpp 
+runtime  = 8 ms 
+memory = 8.1 MB
+title_slug = roman-to-integer
+code =
+ ```class Solution {
+public:
+    int romanToInt(string s) {
+        int num = 0; 
+        unordered_map<char,int> mp ; 
+        
+        mp['I'] = 1 ;
+        mp['V'] = 5 ;
+        mp['X'] = 10 ;
+        mp['L'] = 50 ;
+        mp['C'] = 100 ;
+        mp['D'] = 500 ;
+        mp['M'] = 1000 ;
+        num = mp[s[s.size() -1 ]] ;
+        for(int i = s.size() - 2 ; i >= 0; i-- ) {
+            char cur = s[i] ;
+            char prev = s[i+1] ;
+            
+                if(mp[cur] >= mp[prev]) {
+                num += mp[cur] ;
+            }else {
+                num -= mp[cur] ;
+            }
+        }
+    return abs(num) ;
+
+    }
+    
+    };```

467991088_longest-common-prefix.cxx

@@ -0,0 +1,30 @@
+id = 467991088 
+lang = cpp 
+runtime  = 0 ms 
+memory = 9.3 MB
+title_slug = longest-common-prefix
+code =
+ ```class Solution {
+public:
+    string longestCommonPrefix(vector<string>& str) {
+        int n = str.size();
+        if(n==0) return "";
+        
+        string ans  = "";
+        sort(begin(str), end(str));
+        string a = str[0];
+        string b = str[n-1];
+        
+        for(int i=0; i<a.size(); i++){
+            if(a[i]==b[i]){
+                ans = ans + a[i];
+            }
+            else{
+                break;
+            }
+        }
+        
+        return ans;
+        
+    }
+};```

468008578_valid-parentheses.cxx

@@ -0,0 +1,53 @@
+id = 468008578 
+lang = cpp 
+runtime  = 0 ms 
+memory = 6.3 MB
+title_slug = valid-parentheses
+code =
+ ```class Solution {
+public:
+    bool isValid(string st) {
+        stack<char> s; 
+    char x; 
+  
+    for (int i = 0; i < st.length(); i++)  
+    { 
+        if (st[i] == '(' || st[i] == '['
+            || st[i] == '{')  
+        { 
+            s.push(st[i]); 
+            continue; 
+        } 
+  
+        if (s.empty()) 
+            return false; 
+  
+        switch (st[i]) { 
+        case ')': 
+              
+            x = s.top(); 
+            s.pop(); 
+            if (x == '{' || x == '[') 
+                return false; 
+            break; 
+  
+        case '}': 
+  
+            x = s.top(); 
+            s.pop(); 
+            if (x == '(' || x == '[') 
+                return false; 
+            break; 
+  
+        case ']': 
+  
+            x = s.top(); 
+            s.pop(); 
+            if (x == '(' || x == '{') 
+                return false; 
+            break; 
+        } 
+    } 
+    return (s.empty()); 
+    }
+    };```

468881965_merge-two-sorted-lists.cxx

@@ -0,0 +1,44 @@
+id = 468881965 
+lang = cpp 
+runtime  = 12 ms 
+memory = 14.8 MB
+title_slug = merge-two-sorted-lists
+code =
+ ```/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
+        //let's try two pointer methof 
+        ListNode *head = new ListNode(0) ;
+        
+        ListNode *res = head ;
+        
+        while(l1 != NULL && l2 != NULL) {
+            if(l1->val <= l2->val ){
+                head->next = l1 ;
+                l1 = l1->next ;
+            }else {
+                head->next = l2 ; 
+                l2 = l2->next ;
+            }
+            head = head->next ;
+        }
+        
+        if(l1 == NULL ){
+            head->next = l2 ;
+        }else {
+            head->next = l1 ;
+        }
+        
+        return res->next ;
+    }
+};```