Jaeyoung Heo

• Resume
• Blog

• EN | KO

All-in-One Guide to Coding Tests

Sharing the process of preparing for coding tests.

Table of Contents

1. Introduction to Coding Tests
   • What is a Coding Test?
   • Benefits of Coding Tests
   • Types of Coding Tests
2. Preparing for Coding Tests
   • Learning Basic Concepts
   • Data Structures and Algorithms
   • Practicing Problem-Solving
   • Recommended Learning Resources and Websites
3. Essential Algorithms and Data Structures
   • Arrays and Strings
   • Linked Lists
   • Stacks and Queues
   • Trees and Graphs
   • Hash Tables
   • Sorting and Searching Algorithms
   • Dynamic Programming
4. Coding Test Checklist
   • Arrays
   • Strings
   • Two Pointers
   • Sliding Window
   • Matrix
   • HashMap
   • Intervals
   • Stack
   • Linked List
   • Binary Tree
   • Binary Tree Search
   • Graph
   • BFS/DFS
   • Graph BFS
   • Trie
   • Backtracking
   • Divide & Conquer
   • Kadane’s Algorithm
   • Binary Search
   • Heap
   • Bit Manipulation
   • Math
   • 1D DP
   • Multidimensional DP

Before You Start

If you are already somewhat familiar with coding tests, it’s best to skip ahead to the Coding Test Checklist.

Introduction to Coding Tests

What is a Coding Test?

A coding test is an exam designed to evaluate an applicant’s programming skills. It is mainly required for technical positions, including software development. In a coding test, candidates solve given problems by determining and implementing algorithms in code, assessing their problem-solving skills, coding ability, and understanding of algorithms. Coding tests can be conducted online via platforms or on-site. They are a crucial part of technical interviews in the hiring process, used to verify the candidate’s basic coding skills.

Benefits of Coding Tests

• Skill Assessment: An effective way to evaluate a candidate’s basic programming skills, ensuring they can perform coding tasks required in actual work.
• Problem-Solving Ability: Assesses the candidate’s ability to solve problems efficiently and think algorithmically.
• Fair Evaluation: Provides an objective and fair method to evaluate candidates, minimizing subjective bias.
• Preparation Evaluation: Shows how well-prepared a candidate is, reflecting their study efforts and readiness.
• Cultural Fit: Helps evaluate how well a candidate fits with the company’s tech stack and culture, ensuring they can adapt and contribute effectively.

Types of Coding Tests

• Online Coding Tests: Candidates solve and submit problems on an online platform, often with time limits and automatic grading systems.
• Whiteboard Coding Tests: Conducted during on-site interviews, where candidates solve problems and write code on a whiteboard, allowing interviewers to observe their thought process.
• Programming Assignments: Candidates are given a few days to complete a programming task, allowing in-depth problem-solving.
• Pair Programming Tests: Candidates work with an interviewer to solve problems, evaluating their collaboration and communication skills.
• Algorithm and Data Structure Tests: Tests that evaluate the candidate’s understanding of specific algorithms and data structures, focusing on problem-solving and optimization skills.

Preparing for Coding Tests

Learning Basic Concepts

Building a solid foundation is crucial when preparing for coding tests. Understanding basic syntax, functions, variables, and data types is essential. Common programming languages include Python, Java, C++, and JavaScript. It’s recommended to choose one and study it in-depth.

Basic Concepts to Learn:

• Variables and Data Types
• Conditional Statements and Loops
• Functions and Scope
• List, Array, and String Manipulation
• Input/Output Handling

Data Structures and Algorithms

The core of coding tests lies in data structures and algorithms. Solving problems requires selecting appropriate data structures and implementing efficient algorithms. It’s important to fully understand commonly used data structures and algorithms and practice using them.

Key Data Structures:

• Arrays
• Linked Lists
• Stacks and Queues
• Hash Tables
• Trees and Graphs
• Heaps

Key Algorithms:

• Sorting (Bubble, Selection, Insertion, Quick, Merge Sort)
• Searching (Binary Search, BFS, DFS)
• Recursion and Backtracking
• Dynamic Programming
• Greedy Algorithms
• Divide and Conquer

Practicing Problem-Solving

Understanding theory alone is not enough. Practicing by solving various problems is crucial. Using online coding platforms to practice is highly effective.

Practice Methods:

