new constructure

Author: bbruceyuan

README.md

@@ -0,0 +1,16 @@
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            map.put(nums[i], i);
+        }
+        for (int i = 0; i < nums.length; i++) {
+            int complement = target - nums[i];
+            if (map.get(complement) != null && map.get(complement) != i) {
+                return new int[] { i, map.get(complement) };
+            }
+        }
+        
+        throw new IllegalArgumentException("No two sum solution");
+    }
+}

leetcode-algorithms/001. Two Sum/Solution.java

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int, int> m;
+        vector<int> result;
+        for(int i=0; i< nums.size(); i++){
+            // not found the second one
+            if (m.find(nums[i]) == m.end()) {
+                // store the first one position into the second one's key
+                m[target - nums[i]] = i;
+            }else {
+                // found the second one
+                result.push_back(m[nums[i]]);
+                result.push_back(i);
+                break;
+            }
+        }
+        return result;
+    }
+};

leetcode-algorithms/001. Two Sum/solution.cpp

@@ -0,0 +1,36 @@
+/*
+this function is too slow. We need to have another solution.
+*/
+
+function twoSum(nums, target){
+	var tmp,
+		position,
+		a = [];
+	for(var i = 0; i < nums.length; i++){
+		tmp = target - nums[i];
+		position = nums.indexOf(tmp);
+		if(position !== i && position !== -1){
+		    a.push(i, position);
+		    break;
+		}
+	}
+	return a;
+}
+
+// method 2
+//这里还是利用了hash的思想，我利用python做这道题也是这样做的。
+var twoSum = function(nums, target){
+	var hash = {},
+        result = [];
+    for(var i = 0; i < nums.length; i++){
+        hash[nums[i]] = i; 
+    }
+    for(var j = 0; j< nums.length; j++){
+        var a = target - nums[j];
+        if(hash[a]){
+            result.push(j, hash[a]);
+            break;
+        }
+    }
+    return result;
+}

leetcode-algorithms/001. Two Sum/twoSum.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+# Created by Bruce yuan on 18-1-23.
+
+
+class Solution(object):
+    def twoSum(self, nums, target):
+        i = 0
+        q = 0
+        for i in range(0, len(nums)):
+            m = target - nums[i]
+            if m in nums:
+                q = nums.index(m)
+                if q != i:
+                    break
+        return [i, q]

leetcode-algorithms/001. Two Sum/two_sum.py

@@ -0,0 +1,39 @@
+//this is dum
+var addTwoNumbers = function(l1, l2) {
+    var add = 0,
+		ans,
+		head;
+
+	while(l1 || l2){
+		var a = l1 ? l1.val : 0,
+			b = l2 ? l2.val : 0;
+
+		var sum = a + b + add;
+		add = ~~(sum / 10);//这里是去除小数地作用。
+							//类似于Math.floor(sum / 10);
+		var node = new ListNode(sum % 10);
+		if(!ans){
+			ans = head = node;
+		} else {
+			head.next = node;
+			head = node;
+		}
+
+		if (l1){
+			l1 = l1.next;
+		}
+		if (l2){
+			l2 = l2.next;
+		}
+
+	}
+
+	if(add){
+			var node1 = new ListNode(add);
+			head.next = node1;
+			head =  node1;
+		}
+	return ans;
+	
+    
+};

leetcode-algorithms/002. Add Two Numbers/AddTwoNumbers.js

@@ -0,0 +1,38 @@
+function findMedian(nums1, nums2){
+	var result = [],
+		il = 0,
+		ir = 0;
+	while(il < nums1.length && ir < nums2.length){
+		if(nums1[il] < nums2[ir]){
+			result.push(nums1[il]);
+			il++;
+		} else {
+			result.push(nums2[ir]);
+			ir++;
+		}
+	}
+
+	while(il < nums1.length){
+		result.push(nums1[il]);
+		il++;
+	}
+	while(ir < nums2.length){
+		result.push(nums2[ir]);
+		ir++;
+	}
+
+	if(result.length % 2 === 0){
+		var i = (result.length / 2 - 1),
+			j = (result.length / 2);
+			console.log(i, j);
+
+		return (result[i] + result[j]) / 2;
+
+	} else {
+		return result[Math.floor(result.length / 2)];
+	}
+
+}
+
+var a = findMedian([1,2,5], [3,4]);
+console.log(a);

leetcode-algorithms/004. Median of Two Sorted Arrays/findMedianOfTwoArray.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number} x
+ * @return {number}
+ */
+
+ //这里有一个好弱智的地方啊，其实不能用Number.MAX_VALUE来表示是否超过这了这个数的极限数字。
+ //还有就是需要知道js的除法是不会自动取整啊。而且最后不要用Math.floor()这个方法，貌似有点慢啊
+var reverse = function(x) {
+    var MAX = (1 << 30) * 2 - 1;
+    var sum = 0;
+    while(x !== 0){
+        sum = sum * 10 + x % 10;
+        x = ~~(x / 10);
+    }
+    
+    return  (Math.abs(sum) > MAX) ? 0 : sum;
+
+};

