Paths around obstacles

def unique_paths(grid):
    cols = len(grid[0])
    ways = [0] * cols
    ways[0] = 1 if grid[0][0] == 0 else 0
    for row in grid:
        for c in range(cols):
            if row[c] == 1:
                ways[c] = 0                    # an obstacle: no way in
            elif c > 0:
                ways[c] += ways[c - 1]         # from above (already there) + from the left
    return ways[cols - 1]

#include <vector>

long long solve(const std::vector<std::vector<int>>& grid) {
    const int cols = grid[0].size();
    std::vector<long long> ways(cols, 0);
    ways[0] = grid[0][0] == 0 ? 1 : 0;
    for (const auto& row : grid)
        for (int c = 0; c < cols; ++c) {
            if (row[c] == 1) ways[c] = 0;          // obstacle
            else if (c > 0) ways[c] += ways[c - 1]; // above + left
        }
    return ways[cols - 1];
}

class Solution {
    public long uniquePaths(int[][] grid) {
        int cols = grid[0].length;
        long[] ways = new long[cols];
        ways[0] = grid[0][0] == 0 ? 1 : 0;
        for (int[] row : grid)
            for (int c = 0; c < cols; c++) {
                if (row[c] == 1) ways[c] = 0;          // obstacle
                else if (c > 0) ways[c] += ways[c - 1]; // above + left
            }
        return ways[cols - 1];
    }
}

function uniquePaths(grid) {
  const cols = grid[0].length, ways = new Array(cols).fill(0);
  ways[0] = grid[0][0] === 0 ? 1 : 0;
  for (const row of grid)
    for (let c = 0; c < cols; c++) {
      if (row[c] === 1) ways[c] = 0;           // obstacle
      else if (c > 0) ways[c] += ways[c - 1];  // above + left
    }
  return ways[cols - 1];
}

fn solve<const C: usize>(grid: &[[i64; C]]) -> i64 {
    let mut ways = [0i64; C];
    ways[0] = if grid[0][0] == 0 { 1 } else { 0 };
    for row in grid {
        for c in 0..C {
            if row[c] == 1 {
                ways[c] = 0;                       // obstacle
            } else if c > 0 {
                ways[c] += ways[c - 1];            // above + left
            }
        }
    }
    ways[C - 1]
}

solve :: [[Int]] -> Int
solve grid = last (foldl nextRow start grid)
  where
    start = 1 : replicate (length (head grid) - 1) 0      -- one way to stand above the start
    -- an obstacle has no ways; otherwise above (old value) plus left (new value)
    nextRow above row = tail (scanl (\left (cell, up) -> if cell == 1 then 0 else left + up) 0 (zip row above))