Add LeetCode problems 1-10

Author: AliOsm

LeetCode/1. Two Sum.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int, int> m;
+        
+        int a, b;
+        for(int i = 0, need; i < nums.size(); ++i) {
+            need = target - nums[i];
+            if(m.count(need) != 0) {
+                a = i, b = m[need];
+                break;
+            }
+            m[nums[i]] = i;
+        }
+        
+        vector<int> solution;
+        solution.push_back(a);
+        solution.push_back(b);
+        return solution;
+    }
+};

LeetCode/10. Regular Expression Matching.cpp

@@ -0,0 +1,31 @@
+class Solution {
+private:
+    static int const N = 1e2 + 1;
+    int dp[N][N];
+
+public:
+    bool isMatch(string s, string p) {
+        memset(dp, -1, sizeof dp);
+        return rec(0, 0, s, p);
+    }
+    
+    bool rec(int i, int j, string &s, string &p) {
+        if(j == p.length())
+            return i == s.length();
+        
+        int &ret = dp[i][j];
+        if(ret != -1)
+            return ret;
+        
+        bool match = false;
+        if(i < s.length() && (s[i] == p[j] || p[j] == '.'))
+            match = true;
+        
+        if(j + 1 < p.length() && p[j + 1] == '*')
+            ret = (rec(i, j + 2, s, p) || match && rec(i + 1, j, s, p));
+        else
+            ret = match && rec(i + 1, j + 1, s, p);
+        
+        return ret;
+    }
+};

LeetCode/2. Add Two Numbers.cpp

@@ -0,0 +1,49 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+        ListNode *tmp = new ListNode(l1->val + l2->val);
+        ListNode *solution = tmp;
+        
+        l1 = l1->next;
+        l2 = l2->next;
+        
+        int rem = 0;
+        if(tmp->val >= 10)
+            rem = 1, tmp->val -= 10;
+        
+        while(l1 != NULL || l2 != NULL) {
+            if(l1 == NULL) {
+                tmp->next = new ListNode(l2->val + rem);
+                tmp = tmp->next;
+            } else if(l2 == NULL) {
+                tmp->next = new ListNode(l1->val + rem);
+                tmp = tmp->next;
+            } else {
+                tmp->next = new ListNode(l1->val + l2->val + rem);
+                tmp = tmp->next;
+            }
+            
+            rem = 0;
+            if(tmp->val >= 10)
+                rem = 1, tmp->val -= 10;
+            
+            if(l1 != NULL)
+                l1 = l1->next;
+            if(l2 != NULL)
+                l2 = l2->next;
+        }
+        
+        if(rem != 0)
+            tmp->next = new ListNode(rem);
+        
+        return solution;
+    }
+};

LeetCode/3. Longest Substring Without Repeating Characters.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        int solution = 0, idx[128];
+        for(int i = 0; i < 128; ++i)
+            idx[i] = -1;
+        
+        for(int i = 0, j = 0; j < s.length(); ++j) {
+            if(idx[s[j]] != -1)
+                i = max(idx[s[j]] + 1, i);
+            solution = max(solution, j - i + 1);
+            idx[s[j]] = j;
+        }
+        
+        return solution;
+    }
+};

LeetCode/4. Median of Two Sorted Arrays.cpp

@@ -0,0 +1,46 @@
+class Solution {
+public:
+    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
+        if(nums1.size() > nums2.size())
+            swap(nums1, nums2);
+        
+        int l = 0, r = nums1.size(), mid1, mid2;
+        while(l <= r) {
+            mid1 = (l + r) / 2;
+            mid2 = (nums1.size() + nums2.size() + 1) / 2 - mid1;
+            
+            int nums1_left, nums1_right, nums2_left, nums2_right;
+            
+            if(mid1 - 1 >= 0)
+                nums1_left = nums1[mid1 - 1];
+            else
+                nums1_left = -2e9;
+            
+            if(mid1 < nums1.size())
+                nums1_right = nums1[mid1];
+            else
+                nums1_right = 2e9;
+            
+            if(mid2 - 1 >= 0)
+                nums2_left = nums2[mid2 - 1];
+            else
+                nums2_left = -2e9;
+            
+            if(mid2 < nums2.size())
+                nums2_right = nums2[mid2];
+            else
+                nums2_right = 2e9;
+            
+            if(nums1_left <= nums2_right && nums2_left <= nums1_right) {
+                if((nums1.size() + nums2.size()) & 1)
+                    return max(nums1_left, nums2_left);
+                return (max(nums1_left, nums2_left) + min(nums1_right, nums2_right)) / 2.0;
+            } else if(nums2_left > nums1_right)
+                l = mid1 + 1;
+            else
+                r = mid1 - 1;
+        }
+        
+        return -1;
+    }
+};

