update all

easy/189.go

@@ -6,6 +6,7 @@ import (
 
 func rotate1st(nums []int, k int) {
 	n := len(nums)
+	k %= n
 	tmp := append(nums[n-k:], nums[:n-k]...)
 	copy(nums, tmp)
 }
@@ -22,6 +23,7 @@ func rotate2nd(nums []int, k int) {
 
 func rotate3rd(nums []int, k int) {
 	n := len(nums)
+	k %= n
 	// [1 2 3] -> [3 2 1]
 	for i, j := 0, n-k-1; i < j; i, j = i+1, j-1 {
 		nums[i], nums[j] = nums[j], nums[i]

easy/190.js

@@ -0,0 +1,36 @@
+/**
+ * @param {number} n - a positive integer
+ * @return {number} - a positive integer
+ */
+var reverseBitsOld = function(n) {
+    let res = 0
+    let last
+    for (let i = 0; i < 32; i++) {
+        last = n & 1
+        n >>= 1
+        res <<= 1
+        res += last
+    }
+    return res >>> 0
+};
+
+// [note] in js, signed -> unsigned: n >>> 0
+var reverseBits = function(n) {  
+    for (let i = 0, j = 31; i <= j; i++, j--) {
+        let bit = (1 << i & n) >>> i ^ (1 << j & n) >>> j
+        n ^= bit << j
+        n ^= bit << i
+    }
+    return n >>> 0
+};
+
+function __main__() {
+    console.log(reverseBits(4294967295))
+    console.log(reverseBits(43261596))
+    console.log(reverseBits(1))
+    console.log(reverseBitsOld(4294967295))
+    console.log(reverseBitsOld(43261596))
+    console.log(reverseBitsOld(1))
+}
+
+__main__()

easy/191.js

@@ -0,0 +1,21 @@
+/**
+ * @param {number} n - a positive integer
+ * @return {number}
+ */
+var hammingWeightOld = function(n) {
+    let res = 0
+    for (let i = 0; i < 32; i++, res += n & 1, n >>= 1) {}
+    return res
+};
+
+// simple solution using build-in
+var hammingWeight = function(n) {
+    return (n).toString(2).replace(/0/g, '').length;
+};
+
+function __main__() {
+    console.log(hammingWeight(0xFFFFFFFF))
+    console.log(hammingWeightOld(0xFFFFFFFF))
+}
+
+__main__()

easy/198.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"fmt"
+)
+
+func maxInt(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+// DP? try to understand
+func rob(nums []int) int {
+	odd, even := 0, 0
+	for i := 0; i < len(nums); i++ {
+		// if idx is odd
+		if i&1 == 1 {
+			// rob this store (+nums[i]), or not (even)
+			odd = maxInt(odd+nums[i], even)
+		} else {
+			// rob this store (+nums[i]), or not (odd)
+			even = maxInt(even+nums[i], odd)
+		}
+	}
+	return maxInt(odd, even)
+}
+
+func main() {
+	arr := []int{1, 2, 435, 6543, 31, 43, 543, 21, 532}
+	fmt.Println(rob(arr))
+}

hard/32.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"fmt"
+)
+
+// 穷举
+func longestValidParenthesesOld(s string) int {
+	pair := 0
+	for i := 0; i < len(s); i++ {
+		left, right := 0, 0
+		for j := i; j < len(s); j++ {
+			if s[j] == '(' {
+				left++
+			} else {
+				right++
+			}
+			if right > left {
+				break
+			}
+			if left == right && left > pair {
+				pair = left
+			}
+		}
+	}
+	return pair * 2
+}
+
+func maxInt(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+func longestValidParentheses(s string) int {
+	stack := []int{}
+	// max: longest length, beg: idx of last ')' before current stack
+	max, beg := 0, -1
+	for i := 0; i < len(s); i++ {
+		if s[i] == '(' {
+			stack = append(stack, i)
+		} else if s[i] == ')' {
+			if len(stack) > 0 {
+				// pop last '('
+				stack = stack[:len(stack)-1]
+			} else {
+				beg = i
+				continue
+			}
+			if len(stack) == 0 {
+				// curr idx is the end of curr seq
+				max = maxInt(max, i-beg)
+			} else {
+				// top of stack is the beg of curr seq
+				max = maxInt(max, i-stack[len(stack)-1])
+			}
+		}
+	}
+	return max
+}
+
+func main() {
+	fmt.Println(longestValidParentheses("("))
+	fmt.Println(longestValidParentheses("()()("))
+	fmt.Println(longestValidParentheses("()(((()(()(((()(()())))(()"))
+}

medium/11.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"fmt"
+)
+
+func minInt(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+// 穷举
+func maxAreaOld(height []int) int {
+	n := len(height)
+	max := 0
+	for left := 0; left < n-1; left++ {
+		for right := 1; right < n; right++ {
+			tmp := (right - left) * minInt(height[left], height[right])
+			if tmp > max {
+				max = tmp
+			}
+		}
+	}
+	return max
+}
+
+// DP?
+func maxArea(height []int) int {
+	n := len(height)
+	l, r := 0, n-1
+	max := 0
+	for l < r {
+		hl, hr := height[l], height[r]
+		tmp := (r - l) * minInt(hl, hr)
+		if tmp > max {
+			max = tmp
+		}
+		if hl < hr {
+			for ; l < r && height[l] <= hl; l++ {
+			}
+		} else {
+			for ; l < r && height[r] <= hr; r-- {
+			}
+		}
+	}
+	return max
+}
+
+func main() {
+	arr := []int{1, 2, 4, 54, 6, 54}
+	fmt.Println(maxArea(arr))
+}

medium/15.go

@@ -0,0 +1,71 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+)
+
+func twoSum(nums []int, target int) [][]int {
+	n := len(nums)
+	l, r := 0, n-1
+	res := make([][]int, 0)
+	for l < r {
+		ln, rn := nums[l], nums[r]
+		sum := ln + rn
+		if sum < target {
+			for ; l < r && nums[l] == ln; l++ {
+			}
+		} else if sum > target {
+			for ; l < r && nums[r] == rn; r-- {
+			}
+		} else {
+			res = append(res, []int{ln, rn})
+			for ; l < r && nums[l] == ln; l++ {
+			}
+		}
+	}
+	return res
+}
+
+func threeSum(nums []int) [][]int {
+	if len(nums) < 3 {
+		return [][]int{}
+	}
+	sort.Ints(nums)
+	res := make([][]int, 0)
+	for a := 0; a < len(nums)-2; a++ {
+		if a > 0 && nums[a] == nums[a-1] {
+			continue
+		}
+		// the same as twoSum: target -> -nums[a], nums -> nums[a+1:]
+		// one or more or none solutions
+		b, c := a+1, len(nums)-1
+		for b < c {
+			nb, nc := nums[b], nums[c]
+			sum := nums[a] + nb + nc
+			if sum < 0 {
+				b++
+			} else if sum > 0 {
+				c--
+			} else {
+				res = append(res, []int{nums[a], nb, nc})
+				for ; b < c && nums[b] == nb; b++ {
+				}
+				for ; b < c && nums[c] == nc; c-- {
+				}
+			}
+		}
+	}
+	return res
+}
+
+func main() {
+	a1 := []int{-1, 0, 1, 2, -1, -4}
+	fmt.Println(threeSum(a1))
+
+	a2 := []int{-1, 0, -4}
+	fmt.Println(threeSum(a2))
+
+	a3 := []int{0, 0, 0}
+	fmt.Println(threeSum(a3))
+}

medium/16.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+)
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+// same as three sum
+func threeSumClosest(nums []int, target int) int {
+	sort.Ints(nums)
+	min := 1<<31 - 1
+	res := 0
+	for a := 0; a < len(nums)-2; a++ {
+		// do NOT skip duplicated numbers!
+		// [1 1 1 0], 100 -(skip 1)-> [1 1 0] 100 -> 2, WA
+		b, c := a+1, len(nums)-1
+		for b < c {
+			sum := nums[a] + nums[b] + nums[c]
+			if abs(sum-target) < min {
+				res = sum
+				min = abs(sum - target)
+			}
+			if sum < target {
+				b++
+			} else if sum > target {
+				c--
+			} else {
+				return sum
+			}
+		}
+	}
+	return res
+}
+
+func main() {
+	a1 := []int{-1, 0, 1, 2, -1, -4}
+	fmt.Println(threeSumClosest(a1, 0))
+
+	a2 := []int{-1, 0, -4}
+	fmt.Println(threeSumClosest(a2, 0))
+
+	a3 := []int{1, 1, 1, 0}
+	fmt.Println(threeSumClosest(a3, 100))
+}

medium/17.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"fmt"
+)
+
+var mBtn = map[byte][]string{
+	'2': {"a", "b", "c"},
+	'3': {"d", "e", "f"},
+	'4': {"g", "h", "i"},
+	'5': {"j", "k", "l"},
+	'6': {"m", "n", "o"},
+	'7': {"p", "q", "r", "s"},
+	'8': {"t", "u", "v"},
+	'9': {"w", "x", "y", "z"},
+}
+
+func letterCombinationsIter(digits string, last []string) []string {
+	if len(digits) == 0 {
+		return last
+	}
+	res := make([]string, 0)
+	char := mBtn[digits[0]]
+	for _, v := range last {
+		for _, c := range char {
+			res = append(res, v+c)
+		}
+	}
+	return letterCombinationsIter(digits[1:], res)
+}
+
+func letterCombinations(digits string) []string {
+	if len(digits) == 0 {
+		return []string{}
+	}
+	return letterCombinationsIter(digits[1:], mBtn[digits[0]])
+}
+
+func main() {
+	fmt.Println(letterCombinations("23"))
+	fmt.Println(letterCombinations("234"))
+}

medium/18.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+)
+
+func threeSum(nums []int, target int) [][]int {
+	if len(nums) < 3 {
+		return [][]int{}
+	}
+	sort.Ints(nums)
+	res := make([][]int, 0)
+	for a := 0; a < len(nums)-2; a++ {
+		if a > 0 && nums[a] == nums[a-1] {
+			continue
+		}
+		// the same as twoSum: target -> -nums[a], nums -> nums[a+1:]
+		// one or more or none solutions
+		b, c := a+1, len(nums)-1
+		for b < c {
+			nb, nc := nums[b], nums[c]
+			sum := nums[a] + nb + nc
+			if sum < target {
+				b++
+			} else if sum > target {
+				c--
+			} else {
+				res = append(res, []int{nums[a], nb, nc})
+				for ; b < c && nums[b] == nb; b++ {
+				}
+				for ; b < c && nums[c] == nc; c-- {
+				}
+			}
+		}
+	}
+	return res
+}
+
+func fourSum(nums []int, target int) [][]int {
+	sort.Ints(nums)
+	res := make([][]int, 0)
+	for i := 0; i < len(nums)-3; i++ {
+		if i > 0 && nums[i] == nums[i-1] {
+			continue
+		}
+		tmp := threeSum(nums[i+1:], target-nums[i])
+		for _, v := range tmp {
+			res = append(res, append([]int{nums[i]}, v...))
+		}
+	}
+	return res
+}
+
+func main() {
+	a1 := []int{1, 0, -1, 0, -2, 2}
+	fmt.Println(fourSum(a1, 0))
+}

