Cracking coding interview: 5 key patterns to learn

When I was interviewing for roles at Microsoft and Facebook, I — like many developers — spent as many hours as I could crunching through numerous coding problems. This was brutally exhausting. I felt like I was stuck in a loop, solving problem after problem, but not actually gaining confidence.

Looking back, the problem with this approach is clear: for efficient coding interview prep, we should learning coding patterns instead of grinding individual problems.

Here’s why coding patterns are so powerful: Most coding interview questions boil down to a handful of key patterns. Once you understand the logic behind a pattern, you can apply it to dozens of problems. This not only saves you time — it prepares you for the unknown.

Today, I’ll share 5 key patterns you should learn for coding interview success:

Valid Palindrome
Kth Smallest Number in M Sorted Lists
Serialize and Deserialize Binary Tree
Valid Anagram
Minimum Window Substring

Let’s get started.

Why curated problem lists are efficient

With seemingly endless pools of practice problems out there, many coding interview prep platforms offer curated lists that feature the most common coding interview problems. These lists are tailored to save you time and help you focus on mastering the problems that matter.

Some of the most popular problem lists include:

Blind75
Grind75
LeetCode75
Neetcode150
Educative77

But what do these lists have in common?

They all emphasize some common coding problems that correspond to certain coding patterns.

Here are the common interview problems represented across these problem lists and the patterns underlying them:

Problem Title	Coding Pattern
Valid Palindrome	Two Pointers
Kth Smallest Number in M Sorted Lists	k-Way Merge
Serialize and Deserialize Binary Tree	Tree Depth-First Search
Valid Anagram	Knowing What to Track
Minimum Window Substring	Sliding Window

This overlap in problem represent how common these problems and their patterns are. This is exactly why I’m introducing you to these 5 key patterns now.

But first, here’s 2 things you should know:

Learning these 5 patterns will help you solve 40+ problems: They won’t just help you unlock these 5 problems above. Their application across many problems is the core of what makes patterns powerful.
There are many more coding patterns to learn: These patterns alone will not be enough to be fully prepared for your interview, but they’re a great starting point.

Let’s move on to these patterns and their applications to specific problems.

5 key coding patterns to learn

1. Two Pointers

The Two Pointers coding pattern maintains two pointers that traverse the data structure in a coordinated manner, typically starting from different positions or moving in opposite directions. By dynamically adjusting based on specific conditions or criteria, this pattern enables solutions with optimal time and space complexity. For example, to identify whether a string is a palindrome, we can use one pointer to iterate from the beginning and another from the end, comparing values at each step.

Consider the following template code where the two pointers left and right are adjusted while the conditions for a specific given problem are compared:

def two_pointers(array):
    # Initialize two pointers
    left = 0
    right = len(array) – 1
    
    while left < right:
        # Perform operations based on specific conditions
        # Adjust left and right pointers as needed
        left++;
        right–;
    # Perform remaining checks

Template code for Two Pointers pattern

Let’s solve an interview problem to see the Two Pointers coding pattern in action.

Solving the Valid Palindrome problem with Two Pointers

To solve the Valid Palindrome problem using the Two Pointers pattern, we utilize two pointers—one starting from the beginning of the string and the other from the end. We traverse the string simultaneously, comparing characters at corresponding positions. By advancing the pointers toward each other while checking for equality, we efficiently determine if the string is a palindrome.

def is_palindrome(s):
    left = 0
    right = len(s) – 1
    while left < right:
        if s[left] != s[right]:
            return False
        left = left + 1 
        right = right – 1
    return True


