Pair with a given sum in a sorted array

def pair_sum(nums, target):
    lo, hi = 0, len(nums) - 1
    while lo < hi:
        total = nums[lo] + nums[hi]
        if total == target:
            return [lo, hi]
        if total < target:
            lo += 1          # nums[lo] is too small to pair with anything left
        else:
            hi -= 1          # nums[hi] is too large to pair with anything left
    return []

#include <vector>

std::vector<int> solve(const std::vector<int>& nums, long long target) {
    int lo = 0, hi = static_cast<int>(nums.size()) - 1;
    while (lo < hi) {
        long long total = static_cast<long long>(nums[lo]) + nums[hi];   // avoid 32-bit overflow
        if (total == target) return {lo, hi};
        if (total < target) ++lo;
        else --hi;
    }
    return {};
}

import java.util.*;

class Solution {
    public int[] pairSum(int[] nums, long target) {
        int lo = 0, hi = nums.length - 1;
        while (lo < hi) {
            long total = (long) nums[lo] + nums[hi];   // avoid 32-bit overflow
            if (total == target) return new int[]{lo, hi};
            if (total < target) lo++;
            else hi--;
        }
        return new int[0];
    }
}

function pairSum(nums, target) {
  let lo = 0, hi = nums.length - 1;
  while (lo < hi) {
    const total = nums[lo] + nums[hi];
    if (total === target) return [lo, hi];
    if (total < target) lo++;          // nums[lo] cannot be in the answer
    else hi--;                          // nums[hi] cannot be in the answer
  }
  return [];
}

fn solve(nums: &[i64], target: i64) -> Option<(usize, usize)> {
    let (mut lo, mut hi) = (0usize, nums.len() - 1);
    while lo < hi {
        let total = nums[lo] + nums[hi];
        match total.cmp(&target) {
            std::cmp::Ordering::Equal => return Some((lo, hi)),
            std::cmp::Ordering::Less => lo += 1,
            std::cmp::Ordering::Greater => hi -= 1,
        }
    }
    None
}

import Data.Array

-- Indices from both ends; the array gives O(1) access by index.
solve :: [Int] -> Int -> Maybe (Int, Int)
solve xs target = go 0 (n - 1)
  where
    n   = length xs
    arr = listArray (0, n - 1) xs
    go lo hi
      | lo >= hi        = Nothing
      | total == target = Just (lo, hi)
      | total <  target = go (lo + 1) hi
      | otherwise       = go lo (hi - 1)
      where total = arr ! lo + arr ! hi