Learn and practice the Hash Maps and Knowing What to Track patterns to solve coding interview problems.

Speedrun the Meta Coding Interview: Top Problems in Python

Hash maps are powerful data structures that enable programmers to design more efficient solutions for certain problems. After practicing solving problems using hash maps, we will move to the more general problem-solving skill of figuring out the key characteristics of a problem, using various techniques to track them, in order to design remarkably efficient solutions for seemingly complex problems.

Hashing and Tracking

# Statement

Suppose that two players are playing a tic-tac-toe game on an $n \times n$ board. They're following specific rules to play and win the game:

* A move is guaranteed to be valid if a mark is placed on an empty block.
* No more moves are allowed once a winning condition is reached.
* A player who succeeds in placing $n$ of their marks in a horizontal, vertical, or diagonal row wins the game.

Implement a **TicTacToe** class, which will be used by two players to play the game and win fairly.

Keep in mind the following functionalities that need to be implemented:

* **Constructor**, the constructor, which initializes an object of `TicTacToe`, allowing the players to play on a board of size $n \times n$.
* **move(row, col, player)** indicates that the player with the ID, `player`, places their mark on the cell (`row`, `col`). The move is guaranteed to be a valid move. At each move, this function returns the player ID if the current player wins and returns $0$ if no one wins. 

**Constraints:**

* $2 \leq n \leq 9$
* `player` should be either `1` or `2`.
* $0 \leq$ `row`, `col` $< n$
* Every call to `move()` will be with a unique `row`, `col` combination.

* The `move()` function will be called at most $n^2$ times.


# Examples

# Understanding the problem

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



We are given the current state of a game on a $3 \times 3$ board, showing the moves made so far, where Player 1's moves are denoted by a cross, and Player 2’s moves are denoted by a circle.

<img src="/api/collection/10370001/5500262945128448/page/6354864993206272/image/4763684964663296?page_type=collection_lesson" width="140">

The following moves are now made by the players:

```text
move(0, 2, 2)
move(1, 0, 1)
```

What would the result be?

We are given the current state of a game on a <math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn><mo>×</mo><mn>3</mn></mrow><annotation encoding="application/x-tex">3 \times 3</annotation></semantics></math>3×3 board, showing the moves made so far, where Player 1’s moves are denoted by a cross, and Player 2’s moves are denoted by a circle.
<img src="/api/collection/10370001/5500262945128448/page/6354864993206272/image/4763684964663296?page_type=collection_lesson" width="140">
The following moves are now made by the players:
<pre><code class="language-text">move(0, 2, 2)
move(1, 0, 1)
</code></pre>
What would the result be?

We are given the current state of a game on a $4 \times 4$ board, showing the moves made so far, where Player 1's moves are denoted by a cross, and Player 2’s moves are denoted by a circle.

<img src="/api/collection/10370001/5500262945128448/page/6354864993206272/image/6389897676193792?page_type=collection_lesson" width="150">

The following moves are made by the players:

```text
move(1, 2, 1)
move(0, 1, 2)
move(2, 1, 1)
move(0, 2, 2)
```

What would the result be?

We are given the current state of a game on a <math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mo>×</mo><mn>4</mn></mrow><annotation encoding="application/x-tex">4 \times 4</annotation></semantics></math>4×4 board, showing the moves made so far, where Player 1’s moves are denoted by a cross, and Player 2’s moves are denoted by a circle.
<img src="/api/collection/10370001/5500262945128448/page/6354864993206272/image/6389897676193792?page_type=collection_lesson" width="150">
The following moves are made by the players:
<pre><code class="language-text">move(1, 2, 1)
move(0, 1, 2)
move(2, 1, 1)
move(0, 2, 2)
</code></pre>
What would the result be?

We are given the current state of a game on a $4 \times 4$ board, showing the moves made so far, where Player 1's moves are denoted by a cross, and Player 2’s moves are denoted by a circle.

<img src="/api/collection/10370001/5500262945128448/page/6354864993206272/image/4672027778875392?page_type=collection_lesson" width="150">

The following moves are made by the players:

```text
move(1, 1, 2)
move(1, 3, 1)
move(2, 3, 2)
move(3, 2, 1)
```

What would the result be?

We are given the current state of a game on a <math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mo>×</mo><mn>4</mn></mrow><annotation encoding="application/x-tex">4 \times 4</annotation></semantics></math>4×4 board, showing the moves made so far, where Player 1’s moves are denoted by a cross, and Player 2’s moves are denoted by a circle.
<img src="/api/collection/10370001/5500262945128448/page/6354864993206272/image/4672027778875392?page_type=collection_lesson" width="150">
The following moves are made by the players:
<pre><code class="language-text">move(1, 1, 2)
move(1, 3, 1)
move(2, 3, 2)
move(3, 2, 1)
</code></pre>
What would the result be?

Design Tic-Tac-Toe

Design Tic-Tac-Toe

# Figure it out!

We have a game for you to play. Rearrange the logical building blocks to develop a clearer understanding of how to solve this problem.

> **Note:** This puzzle relates only to the function, `move()`. The data structures that are set up in `Constructor` have been mentioned in the first card.

