Fewest boats under a weight limit

def min_boats(people, limit):
    p = sorted(people)
    i, j, boats = 0, len(p) - 1, 0
    while i <= j:                      # the heaviest left, p[j], takes a boat
        if p[i] + p[j] <= limit:       # and the lightest joins if they fit
            i += 1
        j -= 1
        boats += 1
    return boats

#include <vector>
#include <algorithm>

int solve(std::vector<int> p, int limit) {
    std::sort(p.begin(), p.end());
    int i = 0, j = (int)p.size() - 1, boats = 0;
    while (i <= j) {                       // the heaviest left, p[j], takes a boat
        if (p[i] + p[j] <= limit) ++i;     // and the lightest joins if they fit
        --j;
        ++boats;
    }
    return boats;
}

class Solution {
    public int minBoats(int[] people, int limit) {
        int[] p = people.clone();
        java.util.Arrays.sort(p);
        int i = 0, j = p.length - 1, boats = 0;
        while (i <= j) {                       // the heaviest left, p[j], takes a boat
            if (p[i] + p[j] <= limit) i++;     // and the lightest joins if they fit
            j--;
            boats++;
        }
        return boats;
    }
}

function minBoats(people, limit) {
  const p = people.slice().sort((a, b) => a - b);
  let i = 0, j = p.length - 1, boats = 0;
  while (i <= j) {                       // the heaviest left, p[j], takes a boat
    if (p[i] + p[j] <= limit) i++;       // and the lightest joins if they fit
    j--;
    boats++;
  }
  return boats;
}

fn solve(people: &[i64], limit: i64) -> i64 {
    let mut p = people.to_vec();
    p.sort();
    // i and j as a half-open window [i, j) so j never goes below zero
    let (mut i, mut j, mut boats) = (0usize, p.len(), 0i64);
    while i < j {                          // the heaviest left, p[j - 1], takes a boat
        if i < j - 1 && p[i] + p[j - 1] <= limit { i += 1; }
        j -= 1;
        boats += 1;
    }
    boats
}

import Data.Array
import Data.List (sort)

solve :: [Int] -> Int -> Int
solve people limit = go 0 (n - 1)
  where
    n = length people
    p = listArray (0, n - 1) (sort people)
    -- the heaviest left, p ! j, takes a boat; the lightest joins if they fit
    go i j
      | i > j                    = 0
      | p ! i + p ! j <= limit   = 1 + go (i + 1) (j - 1)
      | otherwise                = 1 + go i (j - 1)