Merge branch 'master' of github.com:doocs/leetcode

Author: yanglbme

.gitignore

@@ -0,0 +1,11 @@
+# @param {Integer[]} nums
+# @param {Integer} target
+# @return {Integer[]}
+def two_sum(nums, target)
+  nums.each_with_index do |x, idx|
+    if nums.include? target - x
+      return [idx, nums.index(target - x)] if nums.index(target - x) != idx
+    end
+    next
+  end
+end

solution/001.Two Sum/Solution.rb

@@ -0,0 +1,51 @@
+# Definition for singly-linked list.
+# class ListNode
+#     attr_accessor :val, :next
+#     def initialize(val)
+#         @val = val
+#         @next = nil
+#     end
+# end
+
+# @param {ListNode} l1
+# @param {ListNode} l2
+# @return {ListNode}
+def add_two_numbers(l1, l2)
+  return l2 if l1 == nil
+  return l1 if l2 == nil
+  cur_val = l1.val + l2.val
+  l3 = ListNode.new(cur_val % 10)
+  add = cur_val >= 10 ? 1 : 0
+  tmp = l3
+
+  l1 = l1.next
+  l2 = l2.next
+  while !l1.nil? && !l2.nil?
+    cur_val = l1.val + l2.val + add
+    tmp.next = ListNode.new(cur_val % 10)
+    tmp = tmp.next
+    add = cur_val >= 10 ? 1 : 0
+
+    l1 = l1.next
+    l2 = l2.next
+  end
+
+  until l1.nil?
+    cur_val = l1.val + add
+    tmp.next = ListNode.new(cur_val % 10)
+    tmp = tmp.next
+    add = cur_val >= 10 ? 1 : 0
+    l1 = l1.next
+  end
+
+  until l2.nil?
+    cur_val = l2.val + add
+    tmp.next = ListNode.new(cur_val % 10)
+    tmp = tmp.next
+    add = l2.val + add >= 10 ? 1 : 0
+    l2 = l2.next
+  end
+
+  tmp.next = ListNode.new(1) if add == 1
+  l3
+end

solution/002.Add Two Numbers/Solution.rb

@@ -0,0 +1,41 @@
+class Solution {
+public:
+	vector<vector<int>> permuteUnique(vector<int>& nums) {
+		if (nums.size() <= 0) return{};
+
+		sort(nums.begin(), nums.end());
+		
+		vector<vector<int>> res;
+		vector<bool> used;
+		vector<int> curr;
+		
+		for (auto item : nums)
+		{
+			used.push_back(false);
+		}
+
+		dfs(res, nums, curr, used, 0);
+		return res;
+	}
+
+	void dfs(vector<vector<int>>& res, vector<int>& nums, vector<int> curr, vector<bool> used, int depth)
+	{
+		if (depth >= nums.size())
+		{
+			res.emplace_back(curr);
+			return;
+		}
+
+		for (int i = 0; i < nums.size(); i++)
+		{
+			if (used[i]) continue; 
+			if (i > 0 && nums[i] == nums[i - 1] && !used[i-1]) continue;
+
+			used[i] = true;
+			curr.emplace_back(nums[i]);
+			dfs(res, nums, curr, used, depth + 1);
+			curr.pop_back();
+			used[i] = false;
+		}
+	}
+};

solution/047.Permutations II/Solution.cpp

@@ -0,0 +1,30 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def partition(self, head, x):
+        """
+        :type head: ListNode
+        :type x: int
+        :rtype: ListNode
+        """
+        leftDummy=ListNode(-1)
+        rightDummy=ListNode(-1)
+        leftCur=leftDummy
+        rightCur=rightDummy              
+        
+        while head:
+            if head.val<x:
+                leftCur.next=head
+                leftCur=leftCur.next
+            else:
+                rightCur.next=head
+                rightCur=rightCur.next
+            head=head.next
+            
+        leftCur.next=rightDummy.next
+        rightCur.next=None
+        return leftDummy.next