LeetCode/5. Longest Palindromic Substring.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    string longestPalindrome(string s) {
+        int b = 0, e = 0;
+        
+        for(int i = 0, j, k; i < s.length(); ++i) {
+            j = i, k = i;
+            while(j >= 0 && k < s.length() && s[j] == s[k])
+                --j, ++k;
+            ++j, --k;
+            if(k - j + 1 > e - b + 1)
+                b = j, e = k;
+            
+            
+            j = i, k = i + 1;
+            while(j >= 0 && k < s.length() && s[j] == s[k])
+                --j, ++k;
+            ++j, --k;
+            if(k - j + 1 > e - b + 1)
+                b = j, e = k;
+        }
+        
+        return s.substr(b, e - b + 1);
+    }
+};

LeetCode/6. ZigZag Conversion.cpp

@@ -0,0 +1,36 @@
+class Solution {
+public:
+    string convert(string s, int numRows) {
+        if(numRows == 1)
+            return s;
+        
+        string solution = "";
+        int down_step = 2 * numRows - 3;
+        int up_step = down_step;
+        
+        for(int k = 0; k < numRows; ++k) {
+            bool down = true;
+            for(int i = k; i < s.length();) {
+                solution += s[i];
+                if(down)
+                    i += down_step + 1;
+                else
+                    i += up_step + 1;
+                down = !down;
+            }
+            
+            if(k == 0) {
+                down_step -= 2;
+                up_step = 1;
+            } else {
+                down_step -= 2;
+                up_step += 2;
+            }
+                
+            if(down_step <= 0)
+                down_step = up_step = 2 * numRows - 3;
+        }
+        
+        return solution;
+    }
+};

LeetCode/7. Reverse Integer.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int reverse(int x) {
+        int solution = 0;
+        
+        while(x != 0) {
+            int front = x % 10;
+            x /= 10;
+            if(solution > INT_MAX / 10 || (solution == INT_MAX / 10 && front > 7)) return 0;
+            if(solution < INT_MIN / 10 || (solution == INT_MIN / 10 && front < -8)) return 0;
+            solution = solution * 10 + front;
+        }
+        
+        return solution;
+    }
+};

LeetCode/8. String to Integer (atoi).cpp

@@ -0,0 +1,41 @@
+class Solution {
+public:
+    int myAtoi(string str) {
+        char sign = '+';
+        int index = -1;
+        for(int i = 0; i < str.length(); ++i) {
+            if(str[i] != '-' && str[i] != '+' && str[i] != ' ' && !isdigit(str[i]))
+                return 0;
+            if(str[i] == '-')
+                sign = '-';
+            if(str[i] == '-' && i + 1 < str.length() && !isdigit(str[i + 1]))
+                return 0;
+            if(str[i] == '+')
+                sign = '+';
+            if(str[i] == '+' && i + 1 < str.length() && !isdigit(str[i + 1]))
+                return 0;
+            if(isdigit(str[i])) {
+                index = i;
+                break;
+            }
+        }
+        
+        if(index == -1)
+            return 0;
+        
+        int solution = 0;
+        for(int i = index; isdigit(str[i]) && i < str.length(); ++i) {
+            if(solution > INT_MAX / 10 || (solution == INT_MAX / 10 && str[i] - '0' > 7))
+                return INT_MAX;
+            if(solution < INT_MIN / 10 || (solution == INT_MIN / 10 && str[i] - '0' > 8))
+                return INT_MIN;
+            
+            if(sign == '-')
+                solution = solution * 10 + -(str[i] - '0');
+            else
+                solution = solution * 10 + (str[i] - '0');
+        }
+        
+        return solution;
+    }
+};

LeetCode/9. Palindrome Number.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    bool isPalindrome(int x) {
+        if(x < 0)
+            return false;
+        
+        long long reverse = 0, tmp = x;
+        while(tmp != 0) {
+            reverse = reverse * 10 + tmp % 10;
+            tmp /= 10;
+        }
+        
+        return x == reverse;
+    }
+};

LeetCode/README.md

@@ -0,0 +1,12 @@
+# Problems links
+
+- [1. Two Sum](https://leetcode.com/problems/two-sum)
+- [2. Add Two Numbers](https://leetcode.com/problems/add-two-numbers)
+- [3. Longest Substring Without Repeating Characters](https://leetcode.com/problems/longest-substring-without-repeating-characters)
+- [4. Median of Two Sorted Arrays](https://leetcode.com/problems/median-of-two-sorted-arrays)
+- [5. Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)
+- [6. ZigZag Conversion](https://leetcode.com/problems/zigzag-conversion)
+- [7. Reverse Integer](https://leetcode.com/problems/reverse-integer)
+- [8. String to Integer (atoi)](https://leetcode.com/problems/string-to-integer-atoi)
+- [9. Palindrome Number](https://leetcode.com/problems/palindrome-number)
+- [10. Regular Expression Matching](https://leetcode.com/problems/regular-expression-matching)