Problem

Given an array of strings strs, group the anagrams together. You can return the answer in any order.

Examples

Example 1:

Input: strs = ["eat","tea","tan","ate","nat","bat"]
Output: [["bat"],["nat","tan"],["ate","eat","tea"]]
Explanation: 
 * There is no string in strs that can be rearranged to form "bat".
 * The strings "nat" and "tan" are anagrams as they can be rearranged to form each other.
 * The strings "ate", "eat", and "tea" are anagrams as they can be rearranged to form each other.

Example 2:

Input: strs = [""]
Output: [[""]]

Example 3:

Input: strs = ["a"]
Output: [["a"]]

Constraints

• 1 <= strs.length <= 10^4

• 0 <= strs[i].length <= 100

• strs[i] consists of lowercase English letters.

How to participate

Drop your solution as a comment (or link a gist) by May 14, 2026 at noon Pacific Time.

Include:

• Your programming language

• Brief explanation of your approach

• Stated complexity

What I’ll do

By May 16, I’ll publish a Review & Lessons post with:

• Annotated feedback on selected submissions

• A clean reference solution

• Notes on how an interviewer would evaluate your approach.

If you’re short on time this week, at least sketch your approach in prose—that’s still valuable practice.

Upcoming Wednesday paid post will be a detailed analysis of strings and anagrams: sorted key O(n * k log k) vs. frequency tuple O(n * k), prime product hashing trick, interview traps

© The Coding Interview Gym | paulepps.substack.com

Problem

Given an array of integers nums and an integer k, return the total number of subarrays whose sum equals to k.

A subarray is a contiguous non-empty sequence of elements within an array.

Examples

Example 1:

Input: nums = [1,1,1], k = 2
Output: 2

Example 2:

Input: nums = [1,2,3], k = 3
Output: 2

Constraints

• 1 <= nums.length <= 2 * 10^4

• -1000 <= nums[i] <= 1000

• -10^7 <= k <= 10^7

How to participate

Drop your solution as a comment (or link a gist) by May 7, 2026 at noon Pacific Time.

Include:

• Your programming language

• Brief explanation of your approach

• Stated complexity

What I’ll do

By May 9, I’ll publish a Review & Lessons post with:

• Annotated feedback on selected submissions

• A clean reference solution

• Notes on how an interviewer would evaluate your approach.

If you’re short on time this week, at least sketch your approach in prose—that’s still valuable practice.

Upcoming Wednesday paid post will be a Prefix Sum deep-dive: sum derivation, cumulative frequency map, 2D prefix sums, running sum vs. extra array.

© The Coding Interview Gym | paulepps.substack.com

Problem

Given a string s, find the length of the longest substring without duplicate characters.

Examples

Example 1:

Input: s = “abcabcbb”
Output: 3
Explanation: The answer is “abc”, with the length of 3. Note that "bca" and "cab" are also correct answers.

Example 2:

Input: s = “bbbbb”
Output: 1
Explanation: The answer is “b”, with the length of 1.

Example 3:

Input: s = “pwwkew”
Output: 3
Explanation: The answer is “wke”, with the length of 3.
Notice that the answer must be a substring, “pwke” is a subsequence and not a substring.

Constraints

• 0 <= s.length <= 5 * 10^4

• s consists of English letters, digits, symbols and spaces.

How to participate

Drop your solution as a comment (or link a gist) by April 30, 2026 at noon Pacific Time.

Include:

• Your programming language

• Brief explanation of your approach

• Stated complexity

What I’ll do

By May 2, I’ll publish a Review & Lessons post with:

• Annotated feedback on selected submissions

• A clean reference solution

• Notes on how an interviewer would evaluate your approach.

If you’re short on time this week, at least sketch your approach in prose—that’s still valuable practice.

Upcoming Wednesday paid post will be a Sliding Window Masterclass: the pattern that solves 20+ interview problems.

© The Coding Interview Gym | paulepps.substack.com

Problem

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input has exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Examples

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

Input: nums = [3,2,4], target = 6
Output: [1,2]

Input: nums = [3,3], target = 6
Output: [0,1]

Constraints

• 2 <= nums.length <= 10^4

• -10^9 <= nums[i] <= 10^9

• -10^9 <= target <= 10^9

• Only one valid answer exists.

How to participate

