Ordered ways to reach a total

def ordered_ways(nums, target):
    ways = [1] + [0] * target             # ways[t]: ordered sequences summing to t
    for t in range(1, target + 1):        # totals outside: order matters
        for x in nums:
            if x <= t:
                ways[t] += ways[t - x]    # x is the last element
    return ways[target]

#include <vector>

long long solve(const std::vector<int>& nums, int target) {
    std::vector<long long> ways(target + 1, 0);
    ways[0] = 1;
    for (int t = 1; t <= target; ++t)              // totals outside: order matters
        for (int x : nums)
            if (x <= t) ways[t] += ways[t - x];
    return ways[target];
}

class Solution {
    public long orderedWays(int[] nums, int target) {
        long[] ways = new long[target + 1];
        ways[0] = 1;
        for (int t = 1; t <= target; t++)            // totals outside: order matters
            for (int x : nums) if (x <= t) ways[t] += ways[t - x];
        return ways[target];
    }
}

function orderedWays(nums, target) {
  const ways = [1, ...new Array(target).fill(0)];
  for (let t = 1; t <= target; t++)           // totals outside: order matters
    for (const x of nums) if (x <= t) ways[t] += ways[t - x];
  return ways[target];
}

fn solve(nums: &[i64], target: i64) -> i64 {
    let n = target as usize;
    let mut ways = vec![0i64; n + 1];
    ways[0] = 1;
    for t in 1..=n {                                 // totals outside: order matters
        for &x in nums {
            let x = x as usize;
            if x <= t {
                ways[t] += ways[t - x];
            }
        }
    }
    ways[n]
}

import Data.Array

solve :: [Int] -> Int -> Int
solve nums target = ways ! target
  where
    -- ways ! t: ordered sequences summing to t, classified by their last element
    ways = listArray (0, target) (1 : [sum [ways ! (t - x) | x <- nums, x <= t] | t <- [1 .. target]]) :: Array Int Int