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

258. 各位相加-简单

题目描述：
给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。返回这个结果。

题解：
模拟方法，两层循环一层判断是否是个位数，一层计算各个位数的和。官方题解可以用数学方法直接计算，这个确实是不会

代码（Go）：

func addDigits(num int) int {
    for num > 9{
        temp := 0
        for num > 0{
            temp += num%10
            num = num/10
        }
        num = temp
    }
    return num
}

1160. 拼写单词-简单

题目描述：
给你一份『词汇表』（字符串数组） words 和一张『字母表』（字符串） chars。
假如你可以用 chars 中的『字母』（字符）拼写出 words 中的某个『单词』（字符串），那么我们就认为你掌握了这个单词。
注意：每次拼写（指拼写词汇表中的一个单词）时，chars 中的每个字母都只能用一次。
返回词汇表 words 中你掌握的所有单词的 长度之和。

题解：
哈希表。因为要查找字符串数组，所以每次都需要复制一遍哈希表，map不能直接复制，只能for循环遍历赋值。官方题解没有go语言版本，不知道这过程是否可以优化

代码（Go）：

func countCharacters(words []string, chars string) int {
    var dict = map[rune]int{}
    for _,v := range chars{
        if _,ok := dict[v];!ok{
            dict[v] = 1
        }else{
            dict[v]++
        }
    }
    re := 0
    flag := 1
    for _,s := range words{
        var temp = map[rune]int{}
        for i,v := range dict{
            temp[i] = v
        }
        for _,v := range s{
            if temp[v] > 0{
                temp[v]--
            }else{
                flag = 0
                break
            }
        }
        if flag == 1{
            re += len(s)
        }
        flag = 1
    }
    return re
}

1365. 有多少小于当前数字的数字-简单

题目描述：
给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。
换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。
以数组形式返回答案。

题解：
计数排序后遍历计数数组，记录每一个数比他小的个数，最后遍历原数组，在修改后的技术数组中取出比它小的数的个数

代码（Go）：

func smallerNumbersThanCurrent(nums []int) []int {
    arr := [101]int{}
    for _,v := range nums{
        arr[v]++
    }
    temp := 0
    for i,v := range arr{
        arr [i] = temp
        temp += v
    }
    for i,v := range nums{
        nums[i] = arr[v]
    }
    return nums
}

143. 重排链表-中等

题目描述：
给定一个单链表 L 的头节点 head ，单链表 L 表示为：
L0 → L1 → … → Ln - 1 → Ln
请将其重新排列后变为：
L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

题解：
这题我脑子抽了，我应该是在王道还是哪做过这个题，结果做的时候没想起来写了个递归，运行了504ms，时间复杂度拉满了属于是。一看到官方题解我一下就想起来了，这题正解应该是寻找中点，右侧反转，左右合并三步完成

代码（Go）：

//放个脑子抽了写的递归，虽然能通过但是时间击败5%
func reorderList(head *ListNode)  {
    p := head
    q := p.Next
    if q == nil || q.Next == nil{
        return
    }else{
        for q.Next != nil{
            p = p.Next
            q = q.Next
        }
        p.Next = nil
        q.Next = head.Next
        head.Next = q
        reorderList(q.Next)
    }
    return
}

总结

整体不是很难，中等题其实就是三个简单题合起来，就算没想到暴力递归也能过