Learn and practice the Tries and Custom Data Structures patterns to solve coding interview problems.

Speedrun the Oracle Coding Interview: Top Problems in C++

Proficiency in advanced data structures is a marker of a highly experienced engineer, and interviewers use such questions to finetune how they grade candidates. To solve problems with very specific requirements that may not be handled by standard data structures, we gain experience in the advanced skill of the design, implementation, and efficient use of custom data structures.

Data Design

# Statement
Implement a **Random Set** data structure that can perform the following operations:
- **Constructor()**: This initializes the **Random Set** object.
- **Insert()**: This function takes an integer, **data**, as its parameter and, if it does not already exist in the set, add it to the set, returning TRUE. If the integer already exists in the set, the function returns FALSE. 
- **Delete()**: This function takes an integer, **data**, as its parameter and, if it exists in the set, removes it, returning TRUE. If the integer does not exist in the set, the function returns FALSE.
- **GetRandom()**: This function takes no parameters. It returns an integer chosen at random from the set.
> **Note:** Your implementation should aim to have a running time of $O(1)$ (on average) for each operation.

**Constraints:**

* $-2^{31} \leq$ **data** $\leq 2^{31}$
*  No more than $2 \times 10^5$ calls will be made to the **Insert()**, **Delete()** and **GetRandom()** functions.
* There will be at least one element in the data structure when the **GetRandom()** function is called.


# Examples


## Understand the problem

Let’s take a moment to make sure you’ve correctly understood the problem. The quiz below helps you check if you’re solving the correct problem:

What is the output for the following series of commands?

```text
Delete(20), Insert(20), Insert(20), GetRandom()
```

What is the output for the following series of commands?
<pre><code class="language-text">Delete(20), Insert(20), Insert(20), GetRandom()
</code></pre>

What is the output for the following series of commands?

```text
Insert(20), Delete(20), Insert(20), GetRandom(), Delete(25), Delete(20)
```

What is the output for the following series of commands?
<pre><code class="language-text">Insert(20), Delete(20), Insert(20), GetRandom(), Delete(25), Delete(20)
</code></pre>

What is the output for the following series of commands?

```text
Insert(20), GetRandom(), Delete(20), Insert(20)
```


What is the output for the following series of commands?
<pre><code class="language-text">Insert(20), GetRandom(), Delete(20), Insert(20)
</code></pre>

Insert Delete GetRandom O(1)

Insert Delete GetRandom O(1)

## Try it yourself

Implement your solution in the following coding playground.

class RandomSet{
    public:
        // Initialize your data structure here
        RandomSet() {
            // Write your code here
        }

        // Inserts a value to the dataset
        // Returns true if the dataset did not already contain the specified value
        bool insert(int prod) {
            // Replace this placeholder return statement with your code
            return false;
        }

        // Removes a value from the dataset
        // Returns true if the dataset contained the specified value
        bool remove(int prod) {
            // Replace this placeholder return statement with your code
            return false;
        }

        // Get a random value from the dataset
        int getRandom() {
            // Replace this placeholder return statement with your code
            return -1;
        }
};


class RandomSet():
    def __init__(self):
        """
        Initialize our data structure here.
        """
        pass

    def insert(self, val):
        """
        Inserts a value in the data structure.
        Returns True if it did not already contain the specified element.
        """
        pass

    def delete(self, val):
        """
        Removes a value from the data structure.
        Returns True if it contained the specified element.
        """
        pass

    def get_random(self):
        """
        Choose an element at random from the data structure.
        """
        pass

# Quick Fix\nYou are Edward, a Senior Software Engineer who specializes in coding interview patterns, data structures and algorithms, and is great at debugging issues in code.\n\n- Edward, please keep in mind that you do not have to print the data of the placeholders. Also, do not mention anything about yourself.\n\nEdward, you are given the following data in the placeholders:\n- Function name: `Init, Insert, Delete, GetRandom`\n- Candidate's submitted solution code: USER_CODE\n- Error: ERROR_DESCRIPTION\n- Failed test case: FAILED_TEST_CASE\n- Coding language: `C++`\n\n- Edward, your task is to understand the type of error that is occurring in the coding language provided.\n- Once you've understood the error as per the error’s description, and why the test case failed, you will suggest how the candidate can improve their solution code to fix the error.\n- Edward, you will not give the corrected code, just a hint on what the error tells, and how to fix it.\n- Edward, please limit your response strictly to 100 words. No more words than the limit.

