Subsets with a given sum

def count_subsets(nums, target):
    ways = [1] + [0] * target              # ways[t]: subsets of the elements so far summing to t
    for x in nums:
        for t in range(target, x - 1, -1):  # downwards: x used at most once
            ways[t] += ways[t - x]
    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 x : nums)
        for (int t = target; t >= x; --t) ways[t] += ways[t - x];   // downwards
    return ways[target];
}

class Solution {
    public long countSubsets(int[] nums, int target) {
        long[] ways = new long[target + 1];
        ways[0] = 1;
        for (int x : nums)
            for (int t = target; t >= x; t--) ways[t] += ways[t - x];   // downwards
        return ways[target];
    }
}

function countSubsets(nums, target) {
  const ways = [1, ...new Array(target).fill(0)];
  for (const x of nums) for (let t = target; t >= x; t--) ways[t] += ways[t - x];   // downwards
  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 &x in nums {
        let x = x as usize;
        if x > n {
            continue;
        }
        for t in (x..=n).rev() {
            ways[t] += ways[t - x];                         // downwards
        }
    }
    ways[n]
}

solve :: [Int] -> Int -> Int
solve nums target = foldl add (1 : replicate target 0) nums !! target
  where
    -- new[t] = old[t] + old[t - x]: x is either left out or put in
    add old x = zipWith (+) old (replicate x 0 ++ old)