# Driver Code
def main():
    test_cases = [“hello”, “madam”, “12321”, “level”, “python”, “radar”]
    for i, test_case in enumerate(test_cases, start=1):
        print(f”Test Case #{i}”)
        print(f”The input string is ‘{test_case}'”)
        print(f”Is it a palindrome? {is_palindrome(test_case)}”)
        print(“-” * 100)


if __name__ == ‘__main__’:
    main()

Valid Palindrome

2. k-Way Merge Pattern

If you have k input lists that are sorted, and you need to merge them into a single sorted list, what’s your game plan? The k–Way Merge coding pattern is your go-to strategy for solving this challenge. The k-Way merge pattern merges k sorted data structures into a single sorted one, expanding on the merge sort algorithm. Here’s how it works:

Use a min-heap: Begin by inserting the first element of each list into a min-heap. This helps track the smallest current element among the lists.
Remove and add: Continuously remove the smallest element from the heap (at the top) and add it to the output list, maintaining the sorted order.
Track and insert: Track the origin of each element in the heap, ensuring that after adding an element to the output list, the subsequent element from its corresponding list is inserted into the heap.
Repeat until done: Continue steps 2–3 until all elements from all input lists are merged into the output list. This systematic approach ensures a final output list in sorted order.

Consider the following self-explanatory template code for the k-way merge pattern:

def merge_k_sorted_lists(lists):
    min_heap = []
    merged_list = []
    
    # Initialize the heap with the first element of each list
    for list_index, lst in enumerate(lists):
        heapq.heappush(min_heap, (lst[0], list_index, 0))  # (value, list_index, element_index)
    
    # Merge elements until the heap is empty
    while min_heap:
        min_value, list_index, element_index = heapq.heappop(min_heap)
        merged_list.append(min_value)
        
        # Add the next element from the same list to the heap
        if element_index + 1 < len(lists[list_index]):
            next_value = lists[list_index][element_index + 1]
            heapq.heappush(min_heap, (next_value, list_index, element_index + 1))
    
    return merged_list

Template code for K-way Merge pattern

Let’s put the k-way Merge coding pattern into action with an example problem.

Solving the k-th Smallest Number in M Sorted Lists problem with k-Way Merge

This algorithm inserts the first element of each list into the min-heap, which ensures that the element with the smallest value is always at the top. As it progresses, the algorithm continuously extracts the smallest element from the heap. If this element has a successor in its original list, that successor is then inserted back into the min-heap. This process repeats until the k-th smallest element is found or until all elements are processed.

from heapq import *

def k_smallest_number(lists, k):
    # storing the length of lists to use it in a loop later
    list_length = len(lists)
    # declaring a min-heap to keep track of smallest elements
    kth_smallest = []

    for index in range(list_length):
        # if there are no elements in the input list, then continue to the next iteration
        if len(lists[index]) == 0:
            continue
        else:
            # placing the first element of each list in the min-heap
            heappush(kth_smallest, (lists[index][0], index, 0))

    # set a counter to match if our kth element
    # equals to that counter, return that number
    numbers_checked, smallest_number = 0, 0
    while kth_smallest:  # iterating over the elements pushed in our min-heap
        # get the smallest number from top of heap and its corresponding list and index
        smallest_number, list_index, num_index = heappop(kth_smallest)
        numbers_checked += 1

        if numbers_checked == k:
            break

        # if there are more elements in list of the top element,
        # add the next element of that list to the min-heap
        if num_index + 1 < len(lists[list_index]):
            heappush(
                kth_smallest, (lists[list_index][num_index + 1], list_index, num_index + 1))

    # return the Kth number found in input lists
    return smallest_number

# driver code
def main():
    # multiple inputs for efficient results
    lists = [[[1, 22, 55], [1,1,1], [6, 8, 10]],
             [[11, 22, 33], [40, 50], [16, 17, 18, 115], [13, 14, 17, 19], [50, 100]],
             [[2], [2], [2]]]

    k = [5, 50, 7]
    
    # loop to execute till the length of list k
    for i in range(len(k)):
        print(i + 1, “.\t Input lists: “, lists[i],
              f”\n\t K = {k[i]}”,
              f”\n\t {k[i]}th smallest number from the given lists is: “,
              k_smallest_number(lists[i], k[i]), sep=””)
        print(“-” * 100)


if __name__ == ‘__main__’:
    main()

Kth Smallest Number in M Sorted Lists

3. Tree Depth-First Search

The Tree Depth-First Search (DFS) pattern involves traversing a binary tree by exploring as far down one branch as possible before backtracking and exploring other branches. DFS can be implemented in three main ways:

Preorder traversal: Visit the root node first, then recursively traverse the left subtree followed by the right subtree.
In-order traversal: Traverse the left subtree first, visit the root node, and then traverse the right subtree, which is useful for binary search trees to retrieve elements in ascending order.
Postorder traversal: Traverse the left subtree, then the right subtree, and visit the root node last.

DFS can be implemented using either recursion or an explicit stack.

In the recursive approach, a helper function is used to visit nodes, processing the current node and then recursively traversing its child nodes. This recursive method leverages the call stack to manage the traversal state, making it intuitive and straightforward to implement.
In the stack-based approach, we initialize a stack with the root node, then repeatedly pop a node from the stack, process it, and push its child nodes onto the stack. This method mimics the recursive approach but uses a manual stack to keep track of nodes.

The following is the template code for the recursive method-based implementation of in-order, pre-order, and post-order DFS traversal:

def preorder_traversal(root):
    result = []                  # List to store the traversal result

    def dfs(node):
        if not node:
            return               # Base case: if the node is None, return
        result.append(node.value)  # Visit the root
        dfs(node.left)             # Traverse left subtree
        dfs(node.right)            # Traverse right subtree
    
    dfs(root)                     # Start the DFS from the root
    return result

Template code for Tree Depth First Search pattern – Pre-order traversal

def inorder_traversal(root):
    result = []                  # List to store the traversal result

    def dfs(node):
        if not node:
            return               # Base case: if the node is None, return
        dfs(node.left)              # Traverse left subtree
        result.append(node.value)   # Visit the root
        dfs(node.right)             # Traverse right subtree
    
    dfs(root)                     # Start the DFS from the root
    return result

Template code for Tree Depth First Search pattern – In-order traversal

def postorder_traversal(root):
    result = []                   # List to store the traversal result

    def dfs(node):
        if not node:
            return               # Base case: if the node is None, return
        dfs(node.left)           # Traverse left subtree
        dfs(node.right)          # Traverse right subtree
        result.append(node.value)  # Visit the root
    
    dfs(root)                    # Start the DFS from the root
    return result

Template code for Tree Depth First Search pattern – Post-order traversal

Let’s apply the Tree Depth-First Search coding pattern with a specific interview problem now.

Solving the Serialize and Deserialize Binary Tree problem with Tree Depth-First Search

Serialization captures the binary tree structure by traversing it in a pre-order manner and representing each node’s value, or NULL otherwise, using a compact stream format. Deserialization reconstructs the binary tree from the serialized stream, recursively creating nodes and their subtrees based on the preorder traversal order and interpreting markers to reconstruct the original tree structure.

Here’s a more detailed breakdown of the algorithm for serializing and deserializing a binary tree using DFS:

Serialization:

Depth-first traversal: Start traversing the binary tree from the root node.
Pre-order serialization: Serialize each node encountered in a preorder manner, meaning first serialize the current node (root), then its left subtree, and finally its right subtree.
Appending nodes: As each node is visited during traversal, append its value to the stream.
Marker for NULL pointers: Whenever encountering a NULL node (leaf node or child of a leaf node), serialize a marker (e.g., “M”) to represent the absence of a child node.
Stream representation: Serialize the binary tree into a stream of values and markers, representing the structure of the tree in a compact format.

Deserialization:

Pre-order traversal: Begin deserialization by traversing the serialized stream in a preorder manner.
Node creation: For each value encountered in the stream:
- If the value is a marker, it represents a NULL node. Do not create a node for NULL pointers.
- If the value is not a marker, create a new node with the value and continue deserialization.
Recursive construction: As nodes are created, recursively construct the left and right subtrees of each non-NULL node using the preorder traversal order.
Handling markers: When encountering markers in the stream, interpret them as NULL nodes, and do not create corresponding child nodes.

Serialize and Deserialize Binary Tree

from BinaryTree import *
from TreeNode import *

# Initializing our marker
MARKER = “M”
m = 1


def serialize_rec(node, stream):
    global m
    # Adding marker to stream if the node is None
    if not node:
        stream.append(MARKER + str(m))
        m += 1
        return

    # Adding node to stream
    stream.append(node.data)

    # Doing a pre-order tree traversal for serialization
    serialize_rec(node.left, stream)
    serialize_rec(node.right, stream)

# Function to serialize tree into list of integers.
def serialize(root):
    stream = []
    serialize_rec(root, stream)
    return stream

def deserialize_helper(stream):
    # pop last element from list
    val = stream.pop()

    # Return None when a marker is encountered
    if type(val) is str and val[0] == MARKER:
        return None

    # Creating new Binary Tree Node from current value from stream
    node = TreeNode(val)

    # Doing a pre-order tree traversal for deserialization
    node.left = deserialize_helper(stream)
    node.right = deserialize_helper(stream)

    # Return node if it exists
    return node

# Function to deserialize integer list into a binary tree.
def deserialize(stream):
    stream.reverse()
    node = deserialize_helper(stream)
    return node

# driver code
def main():
    global m
    input_trees = [
        [TreeNode(100), TreeNode(50), TreeNode(200), TreeNode(25), TreeNode(75), TreeNode(350)],
        [TreeNode(100), TreeNode(200), TreeNode(75), TreeNode(50), TreeNode(25), TreeNode(350)],
        [TreeNode(200), TreeNode(350), TreeNode(100), TreeNode(75), TreeNode(50), TreeNode(200), TreeNode(25)],
        [TreeNode(25), TreeNode(50), TreeNode(75), TreeNode(100), TreeNode(200), TreeNode(350)],
        [TreeNode(350), TreeNode(75), TreeNode(25), TreeNode(200), TreeNode(50), TreeNode(100)],
        [TreeNode(1), None, TreeNode(2), None, TreeNode(3), None, TreeNode(4), None, TreeNode(5)]
    ]

    indx = 1
    for i in input_trees:
        tree = BinaryTree(i)

        print(indx, “.\tBinary Tree:”, sep=””)
        indx += 1
        if not tree.root:
            display_tree(None)
        else:
            display_tree(tree.root)

        print(“\n\tMarker used for NULL nodes in serialization/deserialization: “,
              MARKER, “*”, sep=””)

        # Serialization
        ostream = serialize(tree.root)
        print(“\n\tSerialized integer list:”)
        print(“\t” + str(ostream))

        # Deserialization
        deserialized_root = deserialize(ostream)
        print(“\n\tDeserialized binary tree:”)
        display_tree(deserialized_root)
        print(“-“*100)
        m = 1


if __name__ == ‘__main__’:
    main()

main

from typing import List
from queue import Queue
from TreeNode import *

class BinaryTree:
    def __init__(self, nodes):
        self.root = self.createBinaryTree(nodes)

    def createBinaryTree(self, nodes):
        if not nodes:
            return None

        # Create the root node of the binary tree
        root = TreeNode(nodes[0].data)

        # Create a queue and add the root node to it
        queue = Queue()
        queue.put(root)

        # Start iterating over the list of nodes starting from the second node
        i = 1
        while i < len(nodes):
            # Get the next node from the queue
            curr = queue.get()

            # If the node is not None, create a new TreeNode object for its left child,
            # set it as the left child of the current node, and add it to the queue
            if nodes[i]:
                curr.left = TreeNode(nodes[i].data)
                queue.put(curr.left)

            i += 1

            # If there are more nodes in the list and the next node is not None,
            # create a new TreeNode object for its right child, set it as the right child
            # of the current node, and add it to the queue
            if i < len(nodes) and nodes[i]:
                curr.right = TreeNode(nodes[i].data)
                queue.put(curr.right)

            i += 1

        # Return the root of the binary tree
        return root

Binary Tree

#######################- Printing -#################################
	
# Display List Code Below:
def height(node):
	if (node == None):
		return 0
	return 1 + max(height(node.left), height(node.right))

def draw_node(output, link_above, node, level, p, link_char):
	if (node == None): 
 		return

	out = “[”
	h = len(output)
	SP = ” ”

	if (p < 0):
		for s in output:
			if (s):
				s = ” “*(-1*p) + s
    
		for s in link_above:
			if (s):
				s = ” “*(-1*p) + s

	if level < h – 1:
		p = max(p, len(output[level + 1]))
	if (level > 0):
		p = max(p, len(output[level – 1]))
	p = max(p, len(output[level]))

	# Fill in to left
	if (node.left):
		leftData = SP + str(node.left.data) + SP
		draw_node(output, link_above, node.left, level + 1, p – len(leftData),’L’)
		p = max(p, len(output[level + 1]))

	# Enter this data
	space = p – len(output[level])
	if (space > 0):
		output[level] += (‘ ‘ * space)
	node_data = SP + str(node.data) + SP
	output[level] += node_data

	# Add vertical link above
	space = p + len(SP) – len(link_above[level])
	if (space > 0):
		link_above[level] += (‘ ‘ * space)
	link_above[level] += link_char

	# Fill in to right
	if (node.right):
		draw_node(output, link_above, node.right, level + 1, len(output[level]),’R’)
  
def display_tree(root):
	if (root == None):
		print(“\tNone”)
	h = height(root)
	output = []
	link_above = []
	for i in range(0,h): 
				output.append(“”)
				link_above.append(“”)
	draw_node(output, link_above, root, 0, 5, ‘ ‘)

	# Create link lines
	for i in range(h):
		for j in range(len(link_above[i])):
			if (link_above[i][j] != ‘ ‘):
				size = len(output[i – 1])
				if (size < j + 1):
					output[i – 1] += ” ” *(j + 1 – size)
				jj = j
				if (link_above[i][j] == ‘L’):
					while (output[i – 1][jj] == ‘ ‘):
						jj += 1
					for k in range(j+1, jj-1):
						str1 = output[i – 1]
						list1 = list(str1)
						list1[k] = ‘_’
						output[i – 1] = ”.join(list1)
				elif(link_above[i][j] == ‘R’):
					while (output[i – 1][jj] == ‘ ‘):
						jj-=1
					
					# k = j-1
					for k in range(j-1,jj+1,-1):
						temp = output[i – 1]
						list1 = list(temp)
						list1[k] = ‘_’
						output[i – 1] = ”.join(list1)
						k = k – 1
      
				str1 = link_above[i]
				list1 = list(str1)
				list1[j] = ‘|’
				link_above[i] = ”.join(list1)
					
	# Output
	for i in range(h):
		if (i):
			print(“\t” , link_above[i])
		print(“\t” , output[i])

Tree Node

4. Knowing What to Track

The Knowing What to Track pattern involves efficiently solving problems by counting the occurrences of elements or tracking other parameters in a given data structure and utilizing this information to derive solutions. It consists of two main phases:

Tracking phase:

Iterate and count: Traverse through the elements of the data structure and count the frequency or other parameters of each element.
Data structures: Utilize various data structures such as hash maps, dictionaries, arrays, or simple variables to store and update tracking information.

Utilization phase:

Problem-solving: Use the information obtained during the tracking phase to solve specific problems efficiently.
Examples: Solutions can involve tasks like finding the most frequent element, identifying elements occurring only once, checking for permutations, or determining game outcomes.

Consider the following template code for both phases of the pattern:

def counting_phase(data):
    # Create a dictionary to store the frequency of elements
    freq_map = {}
    
    # Iterate through each element in the data
    for element in data:
        # If the element is already in the frequency map, increment its count
        if element in freq_map:
            freq_map[element] += 1
        # Otherwise, add the element to the frequency map with a count of 1
        else:
            freq_map[element] = 1
    
    # Return the frequency map
    return freq_map

def utilization_phase(freq_map):
    # Initialize variables to store the maximum frequency element and its frequency
    some_var = None

    # Iterate through the items in the frequency map
    for element, frequency in freq_map.items():
        # Update the some_var based in the frequence value
        

    # Return some_var having the required value
    return some_var

Template code for Knowing What to Track pattern

Let’s now solve an interview problem to better understand the Knowing What to Track coding pattern.

Solving the Valid Anagram problem with Knowing What to Track

The algorithm iterates over each character in str1, updating the count in a hash map. Then, it decrements counts for characters in str2. If any count becomes non-zero, it concludes that str2 cannot be an anagram of str1, returning FALSE. Conversely, if all counts are zero, it determines that the occurrences of each character in both strings are identical, returning TRUE.

def is_anagram(str1, str2):
    # Check if the lengths of the strings are equal
    if len(str1) != len(str2):
        return False
    
    # Initialize a HashMap to store the count of characters
    table = {}
    
    # Iterate over str1 and update the count of each character
    for i in str1:
      if i in table:
        table[i] += 1
      
      else:
        table[i] = 1
    
    # Iterate over str2 and update the count of each character
    for i in str2:
      if i in table:
        table[i] -= 1
      
      else:
        # If character is not already present in HashMap return False
        # because it is extra character in str2
        return False
    
    # Iterate over the count of each character and check if it is zero
    for key in table:
        # If the count for any character is not zero, the strings are not anagrams
        if table[key] != 0:
            return False
    
    # If the code reaches this point, the strings are anagrams
    return True

def main():

  str1_list = [“night”, “step”, “spot”, “cat”, “inch”]
  str2_list = [“thing”, “pets”, “pots”, “lat”, “khin”]

  for i in range(len(str1_list)):
    print(i + 1, “.\tstr1: \””, str1_list[i], “\””, sep = “”)
    print(“\tstr2: \””, str2_list[i], “\””, sep = “”)
    print(‘\t”‘, str2_list[i], ‘” is anagram of “‘, str1_list[i], ‘”: ‘,is_anagram(str1_list[i],str2_list[i]), sep = “”)
    print(“-” * 100)

if __name__ == ‘__main__’:
  main()

Valid Anagram

5. Sliding Window

The Sliding Window pattern employs two pointers to create a dynamic window that traverses through sequential data, such as arrays or strings. As this window moves forward, it computes calculations only on the newly added elements, updating previous computations by removing existing elements. By focusing on relevant subsets of data and avoiding redundant calculations, this approach efficiently solves problems involving contiguous data processing.

Consider the following self-explanatory code template for the Sliding Window pattern:

def sliding_window_pattern(arr, window_size):
    # Initialization of pointers and other necessary variables
    left_pointer = 0
    right_pointer = 0
    some_var = 0
    
    # Iterate over the array until the left pointer reaches the end
    while left_pointer < len(arr):
        
        # If window size is met or exceeded, perform operations
        if right_pointer – left_pointer + 1 == window_size:
            # Perform operations on the current window
            perform_some_action(some_var)
            
            # Shrink the window from the left
            left_pointer += 1
            
        # Move the right pointer forward
        right_pointer += 1
    
    # Return the result, if any
    return some_var

Template code for the Sliding Window pattern

Let’s put Sliding Window coding pattern to the test with a coding problem now.

Solving the Minimum Window Substring problem with Sliding Window

The algorithm uses two hash maps:

One to store the frequency of each character in the second string (req_count)
Another to track these characters within the current window in the first string (window_hashmap).

Two pointers (left and right) define the sliding window over the first string. The right pointer expands the window by moving through the first string, and during this process, it updates the character count in the window_hashmap hash map.

When a character’s frequency in the window matches its frequency in the second string (req_count), a counter (current) is incremented. This is checked by comparing the frequency of the character in the current window (tracked by the window_hashmap) with its required frequency as per the second string (req_count). When these frequencies match, it indicates that the current window contains the required number of occurrences of that character from the second string. Therefore, the current counter is incremented to keep track of how many characters in the current window meet their required frequencies from the second string.

Once the window contains all characters of the second string, the left pointer is moved to shrink the window and find the smallest valid substring. The window’s counts are updated, and its validity is checked after each move. The smallest valid window found is updated if the current window is smaller. After the right pointer has traversed the first string, the smallest valid window is returned, or an empty string if no valid window exists. This approach ensures optimal processing time.

def min_window(s, t):
    # empty string scenario
    if t == “”:
        return “”
    
    # creating the two hash maps
    req_count = {}
    window_hashmap = {}

    # populating req_count hash map
    for c in t:
        req_count[c] = 1 + req_count.get(c, 0)

    # populating window hash map
    for c in t:
        window_hashmap[c] = 0

    # setting up the conditional variables
    current, required = 0, len(req_count)
    
    # setting up a variable containing the result’s starting and ending point
    # with default values and a length variable
    res, res_len = [-1, -1], float(“infinity”)
    
    # setting up the sliding window pointers
    left = 0
    for right in range(len(s)):
        c = s[right]

        # if the current character also occurs in t, update its frequency in window hash map
        if c in t:
            window_hashmap[c] = 1 + window_hashmap.get(c, 0)

        # updating the current variable
        if c in req_count and window_hashmap[c] == req_count[c]:
            current += 1

        # adjusting the sliding window
        while current == required:
            # update our result
            if (right – left + 1) < res_len:
                res = [left, right]
                res_len = (right – left + 1)
            
            # pop from the left of our window
            if s[left] in t:
                window_hashmap[s[left]] -= 1

            # if the popped character was among the required characters and
            # removing it has reduced its frequency below its frequency in t, decrement current
            if s[left] in req_count and window_hashmap[s[left]] < req_count[s[left]]:
                current -= 1
            left += 1
    left, right = res

    # return the minimum window substring
    return s[left:right+1] if res_len != float(“infinity”) else “”

# driver Code
def main():
    s = [“PATTERN”, “LIFE”, “ABRACADABRA”, “STRIKER”, “DFFDFDFVD”]
    t = [“TN”, “I”, “ABC”, “RK”, “VDD”]
    for i in range(len(s)):
        print(i + 1, “.\ts: “, s[i], “\n\tt: “, t[i], “\n\tThe minimum substring containing “, \
              t[i], ” is: “, min_window(s[i], t[i]), sep=””)
        print(“-” * 100)

if __name__ == ‘__main__’:
    main()

Minimum Window Substring

Focus on patterns — not problems

There are countless coding problems out there, but the truth is, most interviews focus on a few key patterns. If you understand these patterns and know how to apply them, you’ll be able to handle a wide variety of problems without hesitation or stress.

As mentioned earlier, Educative-77 is one of the curated problem lists that’s excellent for efficient interview prep. With it, you can prepare for the unknown in a crunch by mastering 26 coding patterns that apply to thousands of problems across top tech companies.

Educative-77 in Python: Accelerate Your Coding Interview Prep: Why solve 2800 problems when you can master 26 problem-solving patterns to crack any coding interview? Each module presents a set of related coding patterns, and is available in JavaScript, C++, Java, and Go, with more coming soon!

If you have more time, I’d recommend going deeper with your interview prep. To that end, you may find Educative’s Coding Interview Patterns Course series, where you can apply those 26 patterns to even more practice problems in an AI-powered, hands-on platform.

Check out:

Happy learning — and good luck prepping!

Ishrat Fatima
January 8, 2025

Frequently Asked Questions

Learning these patterns allows you to tackle problems with similar approaches, reducing the need to memorize individual solutions and boosting your ability to solve problems quickly.

You can practice by solving problems on platforms like LeetCode, Educative, and GeeksforGeeks, focusing on grouping problems by patterns and understanding how to apply them in different contexts.

While covering every problem is impossible, focusing on key coding patterns that overlap across multiple problem types will help you solve most interview questions.

Yes, resources like Grokking the Coding Interview Patterns by Educative and LeetCode’s curated problem lists are great places to start learning and practicing these patterns.

When you encounter problems that don’t fit a specific pattern, break them down into smaller components, look for similarities to problems you’ve solved before, and consider if a combination of patterns could be applied.