Dig into creating and implementing custom data structures for solving specialized problems efficiently.

Coding

Designs specialized structures tailored to specific problem requirements, optimizing data representation and operations for efficient solutions.

Custom Data Structures

Efficiently prepare for coding interviews with strategies from FAANG engineers. Avoid the LeetCode grind and simplify your interview prep with real-world questions from top companies.

The ultimate guide to the System Design Interview – developed by Meta & Google engineers. Master distributed system fundamentals, and practice with real-world interview questions & mock interviews.

System Design

The essential guide to API Design & Product Design Interviews – developed by FAANG engineers. Master product design fundamentals & get hands-on with real-world APIs.

API Design

A battle-tested guide to Object Oriented Design Interviews – developed by FAANG engineers. Master OOD fundamentals & practice real-world interview questions.

Low Level Design Interview Using OOD Principles

Your essential EM Interview crash course. Learn strategies from FAANG hiring managers to demonstrate your leadership skills & experience to interviewers.

Engineering Management and Leadership Interviews

The ultimate guide to behavioral interviews. Developed by FAANG engineers. Use real-world questions, video recording, and structured strategies to get interview-ready in just a few hours.

Behavioral

# Statement

In this challenge, you have to implement a **Snapshot Array** with the following properties:

- **Constructor (length)**: This is the constructor and it initializes the data structure to hold the specified number of indexes. 
- **Set Value (idx, val)**: This property sets the value at a given index **idx** to value **val**.

- **Snapshot()**: This method takes no parameters and returns the **Snap ID**. **Snap ID** is the number of times that the snapshot function was called, less $1$, as we start the count at $0$. The first time this function is called, it saves a snapshot and returns $0$. The $n^{th}$ time it is called, after saving the snapshot, it returns $n-1$.
- **Get Value (idx, Snap ID)** method returns the value at the index in the snapshot with the given **Snap ID**.

Suppose that we have three nodes whose values we wish to track in the snapshot array. Initially, the value of all the nodes will be $0$. After calling the **Set Value (1, 4)** function, the value of node 1 will change to $4$. If we take a snapshot at this point, the current values of all the nodes will be saved with **Snap ID** $0$. Now, if we call **Set Value (1, 7)**, the current value for node 1 will change to $7$. Now, if we call the **Get Value (1, 0)** function, we will get the value of node 1 from snapshot $0$, that is, $4$.

**Constraints:**
* $1 \leq$ `length` $\leq 1000$
* $0 \leq$ `idx` $<$ `length`
* $0 \leq$ `val` $\leq 10^9$
* $0 \leq$ `snapid` $<$ (the total number of times we call **Snapshot**)
* At most $5 \times 10^3$ calls will be made to **Set Value**, **Snapshot**, and **Get Value**.



# Solution
So far, you have probably brainstormed some approaches and have an idea of how to solve this problem. Let’s explore some of these approaches and figure out which one to follow based on considerations such as time complexity and any implementation constraints.
## Naive approach
A naive approach to create an array-like data structure that supports snapping its values ​​at different times would be to create a list to store the array values ​​in each snapshot. We will increment the counter to keep track of the current snapshot ID. To take a snapshot, we will copy the current list and add it to the list of snapshots. To get the value on a given index and the snapshot ID, we access the given snapshot ID and the corresponding element in the snapshot list for the index.

For example, we want to create an array of length 5 and take three snapshots of its values at different times. We will create a list to store the values of the array at each snapshot, as well as a counter to keep track of the current snapshot ID:
```
arr = [0, 0, 0, 0, 0]
```
To set a value at a given index, we can update the corresponding element in the list:
```
arr[2] = 4
```
To take a snapshot, we will create a copy of the current list and add it to the list of snapshots. After taking three snapshots, the snapshots list will contain the following:
```
snapshots = [[0, 0, 0, 0, 0], [0, 0, 4, 0, 0], [0, 0, 4, 0, 0], [0, 0, 4, 0, 0]]
```
This naive approach will work for small arrays and a small number of snapshots. When the size of the array and the number of snapshots increases, this approach can become inefficient, since it requires copying the entire list for each snapshot. Let's see if we can use the Custom Data Structures pattern to reduce the complexity of our solution.

## Optimized approach using nested dictionaries
To solve this problem, we will start by creating a dictionary named **Node Value**. The node value will hold all the values, along with the nodes, at different times in further subdictionaries. The keys to the **Node Value** dictionary are the Snapshot IDs. For a  given key, the values are also dictionaries. These inner dictionaries have node IDs as keys and the node’s value as values.

The **Node Value** dictionary keeps track of values that are set until the latest snapshot, rather than storing the entire array for each snapshot, as in the naive approach. This allows for more efficient memory usage and faster performance, especially for large arrays and a large number of snapshots.

Let's solve the Snapshot Array problem using the Custom Data Structures pattern.

Solution: Snapshot Array

Statement▼

Solution: Snapshot Array

Statement▼