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

917.仅仅反转字母-简单

题目描述：
给你一个字符串 s ，根据下述规则反转字符串：
所有非英文字母保留在原有位置。
所有英文字母（小写或大写）位置反转。
返回反转后的 s 。

题解：
双指针遍历一遍，go语言字符串不允许修改，所以需要先建立一个字符切片

代码（Go）：

func reverseOnlyLetters(s string) string {
    sce := []byte(s)
    p,q := 0,len(s) - 1
    for p < q{
        for sce[p] < 'A' || sce[p] > 'z' || (sce[p] > 'Z' && sce[p] < 'a'){
            p++
            if p == len(s){
                return string(sce)
            }
        }
        for sce[q] < 'A' || sce[q] > 'z' || (sce[q] > 'Z' && sce[q] < 'a'){
            q--
            if q == -1{
                return string(sce)
            }
        }
        if p >= q{
            break
        }
        temp := sce[p]
        sce[p] = sce[q]
        sce[q] = temp
        p++
        q--
    }
    return string(sce)
}

680. 验证回文串 II-简单

题目描述：
给你一个字符串 s，最多 可以从中删除一个字符。
请你判断 s 是否能成为回文字符串：如果能，返回 true ；否则，返回 false 。

题解：
双指针判断是否为回文串，如果遇到不相等的字符则分为两种情况讨论，删除左侧字符或者右侧字符

代码（Go）：

func validPalindrome(s string) bool {
    p,q := 0,len(s) - 1
    for p < q{
        if s[p] == s[q]{
            p++
            q--
        }else{
            flag1, flag2 := true, true
            for i, j := p, q - 1; i < j; i, j = i + 1, j - 1 {
                if s[i] != s[j] {
                    flag1 = false
                    break
                }
            }
            for i, j := p + 1, q; i < j; i, j = i + 1, j - 1 {
                if s[i] != s[j] {
                    flag2 = false
                    break
                }
            }
            return flag1 || flag2
        }
    }
    return true
}

771. 宝石与石头-简单

题目描述：
给你一个字符串 jewels 代表石头中宝石的类型，另有一个字符串 stones 代表你拥有的石头。 stones 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
字母区分大小写，因此 “a” 和 “A” 是不同类型的石头。

题解：
经典的哈希表

代码（Go）：

func numJewelsInStones(jewels string, stones string) int {
    var dict = map[rune]int{}
    for _,v := range jewels{
        if _,ok := dict[v];!ok{
            dict[v] = 1
        }
    }
    num := 0
    for _,v := range stones{
        if _,ok := dict[v];ok{
            num++
        }
    }
    return num
}

18.四数之和-中等

题目描述：
给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

题解：
排序加双指针，其实和三数之和一模一样，就是多套了一层循环，为了降低时间复杂度，最里面的两层循环用双指针代替。优化一下还可以对循环做一下剪枝

代码（Go）：

func fourSum(nums []int, target int) (quadruplets [][]int) {
    sort.Ints(nums)
    n := len(nums)
    for i := 0; i < n-3 && nums[i]+nums[i+1]+nums[i+2]+nums[i+3] <= target; i++ {
        if i > 0 && nums[i] == nums[i-1] || nums[i]+nums[n-3]+nums[n-2]+nums[n-1] < target {
            continue
        }
        for j := i + 1; j < n-2 && nums[i]+nums[j]+nums[j+1]+nums[j+2] <= target; j++ {
            if j > i+1 && nums[j] == nums[j-1] || nums[i]+nums[j]+nums[n-2]+nums[n-1] < target {
                continue
            }
            for left, right := j+1, n-1; left < right; {
                if sum := nums[i] + nums[j] + nums[left] + nums[right]; sum == target {
                    quadruplets = append(quadruplets, []int{nums[i], nums[j], nums[left], nums[right]})
                    for left++; left < right && nums[left] == nums[left-1]; left++ {
                    }
                    for right--; left < right && nums[right] == nums[right+1]; right-- {
                    }
                } else if sum < target {
                    left++
                } else {
                    right--
                }
            }
        }
    }
    return
}

总结

今天的题目都是老套路，没什么新鲜的