Merge branch 'master' of https://github.com/KongJHong/leetcode

Author: KongJHong

README.md

@@ -0,0 +1,30 @@
+class Solution {
+    public int myAtoi(String str) {
+        int len = str.length();
+        if (len == 0) return 0;
+        char[] cs = str.toCharArray();
+        int i = 0;
+        while (i < len && cs[i] == ' ') i++;
+        if (i==len) return 0;
+        char c1 = cs[i];
+        int sig = 1;
+        if ((c1 > '9' || c1 < '0')) {
+            if (c1 == '-') {
+                sig = -1;
+                i++;
+            } else if (c1 == '+') {
+                i++;
+            } else return 0;
+        }
+        long v = 0,sv = 0;
+        for (; i < len; i++) {
+            char c = cs[i];
+            if (c < '0' || c > '9') break;
+            v = v * 10 + (c - '0');
+            sv = v * sig;
+            if (sv > Integer.MAX_VALUE) return Integer.MAX_VALUE;
+            else if (sv < Integer.MIN_VALUE) return Integer.MIN_VALUE;
+        }
+        return (int) sv;
+    }
+}

solution/0008.String to Integer(atoi)/Solution.java

@@ -0,0 +1,23 @@
+const myAtoi = function(str){
+  str = str.trim();
+  if(!str) return 0;
+  let isPositive = 1;
+  let i = 0, ans = 0;
+  if(str[i] === '+'){
+    isPositive = 1;
+    i++;
+  }else if(str[i] === '-'){
+    isPositive = 0;
+    i++;
+  }
+  for(; i < str.length; i++){
+    let t = str.charCodeAt(i) - 48;
+    if(t > 9 || t < 0) break;
+    if(ans > 2147483647/10 || ans > (2147483647-t)/10){
+      return isPositive ? 2147483647 : -2147483648;
+    }else{
+      ans = ans*10 + t;
+    }
+  }
+  return isPositive? ans : -ans;
+}

solution/0008.String to Integer(atoi)/Solution.js

@@ -6,4 +6,4 @@ class Solution {
     public String intToRoman(int num) {
         return M[num / 1000] + C[(num % 1000) / 100] + X[(num % 100) / 10] + I[num % 10];
     }
-}
+

solution/0012.Integer to Roman/Solution.java

@@ -0,0 +1,89 @@
+class Solution {
+public:
+     vector<vector<int> > threeSum(vector<int> &num) {
+        return threeSumGen(num, 0);
+    }
+    
+    vector<vector<int> > threeSumGen(vector<int> &num, int target) {
+        vector<vector<int>> allSol;
+        if(num.size()<3) return allSol;
+        sort(num.begin(),num.end());
+        
+        for(int i=0; i<num.size()-2; i++) {
+            if(i>0 && num[i]==num[i-1]) continue; // 去重
+            
+            int left=i+1, right=num.size()-1;
+            
+            while(left<right) {
+                int curSum = num[left]+num[right];
+                int curTarget = target-num[i];
+                if(curSum==curTarget) {
+                    vector<int> sol;
+                    sol.push_back(num[i]);
+                    sol.push_back(num[left]);
+                    sol.push_back(num[right]);
+                    allSol.push_back(sol);
+                    left++;
+                    right--;
+                    while(num[left]==num[left-1]) left++;
+                    while(num[right]==num[right+1]) right--;
+                }
+                else if(curSum<curTarget)
+                    left++;
+                else
+                    right--;
+            }
+        }
+        return allSol;
+    }
+    
+    
+    
+//backtrace TLE  
+    
+// 	vector<vector<int>> threeSum(vector<int>& nums) {
+// 		sort(nums.begin(), nums.end());
+// 		if (nums.size() <= 2 || nums[0] > 0) return{};
+// 		set<vector<int>> res;
+// 		for (int i = 0; i < nums.size(); i++)
+// 		{
+// 			int target = 0 - nums[i];
+// 			int m = 0, n = nums.size() - 1;
+// 			while (m < n)
+// 			{
+// 				while (true)
+// 				{
+//                     if (m >= n) break;
+// 					if (m == i)
+// 					{
+// 						m++;
+// 						continue;
+// 					}
+// 					if (n == i)
+// 					{
+// 						n--;
+// 						continue;
+// 					}
+// 					if (nums[m] + nums[n] == target) {
+// 						vector<int> s = { nums[m++], nums[i], nums[n] };
+// 						sort(s.begin(), s.end());
+//  						res.insert(s);
+// 						break;
+// 					}
+// 					if (nums[m] + nums[n] > target) n--;
+// 					if (nums[m] + nums[n] < target) m++;
+// 				}
+// 			}
+			
+// 		}
+// 		vector<vector<int>> fres(res.begin(), res.end());
+// 		return fres;
+// 	}
+};
+
+// accelerate the cin process.
+int x = []() {
+    std::ios::sync_with_stdio(false);
+    cin.tie(NULL);
+    return 0;
+}();

