Week5

最接近的三数之和

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例 1：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
示例 2：

输入：nums = [0,0,0], target = 1
输出：0

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/3sum-closest
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

func threeSumClosest(nums []int, target int) int {
    
    sort.Ints(nums)
    var (
        n = len(nums)
        best = math.MaxInt32
    )

    // 根据差值的绝对值来更新答案
    update := func(cur int) {
    
        if abs(cur - target) < abs(best - target) {
    
            best = cur
        }
    }

    // 枚举 a
    for i := 0; i < n; i++ {
    
        // 保证和上一次枚举的元素不相等
        if i > 0 && nums[i] == nums[i-1] {
    
            continue
        }
        // 使用双指针枚举 b 和 c
        j, k := i + 1, n - 1
        for j < k {
    
            sum := nums[i] + nums[j] + nums[k]
            // 如果和为 target 直接返回答案
            if sum == target {
    
                return target
            }
            update(sum)
            if sum > target {
    
                // 如果和大于 target，移动 c 对应的指针
                k0 := k - 1
                // 移动到下一个不相等的元素
                for j < k0 && nums[k0] == nums[k] {
    
                    k0--
                } 
                k = k0
            } else {
    
                // 如果和小于 target，移动 b 对应的指针
                j0 := j + 1
                // 移动到下一个不相等的元素
                for j0 < k && nums[j0] == nums[j] {
    
                    j0++
                }
                j = j0
            }
        }
    }
    return best
}

func abs(x int) int {
    
    if x < 0 {
    
        return -1 * x
    }
    return x
}

电话号码的字母组合

var phoneMap map[string]string = map[string]string{
    
    "2": "abc",
    "3": "def",
    "4": "ghi",
    "5": "jkl",
    "6": "mno",
    "7": "pqrs",
    "8": "tuv",
    "9": "wxyz",
}

var combinations []string

func letterCombinations(digits string) []string {
    
    if len(digits) == 0 {
    
        return []string{
    }
    }
    combinations = []string{
    }
    backtrack(digits, 0, "")
    return combinations
}

func backtrack(digits string, index int, combination string) {
    
    if index == len(digits) {
    
        combinations = append(combinations, combination)
    } else {
    
        digit := string(digits[index])
        letters := phoneMap[digit]
        lettersCount := len(letters)
        for i := 0; i < lettersCount; i++ {
    
            backtrack(digits, index + 1, combination + string(letters[i]))
        }
    }
}

四数之和

给你一个由 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
你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/4sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

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
}

两数相加

func addTwoNumbers(l1, l2 *ListNode) (head *ListNode) {
    
    var tail *ListNode
    carry := 0
    for l1 != nil || l2 != nil {
    
        n1, n2 := 0, 0
        if l1 != nil {
    
            n1 = l1.Val
            l1 = l1.Next
        }
        if l2 != nil {
    
            n2 = l2.Val
            l2 = l2.Next
        }
        sum := n1 + n2 + carry
        sum, carry = sum%10, sum/10
        if head == nil {
    
            head = &ListNode{
    Val: sum}
            tail = head
        } else {
    
            tail.Next = &ListNode{
    Val: sum}
            tail = tail.Next
        }
    }
    if carry > 0 {
    
        tail.Next = &ListNode{
    Val: carry}
    }
    return
}