从零开始的力扣刷题记录-第三十九天

228. 汇总区间-简单

题目描述：
给定一个 无重复元素 的 有序 整数数组 nums 。
返回 恰好覆盖数组中所有数字 的 最小有序 区间范围列表 。也就是说，nums 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个范围但不属于 nums 的数字 x 。
列表中的每个区间范围 [a,b] 应该按如下格式输出：
“a->b” ，如果 a != b
“a” ，如果 a == b

题解：
维护一个起点变量和终点变量，遍历数组时遇到的新元素如果不等于终点变量加一就将之前维护的起点到终点放入结果数组中

代码（Go）：

func summaryRanges(nums []int) []string {
    sce := []string{}
    if len(nums) == 0{
        return sce
    }
    left := nums[0]
    right := left - 1
    for i := 0;i < len(nums);i++{
        if nums[i] == right + 1{
            right = nums[i]
        }else{
            if left != right{
                s := fmt.Sprintf("%d->%d",left,right)
                sce = append(sce,s)
                left = nums[i]
                right = left
            }else{
                s := fmt.Sprintf("%d",left)
                sce = append(sce,s)
                left = nums[i]
                right = left
            }
        }
    }
    if left != right{
        s := fmt.Sprintf("%d->%d",left,right)
        sce = append(sce,s)
    }else{
        s := fmt.Sprintf("%d",left)
        sce = append(sce,s)
    }
    return sce
}

1431. 拥有最多糖果的孩子-简单

题目描述：
给你一个数组 candies 和一个整数 extraCandies ，其中 candies[i] 代表第 i 个孩子拥有的糖果数目。
对每一个孩子，检查是否存在一种方案，将额外的 extraCandies 个糖果分配给孩子们之后，此孩子有 最多 的糖果。注意，允许有多个孩子同时拥有 最多 的糖果数目。

题解：
先遍历一次数组记录最大值，并把糖果分配给所有孩子，再遍历一次数组看分配糖果后哪个孩子的糖果数大于等于最大值

代码（Go）：

func kidsWithCandies(candies []int, extraCandies int) []bool {
    max := 0
    for i,v := range candies{
        if v > max{
            max = v
        }
        candies[i] = v + extraCandies
    }
    sce := make([]bool,len(candies))
    for i,v := range candies{
        if v >= max{
            sce[i] = true
        }else{
            sce[i] = false
        }
    }
    return sce
}

637. 二叉树的层平均值-简单

题目描述：
给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

题解：
求层平均值直接层序遍历的同时记录每层的节点个数并把同层的节点值相加保存下来就可以了。官方题解的深度优先搜索和广度优先搜索的代码都比较复杂，感觉不如层序遍历

代码（Go）：

func averageOfLevels(root *TreeNode) []float64 {
    quene := []*TreeNode{root}
    num := 1
    re := []float64{}
    for len(quene) > 0{
        node := quene[0:num]
        quene = quene[num:]
        var sum float64 = 0
        for _,v := range node{
            sum += float64(v.Val)
            num--
            if v.Left != nil{
                quene = append(quene,v.Left)
                num++
            }
            if v.Right != nil{
                quene = append(quene,v.Right)
                num++
            }
        }
        re = append(re,sum/float64(len(node)))
    }
    return re
}

49. 字母异位词分组-中等

题目描述：
给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。

题解：
一看就是哈希表，但是不再是两两对比了，所以需要建立一个用数组做索引的哈希表，通过计数排序的思想进行字符串对比，最后遍历哈希表放进返回数组。一开始哈以为官方会有更好的办法，每有一种字母异位词就要建一个数组做索引占空间好大，结果官方也是这么做的。

代码（Go）：

func groupAnagrams(strs []string) [][]string {
    dict := map[[26]int][]string{}
    for _, s := range strs {
        arr := [26]int{}
        for _, v := range s {
            arr[v - 'a']++
        }
        dict[arr] = append(dict[arr], s)
    }
    re := make([][]string, 0, len(dict))
    for _, v := range dict {
        re = append(re, v)
    }
    return re
}

总结

这两天先捏一捏软柿子，从简单慢慢往难的过度，前两天被几道中等题迎头痛击