一个方法团灭 nSum 问题

// 注意：java 代码由 chatGPT🤖 根据我的 cpp 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码还未经过力扣测试，仅供参考，如有疑惑，可以参照我写的 cpp 代码对比查看。

// 参数 nums 是长度为 n 的数组，target 是目标值
// 返回长度为 2 的数组，表示 nums 中恰好有两个元素的和为 target
public int[] twoSum(int[] nums, int target) {
    // 先对数组排序
    Arrays.sort(nums);
    // 左右指针
    int lo = 0, hi = nums.length - 1;
    while (lo < hi) {
        int sum = nums[lo] + nums[hi];
        // 根据 sum 和 target 的比较，移动左右指针
        if (sum < target) {
            lo++;
        } else if (sum > target) {
            hi--;
        } else if (sum == target) {
            return new int[]{nums[lo], nums[hi]};
        }
    }
    return new int[]{};
}

vector<int> twoSum(vector<int>& nums, int target) {
    // 先对数组排序
    sort(nums.begin(), nums.end());
    // 左右指针
    int lo = 0, hi = nums.size() - 1;
    while (lo < hi) {
        int sum = nums[lo] + nums[hi];
        // 根据 sum 和 target 的比较，移动左右指针
        if (sum < target) {
            lo++;
        } else if (sum > target) {
            hi--;
        } else if (sum == target) {
            return {nums[lo], nums[hi]};
        }
    }
    return {};
}

# 注意：python 代码由 chatGPT🤖 根据我的 cpp 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
# 本代码还未经过力扣测试，仅供参考，如有疑惑，可以参照我写的 cpp 代码对比查看。

def twoSum(nums: List[int], target: int) -> List[int]:
    # 先对数组排序
    nums.sort()
    # 左右指针
    lo, hi = 0, len(nums) - 1
    while lo < hi:
        sum = nums[lo] + nums[hi]
        # 根据 sum 和 target 的比较，移动左右指针
        if sum < target:
            lo += 1
        elif sum > target:
            hi -= 1
        elif sum == target:
            return [nums[lo], nums[hi]]
    return []

// 注意：go 代码由 chatGPT🤖 根据我的 cpp 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码还未经过力扣测试，仅供参考，如有疑惑，可以参照我写的 cpp 代码对比查看。

func twoSum(nums []int, target int) []int {
    // 先对数组排序
    sort.Ints(nums)
    // 左右指针
    lo := 0
    hi := len(nums) - 1
    for lo < hi {
        sum := nums[lo] + nums[hi]
        // 根据 sum 和 target 的比较，移动左右指针
        if sum < target {
            lo++
        } else if sum > target {
            hi--
        } else if sum == target {
            return []int{nums[lo], nums[hi]}
        }
    }
    return []int{}
}

// 注意：javascript 代码由 chatGPT🤖 根据我的 cpp 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码还未经过力扣测试，仅供参考，如有疑惑，可以参照我写的 cpp 代码对比查看。

var twoSum = function(nums, target) {
    // 先对数组排序
    nums.sort((a, b) => a - b);
    // 左右指针
    let lo = 0, hi = nums.length - 1;
    while (lo < hi) {
        let sum = nums[lo] + nums[hi];
        // 根据 sum 和 target 的比较，移动左右指针
        if (sum < target) {
            lo++;
        } else if (sum > target) {
            hi--;
        } else if (sum === target) {
            return [nums[lo], nums[hi]];
        }
    }
    return [];
};

// 注意：java 代码由 chatGPT🤖 根据我的 cpp 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码还未经过力扣测试，仅供参考，如有疑惑，可以参照我写的 cpp 代码对比查看。

public List<List<Integer>> twoSumTarget(List<Integer> nums, int target)

vector<vector<int>> twoSumTarget(vector<int>& nums, int target);

# 注意：python 代码由 chatGPT🤖 根据我的 cpp 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
# 本代码还未经过力扣测试，仅供参考，如有疑惑，可以参照我写的 cpp 代码对比查看。

def twoSumTarget(nums: List[int], target: int) -> List[List[int]]:

// 注意：go 代码由 chatGPT🤖 根据我的 cpp 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码还未经过力扣测试，仅供参考，如有疑惑，可以参照我写的 cpp 代码对比查看。

func twoSumTarget(nums []int, target int) [][]int {
    var result [][]int
    // code implementation here
    return result
}

// 注意：javascript 代码由 chatGPT🤖 根据我的 cpp 代码翻译，旨在帮助不同背景的读者理解算法逻辑。
// 本代码还未经过力扣测试，仅供参考，如有疑惑，可以参照我写的 cpp 代码对比查看。

var twoSumTarget = function(nums, target) {
    // code here
}