The cheapest way up a staircase

def min_cost_stairs(cost):
    two_back, one_back = cost[0], cost[1]       # cheapest way to stand on steps i - 2 and i - 1
    for c in cost[2:]:
        two_back, one_back = one_back, c + min(one_back, two_back)
    return min(one_back, two_back)              # step past the top from either

#include <algorithm>
#include <vector>

int solve(const std::vector<int>& cost) {
    int twoBack = cost[0], oneBack = cost[1];
    for (size_t i = 2; i < cost.size(); ++i) {
        int here = cost[i] + std::min(oneBack, twoBack);
        twoBack = oneBack;
        oneBack = here;
    }
    return std::min(oneBack, twoBack);
}

class Solution {
    public int minCostStairs(int[] cost) {
        int twoBack = cost[0], oneBack = cost[1];
        for (int i = 2; i < cost.length; i++) {
            int here = cost[i] + Math.min(oneBack, twoBack);
            twoBack = oneBack;
            oneBack = here;
        }
        return Math.min(oneBack, twoBack);
    }
}

function minCostStairs(cost) {
  let twoBack = cost[0], oneBack = cost[1];
  for (let i = 2; i < cost.length; i++) [twoBack, oneBack] = [oneBack, cost[i] + Math.min(oneBack, twoBack)];
  return Math.min(oneBack, twoBack);
}

fn solve(cost: &[i64]) -> i64 {
    let (mut two_back, mut one_back) = (cost[0], cost[1]);
    for &c in &cost[2..] {
        let here = c + one_back.min(two_back);
        two_back = one_back;
        one_back = here;
    }
    one_back.min(two_back)
}

solve :: [Int] -> Int
solve (a : b : rest) = uncurry min (foldl step (a, b) rest)
  where step (twoBack, oneBack) c = (oneBack, c + min oneBack twoBack)
solve _ = 0