Fancy Sequence - Practice Coding Problems

Fancy Sequence - Problem

Design and implement a Fancy Sequence data structure that supports dynamic operations on a sequence of integers. This sequence allows you to efficiently append new values, apply bulk transformations (add or multiply all elements), and query values at specific indices.

The challenge is to handle potentially millions of operations efficiently while maintaining the correct sequence state. All values should be returned modulo 10⁹ + 7 to prevent integer overflow.

Operations to implement:

append(val) - Add integer val to the end of the sequence
addAll(inc) - Add inc to every existing element in the sequence
multAll(m) - Multiply every existing element in the sequence by m
getIndex(idx) - Return the current value at index idx (0-indexed), or -1 if index is out of bounds

Key insight: Naive approaches will time out on large inputs due to the bulk operations affecting all elements.

Input & Output

example_1.py — Basic Operations

$ Input: fancy = Fancy() fancy.append(2) fancy.addAll(3) fancy.append(7) fancy.multAll(2) print(fancy.getIndex(0)) print(fancy.getIndex(1))

› Output: 10 14

💡 Note: First append 2, then add 3 to all (making it 5), append 7, then multiply all by 2. Index 0: (2+3)*2 = 10, Index 1: 7*2 = 14

example_2.py — Out of bounds

$ Input: fancy = Fancy() fancy.append(2) print(fancy.getIndex(0)) print(fancy.getIndex(1))

› Output: 2 -1

💡 Note: Index 1 is out of bounds since we only have one element, so return -1

example_3.py — Multiple transformations

$ Input: fancy = Fancy() fancy.append(0) fancy.addAll(5) fancy.multAll(3) fancy.append(10) fancy.multAll(2) print(fancy.getIndex(0)) print(fancy.getIndex(1))

› Output: 30 20

💡 Note: Index 0: ((0+5)*3)*2 = 30. Index 1: 10*2 = 20 (only affected by final multAll)

Constraints

1 ≤ val, inc, m ≤ 100
0 ≤ idx ≤ 10⁵
At most 10⁵ calls will be made to append, addAll, multAll, and getIndex
All values must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Record Original Values

Store each number with a timestamp of when it joined the sequence

Track Global Transformations

Instead of applying operations immediately, record them as global transformation factors

Apply on Demand

When getIndex is called, calculate the final value by applying all transformations that occurred after the element was added

Use Modular Arithmetic

Handle large numbers and division using modular inverse to ensure correctness

Key Takeaway

🎯 Key Insight: By deferring the application of transformations until they're actually needed, we convert expensive O(n) bulk operations into O(1) bookkeeping, making the data structure highly efficient for large sequences with frequent transformations.

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses lazy propagation to achieve O(1) time complexity for all operations. Instead of applying transformations immediately, we record them globally and apply them only when values are queried using modular arithmetic and inverse operations.

Common Approaches

Approach	Time	Space	Notes
✓ Lazy Propagation (Optimal)	O(1)	O(n)	Record transformations and apply them lazily only when values are queried
Brute Force (Direct Application)	O(n²)	O(n)	Apply each transformation immediately to all existing elements

Lazy Propagation (Optimal) — Algorithm Steps

Store original values and their insertion timestamps
Maintain global add and multiply factors that accumulate over time
For append(val): store val with current timestamp
For addAll(inc)/multAll(m): update global transformation factors
For getIndex(idx): apply all transformations since element's insertion time

Visualization

Tap to expand

Step-by-Step Walkthrough

Append with Timestamp

Each element stores its value with current transformation state

Record Transformations

Global operations only update transformation factors

Lazy Evaluation

Apply accumulated transformations only when value is queried

Efficient Updates

All operations except getIndex are O(1)

Code -

solution.c — C

typedef struct {
    long long sequence[100000][3]; // [value, add, mult]
    int size;
    long long globalAdd;
    long long globalMult;
    const long long MOD;
} Fancy;

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp & 1) result = (result * base) % mod;
        base = (base * base) % mod;
        exp >>= 1;
    }
    return result;
}

long long modInverse(long long a, long long mod) {
    return modPow(a, mod - 2, mod);
}

Fancy* fancyCreate() {
    Fancy* obj = malloc(sizeof(Fancy));
    obj->size = 0;
    obj->globalAdd = 0;
    obj->globalMult = 1;
    *(long long*)&obj->MOD = 1000000007;
    return obj;
}

void fancyAppend(Fancy* obj, int val) {
    obj->sequence[obj->size][0] = val;
    obj->sequence[obj->size][1] = obj->globalAdd;
    obj->sequence[obj->size][2] = obj->globalMult;
    obj->size++;
}

void fancyAddAll(Fancy* obj, int inc) {
    obj->globalAdd = (obj->globalAdd + inc) % obj->MOD;
}

void fancyMultAll(Fancy* obj, int m) {
    obj->globalAdd = (obj->globalAdd * m) % obj->MOD;
    obj->globalMult = (obj->globalMult * m) % obj->MOD;
}

int fancyGetIndex(Fancy* obj, int idx) {
    if (idx >= obj->size) return -1;
    
    long long val = obj->sequence[idx][0];
    long long oldAdd = obj->sequence[idx][1];
    long long oldMult = obj->sequence[idx][2];
    
    long long multFactor = (obj->globalMult * modInverse(oldMult, obj->MOD)) % obj->MOD;
    long long addFactor = (obj->globalAdd - (oldAdd * multFactor % obj->MOD) + obj->MOD) % obj->MOD;
    
    return (val * multFactor + addFactor) % obj->MOD;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations are O(1) - transformations are recorded, not applied immediately

✓ Linear Growth

Space Complexity

O(n)

Store original values plus constant space for transformation tracking

⚡ Linearithmic Space

27.6K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Lazy Propagation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler