Ways to make an amount

def count_ways(amount, coins):
    ways = [1] + [0] * amount                # one way to make 0
    for c in coins:                          # coins outside: combinations, not sequences
        for a in range(c, amount + 1):
            ways[a] += ways[a - c]
    return ways[amount]

#include <vector>

long long solve(int amount, const std::vector<int>& coins) {
    std::vector<long long> ways(amount + 1, 0);
    ways[0] = 1;
    for (int c : coins)                          // coins outside: combinations
        for (int a = c; a <= amount; ++a) ways[a] += ways[a - c];
    return ways[amount];
}

class Solution {
    public long countWays(int amount, int[] coins) {
        long[] ways = new long[amount + 1];
        ways[0] = 1;
        for (int c : coins)                        // coins outside: combinations
            for (int a = c; a <= amount; a++) ways[a] += ways[a - c];
        return ways[amount];
    }
}

function countWays(amount, coins) {
  const ways = [1, ...new Array(amount).fill(0)];
  for (const c of coins)                       // coins outside: combinations
    for (let a = c; a <= amount; a++) ways[a] += ways[a - c];
  return ways[amount];
}

fn solve(amount: i64, coins: &[i64]) -> i64 {
    let n = amount as usize;
    let mut ways = vec![0i64; n + 1];
    ways[0] = 1;
    for &c in coins {                            // coins outside: combinations
        for a in (c as usize)..=n {
            ways[a] += ways[a - c as usize];
        }
    }
    ways[n]
}

solve :: Int -> [Int] -> Int
solve amount coins = foldl addCoin (1 : replicate amount 0) coins !! amount
  where
    -- with coin c allowed: new[a] = old[a] + new[a - c], built left to right
    addCoin old c = new
      where new = zipWith (+) old (replicate c 0 ++ new)