# Try it yourself

Implement your solution in the following coding playground.


class TicTacToe:
    # Constructor will be used to initialize TicTacToe data members 
    def __init__(self, n): 
        
        # Write your code here
        pass        

    # move will be used to play a move by a specific player and identify who
    # wins at each move
    def move(self, row, col, player):
        
        # Replace this placeholder return statement with your code
        return -1


# 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__, move`\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__, move` 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__, move`.\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__, move`. \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__, move`. \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.

Two_D_Array

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 Two_D_Array(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, value: str, type_of_arr: int) -> any:
        # parse test case in json string 'value' to your desired data structure
        return json.loads(value)

    # 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
        """
        class TicTacToe:
        # TicTacToe class contains rows, cols, diagonal,
        # and anti_diagonal to create a board.
        # Constructor is used to create board of size n * n.
            def __init__(self, n):
                self.rows = [0] * (n)
                self.cols = [0] * (n)
                self.diagonal = 0
                self.anti_diagonal = 0

            # move function will allow the players to play the game
            # by placing their mark at the row and col of their choice.
            def move(self, row, col, player):
                current_player = -1
                if player == 1:
                    current_player = 1
                
                n = len(self.rows)

                self.rows[row] += current_player
                self.cols[col] += current_player

                if row == col:
                    self.diagonal += current_player

                if col == (n - row - 1):
                    self.anti_diagonal += current_player

                if abs(self.rows[row]) == n or abs(self.cols[col]) == n or abs(self.diagonal) == n or abs(self.anti_diagonal) == n:
                    return player
                return 0

        def main_eval(input_1, input_2):
            result = []
            tic_tac_toe_obj = TicTacToe(input_2[0][0])
            result.append(None)
            for i in range(1, len(input_1)):
                if input_1[i] == "move":
                    res = tic_tac_toe_obj.move(input_2[i][0],input_2[i][1],input_2[i][2])
                    result.append(res)
            return result

        def compareResult(expected, actual_output):
            
            if expected == actual_output:
                return True
            return False

        expected = main_eval(self.__inputs[0], self.__inputs[1])
        expected_outputs = [] 

        if json.dumps(expected) == json.dumps(self.__actual_outputs[0]):
            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 tic_tac_toe import TicTacToe

def main(input_1, input_2):
    result = []
    tic_tac_toe_obj = TicTacToe(input_2[0][0])
    result.append(None)
    for i in range(1, len(input_1)):
        if input_1[i] == "move":
            res = tic_tac_toe_obj.move(input_2[i][0],input_2[i][1],input_2[i][2])
            result.append(res)
    return result

design_tic_tac_toe_append.yaml

testcases:
  - name: "testcase 1"
    inputs:
    - 1 : ["TicTacToe", "move", "move", "move", "move", "move", "move", "move"]
    - 2 : [[3], [0, 0, 1], [0, 2, 2], [2, 2, 1], [1, 1, 2], [2, 0, 1], [1, 0, 2], [2, 1, 1]]
    output: 
    - 1 : [null,0,0,0,0,0,0,1]
  - name: "testcase 2"
    inputs:
    - 1: ["TicTacToe", "move", "move", "move", "move", "move", "move", "move", "move", "move", "move", "move"]
    - 2: [[5],[4,4,2],[0,0,1],[2,2,2], [4, 0, 1], [0, 4, 2],[2, 1, 1], [2, 4, 2], [1, 0, 1],[1,4,2],[2,0,1],[3,4,2]]
    output:
    - 1 : [null,0,0,0,0,0,0,0,0,0,0,2]
  - name: "testcase 3"
    inputs:
    - 1: ["TicTacToe", "move", "move", "move", "move", "move", "move", "move"]
    - 2: [[3],[0,2,2],[0,0,1],[1,1,2],[2,0,1],[1,0,2],[2,2,1],[1,2,2]]
    output:
    - 1 : [null,0,0,0,0,0,0,2]
  - name: "testcase 4"
    inputs:
    - 1: ["TicTacToe", "move", "move", "move", "move", "move", "move", "move", "move", "move", "move", "move", "move"]
    - 2: [[4],[0,1,1],[1,2,2],[2,1,1],[3,2,2],[2,2,1],[2,3,2],[2,0,1],[0,3,2],[1,1,1],[3,3,2],[3,0,1],[1,3,2]]
    output:
    - 1 : [null,0,0,0,0,0,0,0,0,0,0,0,2]
  - name: "testcase 5"
    inputs:
    - 1: ["TicTacToe", "move", "move", "move", "move", "move", "move", "move", "move", "move"]
    - 2: [[3],[1,1,2],[0,0,1],[0,1,2],[2,1,1],[1,0,2],[1,2,1],[0,2,2],[2,0,1],[2,2,2]]
    output:
    - 1 : [null,0,0,0,0,0,0,0,0,0]

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
 """
 length = False
 length = True if len(self.__inputs[0]) == len(self.__inputs[1]) else False
 winning_flag = False

 class TicTacToe:
 # TicTacToe class contains rows, cols, diagonal,
 # and anti_diagonal to create a board.
 # Constructor is used to create board of size n * n.
 def __init__(self, n):
 self.rows = [0] * (n)
 self.cols = [0] * (n)
 self.diagonal = 0
 self.anti_diagonal = 0

 # move function will allow the players to play the game
 # by placing their mark at the row and col of their choice.
 def move(self, row, col, player):
 current_player = -1
 if player == 1:
 current_player = 1
 
 n = len(self.rows)

 self.rows[row] += current_player
 self.cols[col] += current_player

 if row == col:
 self.diagonal += current_player

 if col == (n - row - 1):
 self.anti_diagonal += current_player

 if abs(self.rows[row]) == n or abs(self.cols[col]) == n or abs(self.diagonal) == n or abs(self.anti_diagonal) == n:
 winning_flag = True
 return winning_flag

 def main_eval(input_1, input_2):
 result = []
 tic_tac_toe_obj = TicTacToe(input_2[0][0])
 result.append(None)
 
 for i in range(1, len(input_1)):
 if input_1[i] == "move":
 res = tic_tac_toe_obj.move(input_2[i][0],input_2[i][1],input_2[i][2]) 
 result.append(res)

 return result



 inp = self.__inputs[0]
 input_matrix = self.__inputs[1]

 # Function to check whether valid 2D array of int or not
 def valid_2D(arr):
 if not isinstance(arr, list) or not arr:
 return False

 for row in arr:

 if not isinstance(row, list) or len(row) == 0:
 return False

 for element in row:
 if not isinstance(element, int) or isinstance(element, bool) or element is None:
 return False

 return True

 def check_moves():
 flag = False
 current_player = None
 
 for move in self.__inputs[1][1:]:
 player = move[2]
 
 if current_player is not None and player == current_player:
 flag = True
 
 current_player = player
 return flag

 # Check if input array is actually a 2D array
 if not valid_2D(input_matrix):
 self.store_result ("Input 2: Invalid input for a 2D array of integers", ValidationFunction.FAIL)
 
 elif any(len(x) != 3 for x in self.__inputs[1][1:]):
 self.store_result("Input 2: There should be exactly three parameters for 'move': ('row', 'col', 'player')",ValidationFunction.FAIL)
 
 elif self.__inputs[0][0] != "TicTacToe":
 self.store_result ("The first call for input 1 should be the Constructor name", ValidationFunction.FAIL)
 
 elif any(x != "move" for x in self.__inputs[0][1:]):
 self.store_result ("Input 1: Only function call allowed is 'move'", ValidationFunction.FAIL)

 elif not isinstance(inp, list):
 self.store_result ("Expected string array", ValidationFunction.FAIL)
 
 # inputs can be accessed using self.__inputs starting from 0 to len(self.__inputs) - 1
 elif self.__inputs[1][0][0] < 2 or self.__inputs[1][0][0] > 9:
 self.store_result ("Value of argument 'n' for Constructor should be in range [2, 9]", ValidationFunction.FAIL)

 elif len(self.__inputs[1][0]) > 1:
 self.store_result ("Value of argument 'n' for Constructor should be a single integer between [2, 9]", ValidationFunction.FAIL)
 
 elif any(self.__inputs[1][i][0] < 0 or self.__inputs[1][i][0] >= self.__inputs[1][0][0] for i in range(1, len(self.__inputs[1]))):
 self.store_result("rows should be in range [0,n]",ValidationFunction.FAIL)
 
 elif any(self.__inputs[1][i][1] < 0 or self.__inputs[1][i][1] >= self.__inputs[1][0][0] for i in range(1, len(self.__inputs[1]))):
 self.store_result("cols should be in range [0,n]",ValidationFunction.FAIL)
 
 elif any(self.__inputs[1][i][2] != 1 and self.__inputs[1][i][2] != 2 for i in range(1, len(self.__inputs[1]))):
 self.store_result("Player should be either 1 or 2",ValidationFunction.FAIL)
 
 elif len(self.__inputs[1][1:]) != len(set((move[0], move[1]) for move in self.__inputs[1][1:])):
 self.store_result("All moves should be a unique row-col combination",ValidationFunction.FAIL)
 
 elif sum(1 for action in self.__inputs[0] if action == "move") > self.__inputs[1][0][0]**2:
 self.store_result("Allowed moves threshold passed",ValidationFunction.FAIL)
 
 elif check_moves() == True:
 self.store_result("Same player cannot make two moves at once",ValidationFunction.FAIL)
 
 elif len(self.__inputs[0]) != len(self.__inputs[1]):
 self.store_result("Number of 'move' calls should be equal to the length of parameters in input 2",ValidationFunction.FAIL)
 
 else:
 expected = main_eval(self.__inputs[0], self.__inputs[1]) 
 if any(expected and x is True and expected[-1] != x for x in expected):
 self.store_result("No moves allowed after winning condition is reached",ValidationFunction.FAIL)
 else:
 self.store_result("", ValidationFunction.PASS)

Try to solve the Design Tic-Tac-Toe problem.

Hash Maps

Knowing What to Track

Conclusion

Design Tic-Tac-Toe

Statement

Examples

Understanding the problem

Figure it out!

Try it yourself