Squares of a sorted array, in order

def sorted_squares(nums):
    n = len(nums)
    out = [0] * n
    i, j = 0, n - 1
    for k in range(n - 1, -1, -1):     # the largest remaining square is at an end
        if abs(nums[i]) > abs(nums[j]):
            out[k] = nums[i] * nums[i]
            i += 1
        else:
            out[k] = nums[j] * nums[j]
            j -= 1
    return out

#include <vector>
#include <cstdlib>

std::vector<int> solve(const std::vector<int>& nums) {
    int n = (int)nums.size(), i = 0, j = n - 1;
    std::vector<int> out(n);
    for (int k = n - 1; k >= 0; --k) {     // the largest remaining square is at an end
        if (std::abs(nums[i]) > std::abs(nums[j])) { out[k] = nums[i] * nums[i]; ++i; }
        else { out[k] = nums[j] * nums[j]; --j; }
    }
    return out;
}

class Solution {
    public int[] sortedSquares(int[] nums) {
        int n = nums.length, i = 0, j = n - 1;
        int[] out = new int[n];
        for (int k = n - 1; k >= 0; k--) {     // the largest remaining square is at an end
            if (Math.abs(nums[i]) > Math.abs(nums[j])) { out[k] = nums[i] * nums[i]; i++; }
            else { out[k] = nums[j] * nums[j]; j--; }
        }
        return out;
    }
}

function sortedSquares(nums) {
  const n = nums.length, out = new Array(n);
  let i = 0, j = n - 1;
  for (let k = n - 1; k >= 0; k--) {     // the largest remaining square is at an end
    if (Math.abs(nums[i]) > Math.abs(nums[j])) { out[k] = nums[i] * nums[i]; i++; }
    else { out[k] = nums[j] * nums[j]; j--; }
  }
  return out;
}

fn solve(nums: &[i64]) -> Vec<i64> {
    let n = nums.len();
    let mut out = vec![0i64; n];
    let (mut i, mut j) = (0usize, n - 1);
    for k in (0..n).rev() {                // the largest remaining square is at an end
        if nums[i].abs() > nums[j].abs() { out[k] = nums[i] * nums[i]; i += 1; }
        else { out[k] = nums[j] * nums[j]; if j > 0 { j -= 1; } }
    }
    out
}

import Data.Array

solve :: [Int] -> [Int]
solve nums = go 0 (n - 1) []
  where
    n = length nums
    a = listArray (0, n - 1) nums
    -- prepend the largest remaining square, so the list ends up ascending
    go i j acc
      | i > j                    = acc
      | abs (a ! i) > abs (a ! j) = go (i + 1) j (a ! i * a ! i : acc)
      | otherwise                = go i (j - 1) (a ! j * a ! j : acc)