T1

题目链接

题目描述：

给你一个下标从 0 开始的字符串数组 words 和两个整数：left 和 right 。

如果字符串以元音字母开头并以元音字母结尾，那么该字符串就是一个 元音字符串 ，其中元音字母是 'a'、'e'、'i'、'o'、'u' 。

返回 words[i] 是元音字符串的数目，其中 i 在闭区间 [left, right] 内。

题解思路：

暴力遍历字符串数组，直接查看前后两个字母是否是元音字母。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
func vowelStrings(words []string, left int, right int) int {
    res := 0
    mp := map[byte]bool{
        'a': true,
        'e': true,
        'i': true,
        'o': true,
        'u': true,
    }
    check := func(s string) bool {
        l := len(s)
        if mp[s[0]] && mp[s[l-1]]{
            return true
        }
        return false
    }

    for i := left; i <= right; i++ {
        if check(words[i]){
            res ++
        }
    }
    return res

}

T2

题目链接

题目描述：

给你一个下标从 0 开始的整数数组 nums 。你可以将 nums 中的元素按 任意顺序 重排（包括给定顺序）。

令 prefix 为一个数组，它包含了 nums 重新排列后的前缀和。换句话说，prefix[i] 是 nums 重新排列后下标从 0 到 i 的元素之和。nums 的 分数 是 prefix 数组中正整数的个数。

返回可以得到的最大分数。

题解思路：

排序后直接前缀和，查看大于0的个数就是结果

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func maxScore(nums []int) int {
    sort.Sort(sort.Reverse(sort.IntSlice(nums)))
    res := 0
    for i := 1; i < len(nums); i++ {
        nums[i] = nums[i - 1] + nums[i]
    }
    for _, a := range nums{
        if a > 0 {
            res++
        }
    }
    
    return res
}

T3

题目链接

题目描述：

给你一个下标从 0 开始的整数数组nums 。每次操作中，你可以：

  • 选择两个满足 0 <= i, j < nums.length 的不同下标 i 和 j 。
  • 选择一个非负整数 k ，满足 nums[i] 和 nums[j] 在二进制下的第 k 位（下标编号从 0 开始）是 1 。
  • 将 nums[i] 和 nums[j] 都减去 2k 。

如果一个子数组内执行上述操作若干次后，该子数组可以变成一个全为 0 的数组，那么我们称它是一个 美丽 的子数组。

请你返回数组 nums 中 美丽子数组 的数目。

子数组是一个数组中一段连续 非空 的元素序列。

题解思路：

  • 前缀异或和，之后用map记录前缀异或和一样的个数。（因为前缀异或和一样的就说明这段区间异或和为0）
  • 假如异或和为3的有n个，那就就说明有(n - 1) * n / 2个子区间异或和为0，通过这个公式计算结果
  • 还需要加上map中异或和为0的元素个数就是最终结果

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func beautifulSubarrays(nums []int) int64 {
    
    var res int64 = 0
    mp := make(map[int]int)
    mp[nums[0]] = mp[nums[0]] + 1
    for i := 1; i < len(nums); i++ {
        nums[i] = nums[i] ^ nums[i - 1]
        mp[nums[i]] = mp[nums[i]] + 1
    }
  
    for _, v := range mp {
        var x int64 = int64(v)
        res = res + (x * (x - 1)) / 2
    }
    res = res + int64(mp[0])
    return res
}

T4

题目链接

题目描述：

你有一台电脑，它可以 同时 运行无数个任务。给你一个二维整数数组 tasks ，其中 tasks[i] = [starti, endi, durationi] 表示第 i 个任务需要在 闭区间 时间段 [starti, endi] 内运行 durationi 个整数时间点（但不需要连续）。

当电脑需要运行任务时，你可以打开电脑，如果空闲时，你可以将电脑关闭。

请你返回完成所有任务的情况下，电脑最少需要运行多少秒。

题解思路：

贪心：按照结束时间排序，并且按照优先靠右节点运行的方式。

用一个额外的数组，记录这个时间点是否被占用，（此题核心思想就是被占用的时间点最少，也就是重复覆盖的时间多）

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
func findMinimumTime(tasks [][]int) int {
    sort.Slice(tasks, func(i, j int)bool{return tasks[i][1] < tasks[j][1]})
    st := [2001]bool{}
    res := 0
    for _, task := range tasks {
        start, end, d := task[0], task[1], task[2]
        for _, v := range st[start : end + 1] {
            if v {
                d --    // 被覆盖掉
            }
        }
        for i := end; d > 0; i-- {
            if !st[i] {
                st[i] = true
                d --
                res ++
            }
        }
    }
    return res
}