COMMONLY ASKED QUESTIONS DURING CODING INTERVIEW ► MacroNepal

Table of Contents

1. Array and String Manipulation

Arrays and strings are the foundation of most coding interviews.

Find the missing number in an array: Given an array of n-1 integers where each integer is between 1 and n, find the missing number.
- Tip: Use summation formulas or XOR operations for optimized solutions.
Two Sum Problem: Given an array of integers, return indices of the two numbers that add up to a specific target.
- Tip: Use a hash map to store the difference (target – current element) and check if it exists.
Reverse a string: Reverse the characters in a given string.
- Tip: Use a two-pointer approach, starting from the beginning and the end of the string.
Find the longest substring without repeating characters: Return the length of the longest substring without repeating characters.
- Tip: Use a sliding window and a hash set to track characters.
Rotate array: Rotate an array by k positions.
- Tip: Try reversing parts of the array or using cyclic replacements.

Linked lists are commonly used in interviews to assess knowledge of pointers and memory management.

Reverse a linked list: Given the head of a singly linked list, reverse it.
- Tip: Iterative solutions using three pointers (previous, current, next) are common, but recursive methods also work.
Detect a cycle in a linked list: Determine if a linked list contains a cycle.
- Tip: Use Floyd’s Cycle Detection (slow and fast pointers).
Merge two sorted linked lists: Given two sorted linked lists, merge them into one sorted list.
- Tip: Use a dummy node to simplify list traversal and merging.
Find the middle of a linked list: Return the middle node of the linked list.
- Tip: Use two pointers: a slow pointer and a fast pointer (which moves twice as fast).

Sorting and searching techniques often come up in technical interviews.

Binary search: Implement binary search on a sorted array to find a target value.
- Tip: Keep track of left and right bounds and use integer division for the midpoint.
Merge sort/Quick sort: Explain and implement sorting algorithms like merge sort or quicksort.
- Tip: Understand divide and conquer strategies. For quicksort, explain the pivot selection process.
Find the first and last position of an element in a sorted array: Return the starting and ending position of a given target.
- Tip: Use binary search to optimize time complexity to O(log n).
Find the peak element: Given an array where elements are in ascending order first and then descend, find the peak.
- Tip: Use binary search by comparing mid element with its neighbors.

Dynamic programming (DP) can be tricky, but it’s a crucial topic for coding interviews.

Climbing Stairs: Given that you can take 1 or 2 steps, find how many distinct ways you can climb to the top.
- Tip: Recognize this as a Fibonacci series problem and use either memoization or tabulation.
Longest Increasing Subsequence: Given an array, find the length of the longest increasing subsequence.
- Tip: Use dynamic programming with a nested loop, or use binary search for optimized solutions.
Knapsack Problem: Given weights and values, find the maximum value that can be carried with a given weight capacity.
- Tip: Use a 2D DP array to track the best solutions for different capacities.
Coin Change Problem: Given an array of coins and a target amount, find the fewest number of coins to make up the target amount.
- Tip: Use bottom-up DP to fill up a table with minimum coins for each amount up to the target.

Questions on trees and graphs assess knowledge of recursive structures and traversal techniques.

Binary tree in-order, pre-order, post-order traversal: Implement tree traversal algorithms.
- Tip: Recursion is the easiest way to approach this, but understand iterative methods using stacks as well.
Lowest Common Ancestor (LCA): Find the LCA of two nodes in a binary tree.
- Tip: Use recursion to explore both subtrees and check if the nodes lie in different subtrees.
Level order traversal: Given a binary tree, return its level-order traversal.
- Tip: Use a queue (Breadth-First Search technique) to visit nodes level by level.
Detect a cycle in a graph: Determine if a graph contains a cycle.
- Tip: For directed graphs, use DFS with a recursion stack. For undirected graphs, use union-find.
Topological sort: Implement topological sorting on a directed acyclic graph (DAG).
- Tip: Use Kahn’s algorithm (BFS-based) or a DFS-based method.

Bit manipulation questions are common, especially in tech interviews that focus on optimization.

Check if a number is a power of two: Determine if a given number is a power of two.
- Tip: Use bitwise AND: a number that is a power of two has only one bit set (n & (n-1) == 0).
Count the number of 1s in binary representation (Hamming weight): Given an integer, return the number of 1s in its binary representation.
- Tip: Use n = n & (n-1) to turn off the rightmost set bit in a loop.
Reverse bits: Reverse the bits of a given 32-bit unsigned integer.
- Tip: Swap bits using bit manipulation and shifts.
Find the single number: In an array where every element appears twice except one, find the element that appears once.
- Tip: Use XOR to cancel out duplicate elements (a ^ a = 0).

These questions often test problem-solving skills and understanding of mathematical principles.

FizzBuzz: Write a function that prints the numbers from 1 to 100. But for multiples of three print “Fizz”, for multiples of five print “Buzz”, and for multiples of both print “FizzBuzz”.
- Tip: Simple modulus operations (%), but tests understanding of edge cases.
Palindrome Number: Check if a number is a palindrome.
- Tip: Reverse the number or convert it to a string and check if it matches the original.
Greatest Common Divisor (GCD): Find the greatest common divisor of two numbers.
- Tip: Use the Euclidean algorithm for GCD.
Find the missing number in a sequence: Given a sequence of n-1 numbers from 1 to n, find the missing number.
- Tip: Use the sum formula or XOR technique.

OOP concepts are essential for interviews focused on system design and object design.

Design a parking lot system: Implement classes and methods to manage parking spots and vehicles.
- Tip: Break down the system into core objects (ParkingLot, Vehicle, Spot, etc.) and define their relationships.
Design a library management system: Implement a basic structure for a library with books, patrons, and checkout functions.
- Tip: Focus on class design and interactions between objects.

Clarify the Problem: Before jumping into coding, make sure you understand the problem fully. Ask questions if something is unclear.
Optimize Your Solution: First come up with a brute-force solution, then try to optimize it.
Consider Edge Cases: Always think about potential edge cases (empty inputs, large numbers, negative numbers, etc.).
Explain Your Thought Process: Communicate your approach clearly to the interviewer as you work through the problem.
Practice Time and Space Complexity: Be prepared to discuss the time and space complexity (Big O) of your solution.

By preparing for these types of questions and practicing regularly, you can significantly improve your chances of success in a coding interview!