Ways to decode a string of digits

def num_decodings(s):
    one_ahead, two_ahead = 1, 0               # ways[i + 1] and ways[i + 2]; ways[n] = 1
    for i in range(len(s) - 1, -1, -1):
        here = 0
        if s[i] != '0':
            here = one_ahead                  # a one-digit code
            if i + 1 < len(s) and int(s[i:i + 2]) <= 26:
                here += two_ahead             # a two-digit code, 10..26
        one_ahead, two_ahead = here, one_ahead
    return one_ahead

#include <string>

long long solve(std::string s) {
    long long oneAhead = 1, twoAhead = 0;     // ways[i + 1], ways[i + 2]
    for (int i = (int)s.size() - 1; i >= 0; --i) {
        long long here = 0;
        if (s[i] != '0') {
            here = oneAhead;                    // one digit
            if (i + 1 < (int)s.size() && (s[i] - '0') * 10 + (s[i + 1] - '0') <= 26) here += twoAhead;
        }
        twoAhead = oneAhead;
        oneAhead = here;
    }
    return oneAhead;
}

class Solution {
    public long numDecodings(String s) {
        long oneAhead = 1, twoAhead = 0;           // ways[i + 1], ways[i + 2]
        for (int i = s.length() - 1; i >= 0; i--) {
            long here = 0;
            if (s.charAt(i) != '0') {
                here = oneAhead;                     // one digit
                if (i + 1 < s.length() && (s.charAt(i) - '0') * 10 + (s.charAt(i + 1) - '0') <= 26) here += twoAhead;
            }
            twoAhead = oneAhead;
            oneAhead = here;
        }
        return oneAhead;
    }
}

function numDecodings(s) {
  let oneAhead = 1, twoAhead = 0;           // ways[i + 1], ways[i + 2]
  for (let i = s.length - 1; i >= 0; i--) {
    let here = 0;
    if (s[i] !== '0') {
      here = oneAhead;                        // one digit
      if (i + 1 < s.length && Number(s.slice(i, i + 2)) <= 26) here += twoAhead;   // two digits
    }
    [oneAhead, twoAhead] = [here, oneAhead];
  }
  return oneAhead;
}

fn solve(s: &str) -> i64 {
    let d: Vec<i64> = s.bytes().map(|b| (b - b'0') as i64).collect();
    let (mut one_ahead, mut two_ahead) = (1i64, 0i64);   // ways[i + 1], ways[i + 2]
    for i in (0..d.len()).rev() {
        let mut here = 0;
        if d[i] != 0 {
            here = one_ahead;                              // one digit
            if i + 1 < d.len() && d[i] * 10 + d[i + 1] <= 26 {
                here += two_ahead;                         // two digits
            }
        }
        two_ahead = one_ahead;
        one_ahead = here;
    }
    one_ahead
}

import Data.Char (digitToInt)

solve :: String -> Int
solve s = fst (go s)
  where
    -- go returns (ways for this suffix, ways for the suffix one shorter)
    go [] = (1, 0)
    go (c : rest) =
      let (w1, w2) = go rest
          one = if c /= '0' then w1 else 0
          two = case rest of
                  (d : _) | c /= '0' && digitToInt c * 10 + digitToInt d <= 26 -> w2
                  _ -> 0
      in (one + two, w1)