• Solve problems daily for a consistent period.
• After solving, review other people’s solutions to learn new approaches.
• Practice problems of varying difficulty levels.
• Review and re-solve problems you found difficult or made mistakes on.

Recommended Learning Resources and Websites

Utilizing good learning resources and websites is important for effective preparation. Here are some recommended resources and sites for coding test preparation.

Online Coding Platforms:

• LeetCode: Provides problems of various difficulty levels, optimized for interview preparation.
• HackerRank: Offers problems in algorithms, databases, AI, and more.
• CodeSignal: Allows practice in environments similar to real coding tests.
• Codewars: Offers various coding challenges to improve programming skills.
• AtCoder: A well-known Japanese online judge site with a variety of algorithm problems.

Other Learning Resources:

• GeeksforGeeks: Provides tutorials and problems on various data structures and algorithms.
• Coursera, edX: Platforms offering online courses on data structures and algorithms.
• YouTube: A source for various programming lectures and algorithm explanation videos.

Essential Algorithms and Data Structures

Understanding and utilizing algorithms and data structures frequently tested in coding tests is essential. Below are the key algorithms and data structures to master.

Arrays and Strings

Arrays

Arrays are data structures that store elements of the same type in contiguous memory locations. Key features of arrays include fast element access via indexing and fixed size, requiring resizing for element insertion or deletion.

Strings

Strings are sequences of characters stored as arrays. Key operations on strings include length measurement, character access, substring extraction, and comparison. Common algorithms for handling strings include string searching (KMP, Rabin-Karp) and string sorting.

Linked Lists

Linked lists are data structures where each node contains data and a reference to the next node. The key advantage of linked lists is dynamic resizing and fast insertion/deletion.

• Singly Linked List: Each node has a reference to the next node.
• Doubly Linked List: Each node has references to both the previous and next nodes.
• Circular Linked List: The last node references the first node, forming a circle.

Stacks and Queues

Stacks

Stacks follow Last-In-First-Out (LIFO) order. They are used for function call storage, reverse string creation, and parentheses validation. Key operations include push, pop, and peek.

Queues

Queues follow First-In-First-Out (FIFO) order. They are used for breadth-first search (BFS) and task scheduling. Key operations include enqueue, dequeue, and front.

Trees and Graphs

Trees

Trees are hierarchical data structures with root and child nodes. Binary trees have nodes with at most two children. Key operations include insertion, deletion, and traversal (DFS, BFS).

• Binary Search Tree (BST): Left subtree contains values less than the root, and the right subtree contains values greater than the root.
• Heaps: Complete binary trees that allow fast retrieval of maximum or minimum values.

Graphs

Graphs consist of nodes and edges connecting them. Types include directed/undirected and weighted/unweighted graphs. Key operations include traversal (DFS, BFS), shortest path finding (Dijkstra, Bellman-Ford), and minimum spanning tree (Prim, Kruskal).

Hash Tables

Hash tables map keys to values, supporting fast lookup, insertion, and deletion. Hash functions convert keys to hash values, determining storage locations. Collision resolution methods include chaining and open addressing.

Sorting and Searching Algorithms

Sorting Algorithms

Sorting algorithms arrange data in a specific order. Key sorting algorithms include:

• Bubble Sort: Compares and swaps adjacent elements.
• Selection Sort: Finds the minimum value and swaps it with the first element.
• Insertion Sort: Inserts elements into the correct position in a sorted part.
• Quick Sort: Divides based on a pivot and sorts recursively.
• Merge Sort: Divides and merges sorted parts.
• Heap Sort: Uses heap data structure for sorting.

Searching Algorithms

Searching algorithms find desired values within data. Key searching algorithms include:

• Linear Search: Sequentially checks each element.
• Binary Search: Searches by repeatedly dividing a sorted array in half.

Dynamic Programming

Dynamic programming solves complex problems by breaking them into smaller subproblems. It uses memoization to store results of subproblems and reduce calculations. Dynamic programming is useful for optimization problems, such as Fibonacci sequence, knapsack problem, and longest common subsequence (LCS).

Coding Test Checklist

Wondering if you’re well-prepared for coding tests? Review the content below and fill in any gaps or areas of weakness.

Arrays

• Array declaration

  arr = []
  arr = [1, 2, 3]
  

• Adding elements

  arr = [1, 2, 3]
  arr.append(4)  # [1, 2, 3, 4]
  

• Removing elements

  arr = [1, 2, 3, 4]
  arr.remove(2)  # [1, 3, 4]
  del arr[1]     # [1, 4]
  