# Review Code\nEdward, your current task is to review the `Init, Insert, Delete, GetRandom` function(s) and the other function(s) invoked in it/them.\n\n-Take your time and review the candidate's solution code.\n- Do not review any extra/helper files or functions not invoked in the solution function `Init, Insert, Delete, GetRandom`.\n- Do not review the code of data structure objects instantiated like a binary tree, linked list, trie, union find, etc., in the solution functions. Just review the solution/algorithm function of the problem. \n- Also, if the solution code doesn’t use the coding pattern stated above, then please encourage the candidate to reattempt the problem using that pattern corectly.

# Review time complexity\n- Please provide a brief time complexity analysis of the function(s) `Init, Insert, Delete, GetRandom`. \n- While calculating time complexity, include the time complexity of built-in C++ functions invoked by the code. \n- The answer should be to the point in approximately 60 words.

# Review space complexity\n- Please provide a brief space complexity analysis of the function(s) `Init, Insert, Delete, GetRandom`. \n- While calculating space complexity, include the space complexity of built-in C++ functions invoked by the code. \n- Do not include the space used for the input parameters and the space used for just returning an output (not used as a scratch space). \n- The answer should be to the point in approximately 60 words.

OneDArray

Convert

#include <iostream>
#include <vector>
#include <string>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

class OneDArray : public DataStructure
{

 // define class attributes

private:
 void generateError(string data)
 {
 cerr << "OneDArray is not parsable: " << data;
 exit(-1);
 }

public:

 std::vector<json> val;
 OneDArray()
 {
 // constructor
 }

 OneDArray(std::vector<json> v)
 {
 // constructor
 this->val = v;
 }
 
 
 // return value will be passed to user program
 void *construct(string new_value, int typeOfDs)
 {
 // parse test case in json string 'value' to your desired data structure
 json parsed_json = json::parse(new_value);

 // Check if the parsed JSON is an array
 if (parsed_json.is_array()) {
 for (const auto& item : parsed_json) {
 val.push_back(item);
 }
 } else {
 // Handle the case where the input is not a JSON array
 std::cerr << "Input is not a JSON array." << std::endl;
 }

 return this;
 }

 // input param contains return value of user program
 string traverse(void *input, int typeOfDs)
 {
 // convert your data structure 'input' to a json string representing a test case output
 OneDArray * custom_ds = (OneDArray *)input; 
 json result = (json)(custom_ds->val);
 return result.dump();
 }

 // override operator<< for your data structure if required
};

#include <string>

using namespace std;

class Convert : public DataStructure
{

 // define class attributes

private:
 void generateError(string data)
 {
 cerr << "MyCustomDS is not parsable: " << data;
 exit(-1);
 }

public:
 vector<vector<int>> val;
 Convert()
 {
 // constructor
 }
 
 // return value will be passed to user program
 void *construct(string str, int typeOfDs)
 {
 json j_complete = json::parse(str);
 vector<vector<int>> temp = j_complete;
 this->val = temp;
 //cout << this->val.size();
 return this;
 // parse test case in json string 'value' to your desired data structure
 }

 // input param contains return value of user program
 string traverse(void *input, int typeOfDs)
 {
 return "";
 // convert your data structure 'input' to a json string representing a test case output
 }

 // override operator<< for your data structure if required
};

