1.給你單鏈表的頭節點 head ，請你反轉鏈表，并返回反轉后的鏈表。
示例1:
輸入：head = [1,2,3,4,5]
輸出：[5,4,3,2,1]

package main

import “fmt”

type ListNode struct {
Val int
Next *ListNode
}

func main() {
l1 := &ListNode{Val: 1}
l2 := &ListNode{Val: 2}
l3 := &ListNode{Val: 3}
l4 := &ListNode{Val: 4}
l5 := &ListNode{Val: 5}
l1.Next = l2
l2.Next = l3
l3.Next = l4
l4.Next = l5
newlist := reverseList(l1)
for newlist != nil {
fmt.Print(newlist.Val)
if newlist.Next != nil {
fmt.Print(“,”)
}
newlist = newlist.Next
}
fmt.Println()
}

func reverseList(head *ListNode) *ListNode {
if head == nil || head.Next == nil {
return head
}
var prev *ListNode
cur := head
for cur != nil {
cur.Next, prev, cur = prev, cur, cur.Next
}
return prev
}

2.給你一個整數數組 nums 和一個整數 k 。你需要找到 nums 中長度為 k 的 子序列 ，且這個子序列的 和最大 。
請你返回 任意 一個長度為 k 的整數子序列。
子序列 定義為從一個數組里刪除一些元素后，不改變剩下元素的順序得到的數組。
示例1:
輸入：nums = [2,1,3,3], k = 2
輸出：[3,3]
示例2:
輸入：nums = [-1,-2,3,4], k = 3
輸出：[-1,3,4]
示例3:
輸入：nums = [3,4,3,3], k = 2
輸出：[3,4]
package main

import (
“fmt”
“sort”
“strconv”
“strings”
)

func main() {
//nums := []int{2, 1, 3, 3}
//k := 2
nums := []int{-1, -2, 3, 4}
k := 3
newSlice := SearchMaxSlice(nums, k)
fmt.Println(newSlice)
}

func SearchMaxSlice(nums []int, k int) []int {
n := len(nums)
temp := make([]int, n)
copy(temp, nums)
sort.Slice(temp, func(i, j int) bool {
return temp[i] > temp[j]
})
newtemp := temp[:k]
newslice := []int{}
newslicestr := fmt.Sprint(newtemp)
for _, v := range nums {
if len(newslice) == k {
break
}
if strings.Contains(newslicestr, strconv.Itoa(v)) {
newslice = append(newslice, v)
}
}
return newslice
}

3.給你一個整數數組 nums 和一個整數 k ，請你統計并返回 該數組中和為 k 的子數組的個數 。
子數組是數組中元素的連續非空序列。
示例1:
輸入：nums = [1,1,1], k = 2
輸出：2
示例2:
輸入：nums = [1,2,3], k = 3
輸出：2

func main() {
//slic := []int{1, 1, 1}
slic := []int{1, 2, 3}
k := 3
fmt.Println(calSliceCount(slic, k))
}

func calSliceCount(nums []int, k int) int {
count := 0
for i := 0; i < len(nums); i++ {
sum := 0
for j := i; j < len(nums); j++ {
sum += nums[j]
if sum == k {
count++
}
}
}
return count
}