2017.6.5

Author: lifengliu

main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+
+)
+import (
+	"fmt"
+	"reflect"
+)
+
+func main() {
+	string := "abc"
+	fmt.Println(reflect.TypeOf(string[1]))
+}
+

question/Manacher's.markdown

@@ -0,0 +1,27 @@
+Algorithm Manacher's
+problem：给定一个字符串,找出字符串的最长回文子串
+算法思路：
+step1:预处理子字符串，解决回文子串长度奇偶问题
+该思路是中心检测法一个升级。所有的空隙位置（包括首尾）插入同样的符号（在字符串中没有出现过的，例如 #）,
+然后对处理过的字符串采用中心化检测法，取最大就得出我们想要的结果
+中心化检测法就是以字符串中的每一个字符为中心点，将其两侧的字符比较。但是如果不处理，就需要考虑其为偶数长度 
+e.g. "aba"这个可以用中心化检测，"baab"就不能用中心化检测了。
+
+处理之前：str1=abaaba 
+处理之后：T=#a#b#a#a#b#a#
+现在我们遍历str2中的每一个字符(包含#)，中心化检测他们的回文字符串
+e.g.T = # a # b # a # a # b # a #
+    P = 0 1 0 3 0 1 6 1 0 3 0 1 0  (P数组是处理之后每个字符串对应的回文串长度，有的博客是从1开始，我这里是从0开始，结果不用减一)
+    我们就以P[3]=3为例来解释。T[3]=b,开始中心化检测，T[2]=T[4]且T[1]=T[5],T[0]=T[6],所以P[3]=3
+现在目的很明确了，就是求P
+
+step2：求P数组过程：
+    确定两个变量
+            一个是在遍历每个字符串时候，记录之前的字符扫到了最右的位置(max-right)例如我们上面P[3]比起之前的最远，是6（注意不是7）,同时记录以此对应的字符下标max-id=3(从'b'扫到这里的)
+            max-right 和 max-id
+    遍历三大判断全过程：
+        for(int i=0;i<T.length;i++) 遍历字符串每个字符
+            step:判断当前字符的i是否小于或等于max-right。换句话说就是当前这个字符有没有被以前计算出来的回文数包括在内。
+                 如果小于：
+                      找出i关于当前max-id对称的点j,例如：例如i=5,max-id=3,j=1,然后我们要判断j被求出来的P[i]是否完全包含在max-id对应的回文串中
+                                                   

question/Q1.go

@@ -0,0 +1,24 @@
+package main
+import "fmt"
+
+//twoSum in leetcode question 1
+func twoSum(nums []int, target int) []int {
+	var result=make([]int,2)
+	var map1 =make(map[int]int)
+	for i,number := range nums{
+
+		if _,ok:=map1[target-number];ok {
+			result[1]=i
+			result[0]=map1[target-number]
+			return result
+		}
+		map1[number]=i
+	}
+	return result
+}
+
+func main(){
+	a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
+	b:=twoSum(a,17)
+	fmt.Println(b[0],b[1])
+}

question/Q11.go

@@ -0,0 +1,38 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := [3]int{1,2,1}
+	fmt.Println(maxArea(a[:]))
+}
+
+func maxArea(height []int) int {
+	length:= len(height)
+	left := 0
+	right := length-1
+	max :=0
+	for left<right {
+		max=maxInt(max,minInt(height[left],height[right])*(right-left))
+		if height[left]<height[right] {
+			left++
+		}else{
+			right--
+		}
+	}
+	return max
+}
+
+func maxInt(a,b int) int {
+	if a>b {
+		return a
+	}
+	return b
+}
+
+func minInt(a,b int) int {
+	if a>b {
+		return b
+	}
+	return a
+}

question/Q12.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+)
+
+func intToRoman(num int) string {
+	value := []int{1000,900,500,400,100,90,50,40,10,9,5,4,1}
+	str := []string{"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"}
+	var buffer bytes.Buffer
+	for k, v := range value {
+		for num>=v {
+			num-=v
+			buffer.WriteString(str[k])
+		}
+	}
+	return buffer.String()
+}
+
+func main() {
+	fmt.Println(intToRoman(1234))
+}

question/Q15.go