• Finding length

  arr = [1, 2]
  length = len(arr)  # 2
  

• Slicing

  arr = [1, 2, 3, 4]
  sub_arr = arr[0:2]  # [1, 2]
  

• Iterating

  arr = [1, 2, 3]
  for element in arr:
      print(element)
  # Output:
  # 1
  # 2
  # 3
  

• Reversing

  arr = [1, 2, 3]
  arr.reverse()   # [3, 2, 1]
  arr = arr[::-1] # [1, 2, 3]
  

• Sorting

  arr = [3, 1, 2]
  arr.sort()  # [1, 2, 3]
  sorted_arr = sorted(arr)  # [1, 2, 3]
  

Strings

• String declaration

  s = "hello"
  

• Substring extraction

  s = "hello"
  sub_str = s[1:4]  # "ell"
  

• Finding length

  s = "hello"
  length = len(s)  # 5
  

• String concatenation

  s = "hello"
  s2 = "world"
  s3 = s + " " + s2  # "hello world"
  

• Splitting strings

  s = "hello world"
  words = s.split()  # ['hello', 'world']
  

• Joining strings

  strs = ["hi", "hello", "bye"]
  "".join(strs) # hihellobye
  " ".join(strs) # hi hello bye
  "-".join(strs) # hi-hello-bye
  

• Searching strings

  s = "hello"
  index = s.find("e")  # 1
  

• Replacing in strings

  s = "hello"
  s1 = s.replace("l", "r")  # "herro"
  

• Reversing strings

  s = "hello"
  s_rev = s[::-1]  # "olleh"
  

Two Pointers

• Palindrome
• Subsequence
• Two Sum (with sorted array)
• Water Container

Sliding Window

• Maximum Sum Subarray
• Longest Substring Without Repeating Characters
• Minimum Window Substring
• Subarrays with K Different Integers

Matrix

• Rotate Matrix
• Spiral Matrix
• Search a 2D Matrix
• Number of Islands

HashMap

• Two Sum
• Group Anagrams
• Subarray Sum Equals K
• Longest Consecutive Sequence

Intervals

• Merge Intervals
• Insert Interval
• Meeting Rooms
• Non-overlapping Intervals

Stack

• Valid Parentheses
• Min Stack
• Evaluate Reverse Polish Notation
• Daily Temperatures

Linked List

• Reverse Linked List
• Merge Two Sorted Lists
• Linked List Cycle
• Remove Nth Node From End of List

Binary Tree

• Binary Tree Inorder Traversal
• Maximum Depth of Binary Tree
• Path Sum
• Serialize and Deserialize Binary Tree

Binary Tree Search

• Validate Binary Search Tree
• Lowest Common Ancestor of a BST
• Insert into a Binary Search Tree
• Delete Node in a BST

Graph

• Clone Graph
• Course Schedule
• Number of Connected Components in an Undirected Graph
• Redundant Connection

BFS/DFS

• Word Ladder
• Number of Islands
• Clone Graph
• Pacific Atlantic Water Flow

Graph BFS

• Shortest Path in Binary Matrix
• Word Ladder II
• Open the Lock
• Minimum Knight Moves

Trie

• Implement Trie (Prefix Tree)
• Add and Search Word
• Word Search II
• Replace Words

Backtracking

• Permutations
• Combination Sum
• Sudoku Solver
• Word Search

Divide & Conquer

• Merge Sort
• Quick Sort
• Maximum Subarray
• Kth Largest Element in an Array

Kadane’s Algorithm

• Maximum Subarray
• Maximum Sum Circular Subarray
• Maximum Product Subarray
• Minimum Cost Climbing Stairs

Binary Search

• Binary Search
• Search in Rotated Sorted Array
• Find Minimum in Rotated Sorted Array
• Median of Two Sorted Arrays

Heap

• Kth Largest Element in an Array
• Merge k Sorted Lists
• Top K Frequent Elements
• Find Median from Data Stream

Bit Manipulation

• Single Number
• Number of 1 Bits
• Missing Number
• Reverse Bits

Math

• Sieve of Eratosthenes
• GCD and LCM
• Fibonacci Number
• Power of Three

1D DP

• Climbing Stairs
• House Robber
• Longest Increasing Subsequence
• Coin Change

Multidimensional DP

• Unique Paths
• Longest Common Subsequence
• Edit Distance
• Maximal Square