def evaluate_results(self) -> object:
        """
        self.__inputs is the list of inputs that are passed as input to function
        self.__actual_output is a list of outputs that is produced by the learner's code
        return : self.__edu__result object
        """

        from random import choice


        class RandomSet():
            def __init__(self):
                self.indexor = {}
                self.store = [] 

            # Function to Insert a value
            def Insert(self, val):
                if val in self.indexor:
                    return False
                self.indexor[val] = len(self.store)
                self.store.append(val)
                return True

            # Function to remove a value
            def Delete(self, val):
                if val in self.indexor:
                    last, i = self.store[-1], self.indexor[val]
                    self.store[i], self.indexor[last] = last, i
                    del self.indexor[val]
                    self.store.pop()
                    return True
                return False

            # Function to generate a random value
            def get_random(self):
                return choice(self.store)
        
        def checkr1(res, result):
            found = False
            for i in res:
                if type(i) == int:
                    if i in result:
                        found = True

            return found


        def checkr2(res, result):
            found = False
            for i in res:
                if type(i) == int:
                    if i in result:
                        found = True

            return found


        def check_values(r1, r2, op, val):
            result = []
            for i in range(len(op)):
                if op[i] == "Insert":
                    result.append(val[i][0])
            
            if len(result) == 0 or "GetRandom" not in op:
                return True

            if checkr1(r1, result) and checkr2(r2, result):
                return True

            return False

        def main(input_1, input_2):
            result = []
            dataset = RandomSet()
            for i in range(1, len(input_1)):
                if input_1[i] == "Insert":
                    res = dataset.Insert(input_2[i][0])
                    result.append(res)
                elif input_1[i] == "Delete":
                    res = dataset.Delete(input_2[i][0])
                    result.append(res)
                elif input_1[i] == "GetRandom":
                    res = dataset.get_random()
                    result.append(res)
            return result, input_1, input_2

        

        expected_outputs = [] 
        expected, input_1, input_2 = main(self.__inputs[0],self.__inputs[1])
        actual_output = self.__actual_outputs[0]

        answer = check_values(expected, actual_output, input_1, input_2)

        if answer:
            expected_outputs.append(expected)
            self.__edu_result.store_result(expected_outputs, TestCaseResult.PASS)
        else:
            expected_outputs.append(expected)
            self.__edu_result.store_result(expected_outputs, TestCaseResult.FAIL)

        return self.__edu_result

#include "InsertDeleteGetRandom.cpp"
#include "OneDArray.cpp"
#include "Convert.cpp"

#include <vector>

OneDArray mainFunction(vector<string> input1, Convert input2){
 // vector<string> result;
 std::vector<json> result;
 RandomSet dataset;
 for (int i = 1; i<input1.size(); i++)
 {
 if (input1[i] == "Insert"){
 bool res = dataset.insert(input2.val[i][0]);
 if(res)
 result.push_back(true);
 else
 result.push_back(false);
 }
 else if (input1[i] == "Delete"){
 bool res = dataset.remove(input2.val[i][0]);
 if(res)
 result.push_back(true);
 else
 result.push_back(false);
 }
 else if (input1[i] == "GetRandom"){
 int res = dataset.getRandom();
 result.push_back(res);
 }
 }
 

 OneDArray res = *(new OneDArray(result));
 return res;
}

insert delete getrandom.yaml

testcases:
  - name: "testcase 1"
    inputs:
    - 1 : ["insertDeleteRandom", "Insert", "GetRandom"]
    - 2 : [[], [25],[]]
    output: 
    - 1 : [true, "25"]

  - name: "testcase 2"
    inputs:
    - 1 : ["insertDeleteRandom", "Delete", "Insert", "GetRandom"]
    - 2 : [[], [25], [50], []]
    output: 
    - 1 : ["False", "True", "50"]

  - name: "testcase 3"
    inputs:
    - 1 : ["insertDeleteRandom", "Insert", "Delete", "Delete", "GetRandom", "Delete"]
    - 2 : [[], [25], [20],[100],[],[25]]
    output: 
    - 1 : ["True", "False", "False", "25", "True"]
    
  - name: "testcase 4"
    inputs:
    - 1 : ["insertDeleteRandom", "Insert", "Delete", "Insert", "GetRandom", "Delete", "GetRandom" ]
    - 2 : [[], [125], [125],[100],[],[110], []]
    output: 
    - 1 : ["True", "True", "True", "100", "False", "100"]

  - name: "testcase 5"
    inputs:
    - 1 : ["insertDeleteRandom", "Insert", "Insert", "Delete", "Insert", "GetRandom", "Delete", "GetRandom" ]
    - 2 : [[], [125], [125], [125],[100],[],[110], []]
    output: 
    - 1 : ["True", "False", "True", "True", "100", "False", "100"]

