Top 20 Coding Interview Questions with In-Depth Answers

1. Tell me about your approach to solving a coding problem

This is one of the most important questions because interviewers are evaluating your thinking process, not just the final code. A strong and structured answer should sound like this:

• First, I focus on fully understanding the problem. I clarify requirements, constraints and edge cases-for example, whether the input can be empty, very large or contain duplicates. This step is critical because misunderstanding the problem is one of the most common reasons candidates fail.

• Next, I think through possible approaches. I usually begin with a simple or brute-force solution to ensure correctness, then gradually optimize it. While doing this, I explain my thought process so the interviewer can follow my reasoning.

• Then, I choose the right data structure and algorithm, since they directly impact performance. For example, I may use a hash map for constant-time lookups or arrays for sequential access, depending on the problem.

• Finally, I write clean, readable code, test it with edge cases and clearly explain the time and space complexity to show I understand efficiency and trade-offs.

Why this answer works: It demonstrates a structured, logical and communicative approach, which is exactly what interviewers look for-not just coding ability, but how you think and solve problems step by step.

2. What is time complexity and why is it important?

Time complexity is a measure of how the execution time of an algorithm grows as the input size increases. Instead of measuring exact time (which depends on hardware), it focuses on how the number of operations scales with input size. It is usually expressed using Big-O notation, such as:

• O(1): Constant time (independent of input size)
• O(n): Linear time (grows proportionally)
• O(log n): Logarithmic (very efficient for large data)
• O(n²): Quadratic (slow for large inputs)

Why it is important in interviews: Time complexity helps you evaluate how well your solution will scale for large inputs. For example, a solution with nested loops results in O(n²), which can become very slow as data grows.

It also allows you to compare multiple approaches and justify why one is better than another. Interviewers expect candidates not just to write code, but to analyze and optimize it.

A strong candidate always explains:

• The time complexity of their solution
• Why their approach is efficient (or how it can be improved)

In short, time complexity shows your ability to write scalable and optimized code, which is a key skill in real-world software development.

3. Write a program to reverse a string

There are multiple ways to reverse a string, but the most efficient and commonly discussed approach in interviews is the two-pointer technique.

Approach (Two-Pointer): Start one pointer at the beginning and another at the end of the string. Swap characters and move both pointers toward the center until they meet.

Why this works well:

• Time Complexity: O(n) (each element is processed once)
• Space Complexity: O(1) (in-place, no extra memory required)

Interview Tip: Always clarify whether the string is mutable. In languages like Java or Python (strings immutable), you may need extra space, which changes space complexity.

In short, this approach is efficient because it minimizes both time and space usage.

4. How do you check if a number is prime?

A number is prime if it is divisible only by 1 and itself. The optimized approach is to check divisibility from 2 to √n, instead of checking all numbers up to n.

Why √n? Because factors occur in pairs. If a number has a factor greater than √n, it must also have a corresponding factor smaller than √n.

Complexity:

• Time Complexity: O(√n)

Interview Tip: Always mention this optimization. A brute-force approach (O(n)) is correct but inefficient, while the √n approach shows deeper understanding.

In short, this solution is efficient because it reduces unnecessary checks significantly.

5. What is the difference between array and linked list?

An array stores elements in contiguous memory locations, which allows:

• Fast access using index -> O(1)
• But fixed size and costly insertions/deletions

A linked list stores elements as nodes connected by pointers, which allows:

• Dynamic size (easy to grow/shrink)
• Efficient insertions/deletions -> O(1) (if position known)
• Slower access -> O(n) (must traverse)

When to use what:

• Use arrays when you need fast random access
• Use linked lists when you need frequent insertions/deletions

In short, arrays optimize for speed of access, while linked lists optimize for flexibility.

6. What is a hash map and when do you use it?

A hash map (hash table) is a data structure that stores key-value pairs and provides average O(1) time complexity for insertion, deletion and lookup. It works by using a hash function to map keys to specific indices in memory.

When to use it:

• When you need fast lookup or search
• When you want to avoid nested loops (optimize from O(n²) to O(n))
• When solving problems like:
• Finding duplicates
• Counting frequency of elements
• Two-sum type problems

Example: Instead of checking every pair in an array, you can store values in a hash map and find matches in constant time.

In short, hash maps are essential for writing efficient and optimized solutions, especially in coding interviews.

7. Explain recursion with example

Recursion is a programming technique where a function calls itself to solve smaller instances of the same problem. A recursive solution always has two parts:

• A base case (stopping condition)
• A recursive case (function calling itself with smaller input)

Example: Factorial

• Base case: factorial(0) = 1
• Recursive case: factorial(n) = n * factorial(n-1)

Key points to mention in interviews: Recursion is useful for problems that can be broken into smaller subproblems (like trees or divide-and-conquer). However, it can lead to stack overflow if the base case is missing or too deep and in many cases, it can be converted into an iterative solution for better performance.

In short, recursion is powerful but must be used carefully with proper base conditions.

8. What is dynamic programming?

Dynamic Programming (DP) is an optimization technique used when a problem has:

• Overlapping subproblems
• Optimal substructure

Instead of recomputing the same subproblems, DP stores results (memoization or tabulation) and reuses them.

Example: Fibonacci A simple recursive solution recalculates values multiple times, but DP stores results and reduces complexity significantly.

Interview insight: DP is not just about coding-it's about recognizing patterns. A strong answer explains why DP is needed, i.e. to avoid redundant computation and improve efficiency.

