Merge pull request kamyu104#25 from xiaopeng163/master

try to add some golang solution

Author: kamyu104

Golang/add-two-numbers.go

@@ -0,0 +1,62 @@
+package leetcode
+
+// ListNode represents a non-negative number.
+// You are given two linked lists representing two non-negative numbers.
+// The digits are stored in reverse order and each of their nodes contain a single digit.
+// Add the two numbers and return it as a linked list.
+//
+// Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+// Output: 7 -> 0 -> 8
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+	results := &ListNode{}
+	node := results
+	node1 := l1
+	node2 := l2
+
+	overten := false
+
+	for node1 != nil || node2 != nil {
+
+		tmp := 0
+
+		if node1 != nil {
+			tmp = tmp + node1.Val
+			node1 = node1.Next
+		}
+
+		if node2 != nil {
+			tmp = tmp + node2.Val
+			node2 = node2.Next
+		}
+		if overten {
+			tmp++
+		}
+
+		if tmp >= 10 {
+			overten = true
+			tmp -= 10
+		} else {
+			overten = false
+		}
+
+		node.Val = tmp
+
+		if node1 != nil || node2 != nil {
+			node.Next = &ListNode{}
+			node = node.Next
+		}
+	}
+
+	if overten {
+		node.Next = &ListNode{}
+		node = node.Next
+		node.Val = 1
+	}
+
+	return results
+}

Golang/longest-substring-without-repeating-characters.go

@@ -0,0 +1,34 @@
+package leetcode
+
+// Given a string, find the length of the longest substring without repeating characters.
+//
+// Examples:
+// Given "abcabcbb", the answer is "abc", which the length is 3.
+// Given "bbbbb", the answer is "b", with the length of 1.
+// Given "pwwkew", the answer is "wke", with the length of 3.
+// Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
+//
+func lengthOfLongestSubstring(s string) int {
+	hashmap := map[byte]int{}
+	max := 0
+	for i := range s {
+		_, ok := hashmap[s[i]]
+		if !ok {
+			hashmap[s[i]] = i
+			if len(hashmap) > max {
+				max = len(hashmap)
+			}
+		} else {
+			// remove repeated
+			oldI := hashmap[s[i]]
+			hashmap[s[i]] = i
+
+			for key, value := range hashmap {
+				if value < oldI {
+					delete(hashmap, key)
+				}
+			}
+		}
+	}
+	return max
+}

Golang/two-sum.go

@@ -0,0 +1,37 @@
+package leetcode
+
+import "sort"
+
+// Given an array of integers, return indices of the two numbers
+// such that they add up to a specific target.
+// You may assume that each input would have exactly one solution.
+//
+// Example:
+// Given nums = [2, 7, 11, 15], target = 9,
+// Because nums[0] + nums[1] = 2 + 7 = 9,
+// return [0, 1].
+func TwoSum(nums []int, target int) []int {
+
+	indexs := make([]int, 2)
+	hash := map[int]int{}
+
+	for i := range nums {
+		hash[target-nums[i]] = i
+	}
+
+	for i := range nums {
+		index, ok := hash[nums[i]]
+		if ok {
+			if i == index {
+				continue
+			}
+			indexs[0] = index
+			indexs[1] = i
+			sort.Ints(indexs)
+			break
+		}
+		continue
+	}
+
+	return indexs
+}

Golang/two-sum_test.go

@@ -0,0 +1,13 @@
+package leetcode
+
+import "testing"
+
+func Test_two_sum(t *testing.T) {
+
+	if result := TwoSum([]int{1, 3, 5}, 4); result[0] != 0 && result[1] != 1 {
+		t.Errorf("Error")
+	}
+	if result := TwoSum([]int{3, 1, 5}, 6); result[0] != 1 && result[1] != 2 {
+		t.Errorf("Error")
+	}
+}