3699. Number of ZigZag Arrays I

class Solution {
    private static final int MOD = 1_000_000_007;

    public int zigZagArrays(int n, int l, int r) {
        int m = r - l + 1;

        long[] up = new long[m];
        long[] down = new long[m];

        for (int i = 0; i < m; i++) {
            up[i] = 1;
            down[i] = 1;
        }

        for (int len = 2; len <= n; len++) {
            long[] newUp = new long[m];
            long[] newDown = new long[m];

            long prefix = 0;
            for (int i = 0; i < m; i++) {
                newUp[i] = prefix;
                prefix = (prefix + down[i]) % MOD;
            }

            long suffix = 0;
            for (int i = m - 1; i >= 0; i--) {
                newDown[i] = suffix;
                suffix = (suffix + up[i]) % MOD;
            }

            up = newUp;
            down = newDown;
        }

        long ans = 0;
        for (int i = 0; i < m; i++) {
            ans = (ans + up[i] + down[i]) % MOD;
        }

        return (int) ans;
    }
}

MOD = 1_000_000_007


class Solution:
    def zigZagArrays(self, n: int, l: int, r: int) -> int:
        m = r - l + 1

        up = [1] * m
        down = [1] * m

        for _ in range(2, n + 1):
            newUp = [0] * m
            newDown = [0] * m

            prefix = 0
            for i in range(m):
                newUp[i] = prefix
                prefix = (prefix + down[i]) % MOD

            suffix = 0
            for i in range(m - 1, -1, -1):
                newDown[i] = suffix
                suffix = (suffix + up[i]) % MOD

            up = newUp
            down = newDown

        ans = 0

        for i in range(m):
            ans = (ans + up[i] + down[i]) % MOD

        return ans

class Solution {
public:
    static constexpr int MOD = 1000000007;

    int zigZagArrays(int n, int l, int r) {

        int m = r - l + 1;

        vector<long long> up(m, 1);
        vector<long long> down(m, 1);

        for (int len = 2; len <= n; len++) {

            vector<long long> newUp(m);
            vector<long long> newDown(m);

            long long prefix = 0;
            for (int i = 0; i < m; i++) {
                newUp[i] = prefix;
                prefix = (prefix + down[i]) % MOD;
            }

            long long suffix = 0;
            for (int i = m - 1; i >= 0; i--) {
                newDown[i] = suffix;
                suffix = (suffix + up[i]) % MOD;
            }

            up = move(newUp);
            down = move(newDown);
        }

        long long ans = 0;

        for (int i = 0; i < m; i++) {
            ans = (ans + up[i] + down[i]) % MOD;
        }

        return (int)ans;
    }
};

const MOD = 1000000007;

/**
 * @param {number} n
 * @param {number} l
 * @param {number} r
 * @return {number}
 */
var zigZagArrays = function(n, l, r) {

    const m = r - l + 1;

    let up = new Array(m).fill(1);
    let down = new Array(m).fill(1);

    for (let len = 2; len <= n; len++) {

        const newUp = new Array(m).fill(0);
        const newDown = new Array(m).fill(0);

        let prefix = 0;
        for (let i = 0; i < m; i++) {
            newUp[i] = prefix;
            prefix = (prefix + down[i]) % MOD;
        }

        let suffix = 0;
        for (let i = m - 1; i >= 0; i--) {
            newDown[i] = suffix;
            suffix = (suffix + up[i]) % MOD;
        }

        up = newUp;
        down = newDown;
    }

    let ans = 0;

    for (let i = 0; i < m; i++) {
        ans = (ans + up[i] + down[i]) % MOD;
    }

    return ans;
};