medium/19.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"fmt"
+)
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func list2str(head *ListNode) string {
+	curr := head
+	str := make([]rune, 0)
+	for curr != nil {
+		str = append(str, rune(curr.Val+'0'))
+		curr = curr.Next
+	}
+	return string(str)
+}
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func removeNthFromEnd(head *ListNode, n int) *ListNode {
+	fast, slow := head, head
+	for i := 0; i < n; i++ {
+		fast = fast.Next
+	}
+	if fast == nil {
+		return slow.Next
+	}
+	for fast.Next != nil {
+		fast = fast.Next
+		slow = slow.Next
+	}
+	slow.Next = slow.Next.Next
+	return head
+}
+
+func main() {
+	l15 := ListNode{5, nil}
+	l14 := ListNode{4, &l15}
+	l13 := ListNode{3, &l14}
+	l12 := ListNode{2, &l13}
+	l1 := &ListNode{1, &l12}
+	fmt.Println(list2str(removeNthFromEnd(l1, 2)))
+	l22 := ListNode{2, nil}
+	l2 := &ListNode{1, &l22}
+	fmt.Println(list2str(removeNthFromEnd(l2, 2)))
+}

medium/2.go

@@ -19,6 +19,31 @@ func list2str(head *ListNode) string {
 	return string(str)
 }
 