leetcode-algorithms/007. Reverse Integer/reverse.js

@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+ 
+ /*设置两个指针i, j, 一头一尾, 相向而行. 假设i指向的挡板较低, j指向的挡板较高(height[i] < height[j]).
+    下一步移动哪个指针?
+    -- 若移动j, 无论height[j-1]是何种高度, 形成的面积都小于之前的面积.
+    -- 若移动i, 若height[i+1] <= height[i], 面积一定缩小; 但若height[i+1] > height[i], 面积则有可能增大.
+    综上, 应该移动指向较低挡板的那个指针.
+    */
+var maxArea = function(height) {
+    var max = 0,
+        low = 0,
+        k,
+        high = height.length - 1;
+        
+    while(low < high){
+        max = Math.max(max, (high - low) * Math.min(height[low], height[high]));
+        if(height[low] < height[high]){
+            //move low
+            k = low + 1;
+            if(k < high && height[k] <= height[low]){
+                k++;
+            }
+            low = k;
+            
+        } else{
+            //move high
+            k = high - 1;
+            if(k > low && height[k] <= height[high]){
+                k--;
+            }
+            high = k;
+        }
+    }
+    
+    return max;
+};

leetcode-algorithms/011. Container With Most Water/watercontainer.js

@@ -0,0 +1,17 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var romanToInt = function(s) {
+    let roman = {'M': 1000,'D': 500 ,'C': 100,'L': 50,'X': 10,'V': 5,'I': 1};
+    let z = 0;
+    for (let i = 0; i < s.length - 1; i++) {
+        if (roman[s[i]] < roman[s[i + 1]]) {
+            z -= roman[s[i]];
+        } else {
+            z += roman[s[i]];
+        }
+    }
+    
+    return z + roman[s[s.length - 1]];
+};

leetcode-algorithms/013. Roman to Integer/romanToInt.js

@@ -0,0 +1,18 @@
+/**
+ * @param {string[]} strs
+ * @return {string}
+ */
+var longestCommonPrefix = function(strs) {
+    let pre = strs[0];
+    let i = 1;
+    
+    while (i < strs.length) {
+        while (!strs[i].startsWith(pre)) {
+            pre = strs[0].substring(0, pre.length - 1);
+        }
+        
+        i++;
+    }
+    
+    return pre === undefined ? '' : pre;
+};

leetcode-algorithms/014. Longest Common Prefix/longestPre.js

@@ -0,0 +1,55 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+
+ //方法一。
+var threeSum = function(nums) {
+    var hash = {};
+
+    nums.sort(function(a, b){
+    	return a - b;
+    });
+
+ 	nums.forEach(function(item){
+ 		if(hash[item]){
+ 			hash[item]++;//有重复而且要知道每个出现了多少次，因为可以一个数字出现两次。甚至三次。
+ 		}else{
+ 			hash[item] = 1;
+ 		}
+ 	});
+ 	
+ 	var result = [],
+ 		hashSet = {};
+
+ 	for(var i = 0; i < nums.length; i++){
+ 		for(var j = i + 1; j < nums.length; j++){
+ 			var a = nums[i],
+ 				b = nums[j],
+ 				c = 0 - a -b;
+
+ 			if(c < b){
+ 				break;
+ 			}
+
+ 			if(hashSet[a + ',' + b + ',' + c]){
+ 				continue;
+ 			}
+ 			hash[a]--;
+ 			hash[b]--;//如果出现多次表示还可以继续用这个数字，否则不能用。
+
+ 			if(hash[c]){
+ 				hashSet[a + ',' + b + ',' + c] = true;
+ 				result.push([a, b, c]);
+ 			}
+
+ 			hash[a]++;
+ 			hash[b]++;
+ 		}
+ 	}
+
+ 	return result;
+    
+};
+
+console.log(threeSum([1,-1,-1,-1,-1,2,2,2,0,0,0]));

leetcode-algorithms/015. 3Sum/3Sum.js

@@ -0,0 +1,31 @@
+#coding: utf-8
+
+"""
+想法都是一样的，不想写javascript版本了。
+"""
+
+class Solution(object):
+    '''算法思路：
+    同上，不过这次却巧妙去重
+    '''
+    def threeSum(self, nums):
+        nums, n, r = sorted(nums), len(nums), []
+        for i, target in enumerate(nums):
+            if i and nums[i - 1] == target:
+                continue
+
+            j, k = i + 1, n - 1
+            while j < k:
+                sum = nums[j] + nums[k]
+                if sum > -target:
+                    k -= 1
+                elif sum < -target:
+                    j += 1
+                else:
+                    r.append([target, nums[j], nums[k]])
+                    while j < k and nums[j + 1] == nums[j]:
+                        j += 1
+                    while j < k and nums[k - 1] == nums[k]:
+                        k -= 1
+                    j += 1
+        return r