1622. Fancy Sequence

/**
 * Problem: LeetCode 1622 - Fancy Sequence
 * Difficulty: Hard
 * Language: Java
 * Author: CodeByTushu
 */
import java.util.ArrayList;
import java.util.List;

class Fancy {
    private static final long MOD = 1_000_000_007L;
    private final List<Long> values;
    private long a;
    private long b;

    public Fancy() {
        this.values = new ArrayList<>();
        this.a = 1L;
        this.b = 0L;
    }

    private long power(long base, long exp) {
        long res = 1L;
        base %= MOD;
        while (exp > 0) {
            if ((exp & 1) == 1) {
                res = (res * base) % MOD;
            }
            base = (base * base) % MOD;
            exp >>= 1;
        }
        return res;
    }

    private long modInverse(long n) {
        return power(n, MOD - 2);
    }

    public void append(int val) {
        // x = (val - b) * inv(a) % MOD
        long diff = (val - b) % MOD;
        if (diff < 0) {
            diff += MOD;
        }
        long invA = modInverse(a);
        long x = (diff * invA) % MOD;
        values.add(x);
    }

    public void addAll(int inc) {
        b = (b + inc) % MOD;
    }

    public void multAll(int m) {
        a = (a * m) % MOD;
        b = (b * m) % MOD;
    }

    public int getIndex(int idx) {
        if (idx >= values.size()) {
            return -1;
        }
        return (int) ((a * values.get(idx) + b) % MOD);
    }
}

"""
Problem: LeetCode 1622 - Fancy Sequence
Difficulty: Hard
Language: Python
Author: CodeByTushu
"""
MOD = 1_000_000_007


class Fancy:

    def __init__(self):
        self.values = []
        self.a = 1
        self.b = 0

    def append(self, val: int) -> None:
        # x = (val - b) * inv(a) % MOD
        inv_a = pow(self.a, MOD - 2, MOD)
        x = ((val - self.b) % MOD * inv_a) % MOD
        self.values.append(x)

    def addAll(self, inc: int) -> None:
        self.b = (self.b + inc) % MOD

    def multAll(self, m: int) -> None:
        self.a = (self.a * m) % MOD
        self.b = (self.b * m) % MOD

    def getIndex(self, idx: int) -> int:
        if idx >= len(self.values):
            return -1
        return (self.a * self.values[idx] + self.b) % MOD

/**
 * Problem: LeetCode 1622 - Fancy Sequence
 * Difficulty: Hard
 * Language: C++
 * Author: CodeByTushu
 */
#include <vector>

using namespace std;

class Fancy {
private:
    static constexpr long long MOD = 1'000'000'007LL;
    vector<long long> values;
    long long a;
    long long b;

    long long power(long long base, long long exp) {
        long long res = 1;
        base %= MOD;
        while (exp > 0) {
            if (exp & 1) {
                res = (res * base) % MOD;
            }
            base = (base * base) % MOD;
            exp >>= 1;
        }
        return res;
    }

    long long modInverse(long long n) {
        return power(n, MOD - 2);
    }

public:
    Fancy() : a(1), b(0) {
        values.reserve(100000);
    }

    void append(int val) {
        long long diff = (val - b) % MOD;
        if (diff < 0) {
            diff += MOD;
        }
        long long invA = modInverse(a);
        values.push_back((diff * invA) % MOD);
    }

    void addAll(int inc) {
        b = (b + inc) % MOD;
    }

    void multAll(int m) {
        a = (a * m) % MOD;
        b = (b * m) % MOD;
    }

    int getIndex(int idx) {
        if (idx >= values.size()) {
            return -1;
        }
        return (a * values[idx] + b) % MOD;
    }
};

/**
 * Problem: LeetCode 1622 - Fancy Sequence
 * Difficulty: Hard
 * Language: JavaScript
 * Author: CodeByTushu
 */
const MOD = 1000000007n;

function power(base, exp) {
    let res = 1n;
    base = base % MOD;
    while (exp > 0n) {
        if (exp & 1n) {
            res = (res * base) % MOD;
        }
        base = (base * base) % MOD;
        exp >>= 1n;
    }
    return res;
}

function modInverse(n) {
    return power(n, MOD - 2n);
}

var Fancy = function() {
    this.values = [];
    this.a = 1n;
    this.b = 0n;
};

/** 
 * @param {number} val
 * @return {void}
 */
Fancy.prototype.append = function(val) {
    let diff = (BigInt(val) - this.b) % MOD;
    if (diff < 0n) {
        diff += MOD;
    }
    let invA = modInverse(this.a);
    this.values.push((diff * invA) % MOD);
};

/** 
 * @param {number} inc
 * @return {void}
 */
Fancy.prototype.addAll = function(inc) {
    this.b = (this.b + BigInt(inc)) % MOD;
};

/** 
 * @param {number} m
 * @return {void}
 */
Fancy.prototype.multAll = function(m) {
    this.a = (this.a * BigInt(m)) % MOD;
    this.b = (this.b * BigInt(m)) % MOD;
};

/** 
 * @param {number} idx
 * @return {number}
 */
Fancy.prototype.getIndex = function(idx) {
    if (idx >= this.values.length) {
        return -1;
    }
    return Number((this.a * this.values[idx] + this.b) % MOD);
};