@@ -0,0 +1,109 @@
+package main
+
+import "fmt"
+
+func main() {
+	value := []int{-1,0,1,2,-1,-4}
+
+	fmt.Println(threeSum(value))
+}
+
+func threeSum(nums []int) [][]int {
+	if len(nums)<3{
+		return [][]int{}
+	}
+	var sli [][]int
+	var map1 =make(map[int]int)
+	quickSort(nums,0,len(nums)-1)
+	for i,v := range nums{
+		if v>0 {
+			break
+		}
+		if _,ok:=map1[v];ok {
+			continue
+		}
+		map1[v]=i
+		res:=findEr(nums,i+1,len(nums)-1,v)
+		if len(res)==0{
+			continue
+		}
+		for k,val := range res {
+			sli=append(sli,[]int{v,k,val})
+		}
+	}
+	return sli
+}
+
+func quickSort(arr []int, start int, end int) {
+
+	if len(arr)==0{
+		return
+	}
+
+	var key  int = arr[start]
+	var low  int = start
+	var high int = end
+
+	for {
+		for low < high {
+			if arr[high] < key {
+				arr[low] = arr[high]
+				break
+			}
+			high--
+		}
+		for low < high {
+			if arr[low] > key {
+				arr[high] = arr[low]
+				break
+			}
+			low++
+		}
+		if low >= high {
+			arr[low] = key
+			break
+		}
+	}
+	if low-1 > start {
+		quickSort(arr, start, low-1)
+	}
+	if high+1 < end {
+		quickSort(arr, high+1, end)
+	}
+}
+
+func findEr(arr []int,left,right,target int)map[int]int{
+	var map1 = make(map[int]int)
+	for left <right {
+		if arr[left]+arr[right]+target ==0 {
+			map1[arr[left]]=arr[right]
+			for left<right&&arr[left]==arr[left+1]{
+				left++
+			}
+			for left<right && arr[right]==arr[right-1]{
+				right--
+			}
+			left++
+			right--
+		}else if arr[left]+arr[right]+target<0{
+			left++
+		}else{
+			right--
+		}
+	}
+	return map1
+}
+
+func tSum(arr []int,left,right,target int)map[int]int {
+	var map1 = make(map[int]int)
+	var result = make(map[int]int)
+	var i int
+	for i = left; i < right+1; i++ {
+		if _, ok := map1[target - arr[i]]; ok {
+			result[target - arr[i]] = arr[i]
+		}
+		map1[arr[i]] = i
+	}
+	return result
+}
+

question/Q16.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"fmt"
+
+)
+
+func main() {
+	value := []int{-1,0,1,2,-1,-4,9}
+	quickSort(value,0,len(value)-1)
+	fmt.Println(value)
+}
+func quickSort(sortArray []int, left, right int) {
+	if left < right {
+		pos := partition(sortArray, left, right)
+		quickSort(sortArray, left, pos-1)
+		quickSort(sortArray, pos+1, right)
+	}
+}
+
+func partition(arr []int,left,right int)int{
+	if len(arr)==0{
+		return -1
+	}
+	pivot := arr[left]
+	for left<right {
+		for left<right && arr[right]>=arr[left]{
+			right--
+		}
+		if left<right {
+			arr[left]=arr[right]
+			left++
+		}
+		for left<right && arr[left]<=pivot{
+			left++
+		}
+		if left<right{
+			arr[right]=arr[left]
+			right--
+		}
+	}
+	arr[left]=pivot
+	return left
+}
+
+// Swap the position of a and b
+func swap(arr []int,a, b int) {
+	arr[a], arr[b] = arr[b], arr[a]
+}

question/Q19.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"fmt"
+
+)
+
+func main() {
+	a1:=ListNode{1,nil}
+
+	//result:=&a1
+	//1 2 3 4 5
+	res:=removeNthFromEnd(&a1,1)
+	for res!=nil {
+		fmt.Println(res.Val)
+		res=res.Next
+	}
+}
+type ListNode struct{
+	Val int
+	Next *ListNode
+}
+
+func removeNthFromEnd(head *ListNode, n int) *ListNode {
+	l1:=head
+	l2:=head
+	for l1 != nil{
+		l1=l1.Next
+		if n <0{
+			l2=l2.Next
+		}
+		n--
+	}
+	if n==0 {
+		head=head.Next
+	}else{
+		l2.Next=l2.Next.Next
+	}
+	return head
+}