def sum(input_1, input_2):
    return input_1+input_2

def validate_inputs(self) -> None:
 """
 self.__inputs is the list of inputs that are passed as input to function
 store the result using the self.store_result(error_msg, status)
 return : void
 """

 def is_valid_1d_array(arr):
 if not isinstance(arr, list):
 return False

 return all(isinstance(elem, str) and not isinstance(elem, bool) for elem in arr)


 def is_valid_2d_array(arr):
 if not isinstance(arr, list) or not all(isinstance(row, list) for row in arr):
 return False

 for row in arr:
 if any(elem is None or isinstance(elem, bool) for elem in row):
 return False
 if not all(isinstance(elem, int) for elem in row):
 return False

 return True


 def key_value(calls):
 for i in calls:
 for j in i:
 if not -2 ** 31 <= j <= 2 ** 31:
 return False

 return True


 def operation_and_calls_equal(operation, calls):
 for i, op in enumerate(operation):
 if op == "RandomSet" and calls[i] != []:
 return False
 elif op == "Insert" and len(calls[i]) != 1:
 return False
 elif op == "Delete" and len(calls[i]) != 1:
 return False
 elif op == "GetRandom" and calls[i] != []:
 return False

 return True


 def operation_valid(operation):
 op = operation[1:]
 for i in range(len(op)):
 if op[i] != "Insert":
 if op[i] != "Delete":
 if op[i] != "GetRandom":
 return False
 return True


 def at_least_one(calls):
 ds = []

 for i in range(len(operation)):
 if operation[i] == 'Insert':
 ds.append(calls[i][0])
 elif operation[i] == 'Delete':
 for j in ds:
 if j == calls[i][0]:
 ds.remove(calls[i][0])
 elif operation[i] == 'GetRandom':
 if len(ds) == 0:
 return False

 return True

 # def at_least_one(calls):

 # elements = calls[1:]
 # integer = False

 # for elem in elements:
 # if elem:
 # integer = True
 # elif elem == [] and not integer:
 # return False
 # return True


 operation = self.__inputs[0]
 calls = self.__inputs[1]

 if not is_valid_1d_array(operation):
 self.store_result ("'commands' should be a valid 1D array of strings in the following format: ['insertDeleteRandom','Insert','GetRandom'...]", ValidationFunction.FAIL)
 elif not is_valid_2d_array(calls):
 self.store_result ("'input2' should be a valid 2D array of integers in the following format: [[],[data],[]...]", ValidationFunction.FAIL)
 elif not 0 <= len(calls) <= 200000:
 self.store_result ("'input2' length should be in the range [0,200000]", ValidationFunction.FAIL)
 elif not at_least_one(calls):
 self.store_result ("At least one element should be present in the array before the 'GetRandom' call", ValidationFunction.FAIL)
 elif len(operation) != len(calls):
 self.store_result ("'commands' length should be equal to 'input2' length", ValidationFunction.FAIL)
 elif operation[0] != "insertDeleteRandom":
 self.store_result ("'commands[0]' should have the value: 'insertDeleteRandom'", ValidationFunction.FAIL)
 elif len(operation) == 1:
 self.store_result ("'commands' should have at least one call other than the constructor call", ValidationFunction.FAIL)
 elif len(calls) == 1:
 self.store_result ("'input2' should have at least one call other than the constructor call", ValidationFunction.FAIL)
 elif not operation_valid(operation):
 self.store_result ("'commands[1:]' should have the values 'Insert', 'Delete' or 'GetRandom'", ValidationFunction.FAIL)
 elif not operation_and_calls_equal(operation, calls):
 self.store_result ("'insertDeleteRandom', 'Insert', 'Delete', 'GetRandom' should be followed by [],[int],[int],[] respectively in the 'input2'", ValidationFunction.FAIL)
 elif not key_value(calls):
 self.store_result ("'data' should be in the range [-2^31,2^31]", ValidationFunction.FAIL)
 else:
 self.store_result("", ValidationFunction.PASS)

Try to solve the Insert Delete GetRandom O(1) problem.


Trie

Custom Data Structures

Conclusion

Insert Delete GetRandom O(1)

Statement

Examples

Understand the problem

Figure it out!

Try it yourself