Drop your solution as a comment (or link a gist) by April 23, 2026 at noon Pacific Time.

Include:

• Your programming language

• Brief explanation of your approach

• Stated complexity

If you feel ambitious, compare a memoized recursive solution vs a bottom‑up iterative one in terms of complexity and stack‑overflow risk.

What I’ll do

By April 25, I’ll publish a Review & Lessons post with:

• Annotated feedback on selected submissions

• A clean reference solution

• Notes on how an interviewer would evaluate your approach.

If you’re short on time this week, at least sketch your approach in prose—that’s still valuable practice.

Full breakdown in Wednesday’s paid post: hash map vs two pointers tradeoffs, follow-up variants, code in Python/Java.

© The Coding Interview Gym | paulepps.substack.com

Problem

Given an array of coins[] of size n and a target value sum, where coins[i] represent the coins of different denominations. You have an infinite supply of each of the coins. The task is to find the minimum number of coins required to make the given value sum. If it is not possible to form the sum using the given coins, return -1.

This naturally invites:

• A naive top‑down recursion.

• A memoized top‑down Dynamic Programming (DP).

• A bottom‑up tabulation DP.

• A greedy solution you can analyze and reject.

  ---

Examples

Input: coins[] = [25, 10, 5], sum = 30
Output: 2
Explanation : Minimum 2 coins needed, 25 and 5

Input: coins[] = [9, 6, 5, 1], sum = 19
Output: 3
Explanation: 19 = 9 + 9 + 1

Input: coins[] = [5, 1], sum = 0
Output: 0
Explanation: For 0 sum, we do not need a coin

Input: coins[] = [4, 6, 2], sum = 5
Output: -1
Explanation: Not possible to make the given sum.

Hints

• Try to define f(x) that depends on smaller x.

• Can you reuse results of f(x) instead of recomputing?

  ---

How to participate

Post your solution as a comment (or link a gist) by April 16, 2026 at noon Pacific Time

Include:

• Your language

• Brief explanation of your approach

• Stated complexity

If you feel ambitious, compare a memoized recursive solution vs a bottom‑up iterative one in terms of complexity and stack‑overflow risk.

What I’ll do

By April 18, I’ll publish a Review & Lessons post with:

• Annotated feedback on selected submissions

• A clean reference solution

• Notes on how an interviewer would evaluate your approach.

If you’re short on time this week, at least sketch your approach in prose—that’s still valuable practice.

© The Coding Interview Gym | paulepps.substack.com

What behavioral interviews measure

Behavioral rounds typically probe qualities like communication, teamwork, conflict resolution, ownership, adaptability, and motivation. Interviewers look for evidence in your past stories that you can collaborate effectively, handle setbacks, make informed decisions, and keep learning on the job.

Common question types

You will usually see a mix of:

• “Tell me about yourself” and career preference questions (motivation, ambitions, why this company, why you’re leaving, etc.).

• Deep dives into items on your resume, such as hardest bug, most challenging project, or work you’re most proud of.

• “Tell me about a time…” questions around challenges, conflicts, tight deadlines, failures, and feedback.

• Culture and collaboration questions about working with difficult teammates, influencing others, and contributing to team success.

Example: “Tell me about a time you disagreed with a coworker and how you resolved it” or “Describe a mistake you made and what you learned.”

How to participate

Submit one behavioral story from your own experience (e.g., conflict, ambiguity, failure) as a comment by April 9, 2026 at noon Pacific Time.

What I’ll do

By April 11, I’ll publish a Review & Lessons post with:

• Annotated feedback on selected submissions

• Written edits and suggestions to tighten stories, emphasize impact and avoid common pitfalls.

• Notes on how an interviewer would evaluate your approach.

Problem

You are given nn cities labeled from 0 to n−1.
Some pairs of cities are connected by roads, and some pairs are connected by bridges.

• Roads are free to use.

• Each bridge crossing costs 1 token, regardless of direction or distance.

You are also given a starting city start, a destination city target, and an integer k representing how many bridge tokens you have.

You can travel:

• Along any road edge at zero cost, unlimited times.

• Along any bridge edge, but in total you may use at most k bridges on your entire route.

Return the minimum number of steps (edges traversed, roads or bridges) needed to travel from start to target without using more than k bridges. If it is impossible, return -1.

