Count the pairs whose sum is below a target

def count_pairs(nums, target):
    a = sorted(nums)
    lo, hi = 0, len(a) - 1
    count = 0
    while lo < hi:
        if a[lo] + a[hi] < target:
            count += hi - lo        # a[lo] works with everything up to hi
            lo += 1
        else:
            hi -= 1                 # a[hi] is too big for anything left
    return count

#include <vector>
#include <algorithm>

long long solve(std::vector<int> a, int target) {
    std::sort(a.begin(), a.end());
    int lo = 0, hi = (int)a.size() - 1;
    long long count = 0;
    while (lo < hi) {
        if (a[lo] + a[hi] < target) { count += hi - lo; ++lo; }   // a[lo] works with everything up to hi
        else --hi;                                                // a[hi] is too big for anything left
    }
    return count;
}

import java.util.Arrays;

class Solution {
    public long countPairs(int[] nums, int target) {
        int[] a = nums.clone();
        Arrays.sort(a);
        int lo = 0, hi = a.length - 1;
        long count = 0;
        while (lo < hi) {
            if (a[lo] + a[hi] < target) { count += hi - lo; lo++; }   // a[lo] works with everything up to hi
            else hi--;                                                // a[hi] is too big for anything left
        }
        return count;
    }
}

function countPairs(nums, target) {
  const a = nums.slice().sort((x, y) => x - y);
  let lo = 0, hi = a.length - 1, count = 0;
  while (lo < hi) {
    if (a[lo] + a[hi] < target) { count += hi - lo; lo++; }   // a[lo] works with everything up to hi
    else hi--;                                                // a[hi] is too big for anything left
  }
  return count;
}

fn solve(nums: &[i64], target: i64) -> i64 {
    let mut a = nums.to_vec();
    a.sort();
    if a.len() < 2 { return 0; }
    let (mut lo, mut hi) = (0usize, a.len() - 1);
    let mut count = 0i64;
    while lo < hi {
        if a[lo] + a[hi] < target { count += (hi - lo) as i64; lo += 1; }   // a[lo] works with everything up to hi
        else { hi -= 1; }                                                  // a[hi] is too big for anything left
    }
    count
}

import Data.Array
import Data.List (sort)

solve :: [Int] -> Int -> Int
solve nums target = go 0 (n - 1) 0
  where
    n = length nums
    a = listArray (0, max 0 (n - 1)) (sort nums)
    go lo hi acc
      | lo >= hi                  = acc
      | a ! lo + a ! hi < target  = go (lo + 1) hi (acc + hi - lo)   -- a ! lo works with everything up to hi
      | otherwise                 = go lo (hi - 1) acc               -- a ! hi is too big for anything left