solution/0015.3Sum/Solution.cpp

@@ -0,0 +1,13 @@
+const removeNthFromEnd = function(head, n){
+  let left, before, right = head;
+  left = before = {next: head};
+  while(n--){
+      right = right.next;
+  }
+  while(right){
+      right =right.next;
+      left = left.next;
+  }
+  left.next = left.next.next;
+  return before.next;
+}

solution/0019.Remove Nth Node From End of List/Solution.js

@@ -0,0 +1,57 @@
+const mergeTwoLists2 = function (l1, l2) {
+  if (l1 === null && l2 === null) {
+    return null;
+  }
+  if (l1 !== null && l2 === null) {
+    return l1;
+  }
+  if (l1 === null && l2 !== null) {
+    return l2;
+  }
+  if (l1 !== null && l2 !== null) {
+    let t = null, h = null;
+    if (l1.val > l2.val) {
+      t = l2;
+      h = l2;
+      l2 = l2.next;
+    } else {
+      t = l1;
+      h = l1;
+      l1 = l1.next;
+    }
+    while (l1 !== null && l2 !== null) {
+      if (l1.val > l2.val) {
+        t.next = l2;
+        t = t.next;
+        l2 = l2.next;
+      } else {
+        t.next = l1;
+        t = t.next;
+        l1 = l1.next;
+      }
+    }
+    while (l1 !== null) {
+      t.next = l1;
+      l1 = l1.next;
+      t = t.next;
+    }
+    while (l2 !== null) {
+      t.next = l2;
+      l2 = l2.next;
+      t = t.next;
+    }
+    return h;
+  }
+}
+
+const mergeTwoLists = function (l1, l2) {
+  if (l1 === null) return l2;
+  if (l2 === null) return l1;
+  if (l1.val < l2.val) {
+    l1.next = mergeTwoLists(l1.next, l2);
+    return l1;
+  } else {
+    l2.next = mergeTwoLists(l1, l2.next);
+    return l2;
+  }
+}

solution/0021.Merge Two Sorted Lists/Solution.js

@@ -0,0 +1,21 @@
+class Solution {
+	List<String> result = new ArrayList<>();
+    public List<String> generateParenthesis(int n) {
+        generateParenthesis(n, n, new char[n * 2], 0);
+        return result;
+    }
+    void generateParenthesis(int left, int right, char[] cache, int index) {
+        if (right == 0) {
+            result.add(String.valueOf(cache));
+            return;
+        }
+        if (left > 0) {
+            cache[index] = '(';
+            generateParenthesis(left - 1, right, cache, index + 1);
+        }
+        if (right > left) {
+            cache[index] = ')';
+            generateParenthesis(left, right - 1, cache, index + 1);
+        }
+    }
+}

solution/0022.Generate Parentheses/Solution.java

@@ -0,0 +1,18 @@
+const removeDuplicates = function(nums){
+  let i = 1;
+  let t = 0;
+  let t2 = nums[0];
+  let res = 1;
+  let length = nums.length;
+  for(let k = 1; k < length; k++){
+    if(nums[k] - nums[k-1] !== 0 && nums[k] !== t2){
+      t2 = nums[k];
+      t = nums[i];
+      nums[i] = nums[k];
+      nums[k] = t;
+      i++;
+      res++;
+    }
+  }
+  return res;
+}

solution/0026.Remove Duplicates from Sorted Array/Solution.js

@@ -0,0 +1,24 @@
+class Solution:
+    def longestValidParentheses(self, s):
+        """
+        :type s: string
+        :rtype int
+        """
+        
+        Longest = temp = 0
+        stack = []
+        
+        for i in s:
+            if i == '(' :
+                stack.append(i)
+            elif len(stack) != 0 and stack[-1] == '(' :
+                stack.pop()
+                temp += 2
+            else:
+                stack=[]
+                if temp > Longest:
+                    Longest = temp
+                temp = 0
+        if temp > Longest:
+            Longest = temp
+        return Longest