Snapshot Array - Practice Coding Problems

Snapshot Array - Problem

Design and implement a SnapshotArray that efficiently stores historical versions of an array. Imagine building a version control system for an array where you can take snapshots and later retrieve values from any previous snapshot.

Your SnapshotArray class must support:
• SnapshotArray(int length) - Initialize array with given length, all elements start as 0
• set(index, val) - Update element at given index to val
• snap() - Take a snapshot and return snapshot ID (starting from 0)
• get(index, snap_id) - Retrieve value at index from a specific snapshot

The key challenge: How do you efficiently store snapshots without using excessive memory when only a few elements change between snapshots?

Input & Output

example_1.py — Basic Operations

$ Input: ["SnapshotArray","set","snap","set","get"] [[3],[0,5],[],[0,6],[0,0]]

› Output: [null,null,0,null,5]

💡 Note: Initialize array of length 3: [0,0,0]. Set index 0 to 5: [5,0,0]. Take snapshot 0. Set index 0 to 6: [6,0,0]. Get value at index 0 from snapshot 0, which returns 5 (the value before the second set operation).

example_2.py — Multiple Snapshots

$ Input: ["SnapshotArray","set","snap","set","snap","get","get"] [[2],[1,10],[],[1,20],[],[1,0],[1,1]]

› Output: [null,null,0,null,1,10,20]

💡 Note: Initialize array [0,0]. Set index 1 to 10: [0,10]. Snapshot 0. Set index 1 to 20: [0,20]. Snapshot 1. get(1,0) returns 10, get(1,1) returns 20.

example_3.py — No Changes Edge Case

$ Input: ["SnapshotArray","snap","get","get"] [[4],[],[0,0],[2,0]]

› Output: [null,0,0,0]

💡 Note: Initialize array [0,0,0,0]. Take snapshot 0 immediately. Both get(0,0) and get(2,0) return 0 since no values were changed from the initial state.

Constraints

1 ≤ length ≤ 5 × 10⁴
0 ≤ index < length
0 ≤ val ≤ 10⁹
0 ≤ snap_id < (number of times snap() is called)
At most 5 × 10⁴ calls will be made to set, snap, and get

Visualization

Tap to expand

Result: 5Space Efficiency✅ Only store changes, not full arrays✅ Memory: O(changes) vs O(length×snaps)✅ Fast operations: O(1) set/snap, O(log k) getSnapshots:Snap 0Snap 1Snap 2Snap 3Just counters, no data!

Understanding the Visualization

Initialize

Each array index maintains its own timeline starting with snapshot 0, value 0

Track Changes

When set() is called, append the change to that index's timeline

Snapshot

Increment snapshot counter - no copying needed!

Retrieve

Binary search the timeline to find the latest change at or before target snapshot

Key Takeaway

🎯 Key Insight: By storing only the changes (like Git diffs) and using binary search to find historical values, we achieve optimal space efficiency while maintaining fast query performance. This is a classic example of trading a small amount of query time complexity for massive space savings.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses binary search with change tracking to efficiently implement the SnapshotArray. Instead of storing complete array copies, maintain a timeline of changes for each index and use binary search to find values at specific snapshots. This achieves O(1) for set/snap operations and O(log k) for get operations while using minimal space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Store Complete Snapshots)	O(n) per snap(), O(1) for get/set	O(n * s)	Store a complete copy of the array for each snapshot
Binary Search Optimization (Optimal)	O(1) for set/snap, O(log k) for get	O(c)	Store only changes per index with binary search for efficient retrieval

Brute Force (Store Complete Snapshots) — Algorithm Steps

Initialize with array of given length, all zeros
For set(): update the current array directly
For snap(): create complete copy and add to snapshots list
For get(): access the stored snapshot array at given index

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create array [0,0,0] and empty snapshots list

Set & Snap

Set index 0 to 5, then copy entire array [5,0,0] to snapshots

Another Change

Set index 0 to 6, array becomes [6,0,0] but snapshot 0 still has [5,0,0]

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int* array;
    int** snapshots;
    int length;
    int snap_count;
    int snap_capacity;
} SnapshotArray;

SnapshotArray* snapshotArrayCreate(int length) {
    SnapshotArray* obj = malloc(sizeof(SnapshotArray));
    obj->array = calloc(length, sizeof(int));
    obj->snapshots = malloc(10 * sizeof(int*));
    obj->length = length;
    obj->snap_count = 0;
    obj->snap_capacity = 10;
    return obj;
}

void snapshotArraySet(SnapshotArray* obj, int index, int val) {
    obj->array[index] = val;
}

int snapshotArraySnap(SnapshotArray* obj) {
    if (obj->snap_count >= obj->snap_capacity) {
        obj->snap_capacity *= 2;
        obj->snapshots = realloc(obj->snapshots, obj->snap_capacity * sizeof(int*));
    }
    
    // Store complete copy of current array
    obj->snapshots[obj->snap_count] = malloc(obj->length * sizeof(int));
    memcpy(obj->snapshots[obj->snap_count], obj->array, obj->length * sizeof(int));
    return obj->snap_count++;
}

int snapshotArrayGet(SnapshotArray* obj, int index, int snap_id) {
    return obj->snapshots[snap_id][index];
}

Time & Space Complexity

Time Complexity

⏱️

O(n) per snap(), O(1) for get/set

Each snapshot requires copying the entire array of length n

✓ Linear Growth

Space Complexity

O(n * s)

Where n is array length and s is number of snapshots

⚡ Linearithmic Space

42.0K Views

Medium-High Frequency

~25 min Avg. Time

1.4K 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

Brute Force (Store Complete Snapshots) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler