The largest chain of divisors

def largest_divisible_subset(nums):
    a = sorted(nums)                     # then each element must divide the next
    end = [1] * len(a)
    for i in range(len(a)):
        for j in range(i):
            if a[i] % a[j] == 0:
                end[i] = max(end[i], end[j] + 1)
    return max(end)

#include <algorithm>
#include <vector>

int solve(std::vector<long long> nums) {
    std::sort(nums.begin(), nums.end());          // then each element divides the next
    std::vector<int> end(nums.size(), 1);
    for (size_t i = 0; i < nums.size(); ++i)
        for (size_t j = 0; j < i; ++j)
            if (nums[i] % nums[j] == 0) end[i] = std::max(end[i], end[j] + 1);
    return *std::max_element(end.begin(), end.end());
}

class Solution {
    public int largestDivisibleSubset(int[] nums) {
        int[] a = nums.clone();
        java.util.Arrays.sort(a);                   // then each element divides the next
        int[] end = new int[a.length];
        int best = 0;
        for (int i = 0; i < a.length; i++) {
            end[i] = 1;
            for (int j = 0; j < i; j++) if (a[i] % a[j] == 0) end[i] = Math.max(end[i], end[j] + 1);
            best = Math.max(best, end[i]);
        }
        return best;
    }
}

function largestDivisibleSubset(nums) {
  const a = [...nums].sort((x, y) => x - y);
  const end = new Array(a.length).fill(1);
  for (let i = 0; i < a.length; i++)
    for (let j = 0; j < i; j++) if (a[i] % a[j] === 0) end[i] = Math.max(end[i], end[j] + 1);
  return Math.max(...end);
}

fn solve(nums: &[i64]) -> i64 {
    let mut a = nums.to_vec();
    a.sort();                                       // then each element divides the next
    let mut end = vec![1i64; a.len()];
    for i in 0..a.len() {
        for j in 0..i {
            if a[i] % a[j] == 0 {
                end[i] = end[i].max(end[j] + 1);
            }
        }
    }
    *end.iter().max().unwrap()
}

import Data.Array
import Data.List (sort)

solve :: [Int] -> Int
solve nums = maximum (elems end)
  where
    a = listArray (0, n - 1) (sort nums)
    n = length nums
    end = listArray (0, n - 1) [1 + maximum (0 : [end ! j | j <- [0 .. i - 1], a ! i `mod` a ! j == 0]) | i <- [0 .. n - 1]] :: Array Int Int