feat: finish those

Author: plh97

.idea/workspace.xml

@@ -0,0 +1,43 @@
+# [160. Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists)
+
+## 2019/09/03
+
+### 题目 💗[easy]
+
+Write a program to find the node at which the intersection of two singly linked lists begins.
+
+For example, the following two linked lists:
+
+begin to intersect at node c1.
+
+Example 1:
+
+```bash
+Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
+Output: Reference of the node with value = 8
+Input Explanation: The intersected node's value is 8 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,0,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.
+```
+
+Example 2:
+
+```bash
+Input: intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
+Output: Reference of the node with value = 2
+Input Explanation: The intersected node's value is 2 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [0,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.
+```
+
+Example 3:
+
+```bash
+Input: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
+Output: null
+Input Explanation: From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values.
+Explanation: The two lists do not intersect, so return null.
+```
+
+Notes:
+
+- If the two linked lists have no intersection at all, return null.
+- The linked lists must retain their original structure after the function returns.
+- You may assume there are no cycles anywhere in the entire linked structure.
+- Your code should preferably run in O(n) time and use only O(1) memory.

algorithm/160.IntersectionofTwoLinkedLists/README.md

@@ -0,0 +1,32 @@
+package getIntersectionNode
+
+import (
+	"github.com/pengliheng/leetcode/Helper"
+)
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+
+type ListNode = Helper.ListNode
+
+func getIntersectionNode(headA, headB *ListNode) *ListNode {
+	a, b := headA, headB
+	for a != b {
+		if a == nil {
+			a = headB
+		} else {
+			a = a.Next
+		}
+		if b == nil {
+			b = headA
+		} else {
+			b = b.Next
+		}
+	}
+	return a
+}

algorithm/160.IntersectionofTwoLinkedLists/main.go

@@ -0,0 +1,28 @@
+package getIntersectionNode
+
+import (
+	"testing"
+
+	"github.com/pengliheng/leetcode/Helper"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var tcs = []struct {
+	N1  *Helper.ListNode
+	N2  *Helper.ListNode
+	ans int
+}{
+	{
+		Helper.Ints2LinkList([]int{4, 1, 8, 4, 5}),
+		Helper.Ints2LinkList([]int{5, 0, 1, 8, 4, 5}),
+		8,
+	},
+}
+
+func Test_bitwiseComplement(t *testing.T) {
+	ast := assert.New(t)
+	for _, tc := range tcs {
+		ast.Equal(tc.ans, getIntersectionNode(tc.N1, tc.N2), "输入:%v", tc)
+	}
+}

algorithm/160.IntersectionofTwoLinkedLists/main_test.go

@@ -0,0 +1,28 @@
+# [55. Jump Game](https://leetcode.com/problems/jump-game/)
+
+## 2019/09/03
+
+### 题目 💗[easy]
+
+Given an array of non-negative integers, you are initially positioned at the first index of the array.
+
+Each element in the array represents your maximum jump length at that position.
+
+Determine if you are able to reach the last index.
+
+Example 1:
+
+```bash
+Input: [2,3,1,1,4]
+Output: true
+Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.
+```
+
+Example 2:
+
+```bash
+Input: [3,2,1,0,4]
+Output: false
+Explanation: You will always arrive at index 3 no matter what. Its maximum
+             jump length is 0, which makes it impossible to reach the last index.
+```

algorithm/55.JumpGame/README.md

@@ -0,0 +1,32 @@
+package canJump
+
+func canJump(nums []int) bool {
+	res := helper(nums)
+	return res < 3
+}
+
+func helper(nums []int) int {
+	if len(nums) == 1 {
+		return 0
+	}
+	stepRange := nums[0]
+	if stepRange >= len(nums)-1 {
+		return 0
+	} else {
+		container := []int{}
+		for i := 1; i <= stepRange; i++ {
+			container = append(container, 1+helper(nums[i:]))
+		}
+		return min(container)
+	}
+}
+
+func min(nums []int) int {
+	res := nums[0]
+	for _, e := range nums {
+		if res > e {
+			res = e
+		}
+	}
+	return res
+}