In short, DP turns inefficient recursive solutions into optimized and scalable ones.

9. What is the Two Sum problem?

The Two Sum problem asks you to find two numbers in an array that add up to a given target. The optimal approach uses a hash map:

• Iterate through the array
• Store each number with its index
• Check if (target - current) already exists

This reduces time complexity to O(n) instead of O(n²).

Why this question is important: It tests your understanding of hashing, optimization and problem-solving patterns. It's one of the most common interview questions and forms the base for many advanced variations.

10. What is binary search?

Binary search is an efficient algorithm used to search in a sorted array by repeatedly dividing the search space in half.

• Compare the middle element with the target
• If equal -> return
• If smaller -> search right half
• If larger -> search left half
• Time Complexity: O(log n)

Important point: Binary search only works on sorted data, which is a key condition often tested in interviews.

In short, binary search is a highly efficient technique for fast searching in large datasets.

11. What is a stack and queue?

A stack follows LIFO (Last In, First Out), meaning the last element added is the first to be removed. A queue follows FIFO (First In, First Out), meaning the first element added is the first to be removed.

Use cases: Stacks are used in recursion, expression evaluation and undo operations. Queues are used in scheduling, buffering and algorithms like BFS.

In short, the difference lies in order of processing, which directly affects how problems are solved.

12. Explain sorting algorithms

Sorting algorithms arrange data in a specific order and are fundamental in coding interviews. Some common ones include:

• Bubble Sort: Simple but inefficient -> O(n²)
• Merge Sort: Divide and conquer -> O(n log n)
• Quick Sort: Fast in practice -> average O(n log n)

Interview tip: Instead of just listing algorithms, compare them based on:

• Time complexity
• Space complexity
• Stability (whether order is preserved)
• Use case

In short, sorting questions test your ability to analyze trade-offs between different algorithms.

13. What is object-oriented programming (OOP)?

Object-Oriented Programming (OOP) is a programming paradigm based on objects that combine data and behavior (methods). Key concepts include:

• Encapsulation: Hiding internal details
• Inheritance: Reusing code from parent classes
• Polymorphism: Same interface, different behavior

Languages like Java, Python and C# support OOP.

In short, OOP helps build modular, reusable and maintainable code, which is crucial in real-world development.

14. What is the difference between stack memory and heap memory?

Memory in programs is mainly divided into stack and heap, each serving different purposes.

Stack memory:

• Stores function calls and local variables
• Very fast access
• Limited size

Heap memory:

• Stores dynamically allocated objects
• More flexible and larger
• Slower compared to stack

In short, the stack is used for short-lived, structured data, while the heap is used for dynamic and long-lived data, making both essential in program execution.

15. How do you handle a crashing program?

When a program crashes, I follow a structured debugging approach rather than guessing.

• First, I try to reproduce the issue consistently, because a bug that cannot be reproduced is difficult to fix. Then I check logs, error messages and stack traces to understand where the failure occurred.

• Next, I debug step-by-step-either using a debugger or adding logs-to isolate the exact point of failure. Once identified, I focus on finding the root cause, not just fixing symptoms.

• Finally, I apply the fix, test edge cases and verify that the issue is fully resolved.

This approach shows a strong problem-solving and debugging mindset, which interviewers value highly.

16. What is a palindrome problem?

A palindrome is a string that reads the same forward and backward, such as madam or racecar. The most efficient approach is the two-pointer technique, where one pointer starts from the beginning and the other from the end and both move inward while comparing characters.

This approach runs in O(n) time and requires minimal extra space.

In interviews, this problem tests your understanding of string manipulation and edge cases like spaces, case sensitivity or special characters.

17. What is BFS and DFS?

Breadth-First Search (BFS) and Depth-First Search (DFS) are fundamental graph traversal algorithms.

• BFS explores nodes level by level and uses a queue. It is commonly used for finding the shortest path in unweighted graphs.
• DFS explores as deep as possible along one path before backtracking, typically using recursion or a stack.

The key difference lies in traversal strategy:

• BFS -> level-wise exploration
• DFS -> depth-first exploration

In interviews, choosing the right one depends on the problem. BFS is ideal for shortest paths, while DFS is useful for exploring all possibilities or paths.

18. What is space complexity?

Space complexity measures the amount of memory an algorithm uses relative to input size.

For example:

• Using an extra array -> O(n) space
• Modifying data in place -> O(1) space

It is especially important in large-scale systems where memory usage directly impacts performance and cost.

In interviews, a strong answer includes both time and space complexity, showing complete understanding of efficiency.

19. What is clean code?

Clean code refers to code that is easy to read, understand and maintain. It typically includes:

• Meaningful variable and function names
• Simple and modular structure
• Proper formatting and comments (only where needed)

Interviewers value clean code because in real-world projects, code is read more often than it is written. Writing overly complex or clever code can make maintenance difficult.

In short, clean code improves readability, maintainability and collaboration.

20. How do you optimize code?

Code optimization is about improving performance (time and space efficiency) without compromising correctness. A structured approach includes:

• Reducing unnecessary computations
• Avoiding nested loops where possible
• Choosing better data structures (e.g., hash map instead of brute force)

For example, replacing a double loop (O(n²)) with a hash-based approach can reduce complexity to O(n).

In interviews, optimization is not just about the final answer-it's about showing how you identify inefficiencies and improve step by step, which reflects strong problem-solving skills.