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

Speedrun the Oracle Coding Interview: Top Problems in Python

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():
    # Initialize your data structure here
    def __init__(self):
        # Write your code here
        pass

    # Inserts a value in the data structure
    # Returns True if it did not already contain the specified element
    def insert(self, val):
        # Write your code here
        pass

    # Removes a value from the data structure
    # Returns True if it contained the specified element
    def delete(self, val):
        # Write your code here
        pass

    # Choose an element at random from the data structure.
    def get_random(self):
        # Write your code here
        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, get_random`\n- Candidate's submitted solution code: USER_CODE\n- Error: ERROR_DESCRIPTION\n- Failed test case: FAILED_TEST_CASE\n- Coding language: `Python`\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, get_random` 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, get_random`.\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, get_random`. \n- While calculating time complexity, include the time complexity of built-in Python 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, get_random`. \n- While calculating space complexity, include the space complexity of built-in Python 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.

TwoDArray

OneDArray

import sys
import json

sys.path.append("../ds_v1")
from data_structure import DataStructure

# throw parsing errors for incorrect test case format
def parsingError(element_string, error_message):
    sys.stderr.write(f"Parsing Error: {element_string} {error_message}")
    exit()


# className: MyCustomDS
class TwoDArray(DataStructure):
    def __init__(self):
        # constructor
        pass

    def __str__(self):
        # override print() for your data structure
        pass

    # return value will be passed to user program
    def construct(self, inp_string: str, type_of_arr: int) -> any:
        # parse test case in json string 'value' to your desired data structure
        parse_list = json.loads(inp_string)
        return parse_list

    # input param contains return value of user program
    def traverse(self, input: any, type_of_arr: int) -> str:
        # convert your data structure 'input' to a json string representing a test case output
        return json.dumps(input)


import sys
import json

sys.path.append("../ds_v1")
from data_structure import DataStructure

# throw parsing errors for incorrect test case format
def parsingError(element_string, error_message):
    sys.stderr.write(f"Parsing Error: {element_string} {error_message}")
    exit()


# className: MyCustomDS
class OneDArray(DataStructure):
    def __init__(self):
        # constructor
        pass

    def __str__(self):
        # override print() for your data structure
        pass

    # return value will be passed to user program
    def construct(self, inp_string: str, type_of_arr: int) -> any:
        # parse test case in json string 'value' to your desired data structure
        parse_list = json.loads(inp_string)
        return parse_list

    # input param contains return value of user program
    def traverse(self, input: any, type_of_arr: int) -> str:
        # convert your data structure 'input' to a json string representing a test case output
        return json.dumps(input)


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 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] == "get_random":
                    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

from insert_delete_random import RandomSet

def main(input_1, input2):
    result = []
    dataset = RandomSet()
    for i in range(1, len(input_1)):
        if input_1[i] == "insert":
            res = dataset.insert(input2[i][0])
            result.append(res)
        elif input_1[i] == "delete":
            res = dataset.delete(input2[i][0])
            result.append(res)
        elif input_1[i] == "get_random":
            res = dataset.get_random()
            result.append(res)
    return result

insert delete getrandom.yaml

testcases:
  - name: "testcase 1"
    inputs:
    - 1 : ["RandomSet", "insert", "get_random"]
    - 2 : [[], [25],[]]
    output: 
    - 1 : [True, 25]

  - name: "testcase 2"
    inputs:
    - 1 : ["RandomSet", "delete", "insert", "get_random"]
    - 2 : [[], [25], [50], []]
    output: 
    - 1 : [False, True, 50]

  - name: "testcase 3"
    inputs:
    - 1 : ["RandomSet", "insert", "delete", "delete", "get_random", "delete"]
    - 2 : [[], [25], [20],[100],[],[25]]
    output: 
    - 1 : [True, False, False, 25, True]

  - name: "testcase 4"
    inputs:
    - 1 : ["RandomSet", "insert", "delete", "insert", "get_random", "delete", "get_random" ]
    - 2 : [[], [125], [125],[100],[],[110], []]
    output: 
    - 1 : [True, True, True, 100, False, 100]

  - name: "testcase 5"
    inputs:
    - 1 : ["RandomSet", "insert", "insert", "delete", "insert", "get_random", "delete", "get_random" ]
    - 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 == "get_random" 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] != "get_random":
 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] == 'get_random':
 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: ['RandomSet','insert','get_random'...]", 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 'get_random' call", ValidationFunction.FAIL)
 elif len(operation) != len(calls):
 self.store_result ("'commands' length should be equal to 'input2' length", 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 operation[0] != "RandomSet":
 self.store_result ("'commands[0]' should have the value: 'RandomSet'", ValidationFunction.FAIL)
 elif not operation_valid(operation):
 self.store_result ("'commands[1:]' should have the values 'insert', 'delete' or 'get_random'", ValidationFunction.FAIL)
 elif not operation_and_calls_equal(operation, calls):
 self.store_result ("'RandomSet', 'insert', 'delete', 'get_random' 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