+func list2int(head *ListNode) int64 {
+	beg := head
+	res := int64(0)
+	for i := 1; beg != nil; i *= 10 {
+		res += int64(beg.Val * i)
+		beg = beg.Next
+	}
+	return res
+}
+
+func int2list(num int64) *ListNode {
+	head := &ListNode{int(num % 10), nil}
+	num /= 10
+	for tail := head; num != 0; num /= 10 {
+		tail.Next = &ListNode{int(num % 10), nil}
+		tail = tail.Next
+	}
+	return head
+}
+
+// will overflow
+func addTwoNumbersOld(l1 *ListNode, l2 *ListNode) *ListNode {
+	return int2list(list2int(l1) + list2int(l2))
+}
+
 /**
  * Definition for singly-linked list.
  * type ListNode struct {
@@ -67,31 +92,6 @@ func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
 	return head
 }
 
-func list2int(head *ListNode) int64 {
-	beg := head
-	res := int64(0)
-	for i := 1; beg != nil; i *= 10 {
-		res += int64(beg.Val * i)
-		beg = beg.Next
-	}
-	return res
-}
-
-func int2list(num int64) *ListNode {
-	head := &ListNode{int(num % 10), nil}
-	num /= 10
-	for tail := head; num != 0; num /= 10 {
-		tail.Next = &ListNode{int(num % 10), nil}
-		tail = tail.Next
-	}
-	return head
-}
-
-// will overflow
-func addTwoNumbersOld(l1 *ListNode, l2 *ListNode) *ListNode {
-	return int2list(list2int(l1) + list2int(l2))
-}
-
 func main() {
 	l13 := ListNode{3, nil}
 	l12 := ListNode{2, &l13}

medium/22.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+)
+
+func generateParenthesisIter(last string, left, right, goal int, res *[]string) {
+	if right == goal {
+		*res = append(*res, last)
+		return
+	}
+	if left < goal {
+		generateParenthesisIter(last+"(", left+1, right, goal, res)
+	}
+	if right < left {
+		generateParenthesisIter(last+")", left, right+1, goal, res)
+	}
+}
+
+func generateParenthesis(n int) []string {
+	res := &[]string{}
+	generateParenthesisIter("", 0, 0, n, res)
+	return *res
+}
+
+func main() {
+	fmt.Println(generateParenthesis(3))
+}

medium/24.go

@@ -0,0 +1,85 @@
+package main
+
+import "fmt"
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func list2str(head *ListNode) string {
+	curr := head
+	str := make([]rune, 0)
+	for curr != nil {
+		str = append(str, rune(curr.Val+'0'))
+		curr = curr.Next
+	}
+	return string(str)
+}
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+// before -> curr -> curr.Next -> after
+func swapPairsOld(head *ListNode) *ListNode {
+	if head == nil || head.Next == nil {
+		return head
+	}
+	// initialize before, curr, after
+	before := &ListNode{0, head}
+	curr := head
+	after := curr.Next.Next
+	// swap node
+	before.Next = curr.Next
+	curr.Next.Next = curr
+	curr.Next = after
+	// head of result
+	res := before.Next
+	for after != nil && after.Next != nil {
+		// move ptr
+		before = curr
+		curr = after
+		after = after.Next.Next
+		// swap node
+		before.Next = curr.Next
+		curr.Next.Next = curr
+		curr.Next = after
+	}
+	return res
+}
+
+func swapPairs(head *ListNode) *ListNode {
+	dummy := ListNode{0, head}
+	curr := &dummy
+	for curr.Next != nil && curr.Next.Next != nil {
+		first, second := curr.Next, curr.Next.Next
+		// swap node
+		first.Next = second.Next
+		second.Next = first
+		curr.Next = second
+		// move forward
+		curr = curr.Next.Next
+	}
+	return dummy.Next
+}
+
+func main() {
+	l15 := ListNode{5, nil}
+	l14 := ListNode{4, &l15}
+	l13 := ListNode{3, &l14}
+	l12 := ListNode{2, &l13}
+	l1 := &ListNode{1, &l12}
+	fmt.Println(list2str(swapPairs(l1)))
+	l22 := ListNode{2, nil}
+	l2 := &ListNode{1, &l22}
+	fmt.Println(list2str(swapPairs(l2)))
+	l33 := ListNode{3, nil}
+	l32 := ListNode{2, &l33}
+	l3 := &ListNode{1, &l32}
+	fmt.Println(list2str(swapPairs(l3)))
+	fmt.Println(list2str(swapPairs(&ListNode{1, nil})))
+}

medium/29.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+// time out
+func divideOld(dividend int, divisor int) int {
+	if divisor == 0 {
+		return math.MaxInt32
+	}
+	var cnt, incr int64 = 0, 1
+	if (dividend&(1<<32))^(divisor&(1<<32)) != 0 {
+		incr = -1
+	}
+	dividend, divisor = abs(dividend), abs(divisor)
+	for dividend >= divisor {
+		dividend -= divisor
+		cnt += incr
+	}
+	if cnt < math.MinInt32 || cnt > math.MaxInt32 {
+		return math.MaxInt32
+	}
+	return int(cnt)
+}
+
+func divide(dividend int, divisor int) int {
+	sign := 1
+	// 判断同号、异号
+	if (dividend>>31)^(divisor>>31) != 0 {
+		sign = -1
+	}
+	dividend, divisor = abs(dividend), abs(divisor)
+	res := 0
+	// x/y: x -= y * 2^31, res += 2^31, x -= y * 2^30, res += 2^30, ...
+	for i := uint(32); i > 0; i-- {
+		if divisor<<(i-1) > dividend {
+			continue
+		}
+		dividend -= divisor << (i - 1)
+		res += 1 << (i - 1)
+	}
+	res *= sign
+	// overflow
+	if res < math.MinInt32 || res > math.MaxInt32 {
+		return math.MaxInt32
+	}
+	return res
+}
+
+func main() {
+	fmt.Println(divide(-1, 1))
+	fmt.Println(divide(-1, -1))
+	fmt.Println(divide(-1<<31, -1))
+	fmt.Println(divide(1, 1))
+	fmt.Println(divide(535, 1))
+}

medium/31.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+)
+
+// “字典序”
+func nextPermutation(nums []int) {
+	if len(nums) < 2 {
+		return
+	}
+	// rfind first num descended 'ni'
+	// 346987521 -> 34 '6' 987521
+	i := len(nums) - 2
+	for ; i >= 0 && nums[i] >= nums[i+1]; i-- {
+	}
+	if i != -1 {
+		// find the last num 'nj' which is larger than 'ni'
+		// swap 'nj', 'ni'
+		// 34 '6' 987521 -> 34 '6' 98 '7' 521 -> 34 '7' 98 '6' 521
+		j := i + 1
+		for ; j+1 < len(nums) && nums[j+1] > nums[i]; j++ {
+		}
+		nums[i], nums[j] = nums[j], nums[i]
+	}
+	// reverse the sequence after pos 'i'
+	// 34 '7' '986521' -> 34 '7' '125689'
+	for l, r := i+1, len(nums)-1; l < r; l, r = l+1, r-1 {
+		nums[l], nums[r] = nums[r], nums[l]
+	}
+}
+
+func main() {
+	a1 := []int{1, 2, 3}
+	a2 := []int{3, 2, 1}
+	a3 := []int{2, 3, 1}
+	a4 := []int{1, 2, 2, 1}
+	nextPermutation(a1)
+	nextPermutation(a2)
+	nextPermutation(a3)
+	nextPermutation(a4)
+	fmt.Println(a1)
+	fmt.Println(a2)
+	fmt.Println(a3)
+	fmt.Println(a4)
+}

medium/33.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"fmt"
+)
+
+func searchOld(nums []int, target int) int {
+	for i, v := range nums {
+		if v == target {
+			return i
+		}
+	}
+	return -1
+}
+
+func search(nums []int, target int) int {
+	beg, end := 0, len(nums)-1
+	mid := -1
+	// find the smallest one in nums
+	for beg < end {
+		mid = (beg + end) / 2
+		if nums[mid] > nums[end] {
+			beg = mid + 1
+		} else {
+			end = mid
+		}
+	}
+	if mid == -1 || target == nums[mid] {
+		return mid
+	}
+	// judge which area to search
+	if target > nums[len(nums)-1] {
+		beg, end = 0, mid-1
+	} else {
+		beg, end = mid+1, len(nums)-1
+	}
+	// binary search
+	for beg <= end {
+		mid = (beg + end) / 2
+		if target > nums[mid] {
+			beg = mid + 1
+		} else if target < nums[mid] {
+			end = mid - 1
+		} else {
+			return mid
+		}
+	}
+	return -1
+}
+
+func main() {
+	a1 := []int{4, 5, 6, 0, 1, 2, 3}
+	a2 := []int{1, 3}
+	fmt.Println(search(a1, 6))
+	fmt.Println(search(a2, 3))
+}

medium/34.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"fmt"
+)
+
+// important
+func searchRange(nums []int, target int) []int {
+	beg, end := 0, len(nums)-1
+	res := []int{-1, -1}
+	// search left
+	for beg < end {
+		mid := (beg + end) / 2
+		if target > nums[mid] {
+			beg = mid + 1
+		} else {
+			end = mid
+		}
+	}
+	if end == -1 || nums[beg] != target {
+		return res
+	}
+	res[0] = beg
+	end = len(nums) - 1
+	// search right
+	for beg < end {
+		mid := (beg+end)/2 + 1 // notice: if mid == i, will loop forever
+		if target < nums[mid] {
+			end = mid - 1
+		} else {
+			beg = mid
+		}
+	}
+	res[1] = end
+	return res
+}
+
+func main() {
+	a1 := []int{1, 2, 3, 4, 4, 4, 5, 6, 7, 8, 9, 10}
+	fmt.Println(searchRange(a1, 4))
+	fmt.Println(searchRange(a1, 5))
+	fmt.Println(searchRange(a1, 11))
+	fmt.Println(searchRange(a1, 1))
+	fmt.Println(searchRange(a1, 10))
+	a2 := []int{5, 7, 7, 8, 8, 10}
+	fmt.Println(searchRange(a2, 8))
+	fmt.Println(searchRange([]int{}, 9))
+}

medium/5.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"fmt"
+)
+
+func longestPalindrome(s string) string {
+	n := len(s)
+	if n < 2 {
+		return s
+	}
+	maxBeg, maxEnd := 0, -1
+	// 暴力穷举
+	for beg := 0; beg < n; beg++ {
+		for end := beg; end < n; end++ {
+			i := 0
+			for ; end-beg > maxEnd-maxBeg && i <= end-beg; i++ {
+				if s[beg+i] != s[end-i] {
+					break
+				}
+			}
+			if i == end-beg+1 {
+				maxBeg = beg
+				maxEnd = end
+			}
+		}
+	}
+	return s[maxBeg : maxEnd+1]
+}
+
+func main() {
+	fmt.Println(longestPalindrome("ASDFDSAASBUGAYFUYFSDG"))
+	fmt.Println(longestPalindrome("A"))
+	fmt.Println(longestPalindrome(""))
+	fmt.Println(longestPalindrome("gigiudhfafhsaoifhoifaochasiofueosanfklf"))
+}

medium/6.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"fmt"
+)
+
+func convert(s string, numRows int) string {
+	n := len(s)
+	if n < 3 || numRows == 1 {
+		return s
+	}
+	cycle := numRows*2 - 2
+	arr := make([][]rune, numRows)
+	for i, v := range s {
+		idx := i % cycle
+		if idx < numRows {
+			arr[idx] = append(arr[idx], v)
+		} else {
+			arr[(numRows-1)*2-idx] = append(arr[(numRows-1)*2-idx], v)
+		}
+	}
+	res := make([]rune, 0)
+	for _, v := range arr {
+		res = append(res, v...)
+	}
+	return string(res)
+}
+
+func main() {
+	fmt.Println(convert("PAYPALISHIRING", 3))
+	fmt.Println(convert("ABCDE", 4))
+	fmt.Println("PAHNAPLSIIGYIR")
+}

medium/8.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func myAtoi(str string) int {
+	str = strings.TrimSpace(str)
+	fmt.Println(str)
+	return 0
+}
+
+func main() {
+	myAtoi("   -0.1    ")
+}