Git Rebase vs Merge and Number-to-String Translation Using Dynamic Programming

A newcomer asked whether to use git rebase or git merge in daily development.

git merge creates a new merge commit, preserves all previous commits and is simple, but frequent merges can make the history look noisy.

git rebase rewrites history by inserting commits onto the target branch, yielding a linear and clean log; however it rewrites public history and may cause conflicts, so it is safer for solo or local branches.

The article then introduces a classic dynamic‑programming problem: translate a numeric string into letters (1→a, 2→b, …, 25→z), where “10” and “11” map to ‘j’ and ‘k’.

The DP state dp[i] denotes the number of translation ways for the first i digits. The recurrence is dp[i] = dp[i‑1] plus dp[i‑2] when the two‑digit substring forms a valid number between 10 and 25.

public class TranslateString {
    public int translateNum(int num) {
        String s = String.valueOf(num);
        int n = s.length();
        int[] dp = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1];
            String twoDigits = s.substring(i - 2, i);
            if (isValid(twoDigits)) {
                dp[i] += dp[i - 2];
            }
        }
        return dp[n];
    }
    private boolean isValid(String s) {
        int num = Integer.parseInt(s);
        return num >= 10 && num <= 25;
    }
    public static void main(String[] args) {
        TranslateString ts = new TranslateString();
        System.out.println(ts.translateNum(12258)); // 5
    }
}

The DP solution runs in O(n) time and O(n) space, and for the example 12258 it yields 5 possible translations.