Introduction

In this blog post, we will explore how to solve the LeetCode problem "1622" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

Write an API that generates fancy sequences using the append, addAll, and multAll operations. Implement the Fancy class: Fancy() Initializes the object with an empty sequence. void append(val) Appends an integer val to the end of the sequence. void addAll(inc) Increments all existing values in the sequence by an integer inc. void multAll(m) Multiplies all existing values in the sequence by an integer m. int getIndex(idx) Gets the current value at index idx (0-indexed) of the sequence modulo 109 + 7. If the index is greater or equal than the length of the sequence, return -1. Example 1: Input ["Fancy", "append", "addAll", "append", "multAll", "getIndex", "addAll", "append", "multAll", "getIndex", "getIndex", "getIndex"] [[], [2], [3], [7], [2], [0], [3], [10], [2], [0], [1], [2]] Output [null, null, null, null, null, 10, null, null, null, 26, 34, 20] Explanation Fancy fancy = new Fancy(); fancy.append(2); // fancy sequence: [2] fancy.addAll(3); // fancy sequence: [2+3] -> [5] fancy.append(7); // fancy sequence: [5, 7] fancy.multAll(2); // fancy sequence: [52, 72] -> [10, 14] fancy.getIndex(0); // return 10 fancy.addAll(3); // fancy sequence: [10+3, 14+3] -> [13, 17] fancy.append(10); // fancy sequence: [13, 17, 10] fancy.multAll(2); // fancy sequence: [132, 172, 10*2] -> [26, 34, 20] fancy.getIndex(0); // return 26 fancy.getIndex(1); // return 34 fancy.getIndex(2); // return 20 Constraints: 1 <= val, inc, m <= 100 0 <= idx <= 105 At most 105 calls total will be made to append, addAll, multAll, and getIndex.

Explanation

Here's a breakdown of the solution:

• Lazy Propagation: Instead of immediately updating all elements in the sequence with addAll and multAll, store the cumulative additive and multiplicative factors applied to the entire sequence. This avoids iterating through the sequence for each addAll and multAll operation, which would be inefficient.
• Inverse Modulo: To efficiently calculate the actual value at an index, we need to "undo" the accumulated multiplicative and additive factors. Inverse modulo is used to divide (modulo) by the multiplicative factor. This is crucial for correctly applying the transformations in the correct order when retrieving an element.

• Modular Arithmetic: All calculations are performed modulo 10^9 + 7 to prevent integer overflow and ensure the result stays within the required range.

• Runtime Complexity: O(1) for append, addAll, multAll, and getIndex on average.

• Storage Complexity: O(N) where N is the number of appended elements.

Code

    class Fancy:

    def __init__(self):
        self.sequence = []
        self.add = 0
        self.mult = 1
        self.MOD = 10**9 + 7
        self.add_history = []
        self.mult_history = []

    def append(self, val: int) -> None:
        self.sequence.append(val)
        self.add_history.append(self.add)
        self.mult_history.append(self.mult)

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

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

    def getIndex(self, idx: int) -> int:
        if idx >= len(self.sequence):
            return -1

        val = self.sequence[idx]
        add_before = self.add_history[idx]
        mult_before = self.mult_history[idx]

        curr = val
        curr = (curr * self.mult % self.MOD)
        curr = (curr + self.add) % self.MOD

        if mult_before != 0 and mult_before != 1:
            inverse_mult = pow(mult_before, self.MOD - 2, self.MOD)
            curr = (curr - add_before + self.MOD) % self.MOD  # Ensure positive
            curr = (curr * inverse_mult) % self.MOD

        else:
            curr = (curr - add_before + self.MOD) % self.MOD

        return curr