A “step” is traversing a single edge (road or bridge) from one city to a directly connected city.​

Input format

• n: integer, number of cities.

• roads: list of pairs [u, v] meaning there is an undirected road between u and v.

• bridges: list of pairs [u, v] meaning there is an undirected bridge between u and v.

• start: integer in [0, n-1].

• target: integer in [0, n-1].

• k: integer, maximum number of bridges you may use.​

Assumptions

• The graph can be disconnected.

• There may be multiple edges between two cities (e.g., both a road and a bridge).

• No self-loops are given, but the code shouldn’t rely on that.

• 1≤n≤10^5, total edges up to 2⋅10^5.​

Example

Input:

• n = 5

• roads = [[0,1],[1,2]]

• bridges = [[0,3],[3,4],[4,2]]

• start = 0

• target = 2

• k = 1

Questions:

• What is the minimum number of steps?

• Show the actual path and annotate where you spend your one bridge token.

Answer:

• Path with roads only: 0 → 1 → 2, 2 steps, 0 bridges.

• Longer path using bridges: 0 → 3 → 4 → 2, 3 steps, 2 bridges (invalid if k = 1).
  So the correct answer is 2.​

How to participate

Post your solution as a comment (or link a gist) by April 2, 2026 at noon Pacific Time

Include:

• Your language

• Brief explanation of your approach

• Stated complexity

What I’ll do

By April 3, I’ll publish a Review & Lessons post with:

• Annotated feedback on selected submissions

• A clean reference solution

• Notes on how an interviewer would evaluate your approach.

If you’re short on time this week, at least sketch your approach in prose—that’s still valuable practice.

Problem

You’re given the root of a binary tree.

Write a recursive function maxDepth(root) that returns the maximum depth (height) of the tree, where an empty tree has depth 0.

You may assume each node has left and right pointers (or null) to its children.

Pseudocode signature:

function maxDepth(node: TreeNode): integer

Part 1 — Code

Implement maxDepth recursively.
Do not use any global variables or mutable state outside the function.

Part 2 — Explain time complexity

In 3–5 sentences, explain the time complexity of your recursive solution.

Your explanation should:

• State what work happens in a single call (besides the recursive calls).

• Argue why every node in the tree is visited exactly once.​

• Conclude that the running time is O(n), where n is the number of nodes.

Part 3 — Explain recursion stack depth

In another 3–5 sentences, explain the space complexity in terms of the recursion stack.

Your explanation should:

• Describe what one stack frame represents in this function (a call waiting for its children’s depths).

• Relate the maximum number of simultaneous frames to the height h of the tree, and state that the extra space is O(h).

• Connect that to shapes of the tree:

  • Balanced tree: h ≈ log n

  • Worst-case skewed tree: h ≈ n (so stack space can grow to O(n)).

You can invite readers to submit both their code and their written complexity explanations as their “interview answer.”

How to participate

• Post your solution as a comment (or link a gist) by noon Pacific Time on March 19, 2026.

• Include:

  • Your language

  • Brief explanation of your approach

  • Stated complexity

What I’ll do

On or before March 21, I’ll:.

• Publish a Review & Lessons post with:

  • Detailed feedback on selected solutions

  • A clean reference solution

  • Notes on how an interviewer would evaluate your approach.

If you’re short on time this week, at least sketch your approach in prose—that’s still valuable practice.

Problem

You are given an array of strings words and an integer k.
Return the k most frequent strings, sorted by:

1. Descending frequency.

2. For ties, ascending lexicographic order.

Example:

• Input: words = ["code", "practice", "code", "interview", "practice", "code"], k = 2

• Output: ["code", "practice"]

words.length can be up to 10^5.
Assume 1 ≤ k ≤ unique(words).

Assume Java, Python, C#, Typescript and JavaScript are allowed.

How to participate

• Post your solution as a comment (or link a gist) by March 12 @noon Pacific Time.

• Include:

  • Your language

  • Brief explanation of your approach

  • Stated complexity

What I’ll do

By March 13, I’ll:

• Pick at least 3 submissions for detailed written feedback.

• Publish a Review & Lessons post with:

  • Annotated solutions

  • A clean reference solution

  • Notes on how an interviewer would evaluate your approach.

If you’re short on time this week, at least sketch your approach in prose—that’s still valuable practice.